From 36d22d82aa202bb199967e9512281e9a53db42c9 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sun, 7 Apr 2024 21:33:14 +0200 Subject: Adding upstream version 115.7.0esr. Signed-off-by: Daniel Baumann --- third_party/rust/ash/src/device.rs | 2707 + third_party/rust/ash/src/entry.rs | 402 + .../rust/ash/src/extensions/experimental/amd.rs | 722 + .../rust/ash/src/extensions/experimental/mod.rs | 1 + .../ash/src/extensions/ext/acquire_drm_display.rs | 55 + .../src/extensions/ext/buffer_device_address.rs | 44 + .../src/extensions/ext/calibrated_timestamps.rs | 72 + .../rust/ash/src/extensions/ext/debug_marker.rs | 71 + .../rust/ash/src/extensions/ext/debug_report.rs | 68 + .../rust/ash/src/extensions/ext/debug_utils.rs | 173 + .../ash/src/extensions/ext/descriptor_buffer.rs | 211 + .../src/extensions/ext/extended_dynamic_state.rs | 196 + .../src/extensions/ext/extended_dynamic_state2.rs | 85 + .../src/extensions/ext/extended_dynamic_state3.rs | 409 + .../src/extensions/ext/full_screen_exclusive.rs | 86 + .../ash/src/extensions/ext/headless_surface.rs | 55 + .../extensions/ext/image_compression_control.rs | 47 + .../extensions/ext/image_drm_format_modifier.rs | 48 + .../rust/ash/src/extensions/ext/mesh_shader.rs | 94 + .../rust/ash/src/extensions/ext/metal_surface.rs | 54 + third_party/rust/ash/src/extensions/ext/mod.rs | 45 + .../ash/src/extensions/ext/physical_device_drm.rs | 26 + .../rust/ash/src/extensions/ext/private_data.rs | 105 + .../ash/src/extensions/ext/sample_locations.rs | 54 + .../rust/ash/src/extensions/ext/tooling_info.rs | 40 + .../src/extensions/khr/acceleration_structure.rs | 322 + .../rust/ash/src/extensions/khr/android_surface.rs | 54 + .../src/extensions/khr/buffer_device_address.rs | 62 + .../rust/ash/src/extensions/khr/copy_commands2.rs | 84 + .../ash/src/extensions/khr/create_render_pass2.rs | 90 + .../src/extensions/khr/deferred_host_operations.rs | 93 + .../rust/ash/src/extensions/khr/device_group.rs | 169 + .../src/extensions/khr/device_group_creation.rs | 66 + third_party/rust/ash/src/extensions/khr/display.rs | 143 + .../ash/src/extensions/khr/display_swapchain.rs | 57 + .../ash/src/extensions/khr/draw_indirect_count.rs | 74 + .../ash/src/extensions/khr/dynamic_rendering.rs | 44 + .../ash/src/extensions/khr/external_fence_fd.rs | 49 + .../ash/src/extensions/khr/external_fence_win32.rs | 58 + .../ash/src/extensions/khr/external_memory_fd.rs | 60 + .../src/extensions/khr/external_memory_win32.rs | 66 + .../src/extensions/khr/external_semaphore_fd.rs | 52 + .../src/extensions/khr/external_semaphore_win32.rs | 58 + .../src/extensions/khr/get_memory_requirements2.rs | 92 + .../khr/get_physical_device_properties2.rs | 167 + .../extensions/khr/get_surface_capabilities2.rs | 84 + .../rust/ash/src/extensions/khr/maintenance1.rs | 45 + .../rust/ash/src/extensions/khr/maintenance3.rs | 45 + .../rust/ash/src/extensions/khr/maintenance4.rs | 91 + third_party/rust/ash/src/extensions/khr/mod.rs | 75 + .../khr/pipeline_executable_properties.rs | 84 + .../rust/ash/src/extensions/khr/present_wait.rs | 47 + .../rust/ash/src/extensions/khr/push_descriptor.rs | 68 + .../src/extensions/khr/ray_tracing_maintenance1.rs | 42 + .../ash/src/extensions/khr/ray_tracing_pipeline.rs | 194 + third_party/rust/ash/src/extensions/khr/surface.rs | 110 + .../rust/ash/src/extensions/khr/swapchain.rs | 211 + .../ash/src/extensions/khr/synchronization2.rs | 101 + .../ash/src/extensions/khr/timeline_semaphore.rs | 60 + .../rust/ash/src/extensions/khr/wayland_surface.rs | 71 + .../rust/ash/src/extensions/khr/win32_surface.rs | 69 + .../rust/ash/src/extensions/khr/xcb_surface.rs | 73 + .../rust/ash/src/extensions/khr/xlib_surface.rs | 73 + third_party/rust/ash/src/extensions/mod.rs | 6 + .../rust/ash/src/extensions/mvk/ios_surface.rs | 54 + .../rust/ash/src/extensions/mvk/macos_surface.rs | 54 + third_party/rust/ash/src/extensions/mvk/mod.rs | 5 + third_party/rust/ash/src/extensions/nn/mod.rs | 3 + .../rust/ash/src/extensions/nn/vi_surface.rs | 54 + .../src/extensions/nv/coverage_reduction_mode.rs | 70 + .../extensions/nv/device_diagnostic_checkpoints.rs | 63 + .../rust/ash/src/extensions/nv/mesh_shader.rs | 81 + third_party/rust/ash/src/extensions/nv/mod.rs | 9 + .../rust/ash/src/extensions/nv/ray_tracing.rs | 271 + third_party/rust/ash/src/instance.rs | 535 + third_party/rust/ash/src/lib.rs | 197 + third_party/rust/ash/src/prelude.rs | 122 + third_party/rust/ash/src/util.rs | 139 + third_party/rust/ash/src/vk.rs | 52 + third_party/rust/ash/src/vk/aliases.rs | 251 + third_party/rust/ash/src/vk/bitflags.rs | 1643 + third_party/rust/ash/src/vk/const_debugs.rs | 7167 ++ third_party/rust/ash/src/vk/constants.rs | 27 + third_party/rust/ash/src/vk/definitions.rs | 73178 +++++++++++++++++++ third_party/rust/ash/src/vk/enums.rs | 2917 + third_party/rust/ash/src/vk/extensions.rs | 25322 +++++++ third_party/rust/ash/src/vk/feature_extensions.rs | 451 + third_party/rust/ash/src/vk/features.rs | 5353 ++ third_party/rust/ash/src/vk/macros.rs | 162 + third_party/rust/ash/src/vk/native.rs | 8998 +++ third_party/rust/ash/src/vk/platform_types.rs | 41 + third_party/rust/ash/src/vk/prelude.rs | 61 + 92 files changed, 136559 insertions(+) create mode 100644 third_party/rust/ash/src/device.rs create mode 100644 third_party/rust/ash/src/entry.rs create mode 100644 third_party/rust/ash/src/extensions/experimental/amd.rs create mode 100644 third_party/rust/ash/src/extensions/experimental/mod.rs create mode 100644 third_party/rust/ash/src/extensions/ext/acquire_drm_display.rs create mode 100644 third_party/rust/ash/src/extensions/ext/buffer_device_address.rs create mode 100644 third_party/rust/ash/src/extensions/ext/calibrated_timestamps.rs create mode 100755 third_party/rust/ash/src/extensions/ext/debug_marker.rs create mode 100755 third_party/rust/ash/src/extensions/ext/debug_report.rs create mode 100755 third_party/rust/ash/src/extensions/ext/debug_utils.rs create mode 100644 third_party/rust/ash/src/extensions/ext/descriptor_buffer.rs create mode 100644 third_party/rust/ash/src/extensions/ext/extended_dynamic_state.rs create mode 100644 third_party/rust/ash/src/extensions/ext/extended_dynamic_state2.rs create mode 100644 third_party/rust/ash/src/extensions/ext/extended_dynamic_state3.rs create mode 100644 third_party/rust/ash/src/extensions/ext/full_screen_exclusive.rs create mode 100644 third_party/rust/ash/src/extensions/ext/headless_surface.rs create mode 100644 third_party/rust/ash/src/extensions/ext/image_compression_control.rs create mode 100644 third_party/rust/ash/src/extensions/ext/image_drm_format_modifier.rs create mode 100644 third_party/rust/ash/src/extensions/ext/mesh_shader.rs create mode 100644 third_party/rust/ash/src/extensions/ext/metal_surface.rs create mode 100644 third_party/rust/ash/src/extensions/ext/mod.rs create mode 100644 third_party/rust/ash/src/extensions/ext/physical_device_drm.rs create mode 100644 third_party/rust/ash/src/extensions/ext/private_data.rs create mode 100644 third_party/rust/ash/src/extensions/ext/sample_locations.rs create mode 100644 third_party/rust/ash/src/extensions/ext/tooling_info.rs create mode 100644 third_party/rust/ash/src/extensions/khr/acceleration_structure.rs create mode 100755 third_party/rust/ash/src/extensions/khr/android_surface.rs create mode 100644 third_party/rust/ash/src/extensions/khr/buffer_device_address.rs create mode 100644 third_party/rust/ash/src/extensions/khr/copy_commands2.rs create mode 100644 third_party/rust/ash/src/extensions/khr/create_render_pass2.rs create mode 100644 third_party/rust/ash/src/extensions/khr/deferred_host_operations.rs create mode 100644 third_party/rust/ash/src/extensions/khr/device_group.rs create mode 100644 third_party/rust/ash/src/extensions/khr/device_group_creation.rs create mode 100755 third_party/rust/ash/src/extensions/khr/display.rs create mode 100755 third_party/rust/ash/src/extensions/khr/display_swapchain.rs create mode 100644 third_party/rust/ash/src/extensions/khr/draw_indirect_count.rs create mode 100644 third_party/rust/ash/src/extensions/khr/dynamic_rendering.rs create mode 100644 third_party/rust/ash/src/extensions/khr/external_fence_fd.rs create mode 100644 third_party/rust/ash/src/extensions/khr/external_fence_win32.rs create mode 100644 third_party/rust/ash/src/extensions/khr/external_memory_fd.rs create mode 100644 third_party/rust/ash/src/extensions/khr/external_memory_win32.rs create mode 100644 third_party/rust/ash/src/extensions/khr/external_semaphore_fd.rs create mode 100644 third_party/rust/ash/src/extensions/khr/external_semaphore_win32.rs create mode 100644 third_party/rust/ash/src/extensions/khr/get_memory_requirements2.rs create mode 100644 third_party/rust/ash/src/extensions/khr/get_physical_device_properties2.rs create mode 100644 third_party/rust/ash/src/extensions/khr/get_surface_capabilities2.rs create mode 100644 third_party/rust/ash/src/extensions/khr/maintenance1.rs create mode 100644 third_party/rust/ash/src/extensions/khr/maintenance3.rs create mode 100644 third_party/rust/ash/src/extensions/khr/maintenance4.rs create mode 100644 third_party/rust/ash/src/extensions/khr/mod.rs create mode 100644 third_party/rust/ash/src/extensions/khr/pipeline_executable_properties.rs create mode 100644 third_party/rust/ash/src/extensions/khr/present_wait.rs create mode 100644 third_party/rust/ash/src/extensions/khr/push_descriptor.rs create mode 100644 third_party/rust/ash/src/extensions/khr/ray_tracing_maintenance1.rs create mode 100644 third_party/rust/ash/src/extensions/khr/ray_tracing_pipeline.rs create mode 100755 third_party/rust/ash/src/extensions/khr/surface.rs create mode 100755 third_party/rust/ash/src/extensions/khr/swapchain.rs create mode 100644 third_party/rust/ash/src/extensions/khr/synchronization2.rs create mode 100644 third_party/rust/ash/src/extensions/khr/timeline_semaphore.rs create mode 100755 third_party/rust/ash/src/extensions/khr/wayland_surface.rs create mode 100755 third_party/rust/ash/src/extensions/khr/win32_surface.rs create mode 100755 third_party/rust/ash/src/extensions/khr/xcb_surface.rs create mode 100755 third_party/rust/ash/src/extensions/khr/xlib_surface.rs create mode 100644 third_party/rust/ash/src/extensions/mod.rs create mode 100755 third_party/rust/ash/src/extensions/mvk/ios_surface.rs create mode 100755 third_party/rust/ash/src/extensions/mvk/macos_surface.rs create mode 100644 third_party/rust/ash/src/extensions/mvk/mod.rs create mode 100644 third_party/rust/ash/src/extensions/nn/mod.rs create mode 100644 third_party/rust/ash/src/extensions/nn/vi_surface.rs create mode 100644 third_party/rust/ash/src/extensions/nv/coverage_reduction_mode.rs create mode 100644 third_party/rust/ash/src/extensions/nv/device_diagnostic_checkpoints.rs create mode 100755 third_party/rust/ash/src/extensions/nv/mesh_shader.rs create mode 100644 third_party/rust/ash/src/extensions/nv/mod.rs create mode 100755 third_party/rust/ash/src/extensions/nv/ray_tracing.rs create mode 100644 third_party/rust/ash/src/instance.rs create mode 100644 third_party/rust/ash/src/lib.rs create mode 100644 third_party/rust/ash/src/prelude.rs create mode 100644 third_party/rust/ash/src/util.rs create mode 100644 third_party/rust/ash/src/vk.rs create mode 100644 third_party/rust/ash/src/vk/aliases.rs create mode 100644 third_party/rust/ash/src/vk/bitflags.rs create mode 100644 third_party/rust/ash/src/vk/const_debugs.rs create mode 100644 third_party/rust/ash/src/vk/constants.rs create mode 100644 third_party/rust/ash/src/vk/definitions.rs create mode 100644 third_party/rust/ash/src/vk/enums.rs create mode 100644 third_party/rust/ash/src/vk/extensions.rs create mode 100644 third_party/rust/ash/src/vk/feature_extensions.rs create mode 100644 third_party/rust/ash/src/vk/features.rs create mode 100644 third_party/rust/ash/src/vk/macros.rs create mode 100644 third_party/rust/ash/src/vk/native.rs create mode 100644 third_party/rust/ash/src/vk/platform_types.rs create mode 100644 third_party/rust/ash/src/vk/prelude.rs (limited to 'third_party/rust/ash/src') diff --git a/third_party/rust/ash/src/device.rs b/third_party/rust/ash/src/device.rs new file mode 100644 index 0000000000..60a91ae155 --- /dev/null +++ b/third_party/rust/ash/src/device.rs @@ -0,0 +1,2707 @@ +#![allow(clippy::trivially_copy_pass_by_ref)] +use crate::prelude::*; +use crate::vk; +use crate::RawPtr; +use std::mem; +use std::os::raw::c_void; +use std::ptr; + +/// +#[derive(Clone)] +pub struct Device { + pub(crate) handle: vk::Device, + + pub(crate) device_fn_1_0: vk::DeviceFnV1_0, + pub(crate) device_fn_1_1: vk::DeviceFnV1_1, + pub(crate) device_fn_1_2: vk::DeviceFnV1_2, + pub(crate) device_fn_1_3: vk::DeviceFnV1_3, +} + +impl Device { + pub unsafe fn load(instance_fn: &vk::InstanceFnV1_0, device: vk::Device) -> Self { + let load_fn = |name: &std::ffi::CStr| { + mem::transmute((instance_fn.get_device_proc_addr)(device, name.as_ptr())) + }; + + Self { + handle: device, + + device_fn_1_0: vk::DeviceFnV1_0::load(load_fn), + device_fn_1_1: vk::DeviceFnV1_1::load(load_fn), + device_fn_1_2: vk::DeviceFnV1_2::load(load_fn), + device_fn_1_3: vk::DeviceFnV1_3::load(load_fn), + } + } + + #[inline] + pub fn handle(&self) -> vk::Device { + self.handle + } +} + +/// Vulkan core 1.3 +#[allow(non_camel_case_types)] +impl Device { + #[inline] + pub fn fp_v1_3(&self) -> &vk::DeviceFnV1_3 { + &self.device_fn_1_3 + } + + /// + #[inline] + pub unsafe fn create_private_data_slot( + &self, + create_info: &vk::PrivateDataSlotCreateInfo, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) -> VkResult { + let mut private_data_slot = mem::zeroed(); + (self.device_fn_1_3.create_private_data_slot)( + self.handle, + create_info, + allocation_callbacks.as_raw_ptr(), + &mut private_data_slot, + ) + .result_with_success(private_data_slot) + } + + /// + #[inline] + pub unsafe fn destroy_private_data_slot( + &self, + private_data_slot: vk::PrivateDataSlot, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) { + (self.device_fn_1_3.destroy_private_data_slot)( + self.handle, + private_data_slot, + allocation_callbacks.as_raw_ptr(), + ) + } + + /// + #[inline] + pub unsafe fn set_private_data( + &self, + object: T, + private_data_slot: vk::PrivateDataSlot, + data: u64, + ) -> VkResult<()> { + (self.device_fn_1_3.set_private_data)( + self.handle, + T::TYPE, + object.as_raw(), + private_data_slot, + data, + ) + .result() + } + + /// + #[inline] + pub unsafe fn get_private_data( + &self, + object: T, + private_data_slot: vk::PrivateDataSlot, + ) -> u64 { + let mut data = mem::zeroed(); + (self.device_fn_1_3.get_private_data)( + self.handle, + T::TYPE, + object.as_raw(), + private_data_slot, + &mut data, + ); + data + } + + /// + #[inline] + pub unsafe fn cmd_pipeline_barrier2( + &self, + command_buffer: vk::CommandBuffer, + dependency_info: &vk::DependencyInfo, + ) { + (self.device_fn_1_3.cmd_pipeline_barrier2)(command_buffer, dependency_info) + } + + /// + #[inline] + pub unsafe fn cmd_reset_event2( + &self, + command_buffer: vk::CommandBuffer, + event: vk::Event, + stage_mask: vk::PipelineStageFlags2, + ) { + (self.device_fn_1_3.cmd_reset_event2)(command_buffer, event, stage_mask) + } + + /// + #[inline] + pub unsafe fn cmd_set_event2( + &self, + command_buffer: vk::CommandBuffer, + event: vk::Event, + dependency_info: &vk::DependencyInfo, + ) { + (self.device_fn_1_3.cmd_set_event2)(command_buffer, event, dependency_info) + } + + /// + #[inline] + pub unsafe fn cmd_wait_events2( + &self, + command_buffer: vk::CommandBuffer, + events: &[vk::Event], + dependency_infos: &[vk::DependencyInfo], + ) { + assert_eq!(events.len(), dependency_infos.len()); + (self.device_fn_1_3.cmd_wait_events2)( + command_buffer, + events.len() as u32, + events.as_ptr(), + dependency_infos.as_ptr(), + ) + } + + /// + #[inline] + pub unsafe fn cmd_write_timestamp2( + &self, + command_buffer: vk::CommandBuffer, + stage: vk::PipelineStageFlags2, + query_pool: vk::QueryPool, + query: u32, + ) { + (self.device_fn_1_3.cmd_write_timestamp2)(command_buffer, stage, query_pool, query) + } + + /// + #[inline] + pub unsafe fn queue_submit2( + &self, + queue: vk::Queue, + submits: &[vk::SubmitInfo2], + fence: vk::Fence, + ) -> VkResult<()> { + (self.device_fn_1_3.queue_submit2)(queue, submits.len() as u32, submits.as_ptr(), fence) + .result() + } + + /// + #[inline] + pub unsafe fn cmd_copy_buffer2( + &self, + command_buffer: vk::CommandBuffer, + copy_buffer_info: &vk::CopyBufferInfo2, + ) { + (self.device_fn_1_3.cmd_copy_buffer2)(command_buffer, copy_buffer_info) + } + /// + #[inline] + pub unsafe fn cmd_copy_image2( + &self, + command_buffer: vk::CommandBuffer, + copy_image_info: &vk::CopyImageInfo2, + ) { + (self.device_fn_1_3.cmd_copy_image2)(command_buffer, copy_image_info) + } + /// + #[inline] + pub unsafe fn cmd_copy_buffer_to_image2( + &self, + command_buffer: vk::CommandBuffer, + copy_buffer_to_image_info: &vk::CopyBufferToImageInfo2, + ) { + (self.device_fn_1_3.cmd_copy_buffer_to_image2)(command_buffer, copy_buffer_to_image_info) + } + /// + #[inline] + pub unsafe fn cmd_copy_image_to_buffer2( + &self, + command_buffer: vk::CommandBuffer, + copy_image_to_buffer_info: &vk::CopyImageToBufferInfo2, + ) { + (self.device_fn_1_3.cmd_copy_image_to_buffer2)(command_buffer, copy_image_to_buffer_info) + } + /// + #[inline] + pub unsafe fn cmd_blit_image2( + &self, + command_buffer: vk::CommandBuffer, + blit_image_info: &vk::BlitImageInfo2, + ) { + (self.device_fn_1_3.cmd_blit_image2)(command_buffer, blit_image_info) + } + /// + #[inline] + pub unsafe fn cmd_resolve_image2( + &self, + command_buffer: vk::CommandBuffer, + resolve_image_info: &vk::ResolveImageInfo2, + ) { + (self.device_fn_1_3.cmd_resolve_image2)(command_buffer, resolve_image_info) + } + + /// + #[inline] + pub unsafe fn cmd_begin_rendering( + &self, + command_buffer: vk::CommandBuffer, + rendering_info: &vk::RenderingInfo, + ) { + (self.device_fn_1_3.cmd_begin_rendering)(command_buffer, rendering_info) + } + + /// + #[inline] + pub unsafe fn cmd_end_rendering(&self, command_buffer: vk::CommandBuffer) { + (self.device_fn_1_3.cmd_end_rendering)(command_buffer) + } + + /// + #[inline] + pub unsafe fn cmd_set_cull_mode( + &self, + command_buffer: vk::CommandBuffer, + cull_mode: vk::CullModeFlags, + ) { + (self.device_fn_1_3.cmd_set_cull_mode)(command_buffer, cull_mode) + } + + /// + #[inline] + pub unsafe fn cmd_set_front_face( + &self, + command_buffer: vk::CommandBuffer, + front_face: vk::FrontFace, + ) { + (self.device_fn_1_3.cmd_set_front_face)(command_buffer, front_face) + } + + /// + #[inline] + pub unsafe fn cmd_set_primitive_topology( + &self, + command_buffer: vk::CommandBuffer, + primitive_topology: vk::PrimitiveTopology, + ) { + (self.device_fn_1_3.cmd_set_primitive_topology)(command_buffer, primitive_topology) + } + + /// + #[inline] + pub unsafe fn cmd_set_viewport_with_count( + &self, + command_buffer: vk::CommandBuffer, + viewports: &[vk::Viewport], + ) { + (self.device_fn_1_3.cmd_set_viewport_with_count)( + command_buffer, + viewports.len() as u32, + viewports.as_ptr(), + ) + } + + /// + #[inline] + pub unsafe fn cmd_set_scissor_with_count( + &self, + command_buffer: vk::CommandBuffer, + scissors: &[vk::Rect2D], + ) { + (self.device_fn_1_3.cmd_set_scissor_with_count)( + command_buffer, + scissors.len() as u32, + scissors.as_ptr(), + ) + } + + /// + #[inline] + pub unsafe fn cmd_bind_vertex_buffers2( + &self, + command_buffer: vk::CommandBuffer, + first_binding: u32, + buffers: &[vk::Buffer], + offsets: &[vk::DeviceSize], + sizes: Option<&[vk::DeviceSize]>, + strides: Option<&[vk::DeviceSize]>, + ) { + assert_eq!(offsets.len(), buffers.len()); + let p_sizes = if let Some(sizes) = sizes { + assert_eq!(sizes.len(), buffers.len()); + sizes.as_ptr() + } else { + ptr::null() + }; + let p_strides = if let Some(strides) = strides { + assert_eq!(strides.len(), buffers.len()); + strides.as_ptr() + } else { + ptr::null() + }; + (self.device_fn_1_3.cmd_bind_vertex_buffers2)( + command_buffer, + first_binding, + buffers.len() as u32, + buffers.as_ptr(), + offsets.as_ptr(), + p_sizes, + p_strides, + ) + } + + /// + #[inline] + pub unsafe fn cmd_set_depth_test_enable( + &self, + command_buffer: vk::CommandBuffer, + depth_test_enable: bool, + ) { + (self.device_fn_1_3.cmd_set_depth_test_enable)(command_buffer, depth_test_enable.into()) + } + + /// + #[inline] + pub unsafe fn cmd_set_depth_write_enable( + &self, + command_buffer: vk::CommandBuffer, + depth_write_enable: bool, + ) { + (self.device_fn_1_3.cmd_set_depth_write_enable)(command_buffer, depth_write_enable.into()) + } + + /// + #[inline] + pub unsafe fn cmd_set_depth_compare_op( + &self, + command_buffer: vk::CommandBuffer, + depth_compare_op: vk::CompareOp, + ) { + (self.device_fn_1_3.cmd_set_depth_compare_op)(command_buffer, depth_compare_op) + } + + /// + #[inline] + pub unsafe fn cmd_set_depth_bounds_test_enable( + &self, + command_buffer: vk::CommandBuffer, + depth_bounds_test_enable: bool, + ) { + (self.device_fn_1_3.cmd_set_depth_bounds_test_enable)( + command_buffer, + depth_bounds_test_enable.into(), + ) + } + + /// + #[inline] + pub unsafe fn cmd_set_stencil_test_enable( + &self, + command_buffer: vk::CommandBuffer, + stencil_test_enable: bool, + ) { + (self.device_fn_1_3.cmd_set_stencil_test_enable)(command_buffer, stencil_test_enable.into()) + } + + /// + #[inline] + pub unsafe fn cmd_set_stencil_op( + &self, + command_buffer: vk::CommandBuffer, + face_mask: vk::StencilFaceFlags, + fail_op: vk::StencilOp, + pass_op: vk::StencilOp, + depth_fail_op: vk::StencilOp, + compare_op: vk::CompareOp, + ) { + (self.device_fn_1_3.cmd_set_stencil_op)( + command_buffer, + face_mask, + fail_op, + pass_op, + depth_fail_op, + compare_op, + ) + } + + /// + #[inline] + pub unsafe fn cmd_set_rasterizer_discard_enable( + &self, + command_buffer: vk::CommandBuffer, + rasterizer_discard_enable: bool, + ) { + (self.device_fn_1_3.cmd_set_rasterizer_discard_enable)( + command_buffer, + rasterizer_discard_enable.into(), + ) + } + + /// + #[inline] + pub unsafe fn cmd_set_depth_bias_enable( + &self, + command_buffer: vk::CommandBuffer, + depth_bias_enable: bool, + ) { + (self.device_fn_1_3.cmd_set_depth_bias_enable)(command_buffer, depth_bias_enable.into()) + } + + /// + #[inline] + pub unsafe fn cmd_set_primitive_restart_enable( + &self, + command_buffer: vk::CommandBuffer, + primitive_restart_enable: bool, + ) { + (self.device_fn_1_3.cmd_set_primitive_restart_enable)( + command_buffer, + primitive_restart_enable.into(), + ) + } + + /// + #[inline] + pub unsafe fn get_device_buffer_memory_requirements( + &self, + create_info: &vk::DeviceBufferMemoryRequirements, + out: &mut vk::MemoryRequirements2, + ) { + (self.device_fn_1_3.get_device_buffer_memory_requirements)(self.handle, create_info, out) + } + + /// + #[inline] + pub unsafe fn get_device_image_memory_requirements( + &self, + create_info: &vk::DeviceImageMemoryRequirements, + out: &mut vk::MemoryRequirements2, + ) { + (self.device_fn_1_3.get_device_image_memory_requirements)(self.handle, create_info, out) + } + + /// Retrieve the number of elements to pass to [`get_device_image_sparse_memory_requirements()`][Self::get_device_image_sparse_memory_requirements()] + #[inline] + pub unsafe fn get_device_image_sparse_memory_requirements_len( + &self, + create_info: &vk::DeviceImageMemoryRequirements, + ) -> usize { + let mut count = 0; + (self + .device_fn_1_3 + .get_device_image_sparse_memory_requirements)( + self.handle, + create_info, + &mut count, + std::ptr::null_mut(), + ); + count as usize + } + + /// + /// + /// Call [`get_device_image_sparse_memory_requirements_len()`][Self::get_device_image_sparse_memory_requirements_len()] to query the number of elements to pass to `out`. + /// Be sure to [`Default::default()`]-initialize these elements and optionally set their `p_next` pointer. + #[inline] + pub unsafe fn get_device_image_sparse_memory_requirements( + &self, + create_info: &vk::DeviceImageMemoryRequirements, + out: &mut [vk::SparseImageMemoryRequirements2], + ) { + let mut count = out.len() as u32; + (self + .device_fn_1_3 + .get_device_image_sparse_memory_requirements)( + self.handle, + create_info, + &mut count, + out.as_mut_ptr(), + ); + assert_eq!(count as usize, out.len()); + } +} + +/// Vulkan core 1.2 +#[allow(non_camel_case_types)] +impl Device { + #[inline] + pub fn fp_v1_2(&self) -> &vk::DeviceFnV1_2 { + &self.device_fn_1_2 + } + + /// + #[inline] + pub unsafe fn cmd_draw_indirect_count( + &self, + command_buffer: vk::CommandBuffer, + buffer: vk::Buffer, + offset: vk::DeviceSize, + count_buffer: vk::Buffer, + count_buffer_offset: vk::DeviceSize, + max_draw_count: u32, + stride: u32, + ) { + (self.device_fn_1_2.cmd_draw_indirect_count)( + command_buffer, + buffer, + offset, + count_buffer, + count_buffer_offset, + max_draw_count, + stride, + ); + } + + /// + #[inline] + pub unsafe fn cmd_draw_indexed_indirect_count( + &self, + command_buffer: vk::CommandBuffer, + buffer: vk::Buffer, + offset: vk::DeviceSize, + count_buffer: vk::Buffer, + count_buffer_offset: vk::DeviceSize, + max_draw_count: u32, + stride: u32, + ) { + (self.device_fn_1_2.cmd_draw_indexed_indirect_count)( + command_buffer, + buffer, + offset, + count_buffer, + count_buffer_offset, + max_draw_count, + stride, + ); + } + + /// + #[inline] + pub unsafe fn create_render_pass2( + &self, + create_info: &vk::RenderPassCreateInfo2, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) -> VkResult { + let mut renderpass = mem::zeroed(); + (self.device_fn_1_2.create_render_pass2)( + self.handle(), + create_info, + allocation_callbacks.as_raw_ptr(), + &mut renderpass, + ) + .result_with_success(renderpass) + } + + /// + #[inline] + pub unsafe fn cmd_begin_render_pass2( + &self, + command_buffer: vk::CommandBuffer, + render_pass_begin_info: &vk::RenderPassBeginInfo, + subpass_begin_info: &vk::SubpassBeginInfo, + ) { + (self.device_fn_1_2.cmd_begin_render_pass2)( + command_buffer, + render_pass_begin_info, + subpass_begin_info, + ); + } + + /// + #[inline] + pub unsafe fn cmd_next_subpass2( + &self, + command_buffer: vk::CommandBuffer, + subpass_begin_info: &vk::SubpassBeginInfo, + subpass_end_info: &vk::SubpassEndInfo, + ) { + (self.device_fn_1_2.cmd_next_subpass2)( + command_buffer, + subpass_begin_info, + subpass_end_info, + ); + } + + /// + #[inline] + pub unsafe fn cmd_end_render_pass2( + &self, + command_buffer: vk::CommandBuffer, + subpass_end_info: &vk::SubpassEndInfo, + ) { + (self.device_fn_1_2.cmd_end_render_pass2)(command_buffer, subpass_end_info); + } + + /// + #[inline] + pub unsafe fn reset_query_pool( + &self, + query_pool: vk::QueryPool, + first_query: u32, + query_count: u32, + ) { + (self.device_fn_1_2.reset_query_pool)(self.handle(), query_pool, first_query, query_count); + } + + /// + #[inline] + pub unsafe fn get_semaphore_counter_value(&self, semaphore: vk::Semaphore) -> VkResult { + let mut value = 0; + (self.device_fn_1_2.get_semaphore_counter_value)(self.handle(), semaphore, &mut value) + .result_with_success(value) + } + + /// + #[inline] + pub unsafe fn wait_semaphores( + &self, + wait_info: &vk::SemaphoreWaitInfo, + timeout: u64, + ) -> VkResult<()> { + (self.device_fn_1_2.wait_semaphores)(self.handle(), wait_info, timeout).result() + } + + /// + #[inline] + pub unsafe fn signal_semaphore(&self, signal_info: &vk::SemaphoreSignalInfo) -> VkResult<()> { + (self.device_fn_1_2.signal_semaphore)(self.handle(), signal_info).result() + } + + /// + #[inline] + pub unsafe fn get_buffer_device_address( + &self, + info: &vk::BufferDeviceAddressInfo, + ) -> vk::DeviceAddress { + (self.device_fn_1_2.get_buffer_device_address)(self.handle(), info) + } + + /// + #[inline] + pub unsafe fn get_buffer_opaque_capture_address( + &self, + info: &vk::BufferDeviceAddressInfo, + ) -> u64 { + (self.device_fn_1_2.get_buffer_opaque_capture_address)(self.handle(), info) + } + + /// + #[inline] + pub unsafe fn get_device_memory_opaque_capture_address( + &self, + info: &vk::DeviceMemoryOpaqueCaptureAddressInfo, + ) -> u64 { + (self.device_fn_1_2.get_device_memory_opaque_capture_address)(self.handle(), info) + } +} + +/// Vulkan core 1.1 +#[allow(non_camel_case_types)] +impl Device { + #[inline] + pub fn fp_v1_1(&self) -> &vk::DeviceFnV1_1 { + &self.device_fn_1_1 + } + + /// + #[inline] + pub unsafe fn bind_buffer_memory2( + &self, + bind_infos: &[vk::BindBufferMemoryInfo], + ) -> VkResult<()> { + (self.device_fn_1_1.bind_buffer_memory2)( + self.handle(), + bind_infos.len() as _, + bind_infos.as_ptr(), + ) + .result() + } + + /// + #[inline] + pub unsafe fn bind_image_memory2( + &self, + bind_infos: &[vk::BindImageMemoryInfo], + ) -> VkResult<()> { + (self.device_fn_1_1.bind_image_memory2)( + self.handle(), + bind_infos.len() as _, + bind_infos.as_ptr(), + ) + .result() + } + + /// + #[inline] + pub unsafe fn get_device_group_peer_memory_features( + &self, + heap_index: u32, + local_device_index: u32, + remote_device_index: u32, + ) -> vk::PeerMemoryFeatureFlags { + let mut peer_memory_features = mem::zeroed(); + (self.device_fn_1_1.get_device_group_peer_memory_features)( + self.handle(), + heap_index, + local_device_index, + remote_device_index, + &mut peer_memory_features, + ); + peer_memory_features + } + + /// + #[inline] + pub unsafe fn cmd_set_device_mask(&self, command_buffer: vk::CommandBuffer, device_mask: u32) { + (self.device_fn_1_1.cmd_set_device_mask)(command_buffer, device_mask); + } + + /// + #[inline] + pub unsafe fn cmd_dispatch_base( + &self, + command_buffer: vk::CommandBuffer, + base_group_x: u32, + base_group_y: u32, + base_group_z: u32, + group_count_x: u32, + group_count_y: u32, + group_count_z: u32, + ) { + (self.device_fn_1_1.cmd_dispatch_base)( + command_buffer, + base_group_x, + base_group_y, + base_group_z, + group_count_x, + group_count_y, + group_count_z, + ); + } + + /// + #[inline] + pub unsafe fn get_image_memory_requirements2( + &self, + info: &vk::ImageMemoryRequirementsInfo2, + out: &mut vk::MemoryRequirements2, + ) { + (self.device_fn_1_1.get_image_memory_requirements2)(self.handle(), info, out); + } + + /// + #[inline] + pub unsafe fn get_buffer_memory_requirements2( + &self, + info: &vk::BufferMemoryRequirementsInfo2, + out: &mut vk::MemoryRequirements2, + ) { + (self.device_fn_1_1.get_buffer_memory_requirements2)(self.handle(), info, out); + } + + /// Retrieve the number of elements to pass to [`get_image_sparse_memory_requirements2()`][Self::get_image_sparse_memory_requirements2()] + #[inline] + pub unsafe fn get_image_sparse_memory_requirements2_len( + &self, + info: &vk::ImageSparseMemoryRequirementsInfo2, + ) -> usize { + let mut count = 0; + (self.device_fn_1_1.get_image_sparse_memory_requirements2)( + self.handle(), + info, + &mut count, + ptr::null_mut(), + ); + count as usize + } + + /// + /// + /// Call [`get_image_sparse_memory_requirements2_len()`][Self::get_image_sparse_memory_requirements2_len()] to query the number of elements to pass to `out`. + /// Be sure to [`Default::default()`]-initialize these elements and optionally set their `p_next` pointer. + #[inline] + pub unsafe fn get_image_sparse_memory_requirements2( + &self, + info: &vk::ImageSparseMemoryRequirementsInfo2, + out: &mut [vk::SparseImageMemoryRequirements2], + ) { + let mut count = out.len() as u32; + (self.device_fn_1_1.get_image_sparse_memory_requirements2)( + self.handle(), + info, + &mut count, + out.as_mut_ptr(), + ); + assert_eq!(count as usize, out.len()); + } + + /// + #[inline] + pub unsafe fn trim_command_pool( + &self, + command_pool: vk::CommandPool, + flags: vk::CommandPoolTrimFlags, + ) { + (self.device_fn_1_1.trim_command_pool)(self.handle(), command_pool, flags); + } + + /// + #[inline] + pub unsafe fn create_sampler_ycbcr_conversion( + &self, + create_info: &vk::SamplerYcbcrConversionCreateInfo, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) -> VkResult { + let mut ycbcr_conversion = mem::zeroed(); + (self.device_fn_1_1.create_sampler_ycbcr_conversion)( + self.handle(), + create_info, + allocation_callbacks.as_raw_ptr(), + &mut ycbcr_conversion, + ) + .result_with_success(ycbcr_conversion) + } + + /// + #[inline] + pub unsafe fn destroy_sampler_ycbcr_conversion( + &self, + ycbcr_conversion: vk::SamplerYcbcrConversion, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) { + (self.device_fn_1_1.destroy_sampler_ycbcr_conversion)( + self.handle(), + ycbcr_conversion, + allocation_callbacks.as_raw_ptr(), + ); + } + + /// + #[inline] + pub unsafe fn create_descriptor_update_template( + &self, + create_info: &vk::DescriptorUpdateTemplateCreateInfo, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) -> VkResult { + let mut descriptor_update_template = mem::zeroed(); + (self.device_fn_1_1.create_descriptor_update_template)( + self.handle(), + create_info, + allocation_callbacks.as_raw_ptr(), + &mut descriptor_update_template, + ) + .result_with_success(descriptor_update_template) + } + + /// + #[inline] + pub unsafe fn destroy_descriptor_update_template( + &self, + descriptor_update_template: vk::DescriptorUpdateTemplate, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) { + (self.device_fn_1_1.destroy_descriptor_update_template)( + self.handle(), + descriptor_update_template, + allocation_callbacks.as_raw_ptr(), + ); + } + + /// + #[inline] + pub unsafe fn update_descriptor_set_with_template( + &self, + descriptor_set: vk::DescriptorSet, + descriptor_update_template: vk::DescriptorUpdateTemplate, + data: *const c_void, + ) { + (self.device_fn_1_1.update_descriptor_set_with_template)( + self.handle(), + descriptor_set, + descriptor_update_template, + data, + ); + } + + /// + #[inline] + pub unsafe fn get_descriptor_set_layout_support( + &self, + create_info: &vk::DescriptorSetLayoutCreateInfo, + out: &mut vk::DescriptorSetLayoutSupport, + ) { + (self.device_fn_1_1.get_descriptor_set_layout_support)(self.handle(), create_info, out); + } +} + +/// Vulkan core 1.0 +#[allow(non_camel_case_types)] +impl Device { + #[inline] + pub fn fp_v1_0(&self) -> &vk::DeviceFnV1_0 { + &self.device_fn_1_0 + } + + /// + #[inline] + pub unsafe fn destroy_device(&self, allocation_callbacks: Option<&vk::AllocationCallbacks>) { + (self.device_fn_1_0.destroy_device)(self.handle(), allocation_callbacks.as_raw_ptr()); + } + + /// + #[inline] + pub unsafe fn destroy_sampler( + &self, + sampler: vk::Sampler, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) { + (self.device_fn_1_0.destroy_sampler)( + self.handle(), + sampler, + allocation_callbacks.as_raw_ptr(), + ); + } + + /// + #[inline] + pub unsafe fn free_memory( + &self, + memory: vk::DeviceMemory, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) { + (self.device_fn_1_0.free_memory)(self.handle(), memory, allocation_callbacks.as_raw_ptr()); + } + + /// + #[inline] + pub unsafe fn free_command_buffers( + &self, + command_pool: vk::CommandPool, + command_buffers: &[vk::CommandBuffer], + ) { + (self.device_fn_1_0.free_command_buffers)( + self.handle(), + command_pool, + command_buffers.len() as u32, + command_buffers.as_ptr(), + ); + } + + /// + #[inline] + pub unsafe fn create_event( + &self, + create_info: &vk::EventCreateInfo, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) -> VkResult { + let mut event = mem::zeroed(); + (self.device_fn_1_0.create_event)( + self.handle(), + create_info, + allocation_callbacks.as_raw_ptr(), + &mut event, + ) + .result_with_success(event) + } + + /// Returns [`true`] if the event was set, and [`false`] if the event was reset, otherwise it will + /// return the error code. + /// + #[inline] + pub unsafe fn get_event_status(&self, event: vk::Event) -> VkResult { + let err_code = (self.device_fn_1_0.get_event_status)(self.handle(), event); + match err_code { + vk::Result::EVENT_SET => Ok(true), + vk::Result::EVENT_RESET => Ok(false), + _ => Err(err_code), + } + } + + /// + #[inline] + pub unsafe fn set_event(&self, event: vk::Event) -> VkResult<()> { + (self.device_fn_1_0.set_event)(self.handle(), event).result() + } + + /// + #[inline] + pub unsafe fn reset_event(&self, event: vk::Event) -> VkResult<()> { + (self.device_fn_1_0.reset_event)(self.handle(), event).result() + } + /// + #[inline] + pub unsafe fn cmd_set_event( + &self, + command_buffer: vk::CommandBuffer, + event: vk::Event, + stage_mask: vk::PipelineStageFlags, + ) { + (self.device_fn_1_0.cmd_set_event)(command_buffer, event, stage_mask); + } + /// + #[inline] + pub unsafe fn cmd_reset_event( + &self, + command_buffer: vk::CommandBuffer, + event: vk::Event, + stage_mask: vk::PipelineStageFlags, + ) { + (self.device_fn_1_0.cmd_reset_event)(command_buffer, event, stage_mask); + } + + /// + #[inline] + pub unsafe fn cmd_wait_events( + &self, + command_buffer: vk::CommandBuffer, + events: &[vk::Event], + src_stage_mask: vk::PipelineStageFlags, + dst_stage_mask: vk::PipelineStageFlags, + memory_barriers: &[vk::MemoryBarrier], + buffer_memory_barriers: &[vk::BufferMemoryBarrier], + image_memory_barriers: &[vk::ImageMemoryBarrier], + ) { + (self.device_fn_1_0.cmd_wait_events)( + command_buffer, + events.len() as _, + events.as_ptr(), + src_stage_mask, + dst_stage_mask, + memory_barriers.len() as _, + memory_barriers.as_ptr(), + buffer_memory_barriers.len() as _, + buffer_memory_barriers.as_ptr(), + image_memory_barriers.len() as _, + image_memory_barriers.as_ptr(), + ); + } + + /// + #[inline] + pub unsafe fn destroy_fence( + &self, + fence: vk::Fence, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) { + (self.device_fn_1_0.destroy_fence)(self.handle(), fence, allocation_callbacks.as_raw_ptr()); + } + + /// + #[inline] + pub unsafe fn destroy_event( + &self, + event: vk::Event, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) { + (self.device_fn_1_0.destroy_event)(self.handle(), event, allocation_callbacks.as_raw_ptr()); + } + + /// + #[inline] + pub unsafe fn destroy_image( + &self, + image: vk::Image, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) { + (self.device_fn_1_0.destroy_image)(self.handle(), image, allocation_callbacks.as_raw_ptr()); + } + + /// + #[inline] + pub unsafe fn destroy_command_pool( + &self, + pool: vk::CommandPool, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) { + (self.device_fn_1_0.destroy_command_pool)( + self.handle(), + pool, + allocation_callbacks.as_raw_ptr(), + ); + } + + /// + #[inline] + pub unsafe fn destroy_image_view( + &self, + image_view: vk::ImageView, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) { + (self.device_fn_1_0.destroy_image_view)( + self.handle(), + image_view, + allocation_callbacks.as_raw_ptr(), + ); + } + + /// + #[inline] + pub unsafe fn destroy_render_pass( + &self, + renderpass: vk::RenderPass, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) { + (self.device_fn_1_0.destroy_render_pass)( + self.handle(), + renderpass, + allocation_callbacks.as_raw_ptr(), + ); + } + + /// + #[inline] + pub unsafe fn destroy_framebuffer( + &self, + framebuffer: vk::Framebuffer, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) { + (self.device_fn_1_0.destroy_framebuffer)( + self.handle(), + framebuffer, + allocation_callbacks.as_raw_ptr(), + ); + } + + /// + #[inline] + pub unsafe fn destroy_pipeline_layout( + &self, + pipeline_layout: vk::PipelineLayout, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) { + (self.device_fn_1_0.destroy_pipeline_layout)( + self.handle(), + pipeline_layout, + allocation_callbacks.as_raw_ptr(), + ); + } + + /// + #[inline] + pub unsafe fn destroy_pipeline_cache( + &self, + pipeline_cache: vk::PipelineCache, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) { + (self.device_fn_1_0.destroy_pipeline_cache)( + self.handle(), + pipeline_cache, + allocation_callbacks.as_raw_ptr(), + ); + } + + /// + #[inline] + pub unsafe fn destroy_buffer( + &self, + buffer: vk::Buffer, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) { + (self.device_fn_1_0.destroy_buffer)( + self.handle(), + buffer, + allocation_callbacks.as_raw_ptr(), + ); + } + + /// + #[inline] + pub unsafe fn destroy_shader_module( + &self, + shader: vk::ShaderModule, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) { + (self.device_fn_1_0.destroy_shader_module)( + self.handle(), + shader, + allocation_callbacks.as_raw_ptr(), + ); + } + + /// + #[inline] + pub unsafe fn destroy_pipeline( + &self, + pipeline: vk::Pipeline, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) { + (self.device_fn_1_0.destroy_pipeline)( + self.handle(), + pipeline, + allocation_callbacks.as_raw_ptr(), + ); + } + + /// + #[inline] + pub unsafe fn destroy_semaphore( + &self, + semaphore: vk::Semaphore, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) { + (self.device_fn_1_0.destroy_semaphore)( + self.handle(), + semaphore, + allocation_callbacks.as_raw_ptr(), + ); + } + + /// + #[inline] + pub unsafe fn destroy_descriptor_pool( + &self, + pool: vk::DescriptorPool, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) { + (self.device_fn_1_0.destroy_descriptor_pool)( + self.handle(), + pool, + allocation_callbacks.as_raw_ptr(), + ); + } + + /// + #[inline] + pub unsafe fn destroy_query_pool( + &self, + pool: vk::QueryPool, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) { + (self.device_fn_1_0.destroy_query_pool)( + self.handle(), + pool, + allocation_callbacks.as_raw_ptr(), + ); + } + + /// + #[inline] + pub unsafe fn destroy_descriptor_set_layout( + &self, + layout: vk::DescriptorSetLayout, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) { + (self.device_fn_1_0.destroy_descriptor_set_layout)( + self.handle(), + layout, + allocation_callbacks.as_raw_ptr(), + ); + } + + /// + #[inline] + pub unsafe fn free_descriptor_sets( + &self, + pool: vk::DescriptorPool, + descriptor_sets: &[vk::DescriptorSet], + ) -> VkResult<()> { + (self.device_fn_1_0.free_descriptor_sets)( + self.handle(), + pool, + descriptor_sets.len() as u32, + descriptor_sets.as_ptr(), + ) + .result() + } + + /// + #[inline] + pub unsafe fn update_descriptor_sets( + &self, + descriptor_writes: &[vk::WriteDescriptorSet], + descriptor_copies: &[vk::CopyDescriptorSet], + ) { + (self.device_fn_1_0.update_descriptor_sets)( + self.handle(), + descriptor_writes.len() as u32, + descriptor_writes.as_ptr(), + descriptor_copies.len() as u32, + descriptor_copies.as_ptr(), + ); + } + + /// + #[inline] + pub unsafe fn create_sampler( + &self, + create_info: &vk::SamplerCreateInfo, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) -> VkResult { + let mut sampler = mem::zeroed(); + (self.device_fn_1_0.create_sampler)( + self.handle(), + create_info, + allocation_callbacks.as_raw_ptr(), + &mut sampler, + ) + .result_with_success(sampler) + } + + /// + #[inline] + pub unsafe fn cmd_blit_image( + &self, + command_buffer: vk::CommandBuffer, + src_image: vk::Image, + src_image_layout: vk::ImageLayout, + dst_image: vk::Image, + dst_image_layout: vk::ImageLayout, + regions: &[vk::ImageBlit], + filter: vk::Filter, + ) { + (self.device_fn_1_0.cmd_blit_image)( + command_buffer, + src_image, + src_image_layout, + dst_image, + dst_image_layout, + regions.len() as _, + regions.as_ptr(), + filter, + ); + } + + /// + #[inline] + pub unsafe fn cmd_resolve_image( + &self, + command_buffer: vk::CommandBuffer, + src_image: vk::Image, + src_image_layout: vk::ImageLayout, + dst_image: vk::Image, + dst_image_layout: vk::ImageLayout, + regions: &[vk::ImageResolve], + ) { + (self.device_fn_1_0.cmd_resolve_image)( + command_buffer, + src_image, + src_image_layout, + dst_image, + dst_image_layout, + regions.len() as u32, + regions.as_ptr(), + ); + } + + /// + #[inline] + pub unsafe fn cmd_fill_buffer( + &self, + command_buffer: vk::CommandBuffer, + buffer: vk::Buffer, + offset: vk::DeviceSize, + size: vk::DeviceSize, + data: u32, + ) { + (self.device_fn_1_0.cmd_fill_buffer)(command_buffer, buffer, offset, size, data); + } + + /// + #[inline] + pub unsafe fn cmd_update_buffer( + &self, + command_buffer: vk::CommandBuffer, + buffer: vk::Buffer, + offset: vk::DeviceSize, + data: &[u8], + ) { + (self.device_fn_1_0.cmd_update_buffer)( + command_buffer, + buffer, + offset, + data.len() as u64, + data.as_ptr() as _, + ); + } + + /// + #[inline] + pub unsafe fn cmd_copy_buffer( + &self, + command_buffer: vk::CommandBuffer, + src_buffer: vk::Buffer, + dst_buffer: vk::Buffer, + regions: &[vk::BufferCopy], + ) { + (self.device_fn_1_0.cmd_copy_buffer)( + command_buffer, + src_buffer, + dst_buffer, + regions.len() as u32, + regions.as_ptr(), + ); + } + + /// + #[inline] + pub unsafe fn cmd_copy_image_to_buffer( + &self, + command_buffer: vk::CommandBuffer, + src_image: vk::Image, + src_image_layout: vk::ImageLayout, + dst_buffer: vk::Buffer, + regions: &[vk::BufferImageCopy], + ) { + (self.device_fn_1_0.cmd_copy_image_to_buffer)( + command_buffer, + src_image, + src_image_layout, + dst_buffer, + regions.len() as u32, + regions.as_ptr(), + ); + } + + /// + #[inline] + pub unsafe fn cmd_copy_buffer_to_image( + &self, + command_buffer: vk::CommandBuffer, + src_buffer: vk::Buffer, + dst_image: vk::Image, + dst_image_layout: vk::ImageLayout, + regions: &[vk::BufferImageCopy], + ) { + (self.device_fn_1_0.cmd_copy_buffer_to_image)( + command_buffer, + src_buffer, + dst_image, + dst_image_layout, + regions.len() as u32, + regions.as_ptr(), + ); + } + + /// + #[inline] + pub unsafe fn cmd_copy_image( + &self, + command_buffer: vk::CommandBuffer, + src_image: vk::Image, + src_image_layout: vk::ImageLayout, + dst_image: vk::Image, + dst_image_layout: vk::ImageLayout, + regions: &[vk::ImageCopy], + ) { + (self.device_fn_1_0.cmd_copy_image)( + command_buffer, + src_image, + src_image_layout, + dst_image, + dst_image_layout, + regions.len() as u32, + regions.as_ptr(), + ); + } + + /// + #[inline] + pub unsafe fn allocate_descriptor_sets( + &self, + create_info: &vk::DescriptorSetAllocateInfo, + ) -> VkResult> { + let mut desc_set = Vec::with_capacity(create_info.descriptor_set_count as usize); + (self.device_fn_1_0.allocate_descriptor_sets)( + self.handle(), + create_info, + desc_set.as_mut_ptr(), + ) + .result()?; + + desc_set.set_len(create_info.descriptor_set_count as usize); + Ok(desc_set) + } + + /// + #[inline] + pub unsafe fn create_descriptor_set_layout( + &self, + create_info: &vk::DescriptorSetLayoutCreateInfo, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) -> VkResult { + let mut layout = mem::zeroed(); + (self.device_fn_1_0.create_descriptor_set_layout)( + self.handle(), + create_info, + allocation_callbacks.as_raw_ptr(), + &mut layout, + ) + .result_with_success(layout) + } + + /// + #[inline] + pub unsafe fn device_wait_idle(&self) -> VkResult<()> { + (self.device_fn_1_0.device_wait_idle)(self.handle()).result() + } + + /// + #[inline] + pub unsafe fn create_descriptor_pool( + &self, + create_info: &vk::DescriptorPoolCreateInfo, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) -> VkResult { + let mut pool = mem::zeroed(); + (self.device_fn_1_0.create_descriptor_pool)( + self.handle(), + create_info, + allocation_callbacks.as_raw_ptr(), + &mut pool, + ) + .result_with_success(pool) + } + + /// + #[inline] + pub unsafe fn reset_descriptor_pool( + &self, + pool: vk::DescriptorPool, + flags: vk::DescriptorPoolResetFlags, + ) -> VkResult<()> { + (self.device_fn_1_0.reset_descriptor_pool)(self.handle(), pool, flags).result() + } + + /// + #[inline] + pub unsafe fn reset_command_pool( + &self, + command_pool: vk::CommandPool, + flags: vk::CommandPoolResetFlags, + ) -> VkResult<()> { + (self.device_fn_1_0.reset_command_pool)(self.handle(), command_pool, flags).result() + } + + /// + #[inline] + pub unsafe fn reset_command_buffer( + &self, + command_buffer: vk::CommandBuffer, + flags: vk::CommandBufferResetFlags, + ) -> VkResult<()> { + (self.device_fn_1_0.reset_command_buffer)(command_buffer, flags).result() + } + + /// + #[inline] + pub unsafe fn reset_fences(&self, fences: &[vk::Fence]) -> VkResult<()> { + (self.device_fn_1_0.reset_fences)(self.handle(), fences.len() as u32, fences.as_ptr()) + .result() + } + + /// + #[inline] + pub unsafe fn cmd_bind_index_buffer( + &self, + command_buffer: vk::CommandBuffer, + buffer: vk::Buffer, + offset: vk::DeviceSize, + index_type: vk::IndexType, + ) { + (self.device_fn_1_0.cmd_bind_index_buffer)(command_buffer, buffer, offset, index_type); + } + + /// + #[inline] + pub unsafe fn cmd_clear_color_image( + &self, + command_buffer: vk::CommandBuffer, + image: vk::Image, + image_layout: vk::ImageLayout, + clear_color_value: &vk::ClearColorValue, + ranges: &[vk::ImageSubresourceRange], + ) { + (self.device_fn_1_0.cmd_clear_color_image)( + command_buffer, + image, + image_layout, + clear_color_value, + ranges.len() as u32, + ranges.as_ptr(), + ); + } + + /// + #[inline] + pub unsafe fn cmd_clear_depth_stencil_image( + &self, + command_buffer: vk::CommandBuffer, + image: vk::Image, + image_layout: vk::ImageLayout, + clear_depth_stencil_value: &vk::ClearDepthStencilValue, + ranges: &[vk::ImageSubresourceRange], + ) { + (self.device_fn_1_0.cmd_clear_depth_stencil_image)( + command_buffer, + image, + image_layout, + clear_depth_stencil_value, + ranges.len() as u32, + ranges.as_ptr(), + ); + } + + /// + #[inline] + pub unsafe fn cmd_clear_attachments( + &self, + command_buffer: vk::CommandBuffer, + attachments: &[vk::ClearAttachment], + rects: &[vk::ClearRect], + ) { + (self.device_fn_1_0.cmd_clear_attachments)( + command_buffer, + attachments.len() as u32, + attachments.as_ptr(), + rects.len() as u32, + rects.as_ptr(), + ); + } + + /// + #[inline] + pub unsafe fn cmd_draw_indexed( + &self, + command_buffer: vk::CommandBuffer, + index_count: u32, + instance_count: u32, + first_index: u32, + vertex_offset: i32, + first_instance: u32, + ) { + (self.device_fn_1_0.cmd_draw_indexed)( + command_buffer, + index_count, + instance_count, + first_index, + vertex_offset, + first_instance, + ); + } + + /// + #[inline] + pub unsafe fn cmd_draw_indexed_indirect( + &self, + command_buffer: vk::CommandBuffer, + buffer: vk::Buffer, + offset: vk::DeviceSize, + draw_count: u32, + stride: u32, + ) { + (self.device_fn_1_0.cmd_draw_indexed_indirect)( + command_buffer, + buffer, + offset, + draw_count, + stride, + ); + } + + /// + #[inline] + pub unsafe fn cmd_execute_commands( + &self, + primary_command_buffer: vk::CommandBuffer, + secondary_command_buffers: &[vk::CommandBuffer], + ) { + (self.device_fn_1_0.cmd_execute_commands)( + primary_command_buffer, + secondary_command_buffers.len() as u32, + secondary_command_buffers.as_ptr(), + ); + } + + /// + #[inline] + pub unsafe fn cmd_bind_descriptor_sets( + &self, + command_buffer: vk::CommandBuffer, + pipeline_bind_point: vk::PipelineBindPoint, + layout: vk::PipelineLayout, + first_set: u32, + descriptor_sets: &[vk::DescriptorSet], + dynamic_offsets: &[u32], + ) { + (self.device_fn_1_0.cmd_bind_descriptor_sets)( + command_buffer, + pipeline_bind_point, + layout, + first_set, + descriptor_sets.len() as u32, + descriptor_sets.as_ptr(), + dynamic_offsets.len() as u32, + dynamic_offsets.as_ptr(), + ); + } + + /// + #[inline] + pub unsafe fn cmd_copy_query_pool_results( + &self, + command_buffer: vk::CommandBuffer, + query_pool: vk::QueryPool, + first_query: u32, + query_count: u32, + dst_buffer: vk::Buffer, + dst_offset: vk::DeviceSize, + stride: vk::DeviceSize, + flags: vk::QueryResultFlags, + ) { + (self.device_fn_1_0.cmd_copy_query_pool_results)( + command_buffer, + query_pool, + first_query, + query_count, + dst_buffer, + dst_offset, + stride, + flags, + ); + } + + /// + #[inline] + pub unsafe fn cmd_push_constants( + &self, + command_buffer: vk::CommandBuffer, + layout: vk::PipelineLayout, + stage_flags: vk::ShaderStageFlags, + offset: u32, + constants: &[u8], + ) { + (self.device_fn_1_0.cmd_push_constants)( + command_buffer, + layout, + stage_flags, + offset, + constants.len() as _, + constants.as_ptr() as _, + ); + } + + /// + #[inline] + pub unsafe fn cmd_begin_render_pass( + &self, + command_buffer: vk::CommandBuffer, + create_info: &vk::RenderPassBeginInfo, + contents: vk::SubpassContents, + ) { + (self.device_fn_1_0.cmd_begin_render_pass)(command_buffer, create_info, contents); + } + + /// + #[inline] + pub unsafe fn cmd_next_subpass( + &self, + command_buffer: vk::CommandBuffer, + contents: vk::SubpassContents, + ) { + (self.device_fn_1_0.cmd_next_subpass)(command_buffer, contents); + } + + /// + #[inline] + pub unsafe fn cmd_bind_pipeline( + &self, + command_buffer: vk::CommandBuffer, + pipeline_bind_point: vk::PipelineBindPoint, + pipeline: vk::Pipeline, + ) { + (self.device_fn_1_0.cmd_bind_pipeline)(command_buffer, pipeline_bind_point, pipeline); + } + + /// + #[inline] + pub unsafe fn cmd_set_scissor( + &self, + command_buffer: vk::CommandBuffer, + first_scissor: u32, + scissors: &[vk::Rect2D], + ) { + (self.device_fn_1_0.cmd_set_scissor)( + command_buffer, + first_scissor, + scissors.len() as u32, + scissors.as_ptr(), + ); + } + + /// + #[inline] + pub unsafe fn cmd_set_line_width(&self, command_buffer: vk::CommandBuffer, line_width: f32) { + (self.device_fn_1_0.cmd_set_line_width)(command_buffer, line_width); + } + + /// + #[inline] + pub unsafe fn cmd_bind_vertex_buffers( + &self, + command_buffer: vk::CommandBuffer, + first_binding: u32, + buffers: &[vk::Buffer], + offsets: &[vk::DeviceSize], + ) { + debug_assert_eq!(buffers.len(), offsets.len()); + (self.device_fn_1_0.cmd_bind_vertex_buffers)( + command_buffer, + first_binding, + buffers.len() as u32, + buffers.as_ptr(), + offsets.as_ptr(), + ); + } + + /// + #[inline] + pub unsafe fn cmd_end_render_pass(&self, command_buffer: vk::CommandBuffer) { + (self.device_fn_1_0.cmd_end_render_pass)(command_buffer); + } + + /// + #[inline] + pub unsafe fn cmd_draw( + &self, + command_buffer: vk::CommandBuffer, + vertex_count: u32, + instance_count: u32, + first_vertex: u32, + first_instance: u32, + ) { + (self.device_fn_1_0.cmd_draw)( + command_buffer, + vertex_count, + instance_count, + first_vertex, + first_instance, + ); + } + + /// + #[inline] + pub unsafe fn cmd_draw_indirect( + &self, + command_buffer: vk::CommandBuffer, + buffer: vk::Buffer, + offset: vk::DeviceSize, + draw_count: u32, + stride: u32, + ) { + (self.device_fn_1_0.cmd_draw_indirect)(command_buffer, buffer, offset, draw_count, stride); + } + + /// + #[inline] + pub unsafe fn cmd_dispatch( + &self, + command_buffer: vk::CommandBuffer, + group_count_x: u32, + group_count_y: u32, + group_count_z: u32, + ) { + (self.device_fn_1_0.cmd_dispatch)( + command_buffer, + group_count_x, + group_count_y, + group_count_z, + ); + } + + /// + #[inline] + pub unsafe fn cmd_dispatch_indirect( + &self, + command_buffer: vk::CommandBuffer, + buffer: vk::Buffer, + offset: vk::DeviceSize, + ) { + (self.device_fn_1_0.cmd_dispatch_indirect)(command_buffer, buffer, offset); + } + + /// + #[inline] + pub unsafe fn cmd_set_viewport( + &self, + command_buffer: vk::CommandBuffer, + first_viewport: u32, + viewports: &[vk::Viewport], + ) { + (self.device_fn_1_0.cmd_set_viewport)( + command_buffer, + first_viewport, + viewports.len() as u32, + viewports.as_ptr(), + ); + } + + /// + #[inline] + pub unsafe fn cmd_set_depth_bias( + &self, + command_buffer: vk::CommandBuffer, + constant_factor: f32, + clamp: f32, + slope_factor: f32, + ) { + (self.device_fn_1_0.cmd_set_depth_bias)( + command_buffer, + constant_factor, + clamp, + slope_factor, + ); + } + + /// + #[inline] + pub unsafe fn cmd_set_blend_constants( + &self, + command_buffer: vk::CommandBuffer, + blend_constants: &[f32; 4], + ) { + (self.device_fn_1_0.cmd_set_blend_constants)(command_buffer, blend_constants); + } + + /// + #[inline] + pub unsafe fn cmd_set_depth_bounds( + &self, + command_buffer: vk::CommandBuffer, + min_depth_bounds: f32, + max_depth_bounds: f32, + ) { + (self.device_fn_1_0.cmd_set_depth_bounds)( + command_buffer, + min_depth_bounds, + max_depth_bounds, + ); + } + + /// + #[inline] + pub unsafe fn cmd_set_stencil_compare_mask( + &self, + command_buffer: vk::CommandBuffer, + face_mask: vk::StencilFaceFlags, + compare_mask: u32, + ) { + (self.device_fn_1_0.cmd_set_stencil_compare_mask)(command_buffer, face_mask, compare_mask); + } + + /// + #[inline] + pub unsafe fn cmd_set_stencil_write_mask( + &self, + command_buffer: vk::CommandBuffer, + face_mask: vk::StencilFaceFlags, + write_mask: u32, + ) { + (self.device_fn_1_0.cmd_set_stencil_write_mask)(command_buffer, face_mask, write_mask); + } + + /// + #[inline] + pub unsafe fn cmd_set_stencil_reference( + &self, + command_buffer: vk::CommandBuffer, + face_mask: vk::StencilFaceFlags, + reference: u32, + ) { + (self.device_fn_1_0.cmd_set_stencil_reference)(command_buffer, face_mask, reference); + } + + /// + #[inline] + pub unsafe fn get_query_pool_results( + &self, + query_pool: vk::QueryPool, + first_query: u32, + query_count: u32, + data: &mut [T], + flags: vk::QueryResultFlags, + ) -> VkResult<()> { + let data_length = query_count as usize; + assert!( + data_length <= data.len(), + "query_count was higher than the length of the slice" + ); + let data_size = mem::size_of::() * data_length; + (self.device_fn_1_0.get_query_pool_results)( + self.handle(), + query_pool, + first_query, + query_count, + data_size, + data.as_mut_ptr().cast(), + mem::size_of::() as _, + flags, + ) + .result() + } + + /// + #[inline] + pub unsafe fn cmd_begin_query( + &self, + command_buffer: vk::CommandBuffer, + query_pool: vk::QueryPool, + query: u32, + flags: vk::QueryControlFlags, + ) { + (self.device_fn_1_0.cmd_begin_query)(command_buffer, query_pool, query, flags); + } + + /// + #[inline] + pub unsafe fn cmd_end_query( + &self, + command_buffer: vk::CommandBuffer, + query_pool: vk::QueryPool, + query: u32, + ) { + (self.device_fn_1_0.cmd_end_query)(command_buffer, query_pool, query); + } + + /// + #[inline] + pub unsafe fn cmd_reset_query_pool( + &self, + command_buffer: vk::CommandBuffer, + pool: vk::QueryPool, + first_query: u32, + query_count: u32, + ) { + (self.device_fn_1_0.cmd_reset_query_pool)(command_buffer, pool, first_query, query_count); + } + + /// + #[inline] + pub unsafe fn cmd_write_timestamp( + &self, + command_buffer: vk::CommandBuffer, + pipeline_stage: vk::PipelineStageFlags, + query_pool: vk::QueryPool, + query: u32, + ) { + (self.device_fn_1_0.cmd_write_timestamp)(command_buffer, pipeline_stage, query_pool, query); + } + + /// + #[inline] + pub unsafe fn create_semaphore( + &self, + create_info: &vk::SemaphoreCreateInfo, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) -> VkResult { + let mut semaphore = mem::zeroed(); + (self.device_fn_1_0.create_semaphore)( + self.handle(), + create_info, + allocation_callbacks.as_raw_ptr(), + &mut semaphore, + ) + .result_with_success(semaphore) + } + + /// + #[inline] + pub unsafe fn create_graphics_pipelines( + &self, + pipeline_cache: vk::PipelineCache, + create_infos: &[vk::GraphicsPipelineCreateInfo], + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) -> Result, (Vec, vk::Result)> { + let mut pipelines = Vec::with_capacity(create_infos.len()); + let err_code = (self.device_fn_1_0.create_graphics_pipelines)( + self.handle(), + pipeline_cache, + create_infos.len() as u32, + create_infos.as_ptr(), + allocation_callbacks.as_raw_ptr(), + pipelines.as_mut_ptr(), + ); + pipelines.set_len(create_infos.len()); + match err_code { + vk::Result::SUCCESS => Ok(pipelines), + _ => Err((pipelines, err_code)), + } + } + + /// + #[inline] + pub unsafe fn create_compute_pipelines( + &self, + pipeline_cache: vk::PipelineCache, + create_infos: &[vk::ComputePipelineCreateInfo], + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) -> Result, (Vec, vk::Result)> { + let mut pipelines = Vec::with_capacity(create_infos.len()); + let err_code = (self.device_fn_1_0.create_compute_pipelines)( + self.handle(), + pipeline_cache, + create_infos.len() as u32, + create_infos.as_ptr(), + allocation_callbacks.as_raw_ptr(), + pipelines.as_mut_ptr(), + ); + pipelines.set_len(create_infos.len()); + match err_code { + vk::Result::SUCCESS => Ok(pipelines), + _ => Err((pipelines, err_code)), + } + } + + /// + #[inline] + pub unsafe fn create_buffer( + &self, + create_info: &vk::BufferCreateInfo, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) -> VkResult { + let mut buffer = mem::zeroed(); + (self.device_fn_1_0.create_buffer)( + self.handle(), + create_info, + allocation_callbacks.as_raw_ptr(), + &mut buffer, + ) + .result_with_success(buffer) + } + + /// + #[inline] + pub unsafe fn create_pipeline_layout( + &self, + create_info: &vk::PipelineLayoutCreateInfo, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) -> VkResult { + let mut pipeline_layout = mem::zeroed(); + (self.device_fn_1_0.create_pipeline_layout)( + self.handle(), + create_info, + allocation_callbacks.as_raw_ptr(), + &mut pipeline_layout, + ) + .result_with_success(pipeline_layout) + } + + /// + #[inline] + pub unsafe fn create_pipeline_cache( + &self, + create_info: &vk::PipelineCacheCreateInfo, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) -> VkResult { + let mut pipeline_cache = mem::zeroed(); + (self.device_fn_1_0.create_pipeline_cache)( + self.handle(), + create_info, + allocation_callbacks.as_raw_ptr(), + &mut pipeline_cache, + ) + .result_with_success(pipeline_cache) + } + + /// + #[inline] + pub unsafe fn get_pipeline_cache_data( + &self, + pipeline_cache: vk::PipelineCache, + ) -> VkResult> { + read_into_uninitialized_vector(|count, data| { + (self.device_fn_1_0.get_pipeline_cache_data)( + self.handle(), + pipeline_cache, + count, + data as _, + ) + }) + } + + /// + #[inline] + pub unsafe fn merge_pipeline_caches( + &self, + dst_cache: vk::PipelineCache, + src_caches: &[vk::PipelineCache], + ) -> VkResult<()> { + (self.device_fn_1_0.merge_pipeline_caches)( + self.handle(), + dst_cache, + src_caches.len() as u32, + src_caches.as_ptr(), + ) + .result() + } + + /// + #[inline] + pub unsafe fn map_memory( + &self, + memory: vk::DeviceMemory, + offset: vk::DeviceSize, + size: vk::DeviceSize, + flags: vk::MemoryMapFlags, + ) -> VkResult<*mut c_void> { + let mut data: *mut c_void = ptr::null_mut(); + (self.device_fn_1_0.map_memory)(self.handle(), memory, offset, size, flags, &mut data) + .result_with_success(data) + } + + /// + #[inline] + pub unsafe fn unmap_memory(&self, memory: vk::DeviceMemory) { + (self.device_fn_1_0.unmap_memory)(self.handle(), memory); + } + + /// + #[inline] + pub unsafe fn invalidate_mapped_memory_ranges( + &self, + ranges: &[vk::MappedMemoryRange], + ) -> VkResult<()> { + (self.device_fn_1_0.invalidate_mapped_memory_ranges)( + self.handle(), + ranges.len() as u32, + ranges.as_ptr(), + ) + .result() + } + + /// + #[inline] + pub unsafe fn flush_mapped_memory_ranges( + &self, + ranges: &[vk::MappedMemoryRange], + ) -> VkResult<()> { + (self.device_fn_1_0.flush_mapped_memory_ranges)( + self.handle(), + ranges.len() as u32, + ranges.as_ptr(), + ) + .result() + } + + /// + #[inline] + pub unsafe fn create_framebuffer( + &self, + create_info: &vk::FramebufferCreateInfo, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) -> VkResult { + let mut framebuffer = mem::zeroed(); + (self.device_fn_1_0.create_framebuffer)( + self.handle(), + create_info, + allocation_callbacks.as_raw_ptr(), + &mut framebuffer, + ) + .result_with_success(framebuffer) + } + + /// + #[inline] + pub unsafe fn get_device_queue(&self, queue_family_index: u32, queue_index: u32) -> vk::Queue { + let mut queue = mem::zeroed(); + (self.device_fn_1_0.get_device_queue)( + self.handle(), + queue_family_index, + queue_index, + &mut queue, + ); + queue + } + + /// + #[inline] + pub unsafe fn cmd_pipeline_barrier( + &self, + command_buffer: vk::CommandBuffer, + src_stage_mask: vk::PipelineStageFlags, + dst_stage_mask: vk::PipelineStageFlags, + dependency_flags: vk::DependencyFlags, + memory_barriers: &[vk::MemoryBarrier], + buffer_memory_barriers: &[vk::BufferMemoryBarrier], + image_memory_barriers: &[vk::ImageMemoryBarrier], + ) { + (self.device_fn_1_0.cmd_pipeline_barrier)( + command_buffer, + src_stage_mask, + dst_stage_mask, + dependency_flags, + memory_barriers.len() as u32, + memory_barriers.as_ptr(), + buffer_memory_barriers.len() as u32, + buffer_memory_barriers.as_ptr(), + image_memory_barriers.len() as u32, + image_memory_barriers.as_ptr(), + ); + } + + /// + #[inline] + pub unsafe fn create_render_pass( + &self, + create_info: &vk::RenderPassCreateInfo, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) -> VkResult { + let mut renderpass = mem::zeroed(); + (self.device_fn_1_0.create_render_pass)( + self.handle(), + create_info, + allocation_callbacks.as_raw_ptr(), + &mut renderpass, + ) + .result_with_success(renderpass) + } + + /// + #[inline] + pub unsafe fn begin_command_buffer( + &self, + command_buffer: vk::CommandBuffer, + begin_info: &vk::CommandBufferBeginInfo, + ) -> VkResult<()> { + (self.device_fn_1_0.begin_command_buffer)(command_buffer, begin_info).result() + } + + /// + #[inline] + pub unsafe fn end_command_buffer(&self, command_buffer: vk::CommandBuffer) -> VkResult<()> { + (self.device_fn_1_0.end_command_buffer)(command_buffer).result() + } + + /// + #[inline] + pub unsafe fn wait_for_fences( + &self, + fences: &[vk::Fence], + wait_all: bool, + timeout: u64, + ) -> VkResult<()> { + (self.device_fn_1_0.wait_for_fences)( + self.handle(), + fences.len() as u32, + fences.as_ptr(), + wait_all as u32, + timeout, + ) + .result() + } + + /// + #[inline] + pub unsafe fn get_fence_status(&self, fence: vk::Fence) -> VkResult { + let err_code = (self.device_fn_1_0.get_fence_status)(self.handle(), fence); + match err_code { + vk::Result::SUCCESS => Ok(true), + vk::Result::NOT_READY => Ok(false), + _ => Err(err_code), + } + } + + /// + #[inline] + pub unsafe fn queue_wait_idle(&self, queue: vk::Queue) -> VkResult<()> { + (self.device_fn_1_0.queue_wait_idle)(queue).result() + } + + /// + #[inline] + pub unsafe fn queue_submit( + &self, + queue: vk::Queue, + submits: &[vk::SubmitInfo], + fence: vk::Fence, + ) -> VkResult<()> { + (self.device_fn_1_0.queue_submit)(queue, submits.len() as u32, submits.as_ptr(), fence) + .result() + } + + /// + #[inline] + pub unsafe fn queue_bind_sparse( + &self, + queue: vk::Queue, + bind_info: &[vk::BindSparseInfo], + fence: vk::Fence, + ) -> VkResult<()> { + (self.device_fn_1_0.queue_bind_sparse)( + queue, + bind_info.len() as u32, + bind_info.as_ptr(), + fence, + ) + .result() + } + + /// + #[inline] + pub unsafe fn create_buffer_view( + &self, + create_info: &vk::BufferViewCreateInfo, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) -> VkResult { + let mut buffer_view = mem::zeroed(); + (self.device_fn_1_0.create_buffer_view)( + self.handle(), + create_info, + allocation_callbacks.as_raw_ptr(), + &mut buffer_view, + ) + .result_with_success(buffer_view) + } + + /// + #[inline] + pub unsafe fn destroy_buffer_view( + &self, + buffer_view: vk::BufferView, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) { + (self.device_fn_1_0.destroy_buffer_view)( + self.handle(), + buffer_view, + allocation_callbacks.as_raw_ptr(), + ); + } + + /// + #[inline] + pub unsafe fn create_image_view( + &self, + create_info: &vk::ImageViewCreateInfo, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) -> VkResult { + let mut image_view = mem::zeroed(); + (self.device_fn_1_0.create_image_view)( + self.handle(), + create_info, + allocation_callbacks.as_raw_ptr(), + &mut image_view, + ) + .result_with_success(image_view) + } + + /// + #[inline] + pub unsafe fn allocate_command_buffers( + &self, + create_info: &vk::CommandBufferAllocateInfo, + ) -> VkResult> { + let mut buffers = Vec::with_capacity(create_info.command_buffer_count as usize); + (self.device_fn_1_0.allocate_command_buffers)( + self.handle(), + create_info, + buffers.as_mut_ptr(), + ) + .result()?; + buffers.set_len(create_info.command_buffer_count as usize); + Ok(buffers) + } + + /// + #[inline] + pub unsafe fn create_command_pool( + &self, + create_info: &vk::CommandPoolCreateInfo, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) -> VkResult { + let mut pool = mem::zeroed(); + (self.device_fn_1_0.create_command_pool)( + self.handle(), + create_info, + allocation_callbacks.as_raw_ptr(), + &mut pool, + ) + .result_with_success(pool) + } + + /// + #[inline] + pub unsafe fn create_query_pool( + &self, + create_info: &vk::QueryPoolCreateInfo, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) -> VkResult { + let mut pool = mem::zeroed(); + (self.device_fn_1_0.create_query_pool)( + self.handle(), + create_info, + allocation_callbacks.as_raw_ptr(), + &mut pool, + ) + .result_with_success(pool) + } + + /// + #[inline] + pub unsafe fn create_image( + &self, + create_info: &vk::ImageCreateInfo, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) -> VkResult { + let mut image = mem::zeroed(); + (self.device_fn_1_0.create_image)( + self.handle(), + create_info, + allocation_callbacks.as_raw_ptr(), + &mut image, + ) + .result_with_success(image) + } + + /// + #[inline] + pub unsafe fn get_image_subresource_layout( + &self, + image: vk::Image, + subresource: vk::ImageSubresource, + ) -> vk::SubresourceLayout { + let mut layout = mem::zeroed(); + (self.device_fn_1_0.get_image_subresource_layout)( + self.handle(), + image, + &subresource, + &mut layout, + ); + layout + } + + /// + #[inline] + pub unsafe fn get_image_memory_requirements(&self, image: vk::Image) -> vk::MemoryRequirements { + let mut mem_req = mem::zeroed(); + (self.device_fn_1_0.get_image_memory_requirements)(self.handle(), image, &mut mem_req); + mem_req + } + + /// + #[inline] + pub unsafe fn get_buffer_memory_requirements( + &self, + buffer: vk::Buffer, + ) -> vk::MemoryRequirements { + let mut mem_req = mem::zeroed(); + (self.device_fn_1_0.get_buffer_memory_requirements)(self.handle(), buffer, &mut mem_req); + mem_req + } + + /// + #[inline] + pub unsafe fn allocate_memory( + &self, + create_info: &vk::MemoryAllocateInfo, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) -> VkResult { + let mut memory = mem::zeroed(); + (self.device_fn_1_0.allocate_memory)( + self.handle(), + create_info, + allocation_callbacks.as_raw_ptr(), + &mut memory, + ) + .result_with_success(memory) + } + + /// + #[inline] + pub unsafe fn create_shader_module( + &self, + create_info: &vk::ShaderModuleCreateInfo, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) -> VkResult { + let mut shader = mem::zeroed(); + (self.device_fn_1_0.create_shader_module)( + self.handle(), + create_info, + allocation_callbacks.as_raw_ptr(), + &mut shader, + ) + .result_with_success(shader) + } + + /// + #[inline] + pub unsafe fn create_fence( + &self, + create_info: &vk::FenceCreateInfo, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) -> VkResult { + let mut fence = mem::zeroed(); + (self.device_fn_1_0.create_fence)( + self.handle(), + create_info, + allocation_callbacks.as_raw_ptr(), + &mut fence, + ) + .result_with_success(fence) + } + + /// + #[inline] + pub unsafe fn bind_buffer_memory( + &self, + buffer: vk::Buffer, + device_memory: vk::DeviceMemory, + offset: vk::DeviceSize, + ) -> VkResult<()> { + (self.device_fn_1_0.bind_buffer_memory)(self.handle(), buffer, device_memory, offset) + .result() + } + + /// + #[inline] + pub unsafe fn bind_image_memory( + &self, + image: vk::Image, + device_memory: vk::DeviceMemory, + offset: vk::DeviceSize, + ) -> VkResult<()> { + (self.device_fn_1_0.bind_image_memory)(self.handle(), image, device_memory, offset).result() + } + + /// + #[inline] + pub unsafe fn get_render_area_granularity(&self, render_pass: vk::RenderPass) -> vk::Extent2D { + let mut granularity = mem::zeroed(); + (self.device_fn_1_0.get_render_area_granularity)( + self.handle(), + render_pass, + &mut granularity, + ); + granularity + } + + /// + #[inline] + pub unsafe fn get_device_memory_commitment(&self, memory: vk::DeviceMemory) -> vk::DeviceSize { + let mut committed_memory_in_bytes = 0; + (self.device_fn_1_0.get_device_memory_commitment)( + self.handle(), + memory, + &mut committed_memory_in_bytes, + ); + committed_memory_in_bytes + } + + /// + #[inline] + pub unsafe fn get_image_sparse_memory_requirements( + &self, + image: vk::Image, + ) -> Vec { + read_into_uninitialized_vector(|count, data| { + (self.device_fn_1_0.get_image_sparse_memory_requirements)( + self.handle(), + image, + count, + data, + ); + vk::Result::SUCCESS + }) + // The closure always returns SUCCESS + .unwrap() + } +} diff --git a/third_party/rust/ash/src/entry.rs b/third_party/rust/ash/src/entry.rs new file mode 100644 index 0000000000..67e6c9a739 --- /dev/null +++ b/third_party/rust/ash/src/entry.rs @@ -0,0 +1,402 @@ +use crate::instance::Instance; +use crate::prelude::*; +use crate::vk; +use crate::RawPtr; +use std::ffi::CStr; +#[cfg(feature = "loaded")] +use std::ffi::OsStr; +use std::mem; +use std::os::raw::c_char; +use std::os::raw::c_void; +use std::ptr; +#[cfg(feature = "loaded")] +use std::sync::Arc; + +#[cfg(feature = "loaded")] +use libloading::Library; + +/// Holds the Vulkan functions independent of a particular instance +#[derive(Clone)] +pub struct Entry { + static_fn: vk::StaticFn, + entry_fn_1_0: vk::EntryFnV1_0, + entry_fn_1_1: vk::EntryFnV1_1, + entry_fn_1_2: vk::EntryFnV1_2, + entry_fn_1_3: vk::EntryFnV1_3, + #[cfg(feature = "loaded")] + _lib_guard: Option>, +} + +/// Vulkan core 1.0 +#[allow(non_camel_case_types)] +impl Entry { + /// Load default Vulkan library for the current platform + /// + /// Prefer this over [`linked`](Self::linked) when your application can gracefully handle + /// environments that lack Vulkan support, and when the build environment might not have Vulkan + /// development packages installed (e.g. the Vulkan SDK, or Ubuntu's `libvulkan-dev`). + /// + /// # Safety + /// `dlopen`ing native libraries is inherently unsafe. The safety guidelines + /// for [`Library::new()`] and [`Library::get()`] apply here. + /// + /// ```no_run + /// use ash::{vk, Entry}; + /// # fn main() -> Result<(), Box> { + /// let entry = unsafe { Entry::load()? }; + /// let app_info = vk::ApplicationInfo { + /// api_version: vk::make_api_version(0, 1, 0, 0), + /// ..Default::default() + /// }; + /// let create_info = vk::InstanceCreateInfo { + /// p_application_info: &app_info, + /// ..Default::default() + /// }; + /// let instance = unsafe { entry.create_instance(&create_info, None)? }; + /// # Ok(()) } + /// ``` + #[cfg(feature = "loaded")] + #[cfg_attr(docsrs, doc(cfg(feature = "loaded")))] + pub unsafe fn load() -> Result { + #[cfg(windows)] + const LIB_PATH: &str = "vulkan-1.dll"; + + #[cfg(all( + unix, + not(any(target_os = "macos", target_os = "ios", target_os = "android")) + ))] + const LIB_PATH: &str = "libvulkan.so.1"; + + #[cfg(target_os = "android")] + const LIB_PATH: &str = "libvulkan.so"; + + #[cfg(any(target_os = "macos", target_os = "ios"))] + const LIB_PATH: &str = "libvulkan.dylib"; + + Self::load_from(LIB_PATH) + } + + /// Load entry points from a Vulkan loader linked at compile time + /// + /// Compared to [`load`](Self::load), this is infallible, but requires that the build + /// environment have Vulkan development packages installed (e.g. the Vulkan SDK, or Ubuntu's + /// `libvulkan-dev`), and prevents the resulting binary from starting in environments that do not + /// support Vulkan. + /// + /// Note that instance/device functions are still fetched via `vkGetInstanceProcAddr` and + /// `vkGetDeviceProcAddr` for maximum performance. + /// + /// ```no_run + /// use ash::{vk, Entry}; + /// # fn main() -> Result<(), Box> { + /// let entry = Entry::linked(); + /// let app_info = vk::ApplicationInfo { + /// api_version: vk::make_api_version(0, 1, 0, 0), + /// ..Default::default() + /// }; + /// let create_info = vk::InstanceCreateInfo { + /// p_application_info: &app_info, + /// ..Default::default() + /// }; + /// let instance = unsafe { entry.create_instance(&create_info, None)? }; + /// # Ok(()) } + /// ``` + #[cfg(feature = "linked")] + #[cfg_attr(docsrs, doc(cfg(feature = "linked")))] + pub fn linked() -> Self { + // Sound because we're linking to Vulkan, which provides a vkGetInstanceProcAddr that has + // defined behavior in this use. + unsafe { + Self::from_static_fn(vk::StaticFn { + get_instance_proc_addr: vkGetInstanceProcAddr, + }) + } + } + + /// Load Vulkan library at `path` + /// + /// # Safety + /// `dlopen`ing native libraries is inherently unsafe. The safety guidelines + /// for [`Library::new()`] and [`Library::get()`] apply here. + #[cfg(feature = "loaded")] + #[cfg_attr(docsrs, doc(cfg(feature = "loaded")))] + pub unsafe fn load_from(path: impl AsRef) -> Result { + let lib = Library::new(path) + .map_err(LoadingError::LibraryLoadFailure) + .map(Arc::new)?; + + let static_fn = vk::StaticFn::load_checked(|name| { + lib.get(name.to_bytes_with_nul()) + .map(|symbol| *symbol) + .unwrap_or(ptr::null_mut()) + })?; + + Ok(Self { + _lib_guard: Some(lib), + ..Self::from_static_fn(static_fn) + }) + } + + /// Load entry points based on an already-loaded [`vk::StaticFn`] + /// + /// # Safety + /// `static_fn` must contain valid function pointers that comply with the semantics specified by + /// Vulkan 1.0, which must remain valid for at least the lifetime of the returned [`Entry`]. + pub unsafe fn from_static_fn(static_fn: vk::StaticFn) -> Self { + let load_fn = |name: &std::ffi::CStr| { + mem::transmute((static_fn.get_instance_proc_addr)( + vk::Instance::null(), + name.as_ptr(), + )) + }; + let entry_fn_1_0 = vk::EntryFnV1_0::load(load_fn); + let entry_fn_1_1 = vk::EntryFnV1_1::load(load_fn); + let entry_fn_1_2 = vk::EntryFnV1_2::load(load_fn); + let entry_fn_1_3 = vk::EntryFnV1_3::load(load_fn); + + Self { + static_fn, + entry_fn_1_0, + entry_fn_1_1, + entry_fn_1_2, + entry_fn_1_3, + #[cfg(feature = "loaded")] + _lib_guard: None, + } + } + + #[inline] + pub fn fp_v1_0(&self) -> &vk::EntryFnV1_0 { + &self.entry_fn_1_0 + } + + #[inline] + pub fn static_fn(&self) -> &vk::StaticFn { + &self.static_fn + } + + /// + /// ```no_run + /// # use ash::{Entry, vk}; + /// # fn main() -> Result<(), Box> { + /// let entry = Entry::linked(); + /// match entry.try_enumerate_instance_version()? { + /// // Vulkan 1.1+ + /// Some(version) => { + /// let major = vk::version_major(version); + /// let minor = vk::version_minor(version); + /// let patch = vk::version_patch(version); + /// }, + /// // Vulkan 1.0 + /// None => {}, + /// } + /// # Ok(()) } + /// ``` + #[inline] + pub fn try_enumerate_instance_version(&self) -> VkResult> { + unsafe { + let mut api_version = 0; + let enumerate_instance_version: Option = { + let name = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkEnumerateInstanceVersion\0", + ); + mem::transmute((self.static_fn.get_instance_proc_addr)( + vk::Instance::null(), + name.as_ptr(), + )) + }; + if let Some(enumerate_instance_version) = enumerate_instance_version { + (enumerate_instance_version)(&mut api_version) + .result_with_success(Some(api_version)) + } else { + Ok(None) + } + } + } + + /// + /// + /// # Safety + /// In order for the created [`Instance`] to be valid for the duration of its + /// usage, the [`Entry`](Self) this was called on must be dropped later than the + /// resulting [`Instance`]. + #[inline] + pub unsafe fn create_instance( + &self, + create_info: &vk::InstanceCreateInfo, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) -> VkResult { + let mut instance = mem::zeroed(); + (self.entry_fn_1_0.create_instance)( + create_info, + allocation_callbacks.as_raw_ptr(), + &mut instance, + ) + .result()?; + Ok(Instance::load(&self.static_fn, instance)) + } + + /// + #[inline] + pub fn enumerate_instance_layer_properties(&self) -> VkResult> { + unsafe { + read_into_uninitialized_vector(|count, data| { + (self.entry_fn_1_0.enumerate_instance_layer_properties)(count, data) + }) + } + } + + /// + #[inline] + pub fn enumerate_instance_extension_properties( + &self, + layer_name: Option<&CStr>, + ) -> VkResult> { + unsafe { + read_into_uninitialized_vector(|count, data| { + (self.entry_fn_1_0.enumerate_instance_extension_properties)( + layer_name.map_or(ptr::null(), |str| str.as_ptr()), + count, + data, + ) + }) + } + } + + /// + #[inline] + pub unsafe fn get_instance_proc_addr( + &self, + instance: vk::Instance, + p_name: *const c_char, + ) -> vk::PFN_vkVoidFunction { + (self.static_fn.get_instance_proc_addr)(instance, p_name) + } +} + +/// Vulkan core 1.1 +#[allow(non_camel_case_types)] +impl Entry { + #[inline] + pub fn fp_v1_1(&self) -> &vk::EntryFnV1_1 { + &self.entry_fn_1_1 + } + + #[deprecated = "This function is unavailable and therefore panics on Vulkan 1.0, please use `try_enumerate_instance_version()` instead"] + /// + /// + /// Please use [`try_enumerate_instance_version()`][Self::try_enumerate_instance_version()] instead. + #[inline] + pub fn enumerate_instance_version(&self) -> VkResult { + unsafe { + let mut api_version = 0; + (self.entry_fn_1_1.enumerate_instance_version)(&mut api_version) + .result_with_success(api_version) + } + } +} + +/// Vulkan core 1.2 +#[allow(non_camel_case_types)] +impl Entry { + #[inline] + pub fn fp_v1_2(&self) -> &vk::EntryFnV1_2 { + &self.entry_fn_1_2 + } +} + +/// Vulkan core 1.3 +#[allow(non_camel_case_types)] +impl Entry { + #[inline] + pub fn fp_v1_3(&self) -> &vk::EntryFnV1_3 { + &self.entry_fn_1_3 + } +} + +#[cfg(feature = "linked")] +#[cfg_attr(docsrs, doc(cfg(feature = "linked")))] +impl Default for Entry { + #[inline] + fn default() -> Self { + Self::linked() + } +} + +impl vk::StaticFn { + pub fn load_checked(mut _f: F) -> Result + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + // TODO: Make this a &'static CStr once CStr::from_bytes_with_nul_unchecked is const + static ENTRY_POINT: &[u8] = b"vkGetInstanceProcAddr\0"; + + Ok(Self { + get_instance_proc_addr: unsafe { + let cname = CStr::from_bytes_with_nul_unchecked(ENTRY_POINT); + let val = _f(cname); + if val.is_null() { + return Err(MissingEntryPoint); + } else { + ::std::mem::transmute(val) + } + }, + }) + } +} + +#[derive(Clone, Debug)] +pub struct MissingEntryPoint; +impl std::fmt::Display for MissingEntryPoint { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> { + write!(f, "Cannot load `vkGetInstanceProcAddr` symbol from library") + } +} +impl std::error::Error for MissingEntryPoint {} + +#[cfg(feature = "linked")] +extern "system" { + fn vkGetInstanceProcAddr(instance: vk::Instance, name: *const c_char) + -> vk::PFN_vkVoidFunction; +} + +#[cfg(feature = "loaded")] +mod loaded { + use std::error::Error; + use std::fmt; + + use super::*; + + #[derive(Debug)] + #[cfg_attr(docsrs, doc(cfg(feature = "loaded")))] + pub enum LoadingError { + LibraryLoadFailure(libloading::Error), + MissingEntryPoint(MissingEntryPoint), + } + + impl fmt::Display for LoadingError { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + match self { + Self::LibraryLoadFailure(err) => fmt::Display::fmt(err, f), + Self::MissingEntryPoint(err) => fmt::Display::fmt(err, f), + } + } + } + + impl Error for LoadingError { + fn source(&self) -> Option<&(dyn Error + 'static)> { + Some(match self { + Self::LibraryLoadFailure(err) => err, + Self::MissingEntryPoint(err) => err, + }) + } + } + + impl From for LoadingError { + fn from(err: MissingEntryPoint) -> Self { + Self::MissingEntryPoint(err) + } + } +} +#[cfg(feature = "loaded")] +pub use self::loaded::*; diff --git a/third_party/rust/ash/src/extensions/experimental/amd.rs b/third_party/rust/ash/src/extensions/experimental/amd.rs new file mode 100644 index 0000000000..35b4289f16 --- /dev/null +++ b/third_party/rust/ash/src/extensions/experimental/amd.rs @@ -0,0 +1,722 @@ +#![allow(clippy::unreadable_literal)] + +/* + *********************************************************************************************************************** + * + * Copyright (c) 2014-2019 Advanced Micro Devices, Inc. All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + * + **********************************************************************************************************************/ + +#[cfg(feature = "debug")] +use crate::prelude::debug_flags; +use crate::vk::*; + +use std::fmt; +use std::os::raw::*; + +// Extension: `VK_AMD_gpa_interface` + +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct GpaSqShaderStageFlags(pub(crate) Flags); +vk_bitflags_wrapped!(GpaSqShaderStageFlags, Flags); +#[cfg(feature = "debug")] +impl fmt::Debug for GpaSqShaderStageFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (GpaSqShaderStageFlags::PS.0, "PS"), + (GpaSqShaderStageFlags::VS.0, "VS"), + (GpaSqShaderStageFlags::GS.0, "GS"), + (GpaSqShaderStageFlags::ES.0, "ES"), + (GpaSqShaderStageFlags::HS.0, "HS"), + (GpaSqShaderStageFlags::LS.0, "LS"), + (GpaSqShaderStageFlags::CS.0, "CS"), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl GpaSqShaderStageFlags { + pub const PS: Self = Self(0b1); + pub const VS: Self = Self(0b10); + pub const GS: Self = Self(0b100); + pub const ES: Self = Self(0b1000); + pub const HS: Self = Self(0b10000); + pub const LS: Self = Self(0b100000); + pub const CS: Self = Self(0b1000000); +} + +impl StructureType { + pub const PHYSICAL_DEVICE_GPA_FEATURES_AMD: Self = Self(1000133000); + pub const PHYSICAL_DEVICE_GPA_PROPERTIES_AMD: Self = Self(1000133001); + pub const GPA_SAMPLE_BEGIN_INFO_AMD: Self = Self(1000133002); + pub const GPA_SESSION_CREATE_INFO_AMD: Self = Self(1000133003); + pub const GPA_DEVICE_CLOCK_MODE_INFO_AMD: Self = Self(1000133004); +} + +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[repr(transparent)] +pub struct GpaDeviceClockModeAmd(pub(crate) i32); +impl GpaDeviceClockModeAmd { + pub fn from_raw(x: i32) -> Self { + Self(x) + } + pub fn as_raw(self) -> i32 { + self.0 + } +} +impl GpaDeviceClockModeAmd { + pub const DEFAULT: Self = Self(0); + pub const QUERY: Self = Self(1); + pub const PROFILING: Self = Self(2); + pub const MIN_MEMORY: Self = Self(3); + pub const MIN_ENGINE: Self = Self(4); + pub const PEAK: Self = Self(5); +} + +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[repr(transparent)] +pub struct GpaPerfBlockAmd(pub(crate) i32); +impl GpaPerfBlockAmd { + pub fn from_raw(x: i32) -> Self { + Self(x) + } + pub fn as_raw(self) -> i32 { + self.0 + } +} +impl GpaPerfBlockAmd { + pub const CPF: Self = Self(0); + pub const IA: Self = Self(1); + pub const VGT: Self = Self(2); + pub const PA: Self = Self(3); + pub const SC: Self = Self(4); + pub const SPI: Self = Self(5); + pub const SQ: Self = Self(6); + pub const SX: Self = Self(7); + pub const TA: Self = Self(8); + pub const TD: Self = Self(9); + pub const TCP: Self = Self(10); + pub const TCC: Self = Self(11); + pub const TCA: Self = Self(12); + pub const DB: Self = Self(13); + pub const CB: Self = Self(14); + pub const GDS: Self = Self(15); + pub const SRBM: Self = Self(16); + pub const GRBM: Self = Self(17); + pub const GRBM_SE: Self = Self(18); + pub const RLC: Self = Self(19); + pub const DMA: Self = Self(20); + pub const MC: Self = Self(21); + pub const CPG: Self = Self(22); + pub const CPC: Self = Self(23); + pub const WD: Self = Self(24); + pub const TCS: Self = Self(25); + pub const ATC: Self = Self(26); + pub const ATC_L2: Self = Self(27); + pub const MC_VM_L2: Self = Self(28); + pub const EA: Self = Self(29); + pub const RPB: Self = Self(30); + pub const RMI: Self = Self(31); +} + +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[repr(transparent)] +pub struct GpaSampleTypeAmd(pub(crate) i32); +impl GpaSampleTypeAmd { + pub fn from_raw(x: i32) -> Self { + Self(x) + } + pub fn as_raw(self) -> i32 { + self.0 + } +} +impl GpaSampleTypeAmd { + pub const CUMULATIVE: Self = Self(0); + pub const TRACE: Self = Self(1); + pub const TIMING: Self = Self(2); +} + +handle_nondispatchable!(GpaSessionAmd, UNKNOWN); + +#[repr(C)] +#[derive(Copy, Clone)] +#[cfg_attr(feature = "debug", derive(Debug))] +pub struct GpaSessionCreateInfoAmd { + pub s_type: StructureType, + pub p_next: *const c_void, + pub secondary_copy_source: GpaSessionAmd, +} + +#[repr(C)] +#[derive(Copy, Clone)] +#[cfg_attr(feature = "debug", derive(Debug))] +pub struct GpaPerfBlockPropertiesAmd { + pub block_type: GpaPerfBlockAmd, + pub flags: Flags, + pub instance_count: u32, + pub max_event_id: u32, + pub max_global_only_counters: u32, + pub max_global_shared_counters: u32, + pub max_streaming_counters: u32, +} + +#[repr(C)] +#[derive(Copy, Clone)] +#[cfg_attr(feature = "debug", derive(Debug))] +pub struct PhysicalDeviceGpaFeaturesAmd { + pub s_type: StructureType, + pub p_next: *const c_void, + pub perf_counters: Bool32, + pub streaming_perf_counters: Bool32, + pub sq_thread_tracing: Bool32, + pub clock_modes: Bool32, +} + +#[repr(C)] +#[derive(Copy, Clone)] +#[cfg_attr(feature = "debug", derive(Debug))] +pub struct PhysicalDeviceGpaPropertiesAmd { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: Flags, + pub max_sqtt_se_buffer_size: DeviceSize, + pub shader_engine_count: u32, + pub perf_block_count: u32, + pub p_perf_block_properties: *mut GpaPerfBlockPropertiesAmd, +} + +impl ::std::default::Default for PhysicalDeviceGpaPropertiesAmd { + fn default() -> Self { + Self { + s_type: StructureType::PHYSICAL_DEVICE_GPA_PROPERTIES_AMD, + p_next: ::std::ptr::null_mut(), + flags: Flags::default(), + max_sqtt_se_buffer_size: DeviceSize::default(), + shader_engine_count: u32::default(), + perf_block_count: u32::default(), + p_perf_block_properties: ::std::ptr::null_mut(), + } + } +} +impl PhysicalDeviceGpaPropertiesAmd { + pub fn builder<'a>() -> PhysicalDeviceGpaPropertiesAmdBuilder<'a> { + PhysicalDeviceGpaPropertiesAmdBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct PhysicalDeviceGpaPropertiesAmdBuilder<'a> { + inner: PhysicalDeviceGpaPropertiesAmd, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsPhysicalDeviceGpaPropertiesAmd {} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceGpaPropertiesAmd {} +impl<'a> ::std::ops::Deref for PhysicalDeviceGpaPropertiesAmdBuilder<'a> { + type Target = PhysicalDeviceGpaPropertiesAmd; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> PhysicalDeviceGpaPropertiesAmdBuilder<'a> { + pub fn push_next(mut self, next: &'a mut T) -> PhysicalDeviceGpaPropertiesAmdBuilder<'a> + where + T: ExtendsPhysicalDeviceGpaPropertiesAmd, + { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + pub fn build(self) -> PhysicalDeviceGpaPropertiesAmd { + self.inner + } +} + +#[repr(C)] +#[derive(Copy, Clone)] +#[cfg_attr(feature = "debug", derive(Debug))] +pub struct GpaPerfCounterAmd { + pub block_type: GpaPerfBlockAmd, + pub block_instance: u32, + pub event_id: u32, +} + +#[repr(C)] +#[derive(Copy, Clone)] +#[cfg_attr(feature = "debug", derive(Debug))] +pub struct GpaSampleBeginInfoAmd { + pub s_type: StructureType, + pub p_next: *const c_void, + pub sample_type: GpaSampleTypeAmd, + pub sample_internal_operations: Bool32, + pub cache_flush_on_counter_collection: Bool32, + pub sq_shader_mask_enable: Bool32, + pub sq_shader_mask: GpaSqShaderStageFlags, + pub perf_counter_count: u32, + pub p_perf_counters: *const GpaPerfCounterAmd, + pub streaming_perf_trace_sample_interval: u32, + pub perf_counter_device_memory_limit: DeviceSize, + pub sq_thread_trace_enable: Bool32, + pub sq_thread_trace_suppress_instruction_tokens: Bool32, + pub sq_thread_trace_device_memory_limit: DeviceSize, + pub timing_pre_sample: PipelineStageFlags, + pub timing_post_sample: PipelineStageFlags, +} + +#[repr(C)] +#[derive(Copy, Clone)] +#[cfg_attr(feature = "debug", derive(Debug))] +pub struct GpaDeviceClockModeInfoAmd { + pub s_type: StructureType, + pub p_next: *const c_void, + pub clock_mode: GpaDeviceClockModeAmd, + pub memory_clock_ratio_to_peak: f32, + pub engine_clock_ratio_to_peak: f32, +} + +#[allow(non_camel_case_types)] +pub type PFN_vkCreateGpaSessionAMD = extern "system" fn( + device: Device, + p_create_info: *const GpaSessionCreateInfoAmd, + p_allocator: *const AllocationCallbacks, + p_gpa_session: *mut GpaSessionAmd, +) -> Result; + +#[allow(non_camel_case_types)] +pub type PFN_vkDestroyGpaSessionAMD = extern "system" fn( + device: Device, + gpa_session: GpaSessionAmd, + p_allocator: *const AllocationCallbacks, +) -> c_void; + +#[allow(non_camel_case_types)] +pub type PFN_vkSetGpaDeviceClockModeAMD = + extern "system" fn(device: Device, p_info: *mut GpaDeviceClockModeInfoAmd) -> Result; + +#[allow(non_camel_case_types)] +pub type PFN_vkCmdBeginGpaSessionAMD = + extern "system" fn(commandBuffer: CommandBuffer, gpa_session: GpaSessionAmd) -> Result; + +#[allow(non_camel_case_types)] +pub type PFN_vkCmdEndGpaSessionAMD = + extern "system" fn(commandBuffer: CommandBuffer, gpa_session: GpaSessionAmd) -> Result; + +#[allow(non_camel_case_types)] +pub type PFN_vkCmdBeginGpaSampleAMD = extern "system" fn( + commandBuffer: CommandBuffer, + gpa_session: GpaSessionAmd, + p_gpa_sample_begin_info: *const GpaSampleBeginInfoAmd, + p_sample_id: *mut u32, +) -> Result; + +#[allow(non_camel_case_types)] +pub type PFN_vkCmdEndGpaSampleAMD = extern "system" fn( + commandBuffer: CommandBuffer, + gpa_session: GpaSessionAmd, + sample_id: u32, +) -> c_void; + +#[allow(non_camel_case_types)] +pub type PFN_vkGetGpaSessionStatusAMD = + extern "system" fn(device: Device, gpaSession: GpaSessionAmd) -> Result; + +#[allow(non_camel_case_types)] +pub type PFN_vkGetGpaSessionResultsAMD = extern "system" fn( + device: Device, + gpaSession: GpaSessionAmd, + sample_id: u32, + p_size_in_bytes: *mut usize, + p_data: *mut c_void, +) -> Result; + +#[allow(non_camel_case_types)] +pub type PFN_vkResetGpaSessionAMD = + extern "system" fn(device: Device, gpaSession: GpaSessionAmd) -> Result; + +#[allow(non_camel_case_types)] +pub type PFN_vkCmdCopyGpaSessionResultsAMD = + extern "system" fn(commandBuffer: CommandBuffer, gpaSession: GpaSessionAmd) -> c_void; + +pub struct AmdGpaInterfaceFn { + pub create_gpa_session: PFN_vkCreateGpaSessionAMD, + pub destroy_gpa_session: PFN_vkDestroyGpaSessionAMD, + pub set_gpa_device_clock_mode: PFN_vkSetGpaDeviceClockModeAMD, + pub cmd_begin_gpa_session: PFN_vkCmdBeginGpaSessionAMD, + pub cmd_end_gpa_session: PFN_vkCmdEndGpaSessionAMD, + pub cmd_begin_gpa_sample: PFN_vkCmdBeginGpaSampleAMD, + pub cmd_end_gpa_sample: PFN_vkCmdEndGpaSampleAMD, + pub get_gpa_session_status: PFN_vkGetGpaSessionStatusAMD, + pub get_gpa_session_results: PFN_vkGetGpaSessionResultsAMD, + pub reset_gpa_session: PFN_vkResetGpaSessionAMD, + pub cmd_copy_gpa_session_results: PFN_vkCmdCopyGpaSessionResultsAMD, +} +unsafe impl Send for AmdGpaInterfaceFn {} +unsafe impl Sync for AmdGpaInterfaceFn {} + +impl ::std::clone::Clone for AmdGpaInterfaceFn { + fn clone(&self) -> Self { + Self { + create_gpa_session: self.create_gpa_session, + destroy_gpa_session: self.destroy_gpa_session, + set_gpa_device_clock_mode: self.set_gpa_device_clock_mode, + cmd_begin_gpa_session: self.cmd_begin_gpa_session, + cmd_end_gpa_session: self.cmd_end_gpa_session, + cmd_begin_gpa_sample: self.cmd_begin_gpa_sample, + cmd_end_gpa_sample: self.cmd_end_gpa_sample, + get_gpa_session_status: self.get_gpa_session_status, + get_gpa_session_results: self.get_gpa_session_results, + reset_gpa_session: self.reset_gpa_session, + cmd_copy_gpa_session_results: self.cmd_copy_gpa_session_results, + } + } +} + +impl AmdGpaInterfaceFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + create_gpa_session: unsafe { + extern "system" fn create_gpa_session_amd( + _device: Device, + _p_create_info: *const GpaSessionCreateInfoAmd, + _p_allocator: *const AllocationCallbacks, + _p_gpa_session: *mut GpaSessionAmd, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(create_gpa_session_amd) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateGpaSessionAMD\0"); + let val = _f(cname); + if val.is_null() { + create_gpa_session_amd + } else { + ::std::mem::transmute(val) + } + }, + destroy_gpa_session: unsafe { + extern "system" fn destroy_gpa_session_amd( + _device: Device, + _gpa_session: GpaSessionAmd, + _p_allocator: *const AllocationCallbacks, + ) -> c_void { + panic!(concat!( + "Unable to load ", + stringify!(destroy_gpa_session_amd) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyGpaSessionAMD\0"); + let val = _f(cname); + if val.is_null() { + destroy_gpa_session_amd + } else { + ::std::mem::transmute(val) + } + }, + set_gpa_device_clock_mode: unsafe { + extern "system" fn set_gpa_device_clock_mode_amd( + _device: Device, + _p_info: *mut GpaDeviceClockModeInfoAmd, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(set_gpa_device_clock_mode_amd) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkSetGpaDeviceClockModeAMD\0", + ); + let val = _f(cname); + if val.is_null() { + set_gpa_device_clock_mode_amd + } else { + ::std::mem::transmute(val) + } + }, + cmd_begin_gpa_session: unsafe { + extern "system" fn cmd_begin_gpa_session_amd( + _command_buffer: CommandBuffer, + _gpa_session: GpaSessionAmd, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(cmd_begin_gpa_session_amd) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdBeginGpaSessionAMD\0"); + let val = _f(cname); + if val.is_null() { + cmd_begin_gpa_session_amd + } else { + ::std::mem::transmute(val) + } + }, + cmd_end_gpa_session: unsafe { + extern "system" fn cmd_end_gpa_session_amd( + _command_buffer: CommandBuffer, + _gpa_session: GpaSessionAmd, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(cmd_end_gpa_session_amd) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdEndGpaSessionAMD\0"); + let val = _f(cname); + if val.is_null() { + cmd_end_gpa_session_amd + } else { + ::std::mem::transmute(val) + } + }, + cmd_begin_gpa_sample: unsafe { + extern "system" fn cmd_begin_gpa_sample_amd( + _command_buffer: CommandBuffer, + _gpa_session: GpaSessionAmd, + _p_gpa_sample_begin_info: *const GpaSampleBeginInfoAmd, + _p_sample_id: *mut u32, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(cmd_begin_gpa_sample_amd) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdBeginGpaSampleAMD\0"); + let val = _f(cname); + if val.is_null() { + cmd_begin_gpa_sample_amd + } else { + ::std::mem::transmute(val) + } + }, + cmd_end_gpa_sample: unsafe { + extern "system" fn cmd_end_gpa_sample_amd( + _command_buffer: CommandBuffer, + _gpa_session: GpaSessionAmd, + _sample_id: u32, + ) -> c_void { + panic!(concat!( + "Unable to load ", + stringify!(cmd_end_gpa_sample_amd) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdEndGpaSampleAMD\0"); + let val = _f(cname); + if val.is_null() { + cmd_end_gpa_sample_amd + } else { + ::std::mem::transmute(val) + } + }, + get_gpa_session_status: unsafe { + extern "system" fn get_gpa_session_status_amd( + _device: Device, + _gpa_session: GpaSessionAmd, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_gpa_session_status_amd) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetGpaSessionStatusAMD\0"); + let val = _f(cname); + if val.is_null() { + get_gpa_session_status_amd + } else { + ::std::mem::transmute(val) + } + }, + get_gpa_session_results: unsafe { + extern "system" fn get_gpa_session_results_amd( + _device: Device, + _gpa_session: GpaSessionAmd, + _sample_id: u32, + _p_size_in_bytes: *mut usize, + _p_data: *mut c_void, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_gpa_session_results_amd) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetGpaSessionResultsAMD\0"); + let val = _f(cname); + if val.is_null() { + get_gpa_session_results_amd + } else { + ::std::mem::transmute(val) + } + }, + reset_gpa_session: unsafe { + extern "system" fn reset_gpa_session_amd( + _device: Device, + _gpa_session: GpaSessionAmd, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(reset_gpa_session_amd) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdEndGpaSampleAMD\0"); + let val = _f(cname); + if val.is_null() { + reset_gpa_session_amd + } else { + ::std::mem::transmute(val) + } + }, + cmd_copy_gpa_session_results: unsafe { + extern "system" fn cmd_copy_gpa_session_results_amd( + _command_buffer: CommandBuffer, + _gpa_session: GpaSessionAmd, + ) -> c_void { + panic!(concat!( + "Unable to load ", + stringify!(cmd_copy_gpa_session_results_amd) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdCopyGpaSessionResultsAMD\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_copy_gpa_session_results_amd + } else { + ::std::mem::transmute(val) + } + }, + } + } + pub unsafe fn create_gpa_session( + &self, + device: Device, + create_info: *const GpaSessionCreateInfoAmd, + allocator: *const AllocationCallbacks, + gpa_session: *mut GpaSessionAmd, + ) -> Result { + (self.create_gpa_session)(device, create_info, allocator, gpa_session) + } + pub unsafe fn destroy_gpa_session( + &self, + device: Device, + gpa_session: GpaSessionAmd, + allocator: *const AllocationCallbacks, + ) -> c_void { + (self.destroy_gpa_session)(device, gpa_session, allocator) + } +} + +// Extension: `VK_AMD_wave_limits` + +impl StructureType { + pub const WAVE_LIMIT_AMD: Self = Self(1000045000); + pub const PHYSICAL_DEVICE_WAVE_LIMIT_PROPERTIES_AMD: Self = Self(1000045001); +} + +#[repr(C)] +#[derive(Copy, Clone)] +#[cfg_attr(feature = "debug", derive(Debug))] +pub struct PhysicalDeviceWaveLimitPropertiesAmd { + pub s_type: StructureType, + pub p_next: *const c_void, + pub cu_count: u32, + pub max_waves_per_cu: u32, +} + +impl ::std::default::Default for PhysicalDeviceWaveLimitPropertiesAmd { + fn default() -> Self { + Self { + s_type: StructureType::PHYSICAL_DEVICE_WAVE_LIMIT_PROPERTIES_AMD, + p_next: ::std::ptr::null_mut(), + cu_count: u32::default(), + max_waves_per_cu: u32::default(), + } + } +} +impl PhysicalDeviceWaveLimitPropertiesAmd { + pub fn builder<'a>() -> PhysicalDeviceWaveLimitPropertiesAmdBuilder<'a> { + PhysicalDeviceWaveLimitPropertiesAmdBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct PhysicalDeviceWaveLimitPropertiesAmdBuilder<'a> { + inner: PhysicalDeviceWaveLimitPropertiesAmd, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsPhysicalDeviceWaveLimitPropertiesAmd {} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceWaveLimitPropertiesAmd {} +impl<'a> ::std::ops::Deref for PhysicalDeviceWaveLimitPropertiesAmdBuilder<'a> { + type Target = PhysicalDeviceWaveLimitPropertiesAmd; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> PhysicalDeviceWaveLimitPropertiesAmdBuilder<'a> { + pub fn push_next( + mut self, + next: &'a mut T, + ) -> PhysicalDeviceWaveLimitPropertiesAmdBuilder<'a> + where + T: ExtendsPhysicalDeviceWaveLimitPropertiesAmd, + { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + pub fn build(self) -> PhysicalDeviceWaveLimitPropertiesAmd { + self.inner + } +} + +#[repr(C)] +#[derive(Copy, Clone)] +#[cfg_attr(feature = "debug", derive(Debug))] +pub struct PipelineShaderStageCreateInfoWaveLimitAmd { + pub s_type: StructureType, + pub p_next: *const c_void, + pub waves_per_cu: f32, + pub cu_enable_mask: *mut u32, +} diff --git a/third_party/rust/ash/src/extensions/experimental/mod.rs b/third_party/rust/ash/src/extensions/experimental/mod.rs new file mode 100644 index 0000000000..49e51f80c3 --- /dev/null +++ b/third_party/rust/ash/src/extensions/experimental/mod.rs @@ -0,0 +1 @@ +pub mod amd; diff --git a/third_party/rust/ash/src/extensions/ext/acquire_drm_display.rs b/third_party/rust/ash/src/extensions/ext/acquire_drm_display.rs new file mode 100644 index 0000000000..8c80e506e0 --- /dev/null +++ b/third_party/rust/ash/src/extensions/ext/acquire_drm_display.rs @@ -0,0 +1,55 @@ +use crate::prelude::*; +use crate::vk; +use crate::{Entry, Instance}; +use std::ffi::CStr; +use std::mem; + +/// +#[derive(Clone)] +pub struct AcquireDrmDisplay { + fp: vk::ExtAcquireDrmDisplayFn, +} + +impl AcquireDrmDisplay { + pub fn new(entry: &Entry, instance: &Instance) -> Self { + let handle = instance.handle(); + let fp = vk::ExtAcquireDrmDisplayFn::load(|name| unsafe { + mem::transmute(entry.get_instance_proc_addr(handle, name.as_ptr())) + }); + Self { fp } + } + + /// + #[inline] + pub unsafe fn acquire_drm_display( + &self, + physical_device: vk::PhysicalDevice, + drm_fd: i32, + display: vk::DisplayKHR, + ) -> VkResult<()> { + (self.fp.acquire_drm_display_ext)(physical_device, drm_fd, display).result() + } + + /// + #[inline] + pub unsafe fn get_drm_display( + &self, + physical_device: vk::PhysicalDevice, + drm_fd: i32, + connector_id: u32, + ) -> VkResult { + let mut display = mem::MaybeUninit::uninit(); + (self.fp.get_drm_display_ext)(physical_device, drm_fd, connector_id, display.as_mut_ptr()) + .assume_init_on_success(display) + } + + #[inline] + pub const fn name() -> &'static CStr { + vk::ExtAcquireDrmDisplayFn::name() + } + + #[inline] + pub fn fp(&self) -> &vk::ExtAcquireDrmDisplayFn { + &self.fp + } +} diff --git a/third_party/rust/ash/src/extensions/ext/buffer_device_address.rs b/third_party/rust/ash/src/extensions/ext/buffer_device_address.rs new file mode 100644 index 0000000000..a1d304e639 --- /dev/null +++ b/third_party/rust/ash/src/extensions/ext/buffer_device_address.rs @@ -0,0 +1,44 @@ +use crate::vk; +use crate::{Device, Instance}; +use std::ffi::CStr; +use std::mem; + +#[derive(Clone)] +pub struct BufferDeviceAddress { + handle: vk::Device, + fp: vk::ExtBufferDeviceAddressFn, +} + +impl BufferDeviceAddress { + pub fn new(instance: &Instance, device: &Device) -> Self { + let handle = device.handle(); + let fp = vk::ExtBufferDeviceAddressFn::load(|name| unsafe { + mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr())) + }); + Self { handle, fp } + } + + /// + #[inline] + pub unsafe fn get_buffer_device_address( + &self, + info: &vk::BufferDeviceAddressInfoEXT, + ) -> vk::DeviceAddress { + (self.fp.get_buffer_device_address_ext)(self.handle, info) + } + + #[inline] + pub const fn name() -> &'static CStr { + vk::ExtBufferDeviceAddressFn::name() + } + + #[inline] + pub fn fp(&self) -> &vk::ExtBufferDeviceAddressFn { + &self.fp + } + + #[inline] + pub fn device(&self) -> vk::Device { + self.handle + } +} diff --git a/third_party/rust/ash/src/extensions/ext/calibrated_timestamps.rs b/third_party/rust/ash/src/extensions/ext/calibrated_timestamps.rs new file mode 100644 index 0000000000..e102fca15c --- /dev/null +++ b/third_party/rust/ash/src/extensions/ext/calibrated_timestamps.rs @@ -0,0 +1,72 @@ +use crate::prelude::*; +use crate::vk; +use crate::{Entry, Instance}; +use std::ffi::CStr; +use std::mem; + +#[derive(Clone)] +pub struct CalibratedTimestamps { + handle: vk::Instance, + fp: vk::ExtCalibratedTimestampsFn, +} + +impl CalibratedTimestamps { + pub fn new(entry: &Entry, instance: &Instance) -> Self { + let handle = instance.handle(); + let fp = vk::ExtCalibratedTimestampsFn::load(|name| unsafe { + mem::transmute(entry.get_instance_proc_addr(handle, name.as_ptr())) + }); + Self { handle, fp } + } + + /// + #[inline] + pub unsafe fn get_physical_device_calibrateable_time_domains( + &self, + physical_device: vk::PhysicalDevice, + ) -> VkResult> { + read_into_uninitialized_vector(|count, data| { + (self.fp.get_physical_device_calibrateable_time_domains_ext)( + physical_device, + count, + data, + ) + }) + } + + /// + /// + /// Returns a tuple containing `(timestamps, max_deviation)` + #[inline] + pub unsafe fn get_calibrated_timestamps( + &self, + device: vk::Device, + info: &[vk::CalibratedTimestampInfoEXT], + ) -> VkResult<(Vec, Vec)> { + let mut timestamps = vec![0u64; info.len()]; + let mut max_deviation = vec![0u64; info.len()]; + (self.fp.get_calibrated_timestamps_ext)( + device, + info.len() as u32, + info.as_ptr(), + timestamps.as_mut_ptr(), + max_deviation.as_mut_ptr(), + ) + .result_with_success((timestamps, max_deviation)) + } + + #[inline] + pub const fn name() -> &'static CStr { + vk::ExtCalibratedTimestampsFn::name() + } + + #[inline] + pub fn fp(&self) -> &vk::ExtCalibratedTimestampsFn { + &self.fp + } + + #[inline] + pub fn instance(&self) -> vk::Instance { + self.handle + } +} diff --git a/third_party/rust/ash/src/extensions/ext/debug_marker.rs b/third_party/rust/ash/src/extensions/ext/debug_marker.rs new file mode 100755 index 0000000000..1c21a47fd9 --- /dev/null +++ b/third_party/rust/ash/src/extensions/ext/debug_marker.rs @@ -0,0 +1,71 @@ +use crate::prelude::*; +use crate::vk; +use crate::{Device, Instance}; +use std::ffi::CStr; +use std::mem; + +#[derive(Clone)] +pub struct DebugMarker { + handle: vk::Device, + fp: vk::ExtDebugMarkerFn, +} + +impl DebugMarker { + pub fn new(instance: &Instance, device: &Device) -> Self { + let handle = device.handle(); + let fp = vk::ExtDebugMarkerFn::load(|name| unsafe { + mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr())) + }); + Self { handle, fp } + } + + /// + #[inline] + pub unsafe fn debug_marker_set_object_name( + &self, + name_info: &vk::DebugMarkerObjectNameInfoEXT, + ) -> VkResult<()> { + (self.fp.debug_marker_set_object_name_ext)(self.handle, name_info).result() + } + + /// + #[inline] + pub unsafe fn cmd_debug_marker_begin( + &self, + command_buffer: vk::CommandBuffer, + marker_info: &vk::DebugMarkerMarkerInfoEXT, + ) { + (self.fp.cmd_debug_marker_begin_ext)(command_buffer, marker_info); + } + + /// + #[inline] + pub unsafe fn cmd_debug_marker_end(&self, command_buffer: vk::CommandBuffer) { + (self.fp.cmd_debug_marker_end_ext)(command_buffer); + } + + /// + #[inline] + pub unsafe fn cmd_debug_marker_insert( + &self, + command_buffer: vk::CommandBuffer, + marker_info: &vk::DebugMarkerMarkerInfoEXT, + ) { + (self.fp.cmd_debug_marker_insert_ext)(command_buffer, marker_info); + } + + #[inline] + pub const fn name() -> &'static CStr { + vk::ExtDebugMarkerFn::name() + } + + #[inline] + pub fn fp(&self) -> &vk::ExtDebugMarkerFn { + &self.fp + } + + #[inline] + pub fn device(&self) -> vk::Device { + self.handle + } +} diff --git a/third_party/rust/ash/src/extensions/ext/debug_report.rs b/third_party/rust/ash/src/extensions/ext/debug_report.rs new file mode 100755 index 0000000000..625ebf479e --- /dev/null +++ b/third_party/rust/ash/src/extensions/ext/debug_report.rs @@ -0,0 +1,68 @@ +use crate::prelude::*; +use crate::vk; +use crate::RawPtr; +use crate::{Entry, Instance}; +use std::ffi::CStr; +use std::mem; + +#[derive(Clone)] +pub struct DebugReport { + handle: vk::Instance, + fp: vk::ExtDebugReportFn, +} + +impl DebugReport { + pub fn new(entry: &Entry, instance: &Instance) -> Self { + let handle = instance.handle(); + let fp = vk::ExtDebugReportFn::load(|name| unsafe { + mem::transmute(entry.get_instance_proc_addr(handle, name.as_ptr())) + }); + Self { handle, fp } + } + + /// + #[inline] + pub unsafe fn destroy_debug_report_callback( + &self, + debug: vk::DebugReportCallbackEXT, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) { + (self.fp.destroy_debug_report_callback_ext)( + self.handle, + debug, + allocation_callbacks.as_raw_ptr(), + ); + } + + /// + #[inline] + pub unsafe fn create_debug_report_callback( + &self, + create_info: &vk::DebugReportCallbackCreateInfoEXT, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) -> VkResult { + let mut debug_cb = mem::zeroed(); + (self.fp.create_debug_report_callback_ext)( + self.handle, + create_info, + allocation_callbacks.as_raw_ptr(), + &mut debug_cb, + ) + .result_with_success(debug_cb) + } + + #[inline] + pub const fn name() -> &'static CStr { + vk::ExtDebugReportFn::name() + } + + #[inline] + pub fn fp(&self) -> &vk::ExtDebugReportFn { + &self.fp + } + + #[inline] + pub fn instance(&self) -> vk::Instance { + self.handle + } +} diff --git a/third_party/rust/ash/src/extensions/ext/debug_utils.rs b/third_party/rust/ash/src/extensions/ext/debug_utils.rs new file mode 100755 index 0000000000..46d91769ad --- /dev/null +++ b/third_party/rust/ash/src/extensions/ext/debug_utils.rs @@ -0,0 +1,173 @@ +use crate::prelude::*; +use crate::{vk, RawPtr}; +use crate::{Entry, Instance}; +use std::ffi::CStr; +use std::mem; + +#[derive(Clone)] +pub struct DebugUtils { + handle: vk::Instance, + fp: vk::ExtDebugUtilsFn, +} + +impl DebugUtils { + pub fn new(entry: &Entry, instance: &Instance) -> Self { + let handle = instance.handle(); + let fp = vk::ExtDebugUtilsFn::load(|name| unsafe { + mem::transmute(entry.get_instance_proc_addr(handle, name.as_ptr())) + }); + Self { handle, fp } + } + + /// + #[deprecated = "Backwards-compatible alias containing a typo, use `set_debug_utils_object_name()` instead"] + #[inline] + pub unsafe fn debug_utils_set_object_name( + &self, + device: vk::Device, + name_info: &vk::DebugUtilsObjectNameInfoEXT, + ) -> VkResult<()> { + self.set_debug_utils_object_name(device, name_info) + } + + /// + #[inline] + pub unsafe fn set_debug_utils_object_name( + &self, + device: vk::Device, + name_info: &vk::DebugUtilsObjectNameInfoEXT, + ) -> VkResult<()> { + (self.fp.set_debug_utils_object_name_ext)(device, name_info).result() + } + + /// + #[deprecated = "Backwards-compatible alias containing a typo, use `set_debug_utils_object_tag()` instead"] + #[inline] + pub unsafe fn debug_utils_set_object_tag( + &self, + device: vk::Device, + tag_info: &vk::DebugUtilsObjectTagInfoEXT, + ) -> VkResult<()> { + self.set_debug_utils_object_tag(device, tag_info) + } + + /// + #[inline] + pub unsafe fn set_debug_utils_object_tag( + &self, + device: vk::Device, + tag_info: &vk::DebugUtilsObjectTagInfoEXT, + ) -> VkResult<()> { + (self.fp.set_debug_utils_object_tag_ext)(device, tag_info).result() + } + + /// + #[inline] + pub unsafe fn cmd_begin_debug_utils_label( + &self, + command_buffer: vk::CommandBuffer, + label: &vk::DebugUtilsLabelEXT, + ) { + (self.fp.cmd_begin_debug_utils_label_ext)(command_buffer, label); + } + + /// + #[inline] + pub unsafe fn cmd_end_debug_utils_label(&self, command_buffer: vk::CommandBuffer) { + (self.fp.cmd_end_debug_utils_label_ext)(command_buffer); + } + + /// + #[inline] + pub unsafe fn cmd_insert_debug_utils_label( + &self, + command_buffer: vk::CommandBuffer, + label: &vk::DebugUtilsLabelEXT, + ) { + (self.fp.cmd_insert_debug_utils_label_ext)(command_buffer, label); + } + + /// + #[inline] + pub unsafe fn queue_begin_debug_utils_label( + &self, + queue: vk::Queue, + label: &vk::DebugUtilsLabelEXT, + ) { + (self.fp.queue_begin_debug_utils_label_ext)(queue, label); + } + + /// + #[inline] + pub unsafe fn queue_end_debug_utils_label(&self, queue: vk::Queue) { + (self.fp.queue_end_debug_utils_label_ext)(queue); + } + + /// + #[inline] + pub unsafe fn queue_insert_debug_utils_label( + &self, + queue: vk::Queue, + label: &vk::DebugUtilsLabelEXT, + ) { + (self.fp.queue_insert_debug_utils_label_ext)(queue, label); + } + + /// + #[inline] + pub unsafe fn create_debug_utils_messenger( + &self, + create_info: &vk::DebugUtilsMessengerCreateInfoEXT, + allocator: Option<&vk::AllocationCallbacks>, + ) -> VkResult { + let mut messenger = mem::zeroed(); + (self.fp.create_debug_utils_messenger_ext)( + self.handle, + create_info, + allocator.as_raw_ptr(), + &mut messenger, + ) + .result_with_success(messenger) + } + + /// + #[inline] + pub unsafe fn destroy_debug_utils_messenger( + &self, + messenger: vk::DebugUtilsMessengerEXT, + allocator: Option<&vk::AllocationCallbacks>, + ) { + (self.fp.destroy_debug_utils_messenger_ext)(self.handle, messenger, allocator.as_raw_ptr()); + } + + /// + #[inline] + pub unsafe fn submit_debug_utils_message( + &self, + message_severity: vk::DebugUtilsMessageSeverityFlagsEXT, + message_types: vk::DebugUtilsMessageTypeFlagsEXT, + callback_data: &vk::DebugUtilsMessengerCallbackDataEXT, + ) { + (self.fp.submit_debug_utils_message_ext)( + self.handle, + message_severity, + message_types, + callback_data, + ); + } + + #[inline] + pub const fn name() -> &'static CStr { + vk::ExtDebugUtilsFn::name() + } + + #[inline] + pub fn fp(&self) -> &vk::ExtDebugUtilsFn { + &self.fp + } + + #[inline] + pub fn instance(&self) -> vk::Instance { + self.handle + } +} diff --git a/third_party/rust/ash/src/extensions/ext/descriptor_buffer.rs b/third_party/rust/ash/src/extensions/ext/descriptor_buffer.rs new file mode 100644 index 0000000000..4503f5bdab --- /dev/null +++ b/third_party/rust/ash/src/extensions/ext/descriptor_buffer.rs @@ -0,0 +1,211 @@ +use crate::prelude::*; +use crate::vk; +use crate::{Device, Instance}; +use std::ffi::CStr; +use std::mem; + +/// +#[derive(Clone)] +pub struct DescriptorBuffer { + handle: vk::Device, + fp: vk::ExtDescriptorBufferFn, +} + +impl DescriptorBuffer { + pub fn new(instance: &Instance, device: &Device) -> Self { + let handle = device.handle(); + let fp = vk::ExtDescriptorBufferFn::load(|name| unsafe { + mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr())) + }); + Self { handle, fp } + } + + /// + #[inline] + pub unsafe fn get_descriptor_set_layout_size( + &self, + layout: vk::DescriptorSetLayout, + ) -> vk::DeviceSize { + let mut count = 0; + (self.fp.get_descriptor_set_layout_size_ext)(self.handle, layout, &mut count); + count + } + + /// + #[inline] + pub unsafe fn get_descriptor_set_layout_binding_offset( + &self, + layout: vk::DescriptorSetLayout, + binding: u32, + ) -> vk::DeviceSize { + let mut offset = 0; + (self.fp.get_descriptor_set_layout_binding_offset_ext)( + self.handle, + layout, + binding, + &mut offset, + ); + offset + } + + /// + #[inline] + pub unsafe fn get_descriptor( + &self, + descriptor_info: &vk::DescriptorGetInfoEXT, + descriptor: &mut [u8], + ) { + (self.fp.get_descriptor_ext)( + self.handle, + descriptor_info, + descriptor.len(), + descriptor.as_mut_ptr().cast(), + ) + } + + /// + #[inline] + pub unsafe fn cmd_bind_descriptor_buffers( + &self, + command_buffer: vk::CommandBuffer, + binding_info: &[vk::DescriptorBufferBindingInfoEXT], + ) { + (self.fp.cmd_bind_descriptor_buffers_ext)( + command_buffer, + binding_info.len() as u32, + binding_info.as_ptr(), + ) + } + + /// + #[inline] + pub unsafe fn cmd_set_descriptor_buffer_offsets( + &self, + command_buffer: vk::CommandBuffer, + pipeline_bind_point: vk::PipelineBindPoint, + layout: vk::PipelineLayout, + first_set: u32, + buffer_indices: &[u32], + offsets: &[vk::DeviceSize], + ) { + assert_eq!(buffer_indices.len(), offsets.len()); + (self.fp.cmd_set_descriptor_buffer_offsets_ext)( + command_buffer, + pipeline_bind_point, + layout, + first_set, + buffer_indices.len() as u32, + buffer_indices.as_ptr(), + offsets.as_ptr(), + ) + } + + /// + #[inline] + pub unsafe fn cmd_bind_descriptor_buffer_embedded_samplers( + &self, + command_buffer: vk::CommandBuffer, + pipeline_bind_point: vk::PipelineBindPoint, + layout: vk::PipelineLayout, + set: u32, + ) { + (self.fp.cmd_bind_descriptor_buffer_embedded_samplers_ext)( + command_buffer, + pipeline_bind_point, + layout, + set, + ) + } + + /// + #[inline] + pub unsafe fn get_buffer_opaque_capture_descriptor_data( + &self, + info: &vk::BufferCaptureDescriptorDataInfoEXT, + data: &mut [u8], + ) -> VkResult<()> { + (self.fp.get_buffer_opaque_capture_descriptor_data_ext)( + self.handle, + info, + data.as_mut_ptr().cast(), + ) + .result() + } + + /// + #[inline] + pub unsafe fn get_image_opaque_capture_descriptor_data( + &self, + info: &vk::ImageCaptureDescriptorDataInfoEXT, + data: &mut [u8], + ) -> VkResult<()> { + (self.fp.get_image_opaque_capture_descriptor_data_ext)( + self.handle, + info, + data.as_mut_ptr().cast(), + ) + .result() + } + + /// + #[inline] + pub unsafe fn get_image_view_opaque_capture_descriptor_data( + &self, + info: &vk::ImageViewCaptureDescriptorDataInfoEXT, + data: &mut [u8], + ) -> VkResult<()> { + (self.fp.get_image_view_opaque_capture_descriptor_data_ext)( + self.handle, + info, + data.as_mut_ptr().cast(), + ) + .result() + } + + /// + #[inline] + pub unsafe fn get_sampler_opaque_capture_descriptor_data( + &self, + info: &vk::SamplerCaptureDescriptorDataInfoEXT, + data: &mut [u8], + ) -> VkResult<()> { + (self.fp.get_sampler_opaque_capture_descriptor_data_ext)( + self.handle, + info, + data.as_mut_ptr().cast(), + ) + .result() + } + + /// + #[inline] + pub unsafe fn get_acceleration_structure_opaque_capture_descriptor_data( + &self, + info: &vk::AccelerationStructureCaptureDescriptorDataInfoEXT, + data: &mut [u8], + ) -> VkResult<()> { + (self + .fp + .get_acceleration_structure_opaque_capture_descriptor_data_ext)( + self.handle, + info, + data.as_mut_ptr().cast(), + ) + .result() + } + + #[inline] + pub const fn name() -> &'static CStr { + vk::ExtDescriptorBufferFn::name() + } + + #[inline] + pub fn fp(&self) -> &vk::ExtDescriptorBufferFn { + &self.fp + } + + #[inline] + pub fn device(&self) -> vk::Device { + self.handle + } +} diff --git a/third_party/rust/ash/src/extensions/ext/extended_dynamic_state.rs b/third_party/rust/ash/src/extensions/ext/extended_dynamic_state.rs new file mode 100644 index 0000000000..2e6b3eeca3 --- /dev/null +++ b/third_party/rust/ash/src/extensions/ext/extended_dynamic_state.rs @@ -0,0 +1,196 @@ +use crate::vk; +use crate::{Device, Instance}; +use std::ffi::CStr; +use std::mem; +use std::ptr; + +#[derive(Clone)] +pub struct ExtendedDynamicState { + fp: vk::ExtExtendedDynamicStateFn, +} + +impl ExtendedDynamicState { + pub fn new(instance: &Instance, device: &Device) -> Self { + let fp = vk::ExtExtendedDynamicStateFn::load(|name| unsafe { + mem::transmute(instance.get_device_proc_addr(device.handle(), name.as_ptr())) + }); + Self { fp } + } + + /// + #[inline] + pub unsafe fn cmd_set_cull_mode( + &self, + command_buffer: vk::CommandBuffer, + cull_mode: vk::CullModeFlags, + ) { + (self.fp.cmd_set_cull_mode_ext)(command_buffer, cull_mode) + } + + /// + #[inline] + pub unsafe fn cmd_set_front_face( + &self, + command_buffer: vk::CommandBuffer, + front_face: vk::FrontFace, + ) { + (self.fp.cmd_set_front_face_ext)(command_buffer, front_face) + } + + /// + #[inline] + pub unsafe fn cmd_set_primitive_topology( + &self, + command_buffer: vk::CommandBuffer, + primitive_topology: vk::PrimitiveTopology, + ) { + (self.fp.cmd_set_primitive_topology_ext)(command_buffer, primitive_topology) + } + + /// + #[inline] + pub unsafe fn cmd_set_viewport_with_count( + &self, + command_buffer: vk::CommandBuffer, + viewports: &[vk::Viewport], + ) { + (self.fp.cmd_set_viewport_with_count_ext)( + command_buffer, + viewports.len() as u32, + viewports.as_ptr(), + ) + } + + /// + #[inline] + pub unsafe fn cmd_set_scissor_with_count( + &self, + command_buffer: vk::CommandBuffer, + scissors: &[vk::Rect2D], + ) { + (self.fp.cmd_set_scissor_with_count_ext)( + command_buffer, + scissors.len() as u32, + scissors.as_ptr(), + ) + } + + /// + #[inline] + pub unsafe fn cmd_bind_vertex_buffers2( + &self, + command_buffer: vk::CommandBuffer, + first_binding: u32, + buffers: &[vk::Buffer], + offsets: &[vk::DeviceSize], + sizes: Option<&[vk::DeviceSize]>, + strides: Option<&[vk::DeviceSize]>, + ) { + assert_eq!(offsets.len(), buffers.len()); + let p_sizes = if let Some(sizes) = sizes { + assert_eq!(sizes.len(), buffers.len()); + sizes.as_ptr() + } else { + ptr::null() + }; + let p_strides = if let Some(strides) = strides { + assert_eq!(strides.len(), buffers.len()); + strides.as_ptr() + } else { + ptr::null() + }; + (self.fp.cmd_bind_vertex_buffers2_ext)( + command_buffer, + first_binding, + buffers.len() as u32, + buffers.as_ptr(), + offsets.as_ptr(), + p_sizes, + p_strides, + ) + } + + /// + #[inline] + pub unsafe fn cmd_set_depth_test_enable( + &self, + command_buffer: vk::CommandBuffer, + depth_test_enable: bool, + ) { + (self.fp.cmd_set_depth_test_enable_ext)(command_buffer, depth_test_enable.into()) + } + + /// + #[inline] + pub unsafe fn cmd_set_depth_write_enable( + &self, + command_buffer: vk::CommandBuffer, + depth_write_enable: bool, + ) { + (self.fp.cmd_set_depth_write_enable_ext)(command_buffer, depth_write_enable.into()) + } + + /// + #[inline] + pub unsafe fn cmd_set_depth_compare_op( + &self, + command_buffer: vk::CommandBuffer, + depth_compare_op: vk::CompareOp, + ) { + (self.fp.cmd_set_depth_compare_op_ext)(command_buffer, depth_compare_op) + } + + /// + #[inline] + pub unsafe fn cmd_set_depth_bounds_test_enable( + &self, + command_buffer: vk::CommandBuffer, + depth_bounds_test_enable: bool, + ) { + (self.fp.cmd_set_depth_bounds_test_enable_ext)( + command_buffer, + depth_bounds_test_enable.into(), + ) + } + + /// + #[inline] + pub unsafe fn cmd_set_stencil_test_enable( + &self, + command_buffer: vk::CommandBuffer, + stencil_test_enable: bool, + ) { + (self.fp.cmd_set_stencil_test_enable_ext)(command_buffer, stencil_test_enable.into()) + } + + /// + #[inline] + pub unsafe fn cmd_set_stencil_op( + &self, + command_buffer: vk::CommandBuffer, + face_mask: vk::StencilFaceFlags, + fail_op: vk::StencilOp, + pass_op: vk::StencilOp, + depth_fail_op: vk::StencilOp, + compare_op: vk::CompareOp, + ) { + (self.fp.cmd_set_stencil_op_ext)( + command_buffer, + face_mask, + fail_op, + pass_op, + depth_fail_op, + compare_op, + ) + } + + #[inline] + pub const fn name() -> &'static CStr { + vk::ExtExtendedDynamicStateFn::name() + } + + #[inline] + pub fn fp(&self) -> &vk::ExtExtendedDynamicStateFn { + &self.fp + } +} diff --git a/third_party/rust/ash/src/extensions/ext/extended_dynamic_state2.rs b/third_party/rust/ash/src/extensions/ext/extended_dynamic_state2.rs new file mode 100644 index 0000000000..b515385930 --- /dev/null +++ b/third_party/rust/ash/src/extensions/ext/extended_dynamic_state2.rs @@ -0,0 +1,85 @@ +use crate::vk; +use crate::{Device, Instance}; +use std::ffi::CStr; +use std::mem; + +/// +#[derive(Clone)] +pub struct ExtendedDynamicState2 { + fp: vk::ExtExtendedDynamicState2Fn, +} + +impl ExtendedDynamicState2 { + pub fn new(instance: &Instance, device: &Device) -> Self { + let fp = vk::ExtExtendedDynamicState2Fn::load(|name| unsafe { + mem::transmute(instance.get_device_proc_addr(device.handle(), name.as_ptr())) + }); + Self { fp } + } + + /// + #[inline] + pub unsafe fn cmd_set_patch_control_points( + &self, + command_buffer: vk::CommandBuffer, + patch_control_points: u32, + ) { + (self.fp.cmd_set_patch_control_points_ext)(command_buffer, patch_control_points) + } + + /// + #[inline] + pub unsafe fn cmd_set_rasterizer_discard_enable( + &self, + command_buffer: vk::CommandBuffer, + rasterizer_discard_enable: bool, + ) { + (self.fp.cmd_set_rasterizer_discard_enable_ext)( + command_buffer, + rasterizer_discard_enable.into(), + ) + } + + /// + #[inline] + pub unsafe fn cmd_set_depth_bias_enable( + &self, + command_buffer: vk::CommandBuffer, + depth_bias_enable: bool, + ) { + (self.fp.cmd_set_depth_bias_enable_ext)(command_buffer, depth_bias_enable.into()) + } + + /// + #[inline] + pub unsafe fn cmd_set_logic_op( + &self, + command_buffer: vk::CommandBuffer, + logic_op: vk::LogicOp, + ) { + (self.fp.cmd_set_logic_op_ext)(command_buffer, logic_op) + } + + /// + #[inline] + pub unsafe fn cmd_set_primitive_restart_enable( + &self, + command_buffer: vk::CommandBuffer, + primitive_restart_enable: bool, + ) { + (self.fp.cmd_set_primitive_restart_enable_ext)( + command_buffer, + primitive_restart_enable.into(), + ) + } + + #[inline] + pub const fn name() -> &'static CStr { + vk::ExtExtendedDynamicState2Fn::name() + } + + #[inline] + pub fn fp(&self) -> &vk::ExtExtendedDynamicState2Fn { + &self.fp + } +} diff --git a/third_party/rust/ash/src/extensions/ext/extended_dynamic_state3.rs b/third_party/rust/ash/src/extensions/ext/extended_dynamic_state3.rs new file mode 100644 index 0000000000..bb68f75f3e --- /dev/null +++ b/third_party/rust/ash/src/extensions/ext/extended_dynamic_state3.rs @@ -0,0 +1,409 @@ +use crate::vk; +use crate::{Device, Instance}; +use std::ffi::CStr; +use std::mem; + +/// +#[derive(Clone)] +pub struct ExtendedDynamicState3 { + fp: vk::ExtExtendedDynamicState3Fn, +} + +impl ExtendedDynamicState3 { + pub fn new(instance: &Instance, device: &Device) -> Self { + let fp = vk::ExtExtendedDynamicState3Fn::load(|name| unsafe { + mem::transmute(instance.get_device_proc_addr(device.handle(), name.as_ptr())) + }); + Self { fp } + } + + /// + #[inline] + pub unsafe fn cmd_set_tessellation_domain_origin( + &self, + command_buffer: vk::CommandBuffer, + domain_origin: vk::TessellationDomainOrigin, + ) { + (self.fp.cmd_set_tessellation_domain_origin_ext)(command_buffer, domain_origin) + } + + /// + #[inline] + pub unsafe fn cmd_set_depth_clamp_enable( + &self, + command_buffer: vk::CommandBuffer, + depth_clamp_enable: bool, + ) { + (self.fp.cmd_set_depth_clamp_enable_ext)(command_buffer, depth_clamp_enable.into()) + } + + /// + #[inline] + pub unsafe fn cmd_set_polygon_mode( + &self, + command_buffer: vk::CommandBuffer, + polygon_mode: vk::PolygonMode, + ) { + (self.fp.cmd_set_polygon_mode_ext)(command_buffer, polygon_mode) + } + + /// + #[inline] + pub unsafe fn cmd_set_rasterization_samples( + &self, + command_buffer: vk::CommandBuffer, + rasterization_samples: vk::SampleCountFlags, + ) { + (self.fp.cmd_set_rasterization_samples_ext)(command_buffer, rasterization_samples) + } + + /// + #[inline] + pub unsafe fn cmd_set_sample_mask( + &self, + command_buffer: vk::CommandBuffer, + samples: vk::SampleCountFlags, + sample_mask: &[vk::SampleMask], + ) { + assert!( + samples.as_raw().is_power_of_two(), + "Only one SampleCount bit must be set" + ); + assert_eq!(samples.as_raw() as usize / 32, sample_mask.len()); + (self.fp.cmd_set_sample_mask_ext)(command_buffer, samples, sample_mask.as_ptr()) + } + + /// + #[inline] + pub unsafe fn cmd_set_alpha_to_coverage_enable( + &self, + command_buffer: vk::CommandBuffer, + alpha_to_coverage_enable: bool, + ) { + (self.fp.cmd_set_alpha_to_coverage_enable_ext)( + command_buffer, + alpha_to_coverage_enable.into(), + ) + } + + /// + #[inline] + pub unsafe fn cmd_set_alpha_to_one_enable( + &self, + command_buffer: vk::CommandBuffer, + alpha_to_one_enable: bool, + ) { + (self.fp.cmd_set_alpha_to_one_enable_ext)(command_buffer, alpha_to_one_enable.into()) + } + + /// + #[inline] + pub unsafe fn cmd_set_logic_op_enable( + &self, + command_buffer: vk::CommandBuffer, + logic_op_enable: bool, + ) { + (self.fp.cmd_set_logic_op_enable_ext)(command_buffer, logic_op_enable.into()) + } + + /// + #[inline] + pub unsafe fn cmd_set_color_blend_enable( + &self, + command_buffer: vk::CommandBuffer, + first_attachment: u32, + color_blend_enables: &[vk::Bool32], + ) { + (self.fp.cmd_set_color_blend_enable_ext)( + command_buffer, + first_attachment, + color_blend_enables.len() as u32, + color_blend_enables.as_ptr(), + ) + } + + /// + #[inline] + pub unsafe fn cmd_set_color_blend_equation( + &self, + command_buffer: vk::CommandBuffer, + first_attachment: u32, + color_blend_equations: &[vk::ColorBlendEquationEXT], + ) { + (self.fp.cmd_set_color_blend_equation_ext)( + command_buffer, + first_attachment, + color_blend_equations.len() as u32, + color_blend_equations.as_ptr(), + ) + } + + /// + #[inline] + pub unsafe fn cmd_set_color_write_mask( + &self, + command_buffer: vk::CommandBuffer, + first_attachment: u32, + color_write_masks: &[vk::ColorComponentFlags], + ) { + (self.fp.cmd_set_color_write_mask_ext)( + command_buffer, + first_attachment, + color_write_masks.len() as u32, + color_write_masks.as_ptr(), + ) + } + + /// + #[inline] + pub unsafe fn cmd_set_rasterization_stream( + &self, + command_buffer: vk::CommandBuffer, + rasterization_stream: u32, + ) { + (self.fp.cmd_set_rasterization_stream_ext)(command_buffer, rasterization_stream) + } + + /// + #[inline] + pub unsafe fn cmd_set_conservative_rasterization_mode( + &self, + command_buffer: vk::CommandBuffer, + conservative_rasterization_mode: vk::ConservativeRasterizationModeEXT, + ) { + (self.fp.cmd_set_conservative_rasterization_mode_ext)( + command_buffer, + conservative_rasterization_mode, + ) + } + + /// + #[inline] + pub unsafe fn cmd_set_extra_primitive_overestimation_size( + &self, + command_buffer: vk::CommandBuffer, + extra_primitive_overestimation_size: f32, + ) { + (self.fp.cmd_set_extra_primitive_overestimation_size_ext)( + command_buffer, + extra_primitive_overestimation_size, + ) + } + + /// + #[inline] + pub unsafe fn cmd_set_depth_clip_enable( + &self, + command_buffer: vk::CommandBuffer, + depth_clip_enable: bool, + ) { + (self.fp.cmd_set_depth_clip_enable_ext)(command_buffer, depth_clip_enable.into()) + } + + /// + #[inline] + pub unsafe fn cmd_set_sample_locations_enable( + &self, + command_buffer: vk::CommandBuffer, + sample_locations_enable: bool, + ) { + (self.fp.cmd_set_sample_locations_enable_ext)( + command_buffer, + sample_locations_enable.into(), + ) + } + + /// + #[inline] + pub unsafe fn cmd_set_color_blend_advanced( + &self, + command_buffer: vk::CommandBuffer, + first_attachment: u32, + color_blend_advanced: &[vk::ColorBlendAdvancedEXT], + ) { + (self.fp.cmd_set_color_blend_advanced_ext)( + command_buffer, + first_attachment, + color_blend_advanced.len() as u32, + color_blend_advanced.as_ptr(), + ) + } + + /// + #[inline] + pub unsafe fn cmd_set_provoking_vertex_mode( + &self, + command_buffer: vk::CommandBuffer, + provoking_vertex_mode: vk::ProvokingVertexModeEXT, + ) { + (self.fp.cmd_set_provoking_vertex_mode_ext)(command_buffer, provoking_vertex_mode) + } + + /// + #[inline] + pub unsafe fn cmd_set_line_rasterization_mode( + &self, + command_buffer: vk::CommandBuffer, + line_rasterization_mode: vk::LineRasterizationModeEXT, + ) { + (self.fp.cmd_set_line_rasterization_mode_ext)(command_buffer, line_rasterization_mode) + } + + /// + #[inline] + pub unsafe fn cmd_set_line_stipple_enable( + &self, + command_buffer: vk::CommandBuffer, + stippled_line_enable: bool, + ) { + (self.fp.cmd_set_line_stipple_enable_ext)(command_buffer, stippled_line_enable.into()) + } + + /// + #[inline] + pub unsafe fn cmd_set_depth_clip_negative_one_to_one( + &self, + command_buffer: vk::CommandBuffer, + negative_one_to_one: bool, + ) { + (self.fp.cmd_set_depth_clip_negative_one_to_one_ext)( + command_buffer, + negative_one_to_one.into(), + ) + } + + /// + #[inline] + pub unsafe fn cmd_set_viewport_w_scaling_enable_nv( + &self, + command_buffer: vk::CommandBuffer, + viewport_w_scaling_enable: bool, + ) { + (self.fp.cmd_set_viewport_w_scaling_enable_nv)( + command_buffer, + viewport_w_scaling_enable.into(), + ) + } + + /// + #[inline] + pub unsafe fn cmd_set_viewport_swizzle_nv( + &self, + command_buffer: vk::CommandBuffer, + first_attachment: u32, + viewport_swizzles: &[vk::ViewportSwizzleNV], + ) { + (self.fp.cmd_set_viewport_swizzle_nv)( + command_buffer, + first_attachment, + viewport_swizzles.len() as u32, + viewport_swizzles.as_ptr(), + ) + } + + /// + #[inline] + pub unsafe fn cmd_set_coverage_to_color_enable_nv( + &self, + command_buffer: vk::CommandBuffer, + coverage_to_color_enable: bool, + ) { + (self.fp.cmd_set_coverage_to_color_enable_nv)( + command_buffer, + coverage_to_color_enable.into(), + ) + } + + /// + #[inline] + pub unsafe fn cmd_set_coverage_to_color_location_nv( + &self, + command_buffer: vk::CommandBuffer, + coverage_to_color_location: u32, + ) { + (self.fp.cmd_set_coverage_to_color_location_nv)(command_buffer, coverage_to_color_location) + } + + /// + #[inline] + pub unsafe fn cmd_set_coverage_modulation_mode_nv( + &self, + command_buffer: vk::CommandBuffer, + coverage_modulation_mode: vk::CoverageModulationModeNV, + ) { + (self.fp.cmd_set_coverage_modulation_mode_nv)(command_buffer, coverage_modulation_mode) + } + + /// + #[inline] + pub unsafe fn cmd_set_coverage_modulation_table_enable_nv( + &self, + command_buffer: vk::CommandBuffer, + coverage_modulation_table_enable: bool, + ) { + (self.fp.cmd_set_coverage_modulation_table_enable_nv)( + command_buffer, + coverage_modulation_table_enable.into(), + ) + } + + /// + #[inline] + pub unsafe fn cmd_set_coverage_modulation_table_nv( + &self, + command_buffer: vk::CommandBuffer, + coverage_modulation_table: &[f32], + ) { + (self.fp.cmd_set_coverage_modulation_table_nv)( + command_buffer, + coverage_modulation_table.len() as u32, + coverage_modulation_table.as_ptr(), + ) + } + + /// + #[inline] + pub unsafe fn cmd_set_shading_rate_image_enable_nv( + &self, + command_buffer: vk::CommandBuffer, + shading_rate_image_enable: bool, + ) { + (self.fp.cmd_set_shading_rate_image_enable_nv)( + command_buffer, + shading_rate_image_enable.into(), + ) + } + + /// + #[inline] + pub unsafe fn cmd_set_representative_fragment_test_enable_nv( + &self, + command_buffer: vk::CommandBuffer, + representative_fragment_test_enable: bool, + ) { + (self.fp.cmd_set_representative_fragment_test_enable_nv)( + command_buffer, + representative_fragment_test_enable.into(), + ) + } + + /// + #[inline] + pub unsafe fn cmd_set_coverage_reduction_mode_nv( + &self, + command_buffer: vk::CommandBuffer, + coverage_reduction_mode: vk::CoverageReductionModeNV, + ) { + (self.fp.cmd_set_coverage_reduction_mode_nv)(command_buffer, coverage_reduction_mode) + } + + #[inline] + pub const fn name() -> &'static CStr { + vk::ExtExtendedDynamicState3Fn::name() + } + + #[inline] + pub fn fp(&self) -> &vk::ExtExtendedDynamicState3Fn { + &self.fp + } +} diff --git a/third_party/rust/ash/src/extensions/ext/full_screen_exclusive.rs b/third_party/rust/ash/src/extensions/ext/full_screen_exclusive.rs new file mode 100644 index 0000000000..3cb73cdaeb --- /dev/null +++ b/third_party/rust/ash/src/extensions/ext/full_screen_exclusive.rs @@ -0,0 +1,86 @@ +use crate::prelude::*; +use crate::vk; +use crate::{Device, Instance}; +use std::ffi::CStr; +use std::mem; + +#[derive(Clone)] +pub struct FullScreenExclusive { + handle: vk::Device, + fp: vk::ExtFullScreenExclusiveFn, +} + +impl FullScreenExclusive { + pub fn new(instance: &Instance, device: &Device) -> Self { + let handle = device.handle(); + let fp = vk::ExtFullScreenExclusiveFn::load(|name| unsafe { + mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr())) + }); + Self { handle, fp } + } + + /// + #[inline] + pub unsafe fn acquire_full_screen_exclusive_mode( + &self, + swapchain: vk::SwapchainKHR, + ) -> VkResult<()> { + (self.fp.acquire_full_screen_exclusive_mode_ext)(self.handle, swapchain).result() + } + + /// + #[inline] + pub unsafe fn get_physical_device_surface_present_modes2( + &self, + physical_device: vk::PhysicalDevice, + surface_info: &vk::PhysicalDeviceSurfaceInfo2KHR, + ) -> VkResult> { + read_into_uninitialized_vector(|count, data| { + (self.fp.get_physical_device_surface_present_modes2_ext)( + physical_device, + surface_info, + count, + data, + ) + }) + } + + /// + #[inline] + pub unsafe fn release_full_screen_exclusive_mode( + &self, + swapchain: vk::SwapchainKHR, + ) -> VkResult<()> { + (self.fp.release_full_screen_exclusive_mode_ext)(self.handle, swapchain).result() + } + + /// + #[inline] + pub unsafe fn get_device_group_surface_present_modes2( + &self, + surface_info: &vk::PhysicalDeviceSurfaceInfo2KHR, + ) -> VkResult { + let mut present_modes = mem::zeroed(); + (self.fp.get_device_group_surface_present_modes2_ext)( + self.handle, + surface_info, + &mut present_modes, + ) + .result_with_success(present_modes) + } + + #[inline] + pub const fn name() -> &'static CStr { + vk::ExtFullScreenExclusiveFn::name() + } + + #[inline] + pub fn fp(&self) -> &vk::ExtFullScreenExclusiveFn { + &self.fp + } + + #[inline] + pub fn device(&self) -> vk::Device { + self.handle + } +} diff --git a/third_party/rust/ash/src/extensions/ext/headless_surface.rs b/third_party/rust/ash/src/extensions/ext/headless_surface.rs new file mode 100644 index 0000000000..fe04236aaf --- /dev/null +++ b/third_party/rust/ash/src/extensions/ext/headless_surface.rs @@ -0,0 +1,55 @@ +use crate::prelude::*; +use crate::vk; +use crate::RawPtr; +use crate::{Entry, Instance}; +use std::ffi::CStr; +use std::mem; + +/// +#[derive(Clone)] +pub struct HeadlessSurface { + handle: vk::Instance, + fp: vk::ExtHeadlessSurfaceFn, +} + +impl HeadlessSurface { + pub fn new(entry: &Entry, instance: &Instance) -> Self { + let handle = instance.handle(); + let fp = vk::ExtHeadlessSurfaceFn::load(|name| unsafe { + mem::transmute(entry.get_instance_proc_addr(handle, name.as_ptr())) + }); + Self { handle, fp } + } + + /// + #[inline] + pub unsafe fn create_headless_surface( + &self, + create_info: &vk::HeadlessSurfaceCreateInfoEXT, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) -> VkResult { + let mut surface = mem::zeroed(); + (self.fp.create_headless_surface_ext)( + self.handle, + create_info, + allocation_callbacks.as_raw_ptr(), + &mut surface, + ) + .result_with_success(surface) + } + + #[inline] + pub const fn name() -> &'static CStr { + vk::ExtHeadlessSurfaceFn::name() + } + + #[inline] + pub fn fp(&self) -> &vk::ExtHeadlessSurfaceFn { + &self.fp + } + + #[inline] + pub fn instance(&self) -> vk::Instance { + self.handle + } +} diff --git a/third_party/rust/ash/src/extensions/ext/image_compression_control.rs b/third_party/rust/ash/src/extensions/ext/image_compression_control.rs new file mode 100644 index 0000000000..a326116973 --- /dev/null +++ b/third_party/rust/ash/src/extensions/ext/image_compression_control.rs @@ -0,0 +1,47 @@ +use crate::vk; +use crate::{Device, Instance}; +use std::ffi::CStr; +use std::mem; + +/// +#[derive(Clone)] +pub struct ImageCompressionControl { + handle: vk::Device, + fp: vk::ExtImageCompressionControlFn, +} + +impl ImageCompressionControl { + pub fn new(instance: &Instance, device: &Device) -> Self { + let handle = device.handle(); + let fp = vk::ExtImageCompressionControlFn::load(|name| unsafe { + mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr())) + }); + Self { handle, fp } + } + + /// + #[inline] + pub unsafe fn get_image_subresource_layout2( + &self, + image: vk::Image, + subresource: &vk::ImageSubresource2EXT, + layout: &mut vk::SubresourceLayout2EXT, + ) { + (self.fp.get_image_subresource_layout2_ext)(self.handle, image, subresource, layout) + } + + #[inline] + pub const fn name() -> &'static CStr { + vk::ExtImageCompressionControlFn::name() + } + + #[inline] + pub fn fp(&self) -> &vk::ExtImageCompressionControlFn { + &self.fp + } + + #[inline] + pub fn device(&self) -> vk::Device { + self.handle + } +} diff --git a/third_party/rust/ash/src/extensions/ext/image_drm_format_modifier.rs b/third_party/rust/ash/src/extensions/ext/image_drm_format_modifier.rs new file mode 100644 index 0000000000..ccdce2eb5e --- /dev/null +++ b/third_party/rust/ash/src/extensions/ext/image_drm_format_modifier.rs @@ -0,0 +1,48 @@ +use crate::prelude::*; +use crate::vk; +use crate::{Device, Instance}; +use std::ffi::CStr; +use std::mem; + +/// +#[derive(Clone)] +pub struct ImageDrmFormatModifier { + handle: vk::Device, + fp: vk::ExtImageDrmFormatModifierFn, +} + +impl ImageDrmFormatModifier { + pub fn new(instance: &Instance, device: &Device) -> Self { + let handle = device.handle(); + let fp = vk::ExtImageDrmFormatModifierFn::load(|name| unsafe { + mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr())) + }); + Self { handle, fp } + } + + /// + #[inline] + pub unsafe fn get_image_drm_format_modifier_properties( + &self, + image: vk::Image, + properties: &mut vk::ImageDrmFormatModifierPropertiesEXT, + ) -> VkResult<()> { + (self.fp.get_image_drm_format_modifier_properties_ext)(self.handle, image, properties) + .result() + } + + #[inline] + pub const fn name() -> &'static CStr { + vk::ExtImageDrmFormatModifierFn::name() + } + + #[inline] + pub fn fp(&self) -> &vk::ExtImageDrmFormatModifierFn { + &self.fp + } + + #[inline] + pub fn device(&self) -> vk::Device { + self.handle + } +} diff --git a/third_party/rust/ash/src/extensions/ext/mesh_shader.rs b/third_party/rust/ash/src/extensions/ext/mesh_shader.rs new file mode 100644 index 0000000000..7d58f0c135 --- /dev/null +++ b/third_party/rust/ash/src/extensions/ext/mesh_shader.rs @@ -0,0 +1,94 @@ +use crate::vk; +use crate::{Device, Instance}; +use std::ffi::CStr; +use std::mem; + +/// +#[derive(Clone)] +pub struct MeshShader { + fp: vk::ExtMeshShaderFn, +} + +impl MeshShader { + pub fn new(instance: &Instance, device: &Device) -> Self { + let fp = vk::ExtMeshShaderFn::load(|name| unsafe { + mem::transmute(instance.get_device_proc_addr(device.handle(), name.as_ptr())) + }); + Self { fp } + } + + /// + #[inline] + pub unsafe fn cmd_draw_mesh_tasks( + &self, + command_buffer: vk::CommandBuffer, + group_count_x: u32, + group_count_y: u32, + group_count_z: u32, + ) { + (self.fp.cmd_draw_mesh_tasks_ext)( + command_buffer, + group_count_x, + group_count_y, + group_count_z, + ); + } + + /// + /// + /// `buffer` contains `draw_count` [`vk::DrawMeshTasksIndirectCommandEXT`] structures starting at `offset` in bytes, holding the draw parameters. + #[inline] + pub unsafe fn cmd_draw_mesh_tasks_indirect( + &self, + command_buffer: vk::CommandBuffer, + buffer: vk::Buffer, + offset: vk::DeviceSize, + draw_count: u32, + stride: u32, + ) { + (self.fp.cmd_draw_mesh_tasks_indirect_ext)( + command_buffer, + buffer, + offset, + draw_count, + stride, + ); + } + + /// + /// + /// `buffer` contains a maximum of `max_draw_count` [`vk::DrawMeshTasksIndirectCommandEXT`] structures starting at `offset` in bytes, holding the draw parameters. + /// `count_buffer` is the buffer containing the draw count, starting at `count_buffer_offset` in bytes. + /// The actual number of executed draw calls is the minimum of the count specified in `count_buffer` and `max_draw_count`. + #[inline] + pub unsafe fn cmd_draw_mesh_tasks_indirect_count( + &self, + command_buffer: vk::CommandBuffer, + buffer: vk::Buffer, + offset: vk::DeviceSize, + count_buffer: vk::Buffer, + count_buffer_offset: vk::DeviceSize, + max_draw_count: u32, + stride: u32, + ) { + (self.fp.cmd_draw_mesh_tasks_indirect_count_ext)( + command_buffer, + buffer, + offset, + count_buffer, + count_buffer_offset, + max_draw_count, + stride, + ); + } + + #[inline] + pub const fn name() -> &'static CStr { + vk::ExtMeshShaderFn::name() + } + + #[inline] + pub fn fp(&self) -> &vk::ExtMeshShaderFn { + &self.fp + } +} diff --git a/third_party/rust/ash/src/extensions/ext/metal_surface.rs b/third_party/rust/ash/src/extensions/ext/metal_surface.rs new file mode 100644 index 0000000000..9627d2f510 --- /dev/null +++ b/third_party/rust/ash/src/extensions/ext/metal_surface.rs @@ -0,0 +1,54 @@ +use crate::prelude::*; +use crate::vk; +use crate::RawPtr; +use crate::{Entry, Instance}; +use std::ffi::CStr; +use std::mem; + +#[derive(Clone)] +pub struct MetalSurface { + handle: vk::Instance, + fp: vk::ExtMetalSurfaceFn, +} + +impl MetalSurface { + pub fn new(entry: &Entry, instance: &Instance) -> Self { + let handle = instance.handle(); + let fp = vk::ExtMetalSurfaceFn::load(|name| unsafe { + mem::transmute(entry.get_instance_proc_addr(handle, name.as_ptr())) + }); + Self { handle, fp } + } + + /// + #[inline] + pub unsafe fn create_metal_surface( + &self, + create_info: &vk::MetalSurfaceCreateInfoEXT, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) -> VkResult { + let mut surface = mem::zeroed(); + (self.fp.create_metal_surface_ext)( + self.handle, + create_info, + allocation_callbacks.as_raw_ptr(), + &mut surface, + ) + .result_with_success(surface) + } + + #[inline] + pub const fn name() -> &'static CStr { + vk::ExtMetalSurfaceFn::name() + } + + #[inline] + pub fn fp(&self) -> &vk::ExtMetalSurfaceFn { + &self.fp + } + + #[inline] + pub fn instance(&self) -> vk::Instance { + self.handle + } +} diff --git a/third_party/rust/ash/src/extensions/ext/mod.rs b/third_party/rust/ash/src/extensions/ext/mod.rs new file mode 100644 index 0000000000..26a78f77d6 --- /dev/null +++ b/third_party/rust/ash/src/extensions/ext/mod.rs @@ -0,0 +1,45 @@ +pub use self::acquire_drm_display::AcquireDrmDisplay; +pub use self::buffer_device_address::BufferDeviceAddress; +pub use self::calibrated_timestamps::CalibratedTimestamps; +#[allow(deprecated)] +pub use self::debug_marker::DebugMarker; +#[allow(deprecated)] +pub use self::debug_report::DebugReport; +pub use self::debug_utils::DebugUtils; +pub use self::descriptor_buffer::DescriptorBuffer; +pub use self::extended_dynamic_state::ExtendedDynamicState; +pub use self::extended_dynamic_state2::ExtendedDynamicState2; +pub use self::extended_dynamic_state3::ExtendedDynamicState3; +pub use self::full_screen_exclusive::FullScreenExclusive; +pub use self::headless_surface::HeadlessSurface; +pub use self::image_compression_control::ImageCompressionControl; +pub use self::image_drm_format_modifier::ImageDrmFormatModifier; +pub use self::mesh_shader::MeshShader; +pub use self::metal_surface::MetalSurface; +pub use self::physical_device_drm::PhysicalDeviceDrm; +pub use self::private_data::PrivateData; +pub use self::sample_locations::SampleLocations; +pub use self::tooling_info::ToolingInfo; + +mod acquire_drm_display; +mod buffer_device_address; +mod calibrated_timestamps; +#[deprecated(note = "Please use the [DebugUtils](struct.DebugUtils.html) extension instead.")] +mod debug_marker; +#[deprecated(note = "Please use the [DebugUtils](struct.DebugUtils.html) extension instead.")] +mod debug_report; +mod debug_utils; +mod descriptor_buffer; +mod extended_dynamic_state; +mod extended_dynamic_state2; +mod extended_dynamic_state3; +mod full_screen_exclusive; +mod headless_surface; +mod image_compression_control; +mod image_drm_format_modifier; +mod mesh_shader; +mod metal_surface; +mod physical_device_drm; +mod private_data; +mod sample_locations; +mod tooling_info; diff --git a/third_party/rust/ash/src/extensions/ext/physical_device_drm.rs b/third_party/rust/ash/src/extensions/ext/physical_device_drm.rs new file mode 100644 index 0000000000..29b6cd7b32 --- /dev/null +++ b/third_party/rust/ash/src/extensions/ext/physical_device_drm.rs @@ -0,0 +1,26 @@ +use crate::vk; +use crate::Instance; +use std::ffi::CStr; + +#[derive(Clone)] +pub struct PhysicalDeviceDrm; + +impl PhysicalDeviceDrm { + #[inline] + pub unsafe fn get_properties( + instance: &Instance, + pdevice: vk::PhysicalDevice, + ) -> vk::PhysicalDeviceDrmPropertiesEXT { + let mut props_drm = vk::PhysicalDeviceDrmPropertiesEXT::default(); + { + let mut props = vk::PhysicalDeviceProperties2::builder().push_next(&mut props_drm); + instance.get_physical_device_properties2(pdevice, &mut props); + } + props_drm + } + + #[inline] + pub const fn name() -> &'static CStr { + vk::ExtPhysicalDeviceDrmFn::name() + } +} diff --git a/third_party/rust/ash/src/extensions/ext/private_data.rs b/third_party/rust/ash/src/extensions/ext/private_data.rs new file mode 100644 index 0000000000..c6cc6aefb1 --- /dev/null +++ b/third_party/rust/ash/src/extensions/ext/private_data.rs @@ -0,0 +1,105 @@ +use crate::prelude::*; +use crate::vk; +use crate::RawPtr; +use crate::{Device, Instance}; +use std::ffi::CStr; +use std::mem; + +/// +#[derive(Clone)] +pub struct PrivateData { + handle: vk::Device, + fp: vk::ExtPrivateDataFn, +} + +impl PrivateData { + pub fn new(instance: &Instance, device: &Device) -> Self { + let handle = device.handle(); + let fp = vk::ExtPrivateDataFn::load(|name| unsafe { + mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr())) + }); + Self { handle, fp } + } + + /// + #[inline] + pub unsafe fn create_private_data_slot( + &self, + create_info: &vk::PrivateDataSlotCreateInfoEXT, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) -> VkResult { + let mut private_data_slot = mem::zeroed(); + (self.fp.create_private_data_slot_ext)( + self.handle, + create_info, + allocation_callbacks.as_raw_ptr(), + &mut private_data_slot, + ) + .result_with_success(private_data_slot) + } + + /// + #[inline] + pub unsafe fn destroy_private_data_slot( + &self, + private_data_slot: vk::PrivateDataSlotEXT, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) { + (self.fp.destroy_private_data_slot_ext)( + self.handle, + private_data_slot, + allocation_callbacks.as_raw_ptr(), + ) + } + + /// + #[inline] + pub unsafe fn set_private_data( + &self, + object: T, + private_data_slot: vk::PrivateDataSlotEXT, + data: u64, + ) -> VkResult<()> { + (self.fp.set_private_data_ext)( + self.handle, + T::TYPE, + object.as_raw(), + private_data_slot, + data, + ) + .result() + } + + /// + #[inline] + pub unsafe fn get_private_data( + &self, + object: T, + private_data_slot: vk::PrivateDataSlotEXT, + ) -> u64 { + let mut data = mem::zeroed(); + (self.fp.get_private_data_ext)( + self.handle, + T::TYPE, + object.as_raw(), + private_data_slot, + &mut data, + ); + data + } + + #[inline] + pub const fn name() -> &'static CStr { + vk::ExtPrivateDataFn::name() + } + + #[inline] + pub fn fp(&self) -> &vk::ExtPrivateDataFn { + &self.fp + } + + #[inline] + pub fn device(&self) -> vk::Device { + self.handle + } +} diff --git a/third_party/rust/ash/src/extensions/ext/sample_locations.rs b/third_party/rust/ash/src/extensions/ext/sample_locations.rs new file mode 100644 index 0000000000..360b83a681 --- /dev/null +++ b/third_party/rust/ash/src/extensions/ext/sample_locations.rs @@ -0,0 +1,54 @@ +use crate::vk; +use crate::{Entry, Instance}; +use std::ffi::CStr; +use std::mem; + +/// +#[derive(Clone)] +pub struct SampleLocations { + fp: vk::ExtSampleLocationsFn, +} + +impl SampleLocations { + pub fn new(entry: &Entry, instance: &Instance) -> Self { + let fp = vk::ExtSampleLocationsFn::load(|name| unsafe { + mem::transmute(entry.get_instance_proc_addr(instance.handle(), name.as_ptr())) + }); + Self { fp } + } + + /// + #[inline] + pub unsafe fn get_physical_device_multisample_properties( + &self, + physical_device: vk::PhysicalDevice, + samples: vk::SampleCountFlags, + multisample_properties: &mut vk::MultisamplePropertiesEXT, + ) { + (self.fp.get_physical_device_multisample_properties_ext)( + physical_device, + samples, + multisample_properties, + ) + } + + /// + #[inline] + pub unsafe fn cmd_set_sample_locations( + &self, + command_buffer: vk::CommandBuffer, + sample_locations_info: &vk::SampleLocationsInfoEXT, + ) { + (self.fp.cmd_set_sample_locations_ext)(command_buffer, sample_locations_info) + } + + #[inline] + pub const fn name() -> &'static CStr { + vk::ExtSampleLocationsFn::name() + } + + #[inline] + pub fn fp(&self) -> &vk::ExtSampleLocationsFn { + &self.fp + } +} diff --git a/third_party/rust/ash/src/extensions/ext/tooling_info.rs b/third_party/rust/ash/src/extensions/ext/tooling_info.rs new file mode 100644 index 0000000000..fd4bf994e7 --- /dev/null +++ b/third_party/rust/ash/src/extensions/ext/tooling_info.rs @@ -0,0 +1,40 @@ +use crate::prelude::*; +use crate::vk; +use crate::{Entry, Instance}; +use std::ffi::CStr; +use std::mem; + +#[derive(Clone)] +pub struct ToolingInfo { + fp: vk::ExtToolingInfoFn, +} + +impl ToolingInfo { + pub fn new(entry: &Entry, instance: &Instance) -> Self { + let fp = vk::ExtToolingInfoFn::load(|name| unsafe { + mem::transmute(entry.get_instance_proc_addr(instance.handle(), name.as_ptr())) + }); + Self { fp } + } + + /// + #[inline] + pub unsafe fn get_physical_device_tool_properties( + &self, + physical_device: vk::PhysicalDevice, + ) -> VkResult> { + read_into_defaulted_vector(|count, data| { + (self.fp.get_physical_device_tool_properties_ext)(physical_device, count, data) + }) + } + + #[inline] + pub const fn name() -> &'static CStr { + vk::ExtToolingInfoFn::name() + } + + #[inline] + pub fn fp(&self) -> &vk::ExtToolingInfoFn { + &self.fp + } +} diff --git a/third_party/rust/ash/src/extensions/khr/acceleration_structure.rs b/third_party/rust/ash/src/extensions/khr/acceleration_structure.rs new file mode 100644 index 0000000000..9772e9baf4 --- /dev/null +++ b/third_party/rust/ash/src/extensions/khr/acceleration_structure.rs @@ -0,0 +1,322 @@ +use crate::prelude::*; +use crate::vk; +use crate::RawPtr; +use crate::{Device, Instance}; +use std::ffi::CStr; +use std::mem; + +#[derive(Clone)] +pub struct AccelerationStructure { + handle: vk::Device, + fp: vk::KhrAccelerationStructureFn, +} + +impl AccelerationStructure { + pub fn new(instance: &Instance, device: &Device) -> Self { + let handle = device.handle(); + let fp = vk::KhrAccelerationStructureFn::load(|name| unsafe { + mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr())) + }); + Self { handle, fp } + } + + #[inline] + pub unsafe fn get_properties( + instance: &Instance, + pdevice: vk::PhysicalDevice, + ) -> vk::PhysicalDeviceAccelerationStructurePropertiesKHR { + let mut props_rt = vk::PhysicalDeviceAccelerationStructurePropertiesKHR::default(); + { + let mut props = vk::PhysicalDeviceProperties2::builder().push_next(&mut props_rt); + instance.get_physical_device_properties2(pdevice, &mut props); + } + props_rt + } + + /// + #[inline] + pub unsafe fn create_acceleration_structure( + &self, + create_info: &vk::AccelerationStructureCreateInfoKHR, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) -> VkResult { + let mut accel_struct = mem::zeroed(); + (self.fp.create_acceleration_structure_khr)( + self.handle, + create_info, + allocation_callbacks.as_raw_ptr(), + &mut accel_struct, + ) + .result_with_success(accel_struct) + } + + /// + #[inline] + pub unsafe fn destroy_acceleration_structure( + &self, + accel_struct: vk::AccelerationStructureKHR, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) { + (self.fp.destroy_acceleration_structure_khr)( + self.handle, + accel_struct, + allocation_callbacks.as_raw_ptr(), + ); + } + + /// + #[inline] + pub unsafe fn cmd_build_acceleration_structures( + &self, + command_buffer: vk::CommandBuffer, + infos: &[vk::AccelerationStructureBuildGeometryInfoKHR], + build_range_infos: &[&[vk::AccelerationStructureBuildRangeInfoKHR]], + ) { + assert_eq!(infos.len(), build_range_infos.len()); + + let build_range_infos = build_range_infos + .iter() + .zip(infos.iter()) + .map(|(range_info, info)| { + assert_eq!(range_info.len(), info.geometry_count as usize); + range_info.as_ptr() + }) + .collect::>(); + + (self.fp.cmd_build_acceleration_structures_khr)( + command_buffer, + infos.len() as _, + infos.as_ptr(), + build_range_infos.as_ptr(), + ); + } + + /// + #[inline] + pub unsafe fn cmd_build_acceleration_structures_indirect( + &self, + command_buffer: vk::CommandBuffer, + infos: &[vk::AccelerationStructureBuildGeometryInfoKHR], + indirect_device_addresses: &[vk::DeviceAddress], + indirect_strides: &[u32], + max_primitive_counts: &[&[u32]], + ) { + assert_eq!(infos.len(), indirect_device_addresses.len()); + assert_eq!(infos.len(), indirect_strides.len()); + assert_eq!(infos.len(), max_primitive_counts.len()); + + let max_primitive_counts = max_primitive_counts + .iter() + .zip(infos.iter()) + .map(|(cnt, info)| { + assert_eq!(cnt.len(), info.geometry_count as usize); + cnt.as_ptr() + }) + .collect::>(); + + (self.fp.cmd_build_acceleration_structures_indirect_khr)( + command_buffer, + infos.len() as _, + infos.as_ptr(), + indirect_device_addresses.as_ptr(), + indirect_strides.as_ptr(), + max_primitive_counts.as_ptr(), + ); + } + + /// + #[inline] + pub unsafe fn build_acceleration_structures( + &self, + deferred_operation: vk::DeferredOperationKHR, + infos: &[vk::AccelerationStructureBuildGeometryInfoKHR], + build_range_infos: &[&[vk::AccelerationStructureBuildRangeInfoKHR]], + ) -> VkResult<()> { + assert_eq!(infos.len(), build_range_infos.len()); + + let build_range_infos = build_range_infos + .iter() + .zip(infos.iter()) + .map(|(range_info, info)| { + assert_eq!(range_info.len(), info.geometry_count as usize); + range_info.as_ptr() + }) + .collect::>(); + + (self.fp.build_acceleration_structures_khr)( + self.handle, + deferred_operation, + infos.len() as _, + infos.as_ptr(), + build_range_infos.as_ptr(), + ) + .result() + } + + /// + #[inline] + pub unsafe fn copy_acceleration_structure( + &self, + deferred_operation: vk::DeferredOperationKHR, + info: &vk::CopyAccelerationStructureInfoKHR, + ) -> VkResult<()> { + (self.fp.copy_acceleration_structure_khr)(self.handle, deferred_operation, info).result() + } + + /// + #[inline] + pub unsafe fn copy_acceleration_structure_to_memory( + &self, + deferred_operation: vk::DeferredOperationKHR, + info: &vk::CopyAccelerationStructureToMemoryInfoKHR, + ) -> VkResult<()> { + (self.fp.copy_acceleration_structure_to_memory_khr)(self.handle, deferred_operation, info) + .result() + } + + /// + #[inline] + pub unsafe fn copy_memory_to_acceleration_structure( + &self, + deferred_operation: vk::DeferredOperationKHR, + info: &vk::CopyMemoryToAccelerationStructureInfoKHR, + ) -> VkResult<()> { + (self.fp.copy_memory_to_acceleration_structure_khr)(self.handle, deferred_operation, info) + .result() + } + + /// + #[inline] + pub unsafe fn write_acceleration_structures_properties( + &self, + acceleration_structures: &[vk::AccelerationStructureKHR], + query_type: vk::QueryType, + data: &mut [u8], + stride: usize, + ) -> VkResult<()> { + (self.fp.write_acceleration_structures_properties_khr)( + self.handle, + acceleration_structures.len() as _, + acceleration_structures.as_ptr(), + query_type, + data.len(), + data.as_mut_ptr().cast(), + stride, + ) + .result() + } + + /// + #[inline] + pub unsafe fn cmd_copy_acceleration_structure( + &self, + command_buffer: vk::CommandBuffer, + info: &vk::CopyAccelerationStructureInfoKHR, + ) { + (self.fp.cmd_copy_acceleration_structure_khr)(command_buffer, info); + } + + /// + #[inline] + pub unsafe fn cmd_copy_acceleration_structure_to_memory( + &self, + command_buffer: vk::CommandBuffer, + info: &vk::CopyAccelerationStructureToMemoryInfoKHR, + ) { + (self.fp.cmd_copy_acceleration_structure_to_memory_khr)(command_buffer, info); + } + + /// + #[inline] + pub unsafe fn cmd_copy_memory_to_acceleration_structure( + &self, + command_buffer: vk::CommandBuffer, + info: &vk::CopyMemoryToAccelerationStructureInfoKHR, + ) { + (self.fp.cmd_copy_memory_to_acceleration_structure_khr)(command_buffer, info); + } + + /// + #[inline] + pub unsafe fn get_acceleration_structure_device_address( + &self, + info: &vk::AccelerationStructureDeviceAddressInfoKHR, + ) -> vk::DeviceAddress { + (self.fp.get_acceleration_structure_device_address_khr)(self.handle, info) + } + + /// + #[inline] + pub unsafe fn cmd_write_acceleration_structures_properties( + &self, + command_buffer: vk::CommandBuffer, + structures: &[vk::AccelerationStructureKHR], + query_type: vk::QueryType, + query_pool: vk::QueryPool, + first_query: u32, + ) { + (self.fp.cmd_write_acceleration_structures_properties_khr)( + command_buffer, + structures.len() as _, + structures.as_ptr(), + query_type, + query_pool, + first_query, + ); + } + + /// + #[inline] + pub unsafe fn get_device_acceleration_structure_compatibility( + &self, + version: &vk::AccelerationStructureVersionInfoKHR, + ) -> vk::AccelerationStructureCompatibilityKHR { + let mut compatibility = vk::AccelerationStructureCompatibilityKHR::default(); + + (self.fp.get_device_acceleration_structure_compatibility_khr)( + self.handle, + version, + &mut compatibility, + ); + + compatibility + } + + /// + #[inline] + pub unsafe fn get_acceleration_structure_build_sizes( + &self, + build_type: vk::AccelerationStructureBuildTypeKHR, + build_info: &vk::AccelerationStructureBuildGeometryInfoKHR, + max_primitive_counts: &[u32], + ) -> vk::AccelerationStructureBuildSizesInfoKHR { + assert_eq!(max_primitive_counts.len(), build_info.geometry_count as _); + + let mut size_info = vk::AccelerationStructureBuildSizesInfoKHR::default(); + + (self.fp.get_acceleration_structure_build_sizes_khr)( + self.handle, + build_type, + build_info, + max_primitive_counts.as_ptr(), + &mut size_info, + ); + + size_info + } + + #[inline] + pub const fn name() -> &'static CStr { + vk::KhrAccelerationStructureFn::name() + } + + #[inline] + pub fn fp(&self) -> &vk::KhrAccelerationStructureFn { + &self.fp + } + + #[inline] + pub fn device(&self) -> vk::Device { + self.handle + } +} diff --git a/third_party/rust/ash/src/extensions/khr/android_surface.rs b/third_party/rust/ash/src/extensions/khr/android_surface.rs new file mode 100755 index 0000000000..071d367510 --- /dev/null +++ b/third_party/rust/ash/src/extensions/khr/android_surface.rs @@ -0,0 +1,54 @@ +use crate::prelude::*; +use crate::vk; +use crate::RawPtr; +use crate::{Entry, Instance}; +use std::ffi::CStr; +use std::mem; + +#[derive(Clone)] +pub struct AndroidSurface { + handle: vk::Instance, + fp: vk::KhrAndroidSurfaceFn, +} + +impl AndroidSurface { + pub fn new(entry: &Entry, instance: &Instance) -> Self { + let handle = instance.handle(); + let fp = vk::KhrAndroidSurfaceFn::load(|name| unsafe { + mem::transmute(entry.get_instance_proc_addr(handle, name.as_ptr())) + }); + Self { handle, fp } + } + + /// + #[inline] + pub unsafe fn create_android_surface( + &self, + create_info: &vk::AndroidSurfaceCreateInfoKHR, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) -> VkResult { + let mut surface = mem::zeroed(); + (self.fp.create_android_surface_khr)( + self.handle, + create_info, + allocation_callbacks.as_raw_ptr(), + &mut surface, + ) + .result_with_success(surface) + } + + #[inline] + pub const fn name() -> &'static CStr { + vk::KhrAndroidSurfaceFn::name() + } + + #[inline] + pub fn fp(&self) -> &vk::KhrAndroidSurfaceFn { + &self.fp + } + + #[inline] + pub fn instance(&self) -> vk::Instance { + self.handle + } +} diff --git a/third_party/rust/ash/src/extensions/khr/buffer_device_address.rs b/third_party/rust/ash/src/extensions/khr/buffer_device_address.rs new file mode 100644 index 0000000000..65eae69681 --- /dev/null +++ b/third_party/rust/ash/src/extensions/khr/buffer_device_address.rs @@ -0,0 +1,62 @@ +use crate::vk; +use crate::{Device, Instance}; +use std::ffi::CStr; +use std::mem; + +#[derive(Clone)] +pub struct BufferDeviceAddress { + handle: vk::Device, + fp: vk::KhrBufferDeviceAddressFn, +} + +impl BufferDeviceAddress { + pub fn new(instance: &Instance, device: &Device) -> Self { + let handle = device.handle(); + let fp = vk::KhrBufferDeviceAddressFn::load(|name| unsafe { + mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr())) + }); + Self { handle, fp } + } + + /// + #[inline] + pub unsafe fn get_buffer_device_address( + &self, + info: &vk::BufferDeviceAddressInfoKHR, + ) -> vk::DeviceAddress { + (self.fp.get_buffer_device_address_khr)(self.handle, info) + } + + /// + #[inline] + pub unsafe fn get_buffer_opaque_capture_address( + &self, + info: &vk::BufferDeviceAddressInfoKHR, + ) -> u64 { + (self.fp.get_buffer_opaque_capture_address_khr)(self.handle, info) + } + + /// + #[inline] + pub unsafe fn get_device_memory_opaque_capture_address( + &self, + info: &vk::DeviceMemoryOpaqueCaptureAddressInfoKHR, + ) -> u64 { + (self.fp.get_device_memory_opaque_capture_address_khr)(self.handle, info) + } + + #[inline] + pub const fn name() -> &'static CStr { + vk::KhrBufferDeviceAddressFn::name() + } + + #[inline] + pub fn fp(&self) -> &vk::KhrBufferDeviceAddressFn { + &self.fp + } + + #[inline] + pub fn device(&self) -> vk::Device { + self.handle + } +} diff --git a/third_party/rust/ash/src/extensions/khr/copy_commands2.rs b/third_party/rust/ash/src/extensions/khr/copy_commands2.rs new file mode 100644 index 0000000000..b46593093a --- /dev/null +++ b/third_party/rust/ash/src/extensions/khr/copy_commands2.rs @@ -0,0 +1,84 @@ +use crate::vk; +use crate::{Device, Instance}; +use std::ffi::CStr; +use std::mem; + +/// +#[derive(Clone)] +pub struct CopyCommands2 { + fp: vk::KhrCopyCommands2Fn, +} + +impl CopyCommands2 { + pub fn new(instance: &Instance, device: &Device) -> Self { + let fp = vk::KhrCopyCommands2Fn::load(|name| unsafe { + mem::transmute(instance.get_device_proc_addr(device.handle(), name.as_ptr())) + }); + Self { fp } + } + + /// + #[inline] + pub unsafe fn cmd_copy_buffer2( + &self, + command_buffer: vk::CommandBuffer, + copy_buffer_info: &vk::CopyBufferInfo2KHR, + ) { + (self.fp.cmd_copy_buffer2_khr)(command_buffer, copy_buffer_info) + } + /// + #[inline] + pub unsafe fn cmd_copy_image2( + &self, + command_buffer: vk::CommandBuffer, + copy_image_info: &vk::CopyImageInfo2KHR, + ) { + (self.fp.cmd_copy_image2_khr)(command_buffer, copy_image_info) + } + /// + #[inline] + pub unsafe fn cmd_copy_buffer_to_image2( + &self, + command_buffer: vk::CommandBuffer, + copy_buffer_to_image_info: &vk::CopyBufferToImageInfo2KHR, + ) { + (self.fp.cmd_copy_buffer_to_image2_khr)(command_buffer, copy_buffer_to_image_info) + } + /// + #[inline] + pub unsafe fn cmd_copy_image_to_buffer2( + &self, + command_buffer: vk::CommandBuffer, + copy_image_to_buffer_info: &vk::CopyImageToBufferInfo2KHR, + ) { + (self.fp.cmd_copy_image_to_buffer2_khr)(command_buffer, copy_image_to_buffer_info) + } + /// + #[inline] + pub unsafe fn cmd_blit_image2( + &self, + command_buffer: vk::CommandBuffer, + blit_image_info: &vk::BlitImageInfo2KHR, + ) { + (self.fp.cmd_blit_image2_khr)(command_buffer, blit_image_info) + } + /// + #[inline] + pub unsafe fn cmd_resolve_image2( + &self, + command_buffer: vk::CommandBuffer, + resolve_image_info: &vk::ResolveImageInfo2KHR, + ) { + (self.fp.cmd_resolve_image2_khr)(command_buffer, resolve_image_info) + } + + #[inline] + pub const fn name() -> &'static CStr { + vk::KhrCopyCommands2Fn::name() + } + + #[inline] + pub fn fp(&self) -> &vk::KhrCopyCommands2Fn { + &self.fp + } +} diff --git a/third_party/rust/ash/src/extensions/khr/create_render_pass2.rs b/third_party/rust/ash/src/extensions/khr/create_render_pass2.rs new file mode 100644 index 0000000000..bf78bc5f54 --- /dev/null +++ b/third_party/rust/ash/src/extensions/khr/create_render_pass2.rs @@ -0,0 +1,90 @@ +use crate::prelude::*; +use crate::vk; +use crate::RawPtr; +use crate::{Device, Instance}; +use std::ffi::CStr; +use std::mem; + +#[derive(Clone)] +pub struct CreateRenderPass2 { + handle: vk::Device, + fp: vk::KhrCreateRenderpass2Fn, +} + +impl CreateRenderPass2 { + pub fn new(instance: &Instance, device: &Device) -> Self { + let handle = device.handle(); + let fp = vk::KhrCreateRenderpass2Fn::load(|name| unsafe { + mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr())) + }); + Self { handle, fp } + } + + /// + #[inline] + pub unsafe fn create_render_pass2( + &self, + create_info: &vk::RenderPassCreateInfo2, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) -> VkResult { + let mut renderpass = mem::zeroed(); + (self.fp.create_render_pass2_khr)( + self.handle, + create_info, + allocation_callbacks.as_raw_ptr(), + &mut renderpass, + ) + .result_with_success(renderpass) + } + + /// + #[inline] + pub unsafe fn cmd_begin_render_pass2( + &self, + command_buffer: vk::CommandBuffer, + render_pass_begin_info: &vk::RenderPassBeginInfo, + subpass_begin_info: &vk::SubpassBeginInfo, + ) { + (self.fp.cmd_begin_render_pass2_khr)( + command_buffer, + render_pass_begin_info, + subpass_begin_info, + ); + } + + /// + #[inline] + pub unsafe fn cmd_next_subpass2( + &self, + command_buffer: vk::CommandBuffer, + subpass_begin_info: &vk::SubpassBeginInfo, + subpass_end_info: &vk::SubpassEndInfo, + ) { + (self.fp.cmd_next_subpass2_khr)(command_buffer, subpass_begin_info, subpass_end_info); + } + + /// + #[inline] + pub unsafe fn cmd_end_render_pass2( + &self, + command_buffer: vk::CommandBuffer, + subpass_end_info: &vk::SubpassEndInfo, + ) { + (self.fp.cmd_end_render_pass2_khr)(command_buffer, subpass_end_info); + } + + #[inline] + pub const fn name() -> &'static CStr { + vk::KhrCreateRenderpass2Fn::name() + } + + #[inline] + pub fn fp(&self) -> &vk::KhrCreateRenderpass2Fn { + &self.fp + } + + #[inline] + pub fn device(&self) -> vk::Device { + self.handle + } +} diff --git a/third_party/rust/ash/src/extensions/khr/deferred_host_operations.rs b/third_party/rust/ash/src/extensions/khr/deferred_host_operations.rs new file mode 100644 index 0000000000..51aeaad8bb --- /dev/null +++ b/third_party/rust/ash/src/extensions/khr/deferred_host_operations.rs @@ -0,0 +1,93 @@ +use crate::prelude::*; +use crate::vk; +use crate::RawPtr; +use crate::{Device, Instance}; +use std::ffi::CStr; +use std::mem; + +#[derive(Clone)] +pub struct DeferredHostOperations { + handle: vk::Device, + fp: vk::KhrDeferredHostOperationsFn, +} + +impl DeferredHostOperations { + pub fn new(instance: &Instance, device: &Device) -> Self { + let handle = device.handle(); + let fp = vk::KhrDeferredHostOperationsFn::load(|name| unsafe { + mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr())) + }); + Self { handle, fp } + } + + /// + #[inline] + pub unsafe fn create_deferred_operation( + &self, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) -> VkResult { + let mut operation = mem::zeroed(); + (self.fp.create_deferred_operation_khr)( + self.handle, + allocation_callbacks.as_raw_ptr(), + &mut operation, + ) + .result_with_success(operation) + } + + /// + #[inline] + pub unsafe fn deferred_operation_join( + &self, + operation: vk::DeferredOperationKHR, + ) -> VkResult<()> { + (self.fp.deferred_operation_join_khr)(self.handle, operation).result() + } + + /// + #[inline] + pub unsafe fn destroy_deferred_operation( + &self, + operation: vk::DeferredOperationKHR, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) { + (self.fp.destroy_deferred_operation_khr)( + self.handle, + operation, + allocation_callbacks.as_raw_ptr(), + ); + } + + /// + #[inline] + pub unsafe fn get_deferred_operation_max_concurrency( + &self, + operation: vk::DeferredOperationKHR, + ) -> u32 { + (self.fp.get_deferred_operation_max_concurrency_khr)(self.handle, operation) + } + + /// + #[inline] + pub unsafe fn get_deferred_operation_result( + &self, + operation: vk::DeferredOperationKHR, + ) -> VkResult<()> { + (self.fp.get_deferred_operation_result_khr)(self.handle, operation).result() + } + + #[inline] + pub const fn name() -> &'static CStr { + vk::KhrDeferredHostOperationsFn::name() + } + + #[inline] + pub fn fp(&self) -> &vk::KhrDeferredHostOperationsFn { + &self.fp + } + + #[inline] + pub fn device(&self) -> vk::Device { + self.handle + } +} diff --git a/third_party/rust/ash/src/extensions/khr/device_group.rs b/third_party/rust/ash/src/extensions/khr/device_group.rs new file mode 100644 index 0000000000..356db71e4d --- /dev/null +++ b/third_party/rust/ash/src/extensions/khr/device_group.rs @@ -0,0 +1,169 @@ +#[cfg(doc)] +use super::Swapchain; +use crate::prelude::*; +use crate::vk; +use crate::{Device, Instance}; +use std::ffi::CStr; +use std::mem; + +/// +#[derive(Clone)] +pub struct DeviceGroup { + handle: vk::Device, + fp: vk::KhrDeviceGroupFn, +} + +impl DeviceGroup { + pub fn new(instance: &Instance, device: &Device) -> Self { + let handle = device.handle(); + let fp = vk::KhrDeviceGroupFn::load(|name| unsafe { + mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr())) + }); + Self { handle, fp } + } + + /// + #[inline] + pub unsafe fn get_device_group_peer_memory_features( + &self, + heap_index: u32, + local_device_index: u32, + remote_device_index: u32, + ) -> vk::PeerMemoryFeatureFlags { + let mut peer_memory_features = mem::zeroed(); + (self.fp.get_device_group_peer_memory_features_khr)( + self.handle, + heap_index, + local_device_index, + remote_device_index, + &mut peer_memory_features, + ); + peer_memory_features + } + + /// + #[inline] + pub unsafe fn cmd_set_device_mask(&self, command_buffer: vk::CommandBuffer, device_mask: u32) { + (self.fp.cmd_set_device_mask_khr)(command_buffer, device_mask) + } + + /// + #[inline] + pub unsafe fn cmd_dispatch_base( + &self, + command_buffer: vk::CommandBuffer, + base_group: (u32, u32, u32), + group_count: (u32, u32, u32), + ) { + (self.fp.cmd_dispatch_base_khr)( + command_buffer, + base_group.0, + base_group.1, + base_group.2, + group_count.0, + group_count.1, + group_count.2, + ) + } + + /// Requires [`VK_KHR_surface`] to be enabled. + /// + /// Also available as [`Swapchain::get_device_group_present_capabilities()`] since [Vulkan 1.1]. + /// + /// + /// + /// [Vulkan 1.1]: https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_VERSION_1_1.html + /// [`VK_KHR_surface`]: https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_KHR_surface.html + #[inline] + pub unsafe fn get_device_group_present_capabilities( + &self, + device_group_present_capabilities: &mut vk::DeviceGroupPresentCapabilitiesKHR, + ) -> VkResult<()> { + (self.fp.get_device_group_present_capabilities_khr)( + self.handle, + device_group_present_capabilities, + ) + .result() + } + + /// Requires [`VK_KHR_surface`] to be enabled. + /// + /// Also available as [`Swapchain::get_device_group_surface_present_modes()`] since [Vulkan 1.1]. + /// + /// + /// + /// [Vulkan 1.1]: https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_VERSION_1_1.html + /// [`VK_KHR_surface`]: https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_KHR_surface.html + #[inline] + pub unsafe fn get_device_group_surface_present_modes( + &self, + surface: vk::SurfaceKHR, + ) -> VkResult { + let mut modes = mem::zeroed(); + (self.fp.get_device_group_surface_present_modes_khr)(self.handle, surface, &mut modes) + .result_with_success(modes) + } + + /// Requires [`VK_KHR_surface`] to be enabled. + /// + /// Also available as [`Swapchain::get_physical_device_present_rectangles()`] since [Vulkan 1.1]. + /// + /// + /// + /// [Vulkan 1.1]: https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_VERSION_1_1.html + /// [`VK_KHR_surface`]: https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_KHR_surface.html + #[inline] + pub unsafe fn get_physical_device_present_rectangles( + &self, + physical_device: vk::PhysicalDevice, + surface: vk::SurfaceKHR, + ) -> VkResult> { + read_into_uninitialized_vector(|count, data| { + (self.fp.get_physical_device_present_rectangles_khr)( + physical_device, + surface, + count, + data, + ) + }) + } + + /// On success, returns the next image's index and whether the swapchain is suboptimal for the surface. + /// + /// Requires [`VK_KHR_swapchain`] to be enabled. + /// + /// Also available as [`Swapchain::acquire_next_image2()`] since [Vulkan 1.1]. + /// + /// + /// + /// [Vulkan 1.1]: https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_VERSION_1_1.html + /// [`VK_KHR_swapchain`]: https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_KHR_swapchain.html + #[inline] + pub unsafe fn acquire_next_image2( + &self, + acquire_info: &vk::AcquireNextImageInfoKHR, + ) -> VkResult<(u32, bool)> { + let mut index = 0; + let err_code = (self.fp.acquire_next_image2_khr)(self.handle, acquire_info, &mut index); + match err_code { + vk::Result::SUCCESS => Ok((index, false)), + vk::Result::SUBOPTIMAL_KHR => Ok((index, true)), + _ => Err(err_code), + } + } + + #[inline] + pub const fn name() -> &'static CStr { + vk::KhrDeviceGroupFn::name() + } + + #[inline] + pub fn fp(&self) -> &vk::KhrDeviceGroupFn { + &self.fp + } + + #[inline] + pub fn device(&self) -> vk::Device { + self.handle + } +} diff --git a/third_party/rust/ash/src/extensions/khr/device_group_creation.rs b/third_party/rust/ash/src/extensions/khr/device_group_creation.rs new file mode 100644 index 0000000000..9a21a714c9 --- /dev/null +++ b/third_party/rust/ash/src/extensions/khr/device_group_creation.rs @@ -0,0 +1,66 @@ +use crate::prelude::*; +use crate::vk; +use crate::{Entry, Instance}; +use std::ffi::CStr; +use std::mem; +use std::ptr; + +/// +#[derive(Clone)] +pub struct DeviceGroupCreation { + handle: vk::Instance, + fp: vk::KhrDeviceGroupCreationFn, +} + +impl DeviceGroupCreation { + pub fn new(entry: Entry, instance: &Instance) -> Self { + let handle = instance.handle(); + let fp = vk::KhrDeviceGroupCreationFn::load(|name| unsafe { + mem::transmute(entry.get_instance_proc_addr(handle, name.as_ptr())) + }); + Self { handle, fp } + } + + /// Retrieve the number of elements to pass to [`enumerate_physical_device_groups()`][Self::enumerate_physical_device_groups()] + #[inline] + pub unsafe fn enumerate_physical_device_groups_len(&self) -> VkResult { + let mut group_count = 0; + (self.fp.enumerate_physical_device_groups_khr)( + self.handle, + &mut group_count, + ptr::null_mut(), + ) + .result_with_success(group_count as usize) + } + + /// + /// + /// Call [`enumerate_physical_device_groups_len()`][Self::enumerate_physical_device_groups_len()] to query the number of elements to pass to `out`. + /// Be sure to [`Default::default()`]-initialize these elements and optionally set their `p_next` pointer. + #[inline] + pub unsafe fn enumerate_physical_device_groups( + &self, + out: &mut [vk::PhysicalDeviceGroupProperties], + ) -> VkResult<()> { + let mut count = out.len() as u32; + (self.fp.enumerate_physical_device_groups_khr)(self.handle, &mut count, out.as_mut_ptr()) + .result()?; + assert_eq!(count as usize, out.len()); + Ok(()) + } + + #[inline] + pub const fn name() -> &'static CStr { + vk::KhrDeviceGroupCreationFn::name() + } + + #[inline] + pub fn fp(&self) -> &vk::KhrDeviceGroupCreationFn { + &self.fp + } + + #[inline] + pub fn device(&self) -> vk::Instance { + self.handle + } +} diff --git a/third_party/rust/ash/src/extensions/khr/display.rs b/third_party/rust/ash/src/extensions/khr/display.rs new file mode 100755 index 0000000000..b71c9c11e1 --- /dev/null +++ b/third_party/rust/ash/src/extensions/khr/display.rs @@ -0,0 +1,143 @@ +use crate::prelude::*; +use crate::vk; +use crate::RawPtr; +use crate::{Entry, Instance}; +use std::ffi::CStr; +use std::mem; + +#[derive(Clone)] +pub struct Display { + handle: vk::Instance, + fp: vk::KhrDisplayFn, +} + +impl Display { + pub fn new(entry: &Entry, instance: &Instance) -> Self { + let handle = instance.handle(); + let fp = vk::KhrDisplayFn::load(|name| unsafe { + mem::transmute(entry.get_instance_proc_addr(handle, name.as_ptr())) + }); + Self { handle, fp } + } + + /// + #[inline] + pub unsafe fn get_physical_device_display_properties( + &self, + physical_device: vk::PhysicalDevice, + ) -> VkResult> { + read_into_uninitialized_vector(|count, data| { + (self.fp.get_physical_device_display_properties_khr)(physical_device, count, data) + }) + } + + /// + #[inline] + pub unsafe fn get_physical_device_display_plane_properties( + &self, + physical_device: vk::PhysicalDevice, + ) -> VkResult> { + read_into_uninitialized_vector(|count, data| { + (self.fp.get_physical_device_display_plane_properties_khr)(physical_device, count, data) + }) + } + + /// + #[inline] + pub unsafe fn get_display_plane_supported_displays( + &self, + physical_device: vk::PhysicalDevice, + plane_index: u32, + ) -> VkResult> { + read_into_uninitialized_vector(|count, data| { + (self.fp.get_display_plane_supported_displays_khr)( + physical_device, + plane_index, + count, + data, + ) + }) + } + + /// + #[inline] + pub unsafe fn get_display_mode_properties( + &self, + physical_device: vk::PhysicalDevice, + display: vk::DisplayKHR, + ) -> VkResult> { + read_into_uninitialized_vector(|count, data| { + (self.fp.get_display_mode_properties_khr)(physical_device, display, count, data) + }) + } + + /// + #[inline] + pub unsafe fn create_display_mode( + &self, + physical_device: vk::PhysicalDevice, + display: vk::DisplayKHR, + create_info: &vk::DisplayModeCreateInfoKHR, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) -> VkResult { + let mut display_mode = mem::MaybeUninit::zeroed(); + (self.fp.create_display_mode_khr)( + physical_device, + display, + create_info, + allocation_callbacks.as_raw_ptr(), + display_mode.as_mut_ptr(), + ) + .assume_init_on_success(display_mode) + } + + /// + #[inline] + pub unsafe fn get_display_plane_capabilities( + &self, + physical_device: vk::PhysicalDevice, + mode: vk::DisplayModeKHR, + plane_index: u32, + ) -> VkResult { + let mut display_plane_capabilities = mem::MaybeUninit::zeroed(); + (self.fp.get_display_plane_capabilities_khr)( + physical_device, + mode, + plane_index, + display_plane_capabilities.as_mut_ptr(), + ) + .assume_init_on_success(display_plane_capabilities) + } + + /// + #[inline] + pub unsafe fn create_display_plane_surface( + &self, + create_info: &vk::DisplaySurfaceCreateInfoKHR, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) -> VkResult { + let mut surface = mem::MaybeUninit::zeroed(); + (self.fp.create_display_plane_surface_khr)( + self.handle, + create_info, + allocation_callbacks.as_raw_ptr(), + surface.as_mut_ptr(), + ) + .assume_init_on_success(surface) + } + + #[inline] + pub const fn name() -> &'static CStr { + vk::KhrDisplayFn::name() + } + + #[inline] + pub fn fp(&self) -> &vk::KhrDisplayFn { + &self.fp + } + + #[inline] + pub fn instance(&self) -> vk::Instance { + self.handle + } +} diff --git a/third_party/rust/ash/src/extensions/khr/display_swapchain.rs b/third_party/rust/ash/src/extensions/khr/display_swapchain.rs new file mode 100755 index 0000000000..e4a33b2bdb --- /dev/null +++ b/third_party/rust/ash/src/extensions/khr/display_swapchain.rs @@ -0,0 +1,57 @@ +use crate::prelude::*; +use crate::vk; +use crate::RawPtr; +use crate::{Device, Instance}; +use std::ffi::CStr; +use std::mem; + +#[derive(Clone)] +pub struct DisplaySwapchain { + handle: vk::Device, + fp: vk::KhrDisplaySwapchainFn, +} + +impl DisplaySwapchain { + pub fn new(instance: &Instance, device: &Device) -> Self { + let handle = device.handle(); + let fp = vk::KhrDisplaySwapchainFn::load(|name| unsafe { + mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr())) + }); + Self { handle, fp } + } + + /// + #[inline] + pub unsafe fn create_shared_swapchains( + &self, + create_infos: &[vk::SwapchainCreateInfoKHR], + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) -> VkResult> { + let mut swapchains = Vec::with_capacity(create_infos.len()); + (self.fp.create_shared_swapchains_khr)( + self.handle, + create_infos.len() as u32, + create_infos.as_ptr(), + allocation_callbacks.as_raw_ptr(), + swapchains.as_mut_ptr(), + ) + .result()?; + swapchains.set_len(create_infos.len()); + Ok(swapchains) + } + + #[inline] + pub const fn name() -> &'static CStr { + vk::KhrDisplaySwapchainFn::name() + } + + #[inline] + pub fn fp(&self) -> &vk::KhrDisplaySwapchainFn { + &self.fp + } + + #[inline] + pub fn device(&self) -> vk::Device { + self.handle + } +} diff --git a/third_party/rust/ash/src/extensions/khr/draw_indirect_count.rs b/third_party/rust/ash/src/extensions/khr/draw_indirect_count.rs new file mode 100644 index 0000000000..f35ecbe9e3 --- /dev/null +++ b/third_party/rust/ash/src/extensions/khr/draw_indirect_count.rs @@ -0,0 +1,74 @@ +use crate::vk; +use crate::{Device, Instance}; +use std::ffi::CStr; +use std::mem; + +#[derive(Clone)] +pub struct DrawIndirectCount { + fp: vk::KhrDrawIndirectCountFn, +} + +impl DrawIndirectCount { + pub fn new(instance: &Instance, device: &Device) -> Self { + let fp = vk::KhrDrawIndirectCountFn::load(|name| unsafe { + mem::transmute(instance.get_device_proc_addr(device.handle(), name.as_ptr())) + }); + Self { fp } + } + + /// + #[inline] + pub unsafe fn cmd_draw_indexed_indirect_count( + &self, + command_buffer: vk::CommandBuffer, + buffer: vk::Buffer, + offset: vk::DeviceSize, + count_buffer: vk::Buffer, + count_buffer_offset: vk::DeviceSize, + max_draw_count: u32, + stride: u32, + ) { + (self.fp.cmd_draw_indexed_indirect_count_khr)( + command_buffer, + buffer, + offset, + count_buffer, + count_buffer_offset, + max_draw_count, + stride, + ); + } + + /// + #[inline] + pub unsafe fn cmd_draw_indirect_count( + &self, + command_buffer: vk::CommandBuffer, + buffer: vk::Buffer, + offset: vk::DeviceSize, + count_buffer: vk::Buffer, + count_buffer_offset: vk::DeviceSize, + max_draw_count: u32, + stride: u32, + ) { + (self.fp.cmd_draw_indirect_count_khr)( + command_buffer, + buffer, + offset, + count_buffer, + count_buffer_offset, + max_draw_count, + stride, + ); + } + + #[inline] + pub const fn name() -> &'static CStr { + vk::KhrDrawIndirectCountFn::name() + } + + #[inline] + pub fn fp(&self) -> &vk::KhrDrawIndirectCountFn { + &self.fp + } +} diff --git a/third_party/rust/ash/src/extensions/khr/dynamic_rendering.rs b/third_party/rust/ash/src/extensions/khr/dynamic_rendering.rs new file mode 100644 index 0000000000..ea6149a816 --- /dev/null +++ b/third_party/rust/ash/src/extensions/khr/dynamic_rendering.rs @@ -0,0 +1,44 @@ +use crate::vk; +use crate::{Device, Instance}; +use std::ffi::CStr; +use std::mem; + +#[derive(Clone)] +pub struct DynamicRendering { + fp: vk::KhrDynamicRenderingFn, +} + +impl DynamicRendering { + pub fn new(instance: &Instance, device: &Device) -> Self { + let fp = vk::KhrDynamicRenderingFn::load(|name| unsafe { + mem::transmute(instance.get_device_proc_addr(device.handle(), name.as_ptr())) + }); + Self { fp } + } + + /// + #[inline] + pub unsafe fn cmd_begin_rendering( + &self, + command_buffer: vk::CommandBuffer, + rendering_info: &vk::RenderingInfoKHR, + ) { + (self.fp.cmd_begin_rendering_khr)(command_buffer, rendering_info) + } + + /// + #[inline] + pub unsafe fn cmd_end_rendering(&self, command_buffer: vk::CommandBuffer) { + (self.fp.cmd_end_rendering_khr)(command_buffer) + } + + #[inline] + pub const fn name() -> &'static CStr { + vk::KhrDynamicRenderingFn::name() + } + + #[inline] + pub fn fp(&self) -> &vk::KhrDynamicRenderingFn { + &self.fp + } +} diff --git a/third_party/rust/ash/src/extensions/khr/external_fence_fd.rs b/third_party/rust/ash/src/extensions/khr/external_fence_fd.rs new file mode 100644 index 0000000000..6a3ec559d4 --- /dev/null +++ b/third_party/rust/ash/src/extensions/khr/external_fence_fd.rs @@ -0,0 +1,49 @@ +use crate::prelude::*; +use crate::vk; +use crate::{Device, Instance}; +use std::ffi::CStr; +use std::mem; + +#[derive(Clone)] +pub struct ExternalFenceFd { + handle: vk::Device, + fp: vk::KhrExternalFenceFdFn, +} + +impl ExternalFenceFd { + pub fn new(instance: &Instance, device: &Device) -> Self { + let handle = device.handle(); + let fp = vk::KhrExternalFenceFdFn::load(|name| unsafe { + mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr())) + }); + Self { handle, fp } + } + + /// + #[inline] + pub unsafe fn import_fence_fd(&self, import_info: &vk::ImportFenceFdInfoKHR) -> VkResult<()> { + (self.fp.import_fence_fd_khr)(self.handle, import_info).result() + } + + /// + #[inline] + pub unsafe fn get_fence_fd(&self, get_info: &vk::FenceGetFdInfoKHR) -> VkResult { + let mut fd = -1; + (self.fp.get_fence_fd_khr)(self.handle, get_info, &mut fd).result_with_success(fd) + } + + #[inline] + pub const fn name() -> &'static CStr { + vk::KhrExternalFenceFdFn::name() + } + + #[inline] + pub fn fp(&self) -> &vk::KhrExternalFenceFdFn { + &self.fp + } + + #[inline] + pub fn device(&self) -> vk::Device { + self.handle + } +} diff --git a/third_party/rust/ash/src/extensions/khr/external_fence_win32.rs b/third_party/rust/ash/src/extensions/khr/external_fence_win32.rs new file mode 100644 index 0000000000..627bd1cca9 --- /dev/null +++ b/third_party/rust/ash/src/extensions/khr/external_fence_win32.rs @@ -0,0 +1,58 @@ +use crate::prelude::*; +use crate::vk; +use crate::{Device, Instance}; +use std::ffi::CStr; +use std::mem; +use std::ptr; + +/// +#[derive(Clone)] +pub struct ExternalFenceWin32 { + handle: vk::Device, + fp: vk::KhrExternalFenceWin32Fn, +} + +impl ExternalFenceWin32 { + pub fn new(instance: &Instance, device: &Device) -> Self { + let handle = device.handle(); + let fp = vk::KhrExternalFenceWin32Fn::load(|name| unsafe { + mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr())) + }); + Self { handle, fp } + } + + /// + #[inline] + pub unsafe fn import_fence_win32_handle( + &self, + import_info: &vk::ImportFenceWin32HandleInfoKHR, + ) -> VkResult<()> { + (self.fp.import_fence_win32_handle_khr)(self.handle, import_info).result() + } + + /// + #[inline] + pub unsafe fn get_fence_win32_handle( + &self, + get_info: &vk::FenceGetWin32HandleInfoKHR, + ) -> VkResult { + let mut handle = ptr::null_mut(); + (self.fp.get_fence_win32_handle_khr)(self.handle, get_info, &mut handle) + .result_with_success(handle) + } + + #[inline] + pub const fn name() -> &'static CStr { + vk::KhrExternalFenceWin32Fn::name() + } + + #[inline] + pub fn fp(&self) -> &vk::KhrExternalFenceWin32Fn { + &self.fp + } + + #[inline] + pub fn device(&self) -> vk::Device { + self.handle + } +} diff --git a/third_party/rust/ash/src/extensions/khr/external_memory_fd.rs b/third_party/rust/ash/src/extensions/khr/external_memory_fd.rs new file mode 100644 index 0000000000..902349802f --- /dev/null +++ b/third_party/rust/ash/src/extensions/khr/external_memory_fd.rs @@ -0,0 +1,60 @@ +use crate::prelude::*; +use crate::vk; +use crate::{Device, Instance}; +use std::ffi::CStr; +use std::mem; + +#[derive(Clone)] +pub struct ExternalMemoryFd { + handle: vk::Device, + fp: vk::KhrExternalMemoryFdFn, +} + +impl ExternalMemoryFd { + pub fn new(instance: &Instance, device: &Device) -> Self { + let handle = device.handle(); + let fp = vk::KhrExternalMemoryFdFn::load(|name| unsafe { + mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr())) + }); + Self { handle, fp } + } + + /// + #[inline] + pub unsafe fn get_memory_fd(&self, create_info: &vk::MemoryGetFdInfoKHR) -> VkResult { + let mut fd = -1; + (self.fp.get_memory_fd_khr)(self.handle, create_info, &mut fd).result_with_success(fd) + } + + /// + #[inline] + pub unsafe fn get_memory_fd_properties( + &self, + handle_type: vk::ExternalMemoryHandleTypeFlags, + fd: i32, + ) -> VkResult { + let mut memory_fd_properties = Default::default(); + (self.fp.get_memory_fd_properties_khr)( + self.handle, + handle_type, + fd, + &mut memory_fd_properties, + ) + .result_with_success(memory_fd_properties) + } + + #[inline] + pub const fn name() -> &'static CStr { + vk::KhrExternalMemoryFdFn::name() + } + + #[inline] + pub fn fp(&self) -> &vk::KhrExternalMemoryFdFn { + &self.fp + } + + #[inline] + pub fn device(&self) -> vk::Device { + self.handle + } +} diff --git a/third_party/rust/ash/src/extensions/khr/external_memory_win32.rs b/third_party/rust/ash/src/extensions/khr/external_memory_win32.rs new file mode 100644 index 0000000000..8e43a26d48 --- /dev/null +++ b/third_party/rust/ash/src/extensions/khr/external_memory_win32.rs @@ -0,0 +1,66 @@ +use crate::prelude::*; +use crate::vk; +use crate::{Device, Instance}; +use std::ffi::CStr; +use std::mem; +use std::ptr; + +/// +#[derive(Clone)] +pub struct ExternalMemoryWin32 { + handle: vk::Device, + fp: vk::KhrExternalMemoryWin32Fn, +} + +impl ExternalMemoryWin32 { + pub fn new(instance: &Instance, device: &Device) -> Self { + let handle = device.handle(); + let fp = vk::KhrExternalMemoryWin32Fn::load(|name| unsafe { + mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr())) + }); + Self { handle, fp } + } + + /// + #[inline] + pub unsafe fn get_memory_win32_handle( + &self, + create_info: &vk::MemoryGetWin32HandleInfoKHR, + ) -> VkResult { + let mut handle = ptr::null_mut(); + (self.fp.get_memory_win32_handle_khr)(self.handle, create_info, &mut handle) + .result_with_success(handle) + } + + /// + #[inline] + pub unsafe fn get_memory_win32_handle_properties( + &self, + handle_type: vk::ExternalMemoryHandleTypeFlags, + handle: vk::HANDLE, + ) -> VkResult { + let mut memory_win32_handle_properties = Default::default(); + (self.fp.get_memory_win32_handle_properties_khr)( + self.handle, + handle_type, + handle, + &mut memory_win32_handle_properties, + ) + .result_with_success(memory_win32_handle_properties) + } + + #[inline] + pub const fn name() -> &'static CStr { + vk::KhrExternalMemoryWin32Fn::name() + } + + #[inline] + pub fn fp(&self) -> &vk::KhrExternalMemoryWin32Fn { + &self.fp + } + + #[inline] + pub fn device(&self) -> vk::Device { + self.handle + } +} diff --git a/third_party/rust/ash/src/extensions/khr/external_semaphore_fd.rs b/third_party/rust/ash/src/extensions/khr/external_semaphore_fd.rs new file mode 100644 index 0000000000..eadebef40d --- /dev/null +++ b/third_party/rust/ash/src/extensions/khr/external_semaphore_fd.rs @@ -0,0 +1,52 @@ +use crate::prelude::*; +use crate::vk; +use crate::{Device, Instance}; +use std::ffi::CStr; +use std::mem; + +#[derive(Clone)] +pub struct ExternalSemaphoreFd { + handle: vk::Device, + fp: vk::KhrExternalSemaphoreFdFn, +} + +impl ExternalSemaphoreFd { + pub fn new(instance: &Instance, device: &Device) -> Self { + let handle = device.handle(); + let fp = vk::KhrExternalSemaphoreFdFn::load(|name| unsafe { + mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr())) + }); + Self { handle, fp } + } + + /// + #[inline] + pub unsafe fn import_semaphore_fd( + &self, + import_info: &vk::ImportSemaphoreFdInfoKHR, + ) -> VkResult<()> { + (self.fp.import_semaphore_fd_khr)(self.handle, import_info).result() + } + + /// + #[inline] + pub unsafe fn get_semaphore_fd(&self, get_info: &vk::SemaphoreGetFdInfoKHR) -> VkResult { + let mut fd = -1; + (self.fp.get_semaphore_fd_khr)(self.handle, get_info, &mut fd).result_with_success(fd) + } + + #[inline] + pub const fn name() -> &'static CStr { + vk::KhrExternalSemaphoreFdFn::name() + } + + #[inline] + pub fn fp(&self) -> &vk::KhrExternalSemaphoreFdFn { + &self.fp + } + + #[inline] + pub fn device(&self) -> vk::Device { + self.handle + } +} diff --git a/third_party/rust/ash/src/extensions/khr/external_semaphore_win32.rs b/third_party/rust/ash/src/extensions/khr/external_semaphore_win32.rs new file mode 100644 index 0000000000..102da8c1ee --- /dev/null +++ b/third_party/rust/ash/src/extensions/khr/external_semaphore_win32.rs @@ -0,0 +1,58 @@ +use crate::prelude::*; +use crate::vk; +use crate::{Device, Instance}; +use std::ffi::CStr; +use std::mem; +use std::ptr; + +/// +#[derive(Clone)] +pub struct ExternalSemaphoreWin32 { + handle: vk::Device, + fp: vk::KhrExternalSemaphoreWin32Fn, +} + +impl ExternalSemaphoreWin32 { + pub fn new(instance: &Instance, device: &Device) -> Self { + let handle = device.handle(); + let fp = vk::KhrExternalSemaphoreWin32Fn::load(|name| unsafe { + mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr())) + }); + Self { handle, fp } + } + + /// + #[inline] + pub unsafe fn import_semaphore_win32_handle( + &self, + import_info: &vk::ImportSemaphoreWin32HandleInfoKHR, + ) -> VkResult<()> { + (self.fp.import_semaphore_win32_handle_khr)(self.handle, import_info).result() + } + + /// + #[inline] + pub unsafe fn get_semaphore_win32_handle( + &self, + get_info: &vk::SemaphoreGetWin32HandleInfoKHR, + ) -> VkResult { + let mut handle = ptr::null_mut(); + (self.fp.get_semaphore_win32_handle_khr)(self.handle, get_info, &mut handle) + .result_with_success(handle) + } + + #[inline] + pub const fn name() -> &'static CStr { + vk::KhrExternalSemaphoreWin32Fn::name() + } + + #[inline] + pub fn fp(&self) -> &vk::KhrExternalSemaphoreWin32Fn { + &self.fp + } + + #[inline] + pub fn device(&self) -> vk::Device { + self.handle + } +} diff --git a/third_party/rust/ash/src/extensions/khr/get_memory_requirements2.rs b/third_party/rust/ash/src/extensions/khr/get_memory_requirements2.rs new file mode 100644 index 0000000000..13e5a1bf61 --- /dev/null +++ b/third_party/rust/ash/src/extensions/khr/get_memory_requirements2.rs @@ -0,0 +1,92 @@ +use crate::vk; +use crate::{Device, Instance}; +use std::ffi::CStr; +use std::mem; +use std::ptr; + +#[derive(Clone)] +pub struct GetMemoryRequirements2 { + handle: vk::Device, + fp: vk::KhrGetMemoryRequirements2Fn, +} + +impl GetMemoryRequirements2 { + pub fn new(instance: &Instance, device: &Device) -> Self { + let handle = device.handle(); + let fp = vk::KhrGetMemoryRequirements2Fn::load(|name| unsafe { + mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr())) + }); + Self { handle, fp } + } + + /// + #[inline] + pub unsafe fn get_buffer_memory_requirements2( + &self, + info: &vk::BufferMemoryRequirementsInfo2KHR, + memory_requirements: &mut vk::MemoryRequirements2KHR, + ) { + (self.fp.get_buffer_memory_requirements2_khr)(self.handle, info, memory_requirements); + } + + /// + #[inline] + pub unsafe fn get_image_memory_requirements2( + &self, + info: &vk::ImageMemoryRequirementsInfo2KHR, + memory_requirements: &mut vk::MemoryRequirements2KHR, + ) { + (self.fp.get_image_memory_requirements2_khr)(self.handle, info, memory_requirements); + } + + /// Retrieve the number of elements to pass to [`get_image_sparse_memory_requirements2()`][Self::get_image_sparse_memory_requirements2()] + #[inline] + pub unsafe fn get_image_sparse_memory_requirements2_len( + &self, + info: &vk::ImageSparseMemoryRequirementsInfo2KHR, + ) -> usize { + let mut count = 0; + (self.fp.get_image_sparse_memory_requirements2_khr)( + self.handle, + info, + &mut count, + ptr::null_mut(), + ); + count as usize + } + + /// + /// + /// Call [`get_image_sparse_memory_requirements2_len()`][Self::get_image_sparse_memory_requirements2_len()] to query the number of elements to pass to `out`. + /// Be sure to [`Default::default()`]-initialize these elements and optionally set their `p_next` pointer. + #[inline] + pub unsafe fn get_image_sparse_memory_requirements2( + &self, + info: &vk::ImageSparseMemoryRequirementsInfo2KHR, + out: &mut [vk::SparseImageMemoryRequirements2KHR], + ) { + let mut count = out.len() as u32; + (self.fp.get_image_sparse_memory_requirements2_khr)( + self.handle, + info, + &mut count, + out.as_mut_ptr(), + ); + assert_eq!(count as usize, out.len()); + } + + #[inline] + pub const fn name() -> &'static CStr { + vk::KhrGetMemoryRequirements2Fn::name() + } + + #[inline] + pub fn fp(&self) -> &vk::KhrGetMemoryRequirements2Fn { + &self.fp + } + + #[inline] + pub fn device(&self) -> vk::Device { + self.handle + } +} diff --git a/third_party/rust/ash/src/extensions/khr/get_physical_device_properties2.rs b/third_party/rust/ash/src/extensions/khr/get_physical_device_properties2.rs new file mode 100644 index 0000000000..9e610b4831 --- /dev/null +++ b/third_party/rust/ash/src/extensions/khr/get_physical_device_properties2.rs @@ -0,0 +1,167 @@ +use crate::prelude::*; +use crate::vk; +use crate::{Entry, Instance}; +use std::ffi::CStr; +use std::mem; +use std::ptr; + +#[derive(Clone)] +pub struct GetPhysicalDeviceProperties2 { + fp: vk::KhrGetPhysicalDeviceProperties2Fn, +} + +impl GetPhysicalDeviceProperties2 { + pub fn new(entry: &Entry, instance: &Instance) -> Self { + let fp = vk::KhrGetPhysicalDeviceProperties2Fn::load(|name| unsafe { + mem::transmute(entry.get_instance_proc_addr(instance.handle(), name.as_ptr())) + }); + Self { fp } + } + + /// + #[inline] + pub unsafe fn get_physical_device_features2( + &self, + physical_device: vk::PhysicalDevice, + features: &mut vk::PhysicalDeviceFeatures2KHR, + ) { + (self.fp.get_physical_device_features2_khr)(physical_device, features); + } + + /// + #[inline] + pub unsafe fn get_physical_device_format_properties2( + &self, + physical_device: vk::PhysicalDevice, + format: vk::Format, + format_properties: &mut vk::FormatProperties2KHR, + ) { + (self.fp.get_physical_device_format_properties2_khr)( + physical_device, + format, + format_properties, + ); + } + + /// + #[inline] + pub unsafe fn get_physical_device_image_format_properties2( + &self, + physical_device: vk::PhysicalDevice, + image_format_info: &vk::PhysicalDeviceImageFormatInfo2KHR, + image_format_properties: &mut vk::ImageFormatProperties2KHR, + ) -> VkResult<()> { + (self.fp.get_physical_device_image_format_properties2_khr)( + physical_device, + image_format_info, + image_format_properties, + ) + .result() + } + + /// + #[inline] + pub unsafe fn get_physical_device_memory_properties2( + &self, + physical_device: vk::PhysicalDevice, + memory_properties: &mut vk::PhysicalDeviceMemoryProperties2KHR, + ) { + (self.fp.get_physical_device_memory_properties2_khr)(physical_device, memory_properties); + } + + /// + #[inline] + pub unsafe fn get_physical_device_properties2( + &self, + physical_device: vk::PhysicalDevice, + properties: &mut vk::PhysicalDeviceProperties2KHR, + ) { + (self.fp.get_physical_device_properties2_khr)(physical_device, properties); + } + + /// Retrieve the number of elements to pass to [`get_physical_device_queue_family_properties2()`][Self::get_physical_device_queue_family_properties2()] + #[inline] + pub unsafe fn get_physical_device_queue_family_properties2_len( + &self, + physical_device: vk::PhysicalDevice, + ) -> usize { + let mut count = 0; + (self.fp.get_physical_device_queue_family_properties2_khr)( + physical_device, + &mut count, + ptr::null_mut(), + ); + count as usize + } + + /// + /// + /// Call [`get_physical_device_queue_family_properties2_len()`][Self::get_physical_device_queue_family_properties2_len()] to query the number of elements to pass to `out`. + /// Be sure to [`Default::default()`]-initialize these elements and optionally set their `p_next` pointer. + #[inline] + pub unsafe fn get_physical_device_queue_family_properties2( + &self, + physical_device: vk::PhysicalDevice, + out: &mut [vk::QueueFamilyProperties2KHR], + ) { + let mut count = out.len() as u32; + (self.fp.get_physical_device_queue_family_properties2_khr)( + physical_device, + &mut count, + out.as_mut_ptr(), + ); + assert_eq!(count as usize, out.len()); + } + + /// Retrieve the number of elements to pass to [`get_physical_device_sparse_image_format_properties2()`][Self::get_physical_device_sparse_image_format_properties2()] + #[inline] + pub unsafe fn get_physical_device_sparse_image_format_properties2_len( + &self, + physical_device: vk::PhysicalDevice, + format_info: &vk::PhysicalDeviceSparseImageFormatInfo2KHR, + ) -> usize { + let mut count = 0; + (self + .fp + .get_physical_device_sparse_image_format_properties2_khr)( + physical_device, + format_info, + &mut count, + ptr::null_mut(), + ); + count as usize + } + + /// + /// + /// Call [`get_physical_device_sparse_image_format_properties2_len()`][Self::get_physical_device_sparse_image_format_properties2_len()] to query the number of elements to pass to `out`. + /// Be sure to [`Default::default()`]-initialize these elements and optionally set their `p_next` pointer. + #[inline] + pub unsafe fn get_physical_device_sparse_image_format_properties2( + &self, + physical_device: vk::PhysicalDevice, + format_info: &vk::PhysicalDeviceSparseImageFormatInfo2KHR, + out: &mut [vk::SparseImageFormatProperties2KHR], + ) { + let mut count = out.len() as u32; + (self + .fp + .get_physical_device_sparse_image_format_properties2_khr)( + physical_device, + format_info, + &mut count, + out.as_mut_ptr(), + ); + assert_eq!(count as usize, out.len()); + } + + #[inline] + pub const fn name() -> &'static CStr { + vk::KhrGetPhysicalDeviceProperties2Fn::name() + } + + #[inline] + pub fn fp(&self) -> &vk::KhrGetPhysicalDeviceProperties2Fn { + &self.fp + } +} diff --git a/third_party/rust/ash/src/extensions/khr/get_surface_capabilities2.rs b/third_party/rust/ash/src/extensions/khr/get_surface_capabilities2.rs new file mode 100644 index 0000000000..0208b7b4a5 --- /dev/null +++ b/third_party/rust/ash/src/extensions/khr/get_surface_capabilities2.rs @@ -0,0 +1,84 @@ +use crate::prelude::*; +use crate::vk; +use crate::{Entry, Instance}; +use std::ffi::CStr; +use std::mem; + +#[derive(Clone)] +pub struct GetSurfaceCapabilities2 { + fp: vk::KhrGetSurfaceCapabilities2Fn, +} + +impl GetSurfaceCapabilities2 { + pub fn new(entry: &Entry, instance: &Instance) -> Self { + let fp = vk::KhrGetSurfaceCapabilities2Fn::load(|name| unsafe { + mem::transmute(entry.get_instance_proc_addr(instance.handle(), name.as_ptr())) + }); + Self { fp } + } + + /// + #[inline] + pub unsafe fn get_physical_device_surface_capabilities2( + &self, + physical_device: vk::PhysicalDevice, + surface_info: &vk::PhysicalDeviceSurfaceInfo2KHR, + ) -> VkResult { + let mut surface_capabilities = Default::default(); + (self.fp.get_physical_device_surface_capabilities2_khr)( + physical_device, + surface_info, + &mut surface_capabilities, + ) + .result_with_success(surface_capabilities) + } + + /// Retrieve the number of elements to pass to [`get_physical_device_surface_formats2()`][Self::get_physical_device_surface_formats2()] + #[inline] + pub unsafe fn get_physical_device_surface_formats2_len( + &self, + physical_device: vk::PhysicalDevice, + surface_info: &vk::PhysicalDeviceSurfaceInfo2KHR, + ) -> VkResult { + let mut count = 0; + let err_code = (self.fp.get_physical_device_surface_formats2_khr)( + physical_device, + surface_info, + &mut count, + std::ptr::null_mut(), + ); + err_code.result_with_success(count as usize) + } + + /// + /// + /// Call [`get_physical_device_surface_formats2_len()`][Self::get_physical_device_surface_formats2_len()] to query the number of elements to pass to `out`. + /// Be sure to [`Default::default()`]-initialize these elements and optionally set their `p_next` pointer. + #[inline] + pub unsafe fn get_physical_device_surface_formats2( + &self, + physical_device: vk::PhysicalDevice, + surface_info: &vk::PhysicalDeviceSurfaceInfo2KHR, + out: &mut [vk::SurfaceFormat2KHR], + ) -> VkResult<()> { + let mut count = out.len() as u32; + let err_code = (self.fp.get_physical_device_surface_formats2_khr)( + physical_device, + surface_info, + &mut count, + out.as_mut_ptr(), + ); + assert_eq!(count as usize, out.len()); + err_code.result() + } + + #[inline] + pub const fn name() -> &'static CStr { + vk::KhrGetSurfaceCapabilities2Fn::name() + } + + #[inline] + pub fn fp(&self) -> &vk::KhrGetSurfaceCapabilities2Fn { + &self.fp + } +} diff --git a/third_party/rust/ash/src/extensions/khr/maintenance1.rs b/third_party/rust/ash/src/extensions/khr/maintenance1.rs new file mode 100644 index 0000000000..1226d31cd5 --- /dev/null +++ b/third_party/rust/ash/src/extensions/khr/maintenance1.rs @@ -0,0 +1,45 @@ +use crate::vk; +use crate::{Device, Instance}; +use std::ffi::CStr; +use std::mem; + +#[derive(Clone)] +pub struct Maintenance1 { + handle: vk::Device, + fp: vk::KhrMaintenance1Fn, +} + +impl Maintenance1 { + pub fn new(instance: &Instance, device: &Device) -> Self { + let handle = device.handle(); + let fp = vk::KhrMaintenance1Fn::load(|name| unsafe { + mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr())) + }); + Self { handle, fp } + } + + /// + #[inline] + pub unsafe fn trim_command_pool( + &self, + command_pool: vk::CommandPool, + flags: vk::CommandPoolTrimFlagsKHR, + ) { + (self.fp.trim_command_pool_khr)(self.handle, command_pool, flags); + } + + #[inline] + pub const fn name() -> &'static CStr { + vk::KhrMaintenance1Fn::name() + } + + #[inline] + pub fn fp(&self) -> &vk::KhrMaintenance1Fn { + &self.fp + } + + #[inline] + pub fn device(&self) -> vk::Device { + self.handle + } +} diff --git a/third_party/rust/ash/src/extensions/khr/maintenance3.rs b/third_party/rust/ash/src/extensions/khr/maintenance3.rs new file mode 100644 index 0000000000..3b22959332 --- /dev/null +++ b/third_party/rust/ash/src/extensions/khr/maintenance3.rs @@ -0,0 +1,45 @@ +use crate::vk; +use crate::{Device, Instance}; +use std::ffi::CStr; +use std::mem; + +#[derive(Clone)] +pub struct Maintenance3 { + handle: vk::Device, + fp: vk::KhrMaintenance3Fn, +} + +impl Maintenance3 { + pub fn new(instance: &Instance, device: &Device) -> Self { + let handle = device.handle(); + let fp = vk::KhrMaintenance3Fn::load(|name| unsafe { + mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr())) + }); + Self { handle, fp } + } + + /// + #[inline] + pub unsafe fn get_descriptor_set_layout_support( + &self, + create_info: &vk::DescriptorSetLayoutCreateInfo, + out: &mut vk::DescriptorSetLayoutSupportKHR, + ) { + (self.fp.get_descriptor_set_layout_support_khr)(self.handle, create_info, out); + } + + #[inline] + pub const fn name() -> &'static CStr { + vk::KhrMaintenance3Fn::name() + } + + #[inline] + pub fn fp(&self) -> &vk::KhrMaintenance3Fn { + &self.fp + } + + #[inline] + pub fn device(&self) -> vk::Device { + self.handle + } +} diff --git a/third_party/rust/ash/src/extensions/khr/maintenance4.rs b/third_party/rust/ash/src/extensions/khr/maintenance4.rs new file mode 100644 index 0000000000..003e1a9cf2 --- /dev/null +++ b/third_party/rust/ash/src/extensions/khr/maintenance4.rs @@ -0,0 +1,91 @@ +use crate::vk; +use crate::{Device, Instance}; +use std::ffi::CStr; +use std::mem; + +#[derive(Clone)] +pub struct Maintenance4 { + handle: vk::Device, + fp: vk::KhrMaintenance4Fn, +} + +impl Maintenance4 { + pub fn new(instance: &Instance, device: &Device) -> Self { + let handle = device.handle(); + let fp = vk::KhrMaintenance4Fn::load(|name| unsafe { + mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr())) + }); + Self { handle, fp } + } + + /// + #[inline] + pub unsafe fn get_device_buffer_memory_requirements( + &self, + create_info: &vk::DeviceBufferMemoryRequirementsKHR, + out: &mut vk::MemoryRequirements2, + ) { + (self.fp.get_device_buffer_memory_requirements_khr)(self.handle, create_info, out) + } + + /// + #[inline] + pub unsafe fn get_device_image_memory_requirements( + &self, + create_info: &vk::DeviceImageMemoryRequirementsKHR, + out: &mut vk::MemoryRequirements2, + ) { + (self.fp.get_device_image_memory_requirements_khr)(self.handle, create_info, out) + } + + /// Retrieve the number of elements to pass to [`get_device_image_sparse_memory_requirements()`][Self::get_device_image_sparse_memory_requirements()] + #[inline] + pub unsafe fn get_device_image_sparse_memory_requirements_len( + &self, + create_info: &vk::DeviceImageMemoryRequirementsKHR, + ) -> usize { + let mut count = 0; + (self.fp.get_device_image_sparse_memory_requirements_khr)( + self.handle, + create_info, + &mut count, + std::ptr::null_mut(), + ); + count as usize + } + + /// + /// + /// Call [`get_device_image_sparse_memory_requirements_len()`][Self::get_device_image_sparse_memory_requirements_len()] to query the number of elements to pass to `out`. + /// Be sure to [`Default::default()`]-initialize these elements and optionally set their `p_next` pointer. + #[inline] + pub unsafe fn get_device_image_sparse_memory_requirements( + &self, + create_info: &vk::DeviceImageMemoryRequirementsKHR, + out: &mut [vk::SparseImageMemoryRequirements2], + ) { + let mut count = out.len() as u32; + (self.fp.get_device_image_sparse_memory_requirements_khr)( + self.handle, + create_info, + &mut count, + out.as_mut_ptr(), + ); + assert_eq!(count as usize, out.len()); + } + + #[inline] + pub const fn name() -> &'static CStr { + vk::KhrMaintenance4Fn::name() + } + + #[inline] + pub fn fp(&self) -> &vk::KhrMaintenance4Fn { + &self.fp + } + + #[inline] + pub fn device(&self) -> vk::Device { + self.handle + } +} diff --git a/third_party/rust/ash/src/extensions/khr/mod.rs b/third_party/rust/ash/src/extensions/khr/mod.rs new file mode 100644 index 0000000000..ea809b43da --- /dev/null +++ b/third_party/rust/ash/src/extensions/khr/mod.rs @@ -0,0 +1,75 @@ +pub use self::acceleration_structure::AccelerationStructure; +pub use self::android_surface::AndroidSurface; +pub use self::buffer_device_address::BufferDeviceAddress; +pub use self::copy_commands2::CopyCommands2; +pub use self::create_render_pass2::CreateRenderPass2; +pub use self::deferred_host_operations::DeferredHostOperations; +pub use self::device_group::DeviceGroup; +pub use self::device_group_creation::DeviceGroupCreation; +pub use self::display::Display; +pub use self::display_swapchain::DisplaySwapchain; +pub use self::draw_indirect_count::DrawIndirectCount; +pub use self::dynamic_rendering::DynamicRendering; +pub use self::external_fence_fd::ExternalFenceFd; +pub use self::external_fence_win32::ExternalFenceWin32; +pub use self::external_memory_fd::ExternalMemoryFd; +pub use self::external_memory_win32::ExternalMemoryWin32; +pub use self::external_semaphore_fd::ExternalSemaphoreFd; +pub use self::external_semaphore_win32::ExternalSemaphoreWin32; +pub use self::get_memory_requirements2::GetMemoryRequirements2; +pub use self::get_physical_device_properties2::GetPhysicalDeviceProperties2; +pub use self::get_surface_capabilities2::GetSurfaceCapabilities2; +pub use self::maintenance1::Maintenance1; +pub use self::maintenance3::Maintenance3; +pub use self::maintenance4::Maintenance4; +pub use self::pipeline_executable_properties::PipelineExecutableProperties; +pub use self::present_wait::PresentWait; +pub use self::push_descriptor::PushDescriptor; +pub use self::ray_tracing_maintenance1::RayTracingMaintenance1; +pub use self::ray_tracing_pipeline::RayTracingPipeline; +pub use self::surface::Surface; +pub use self::swapchain::Swapchain; +pub use self::synchronization2::Synchronization2; +pub use self::timeline_semaphore::TimelineSemaphore; +pub use self::wayland_surface::WaylandSurface; +pub use self::win32_surface::Win32Surface; +pub use self::xcb_surface::XcbSurface; +pub use self::xlib_surface::XlibSurface; + +mod acceleration_structure; +mod android_surface; +mod buffer_device_address; +mod copy_commands2; +mod create_render_pass2; +mod deferred_host_operations; +mod device_group; +mod device_group_creation; +mod display; +mod display_swapchain; +mod draw_indirect_count; +mod dynamic_rendering; +mod external_fence_fd; +mod external_fence_win32; +mod external_memory_fd; +mod external_memory_win32; +mod external_semaphore_fd; +mod external_semaphore_win32; +mod get_memory_requirements2; +mod get_physical_device_properties2; +mod get_surface_capabilities2; +mod maintenance1; +mod maintenance3; +mod maintenance4; +mod pipeline_executable_properties; +mod present_wait; +mod push_descriptor; +mod ray_tracing_maintenance1; +mod ray_tracing_pipeline; +mod surface; +mod swapchain; +mod synchronization2; +mod timeline_semaphore; +mod wayland_surface; +mod win32_surface; +mod xcb_surface; +mod xlib_surface; diff --git a/third_party/rust/ash/src/extensions/khr/pipeline_executable_properties.rs b/third_party/rust/ash/src/extensions/khr/pipeline_executable_properties.rs new file mode 100644 index 0000000000..68e43b4a81 --- /dev/null +++ b/third_party/rust/ash/src/extensions/khr/pipeline_executable_properties.rs @@ -0,0 +1,84 @@ +use crate::prelude::*; +use crate::vk; +use crate::{Device, Instance}; +use std::ffi::CStr; +use std::mem; + +#[derive(Clone)] +pub struct PipelineExecutableProperties { + handle: vk::Device, + fp: vk::KhrPipelineExecutablePropertiesFn, +} + +impl PipelineExecutableProperties { + pub fn new(instance: &Instance, device: &Device) -> Self { + let handle = device.handle(); + let fp = vk::KhrPipelineExecutablePropertiesFn::load(|name| unsafe { + mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr())) + }); + Self { handle, fp } + } + + /// + #[inline] + pub unsafe fn get_pipeline_executable_internal_representations( + &self, + executable_info: &vk::PipelineExecutableInfoKHR, + ) -> VkResult> { + read_into_defaulted_vector(|count, data| { + (self.fp.get_pipeline_executable_internal_representations_khr)( + self.handle, + executable_info, + count, + data, + ) + }) + } + + /// + #[inline] + pub unsafe fn get_pipeline_executable_properties( + &self, + pipeline_info: &vk::PipelineInfoKHR, + ) -> VkResult> { + read_into_defaulted_vector(|count, data| { + (self.fp.get_pipeline_executable_properties_khr)( + self.handle, + pipeline_info, + count, + data, + ) + }) + } + + /// + #[inline] + pub unsafe fn get_pipeline_executable_statistics( + &self, + executable_info: &vk::PipelineExecutableInfoKHR, + ) -> VkResult> { + read_into_defaulted_vector(|count, data| { + (self.fp.get_pipeline_executable_statistics_khr)( + self.handle, + executable_info, + count, + data, + ) + }) + } + + #[inline] + pub const fn name() -> &'static CStr { + vk::KhrPipelineExecutablePropertiesFn::name() + } + + #[inline] + pub fn fp(&self) -> &vk::KhrPipelineExecutablePropertiesFn { + &self.fp + } + + #[inline] + pub fn device(&self) -> vk::Device { + self.handle + } +} diff --git a/third_party/rust/ash/src/extensions/khr/present_wait.rs b/third_party/rust/ash/src/extensions/khr/present_wait.rs new file mode 100644 index 0000000000..4d8effe48d --- /dev/null +++ b/third_party/rust/ash/src/extensions/khr/present_wait.rs @@ -0,0 +1,47 @@ +use crate::prelude::*; +use crate::vk; +use crate::{Device, Instance}; +use std::ffi::CStr; +use std::mem; + +#[derive(Clone)] +pub struct PresentWait { + handle: vk::Device, + fp: vk::KhrPresentWaitFn, +} + +impl PresentWait { + pub fn new(instance: &Instance, device: &Device) -> Self { + let handle = device.handle(); + let fp = vk::KhrPresentWaitFn::load(|name| unsafe { + mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr())) + }); + Self { handle, fp } + } + + /// + #[inline] + pub unsafe fn wait_for_present( + &self, + swapchain: vk::SwapchainKHR, + present_id: u64, + timeout: u64, + ) -> VkResult<()> { + (self.fp.wait_for_present_khr)(self.handle, swapchain, present_id, timeout).result() + } + + #[inline] + pub const fn name() -> &'static CStr { + vk::KhrPresentWaitFn::name() + } + + #[inline] + pub fn fp(&self) -> &vk::KhrPresentWaitFn { + &self.fp + } + + #[inline] + pub fn device(&self) -> vk::Device { + self.handle + } +} diff --git a/third_party/rust/ash/src/extensions/khr/push_descriptor.rs b/third_party/rust/ash/src/extensions/khr/push_descriptor.rs new file mode 100644 index 0000000000..22d1572883 --- /dev/null +++ b/third_party/rust/ash/src/extensions/khr/push_descriptor.rs @@ -0,0 +1,68 @@ +use crate::vk; +use crate::{Device, Instance}; +use std::ffi::c_void; +use std::ffi::CStr; +use std::mem; + +#[derive(Clone)] +pub struct PushDescriptor { + fp: vk::KhrPushDescriptorFn, +} + +impl PushDescriptor { + pub fn new(instance: &Instance, device: &Device) -> Self { + let fp = vk::KhrPushDescriptorFn::load(|name| unsafe { + mem::transmute(instance.get_device_proc_addr(device.handle(), name.as_ptr())) + }); + Self { fp } + } + + /// + #[inline] + pub unsafe fn cmd_push_descriptor_set( + &self, + command_buffer: vk::CommandBuffer, + pipeline_bind_point: vk::PipelineBindPoint, + layout: vk::PipelineLayout, + set: u32, + descriptor_writes: &[vk::WriteDescriptorSet], + ) { + (self.fp.cmd_push_descriptor_set_khr)( + command_buffer, + pipeline_bind_point, + layout, + set, + descriptor_writes.len() as u32, + descriptor_writes.as_ptr(), + ); + } + + /// + #[inline] + pub unsafe fn cmd_push_descriptor_set_with_template( + &self, + command_buffer: vk::CommandBuffer, + descriptor_update_template: vk::DescriptorUpdateTemplate, + layout: vk::PipelineLayout, + set: u32, + p_data: *const c_void, + ) { + (self.fp.cmd_push_descriptor_set_with_template_khr)( + command_buffer, + descriptor_update_template, + layout, + set, + p_data, + ); + } + + #[inline] + pub const fn name() -> &'static CStr { + vk::KhrPushDescriptorFn::name() + } + + #[inline] + pub fn fp(&self) -> &vk::KhrPushDescriptorFn { + &self.fp + } +} diff --git a/third_party/rust/ash/src/extensions/khr/ray_tracing_maintenance1.rs b/third_party/rust/ash/src/extensions/khr/ray_tracing_maintenance1.rs new file mode 100644 index 0000000000..a5159ad395 --- /dev/null +++ b/third_party/rust/ash/src/extensions/khr/ray_tracing_maintenance1.rs @@ -0,0 +1,42 @@ +use crate::vk; +use crate::{Device, Instance}; +use std::ffi::CStr; +use std::mem; + +/// +#[derive(Clone)] +pub struct RayTracingMaintenance1 { + fp: vk::KhrRayTracingMaintenance1Fn, +} + +impl RayTracingMaintenance1 { + pub fn new(instance: &Instance, device: &Device) -> Self { + let handle = device.handle(); + let fp = vk::KhrRayTracingMaintenance1Fn::load(|name| unsafe { + mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr())) + }); + Self { fp } + } + + /// + /// + /// `indirect_device_address` is a buffer device address which is a pointer to a [`vk::TraceRaysIndirectCommand2KHR`] structure containing the trace ray parameters. + #[inline] + pub unsafe fn cmd_trace_rays_indirect2( + &self, + command_buffer: vk::CommandBuffer, + indirect_device_address: vk::DeviceAddress, + ) { + (self.fp.cmd_trace_rays_indirect2_khr)(command_buffer, indirect_device_address); + } + + #[inline] + pub const fn name() -> &'static CStr { + vk::KhrRayTracingMaintenance1Fn::name() + } + + #[inline] + pub fn fp(&self) -> &vk::KhrRayTracingMaintenance1Fn { + &self.fp + } +} diff --git a/third_party/rust/ash/src/extensions/khr/ray_tracing_pipeline.rs b/third_party/rust/ash/src/extensions/khr/ray_tracing_pipeline.rs new file mode 100644 index 0000000000..af733430d1 --- /dev/null +++ b/third_party/rust/ash/src/extensions/khr/ray_tracing_pipeline.rs @@ -0,0 +1,194 @@ +use crate::prelude::*; +use crate::vk; +use crate::RawPtr; +use crate::{Device, Instance}; +use std::ffi::CStr; +use std::mem; + +#[derive(Clone)] +pub struct RayTracingPipeline { + handle: vk::Device, + fp: vk::KhrRayTracingPipelineFn, +} + +impl RayTracingPipeline { + pub fn new(instance: &Instance, device: &Device) -> Self { + let handle = device.handle(); + let fp = vk::KhrRayTracingPipelineFn::load(|name| unsafe { + mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr())) + }); + Self { handle, fp } + } + + #[inline] + pub unsafe fn get_properties( + instance: &Instance, + pdevice: vk::PhysicalDevice, + ) -> vk::PhysicalDeviceRayTracingPipelinePropertiesKHR { + let mut props_rt = vk::PhysicalDeviceRayTracingPipelinePropertiesKHR::default(); + { + let mut props = vk::PhysicalDeviceProperties2::builder().push_next(&mut props_rt); + instance.get_physical_device_properties2(pdevice, &mut props); + } + props_rt + } + + /// + #[inline] + pub unsafe fn cmd_trace_rays( + &self, + command_buffer: vk::CommandBuffer, + raygen_shader_binding_tables: &vk::StridedDeviceAddressRegionKHR, + miss_shader_binding_tables: &vk::StridedDeviceAddressRegionKHR, + hit_shader_binding_tables: &vk::StridedDeviceAddressRegionKHR, + callable_shader_binding_tables: &vk::StridedDeviceAddressRegionKHR, + width: u32, + height: u32, + depth: u32, + ) { + (self.fp.cmd_trace_rays_khr)( + command_buffer, + raygen_shader_binding_tables, + miss_shader_binding_tables, + hit_shader_binding_tables, + callable_shader_binding_tables, + width, + height, + depth, + ); + } + + /// + #[inline] + pub unsafe fn create_ray_tracing_pipelines( + &self, + deferred_operation: vk::DeferredOperationKHR, + pipeline_cache: vk::PipelineCache, + create_info: &[vk::RayTracingPipelineCreateInfoKHR], + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) -> VkResult> { + let mut pipelines = vec![mem::zeroed(); create_info.len()]; + (self.fp.create_ray_tracing_pipelines_khr)( + self.handle, + deferred_operation, + pipeline_cache, + create_info.len() as u32, + create_info.as_ptr(), + allocation_callbacks.as_raw_ptr(), + pipelines.as_mut_ptr(), + ) + .result_with_success(pipelines) + } + + /// + #[inline] + pub unsafe fn get_ray_tracing_shader_group_handles( + &self, + pipeline: vk::Pipeline, + first_group: u32, + group_count: u32, + data_size: usize, + ) -> VkResult> { + let mut data = Vec::::with_capacity(data_size); + (self.fp.get_ray_tracing_shader_group_handles_khr)( + self.handle, + pipeline, + first_group, + group_count, + data_size, + data.as_mut_ptr().cast(), + ) + .result()?; + data.set_len(data_size); + Ok(data) + } + + /// + #[inline] + pub unsafe fn get_ray_tracing_capture_replay_shader_group_handles( + &self, + pipeline: vk::Pipeline, + first_group: u32, + group_count: u32, + data_size: usize, + ) -> VkResult> { + let mut data = Vec::::with_capacity(data_size); + (self + .fp + .get_ray_tracing_capture_replay_shader_group_handles_khr)( + self.handle, + pipeline, + first_group, + group_count, + data_size, + data.as_mut_ptr().cast(), + ) + .result()?; + data.set_len(data_size); + Ok(data) + } + + /// + /// + /// `indirect_device_address` is a buffer device address which is a pointer to a [`vk::TraceRaysIndirectCommandKHR`] structure containing the trace ray parameters. + #[inline] + pub unsafe fn cmd_trace_rays_indirect( + &self, + command_buffer: vk::CommandBuffer, + raygen_shader_binding_table: &[vk::StridedDeviceAddressRegionKHR], + miss_shader_binding_table: &[vk::StridedDeviceAddressRegionKHR], + hit_shader_binding_table: &[vk::StridedDeviceAddressRegionKHR], + callable_shader_binding_table: &[vk::StridedDeviceAddressRegionKHR], + indirect_device_address: vk::DeviceAddress, + ) { + (self.fp.cmd_trace_rays_indirect_khr)( + command_buffer, + raygen_shader_binding_table.as_ptr(), + miss_shader_binding_table.as_ptr(), + hit_shader_binding_table.as_ptr(), + callable_shader_binding_table.as_ptr(), + indirect_device_address, + ); + } + + /// + #[inline] + pub unsafe fn get_ray_tracing_shader_group_stack_size( + &self, + pipeline: vk::Pipeline, + group: u32, + group_shader: vk::ShaderGroupShaderKHR, + ) -> vk::DeviceSize { + (self.fp.get_ray_tracing_shader_group_stack_size_khr)( + self.handle, + pipeline, + group, + group_shader, + ) + } + + /// + #[inline] + pub unsafe fn cmd_set_ray_tracing_pipeline_stack_size( + &self, + command_buffer: vk::CommandBuffer, + pipeline_stack_size: u32, + ) { + (self.fp.cmd_set_ray_tracing_pipeline_stack_size_khr)(command_buffer, pipeline_stack_size); + } + + #[inline] + pub const fn name() -> &'static CStr { + vk::KhrRayTracingPipelineFn::name() + } + + #[inline] + pub fn fp(&self) -> &vk::KhrRayTracingPipelineFn { + &self.fp + } + + #[inline] + pub fn device(&self) -> vk::Device { + self.handle + } +} diff --git a/third_party/rust/ash/src/extensions/khr/surface.rs b/third_party/rust/ash/src/extensions/khr/surface.rs new file mode 100755 index 0000000000..11508bdcc9 --- /dev/null +++ b/third_party/rust/ash/src/extensions/khr/surface.rs @@ -0,0 +1,110 @@ +use crate::prelude::*; +use crate::vk; +use crate::RawPtr; +use crate::{Entry, Instance}; +use std::ffi::CStr; +use std::mem; + +#[derive(Clone)] +pub struct Surface { + handle: vk::Instance, + fp: vk::KhrSurfaceFn, +} + +impl Surface { + pub fn new(entry: &Entry, instance: &Instance) -> Self { + let handle = instance.handle(); + let fp = vk::KhrSurfaceFn::load(|name| unsafe { + mem::transmute(entry.get_instance_proc_addr(handle, name.as_ptr())) + }); + Self { handle, fp } + } + + /// + #[inline] + pub unsafe fn get_physical_device_surface_support( + &self, + physical_device: vk::PhysicalDevice, + queue_family_index: u32, + surface: vk::SurfaceKHR, + ) -> VkResult { + let mut b = 0; + (self.fp.get_physical_device_surface_support_khr)( + physical_device, + queue_family_index, + surface, + &mut b, + ) + .result_with_success(b > 0) + } + + /// + #[inline] + pub unsafe fn get_physical_device_surface_present_modes( + &self, + physical_device: vk::PhysicalDevice, + surface: vk::SurfaceKHR, + ) -> VkResult> { + read_into_uninitialized_vector(|count, data| { + (self.fp.get_physical_device_surface_present_modes_khr)( + physical_device, + surface, + count, + data, + ) + }) + } + + /// + #[inline] + pub unsafe fn get_physical_device_surface_capabilities( + &self, + physical_device: vk::PhysicalDevice, + surface: vk::SurfaceKHR, + ) -> VkResult { + let mut surface_capabilities = mem::zeroed(); + (self.fp.get_physical_device_surface_capabilities_khr)( + physical_device, + surface, + &mut surface_capabilities, + ) + .result_with_success(surface_capabilities) + } + + /// + #[inline] + pub unsafe fn get_physical_device_surface_formats( + &self, + physical_device: vk::PhysicalDevice, + surface: vk::SurfaceKHR, + ) -> VkResult> { + read_into_uninitialized_vector(|count, data| { + (self.fp.get_physical_device_surface_formats_khr)(physical_device, surface, count, data) + }) + } + + /// + #[inline] + pub unsafe fn destroy_surface( + &self, + surface: vk::SurfaceKHR, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) { + (self.fp.destroy_surface_khr)(self.handle, surface, allocation_callbacks.as_raw_ptr()); + } + + #[inline] + pub const fn name() -> &'static CStr { + vk::KhrSurfaceFn::name() + } + + #[inline] + pub fn fp(&self) -> &vk::KhrSurfaceFn { + &self.fp + } + + #[inline] + pub fn instance(&self) -> vk::Instance { + self.handle + } +} diff --git a/third_party/rust/ash/src/extensions/khr/swapchain.rs b/third_party/rust/ash/src/extensions/khr/swapchain.rs new file mode 100755 index 0000000000..8f57729de7 --- /dev/null +++ b/third_party/rust/ash/src/extensions/khr/swapchain.rs @@ -0,0 +1,211 @@ +#[cfg(doc)] +use super::DeviceGroup; +use crate::prelude::*; +use crate::vk; +use crate::RawPtr; +use crate::{Device, Instance}; +use std::ffi::CStr; +use std::mem; + +#[derive(Clone)] +pub struct Swapchain { + handle: vk::Device, + fp: vk::KhrSwapchainFn, +} + +impl Swapchain { + pub fn new(instance: &Instance, device: &Device) -> Self { + let handle = device.handle(); + let fp = vk::KhrSwapchainFn::load(|name| unsafe { + mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr())) + }); + Self { handle, fp } + } + + /// + #[inline] + pub unsafe fn create_swapchain( + &self, + create_info: &vk::SwapchainCreateInfoKHR, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) -> VkResult { + let mut swapchain = mem::zeroed(); + (self.fp.create_swapchain_khr)( + self.handle, + create_info, + allocation_callbacks.as_raw_ptr(), + &mut swapchain, + ) + .result_with_success(swapchain) + } + + /// + #[inline] + pub unsafe fn destroy_swapchain( + &self, + swapchain: vk::SwapchainKHR, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) { + (self.fp.destroy_swapchain_khr)(self.handle, swapchain, allocation_callbacks.as_raw_ptr()); + } + + /// + #[inline] + pub unsafe fn get_swapchain_images( + &self, + swapchain: vk::SwapchainKHR, + ) -> VkResult> { + read_into_uninitialized_vector(|count, data| { + (self.fp.get_swapchain_images_khr)(self.handle, swapchain, count, data) + }) + } + + /// On success, returns the next image's index and whether the swapchain is suboptimal for the surface. + /// + /// + #[inline] + pub unsafe fn acquire_next_image( + &self, + swapchain: vk::SwapchainKHR, + timeout: u64, + semaphore: vk::Semaphore, + fence: vk::Fence, + ) -> VkResult<(u32, bool)> { + let mut index = 0; + let err_code = (self.fp.acquire_next_image_khr)( + self.handle, + swapchain, + timeout, + semaphore, + fence, + &mut index, + ); + match err_code { + vk::Result::SUCCESS => Ok((index, false)), + vk::Result::SUBOPTIMAL_KHR => Ok((index, true)), + _ => Err(err_code), + } + } + + /// On success, returns whether the swapchain is suboptimal for the surface. + /// + /// + #[inline] + pub unsafe fn queue_present( + &self, + queue: vk::Queue, + present_info: &vk::PresentInfoKHR, + ) -> VkResult { + let err_code = (self.fp.queue_present_khr)(queue, present_info); + match err_code { + vk::Result::SUCCESS => Ok(false), + vk::Result::SUBOPTIMAL_KHR => Ok(true), + _ => Err(err_code), + } + } + + /// Only available since [Vulkan 1.1]. + /// + /// Also available as [`DeviceGroup::get_device_group_present_capabilities()`] + /// when [`VK_KHR_surface`] is enabled. + /// + /// + /// + /// [Vulkan 1.1]: https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_VERSION_1_1.html + /// [`VK_KHR_surface`]: https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_KHR_surface.html + #[inline] + pub unsafe fn get_device_group_present_capabilities( + &self, + device_group_present_capabilities: &mut vk::DeviceGroupPresentCapabilitiesKHR, + ) -> VkResult<()> { + (self.fp.get_device_group_present_capabilities_khr)( + self.handle, + device_group_present_capabilities, + ) + .result() + } + + /// Only available since [Vulkan 1.1]. + /// + /// Also available as [`DeviceGroup::get_device_group_surface_present_modes()`] + /// when [`VK_KHR_surface`] is enabled. + /// + /// + /// + /// [Vulkan 1.1]: https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_VERSION_1_1.html + /// [`VK_KHR_surface`]: https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_KHR_surface.html + #[inline] + pub unsafe fn get_device_group_surface_present_modes( + &self, + surface: vk::SurfaceKHR, + ) -> VkResult { + let mut modes = mem::zeroed(); + (self.fp.get_device_group_surface_present_modes_khr)(self.handle, surface, &mut modes) + .result_with_success(modes) + } + + /// Only available since [Vulkan 1.1]. + /// + /// Also available as [`DeviceGroup::get_physical_device_present_rectangles()`] + /// when [`VK_KHR_surface`] is enabled. + /// + /// + /// + /// [Vulkan 1.1]: https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_VERSION_1_1.html + /// [`VK_KHR_surface`]: https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_KHR_surface.html + #[inline] + pub unsafe fn get_physical_device_present_rectangles( + &self, + physical_device: vk::PhysicalDevice, + surface: vk::SurfaceKHR, + ) -> VkResult> { + read_into_uninitialized_vector(|count, data| { + (self.fp.get_physical_device_present_rectangles_khr)( + physical_device, + surface, + count, + data, + ) + }) + } + + /// On success, returns the next image's index and whether the swapchain is suboptimal for the surface. + /// + /// Only available since [Vulkan 1.1]. + /// + /// Also available as [`DeviceGroup::acquire_next_image2()`] + /// when [`VK_KHR_swapchain`] is enabled. + /// + /// + /// + /// [Vulkan 1.1]: https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_VERSION_1_1.html + /// [`VK_KHR_swapchain`]: https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_KHR_swapchain.html + #[inline] + pub unsafe fn acquire_next_image2( + &self, + acquire_info: &vk::AcquireNextImageInfoKHR, + ) -> VkResult<(u32, bool)> { + let mut index = 0; + let err_code = (self.fp.acquire_next_image2_khr)(self.handle, acquire_info, &mut index); + match err_code { + vk::Result::SUCCESS => Ok((index, false)), + vk::Result::SUBOPTIMAL_KHR => Ok((index, true)), + _ => Err(err_code), + } + } + + #[inline] + pub const fn name() -> &'static CStr { + vk::KhrSwapchainFn::name() + } + + #[inline] + pub fn fp(&self) -> &vk::KhrSwapchainFn { + &self.fp + } + + #[inline] + pub fn device(&self) -> vk::Device { + self.handle + } +} diff --git a/third_party/rust/ash/src/extensions/khr/synchronization2.rs b/third_party/rust/ash/src/extensions/khr/synchronization2.rs new file mode 100644 index 0000000000..d8baefd602 --- /dev/null +++ b/third_party/rust/ash/src/extensions/khr/synchronization2.rs @@ -0,0 +1,101 @@ +use crate::prelude::*; +use crate::vk; +use crate::{Device, Instance}; +use std::ffi::CStr; +use std::mem; + +#[derive(Clone)] +pub struct Synchronization2 { + fp: vk::KhrSynchronization2Fn, +} + +impl Synchronization2 { + pub fn new(instance: &Instance, device: &Device) -> Self { + let fp = vk::KhrSynchronization2Fn::load(|name| unsafe { + mem::transmute(instance.get_device_proc_addr(device.handle(), name.as_ptr())) + }); + Self { fp } + } + + /// + #[inline] + pub unsafe fn cmd_pipeline_barrier2( + &self, + command_buffer: vk::CommandBuffer, + dependency_info: &vk::DependencyInfoKHR, + ) { + (self.fp.cmd_pipeline_barrier2_khr)(command_buffer, dependency_info) + } + + /// + #[inline] + pub unsafe fn cmd_reset_event2( + &self, + command_buffer: vk::CommandBuffer, + event: vk::Event, + stage_mask: vk::PipelineStageFlags2KHR, + ) { + (self.fp.cmd_reset_event2_khr)(command_buffer, event, stage_mask) + } + + /// + #[inline] + pub unsafe fn cmd_set_event2( + &self, + command_buffer: vk::CommandBuffer, + event: vk::Event, + dependency_info: &vk::DependencyInfoKHR, + ) { + (self.fp.cmd_set_event2_khr)(command_buffer, event, dependency_info) + } + + /// + #[inline] + pub unsafe fn cmd_wait_events2( + &self, + command_buffer: vk::CommandBuffer, + events: &[vk::Event], + dependency_infos: &[vk::DependencyInfoKHR], + ) { + assert_eq!(events.len(), dependency_infos.len()); + (self.fp.cmd_wait_events2_khr)( + command_buffer, + events.len() as u32, + events.as_ptr(), + dependency_infos.as_ptr(), + ) + } + + /// + #[inline] + pub unsafe fn cmd_write_timestamp2( + &self, + command_buffer: vk::CommandBuffer, + stage: vk::PipelineStageFlags2KHR, + query_pool: vk::QueryPool, + query: u32, + ) { + (self.fp.cmd_write_timestamp2_khr)(command_buffer, stage, query_pool, query) + } + + /// + #[inline] + pub unsafe fn queue_submit2( + &self, + queue: vk::Queue, + submits: &[vk::SubmitInfo2KHR], + fence: vk::Fence, + ) -> VkResult<()> { + (self.fp.queue_submit2_khr)(queue, submits.len() as u32, submits.as_ptr(), fence).result() + } + + #[inline] + pub const fn name() -> &'static CStr { + vk::KhrSynchronization2Fn::name() + } + + #[inline] + pub fn fp(&self) -> &vk::KhrSynchronization2Fn { + &self.fp + } +} diff --git a/third_party/rust/ash/src/extensions/khr/timeline_semaphore.rs b/third_party/rust/ash/src/extensions/khr/timeline_semaphore.rs new file mode 100644 index 0000000000..de9a492506 --- /dev/null +++ b/third_party/rust/ash/src/extensions/khr/timeline_semaphore.rs @@ -0,0 +1,60 @@ +use crate::prelude::*; +use crate::vk; +use crate::{Device, Instance}; +use std::ffi::CStr; +use std::mem; + +#[derive(Clone)] +pub struct TimelineSemaphore { + handle: vk::Device, + fp: vk::KhrTimelineSemaphoreFn, +} + +impl TimelineSemaphore { + pub fn new(instance: &Instance, device: &Device) -> Self { + let handle = device.handle(); + let fp = vk::KhrTimelineSemaphoreFn::load(|name| unsafe { + mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr())) + }); + Self { handle, fp } + } + + /// + #[inline] + pub unsafe fn get_semaphore_counter_value(&self, semaphore: vk::Semaphore) -> VkResult { + let mut value = 0; + (self.fp.get_semaphore_counter_value_khr)(self.handle, semaphore, &mut value) + .result_with_success(value) + } + + /// + #[inline] + pub unsafe fn wait_semaphores( + &self, + wait_info: &vk::SemaphoreWaitInfo, + timeout: u64, + ) -> VkResult<()> { + (self.fp.wait_semaphores_khr)(self.handle, wait_info, timeout).result() + } + + /// + #[inline] + pub unsafe fn signal_semaphore(&self, signal_info: &vk::SemaphoreSignalInfo) -> VkResult<()> { + (self.fp.signal_semaphore_khr)(self.handle, signal_info).result() + } + + #[inline] + pub const fn name() -> &'static CStr { + vk::KhrTimelineSemaphoreFn::name() + } + + #[inline] + pub fn fp(&self) -> &vk::KhrTimelineSemaphoreFn { + &self.fp + } + + #[inline] + pub fn device(&self) -> vk::Device { + self.handle + } +} diff --git a/third_party/rust/ash/src/extensions/khr/wayland_surface.rs b/third_party/rust/ash/src/extensions/khr/wayland_surface.rs new file mode 100755 index 0000000000..d51fcb9914 --- /dev/null +++ b/third_party/rust/ash/src/extensions/khr/wayland_surface.rs @@ -0,0 +1,71 @@ +use crate::prelude::*; +use crate::vk; +use crate::RawPtr; +use crate::{Entry, Instance}; +use std::ffi::CStr; +use std::mem; + +#[derive(Clone)] +pub struct WaylandSurface { + handle: vk::Instance, + fp: vk::KhrWaylandSurfaceFn, +} + +impl WaylandSurface { + pub fn new(entry: &Entry, instance: &Instance) -> Self { + let handle = instance.handle(); + let fp = vk::KhrWaylandSurfaceFn::load(|name| unsafe { + mem::transmute(entry.get_instance_proc_addr(handle, name.as_ptr())) + }); + Self { handle, fp } + } + + /// + #[inline] + pub unsafe fn create_wayland_surface( + &self, + create_info: &vk::WaylandSurfaceCreateInfoKHR, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) -> VkResult { + let mut surface = mem::zeroed(); + (self.fp.create_wayland_surface_khr)( + self.handle, + create_info, + allocation_callbacks.as_raw_ptr(), + &mut surface, + ) + .result_with_success(surface) + } + + /// + #[inline] + pub unsafe fn get_physical_device_wayland_presentation_support( + &self, + physical_device: vk::PhysicalDevice, + queue_family_index: u32, + wl_display: &mut vk::wl_display, + ) -> bool { + let b = (self.fp.get_physical_device_wayland_presentation_support_khr)( + physical_device, + queue_family_index, + wl_display, + ); + + b > 0 + } + + #[inline] + pub const fn name() -> &'static CStr { + vk::KhrWaylandSurfaceFn::name() + } + + #[inline] + pub fn fp(&self) -> &vk::KhrWaylandSurfaceFn { + &self.fp + } + + #[inline] + pub fn instance(&self) -> vk::Instance { + self.handle + } +} diff --git a/third_party/rust/ash/src/extensions/khr/win32_surface.rs b/third_party/rust/ash/src/extensions/khr/win32_surface.rs new file mode 100755 index 0000000000..be56a02e2e --- /dev/null +++ b/third_party/rust/ash/src/extensions/khr/win32_surface.rs @@ -0,0 +1,69 @@ +use crate::prelude::*; +use crate::vk; +use crate::RawPtr; +use crate::{Entry, Instance}; +use std::ffi::CStr; +use std::mem; + +#[derive(Clone)] +pub struct Win32Surface { + handle: vk::Instance, + fp: vk::KhrWin32SurfaceFn, +} + +impl Win32Surface { + pub fn new(entry: &Entry, instance: &Instance) -> Self { + let handle = instance.handle(); + let fp = vk::KhrWin32SurfaceFn::load(|name| unsafe { + mem::transmute(entry.get_instance_proc_addr(handle, name.as_ptr())) + }); + Self { handle, fp } + } + + /// + #[inline] + pub unsafe fn create_win32_surface( + &self, + create_info: &vk::Win32SurfaceCreateInfoKHR, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) -> VkResult { + let mut surface = mem::zeroed(); + (self.fp.create_win32_surface_khr)( + self.handle, + create_info, + allocation_callbacks.as_raw_ptr(), + &mut surface, + ) + .result_with_success(surface) + } + + /// + #[inline] + pub unsafe fn get_physical_device_win32_presentation_support( + &self, + physical_device: vk::PhysicalDevice, + queue_family_index: u32, + ) -> bool { + let b = (self.fp.get_physical_device_win32_presentation_support_khr)( + physical_device, + queue_family_index, + ); + + b > 0 + } + + #[inline] + pub const fn name() -> &'static CStr { + vk::KhrWin32SurfaceFn::name() + } + + #[inline] + pub fn fp(&self) -> &vk::KhrWin32SurfaceFn { + &self.fp + } + + #[inline] + pub fn instance(&self) -> vk::Instance { + self.handle + } +} diff --git a/third_party/rust/ash/src/extensions/khr/xcb_surface.rs b/third_party/rust/ash/src/extensions/khr/xcb_surface.rs new file mode 100755 index 0000000000..967376e7c6 --- /dev/null +++ b/third_party/rust/ash/src/extensions/khr/xcb_surface.rs @@ -0,0 +1,73 @@ +use crate::prelude::*; +use crate::vk; +use crate::RawPtr; +use crate::{Entry, Instance}; +use std::ffi::CStr; +use std::mem; + +#[derive(Clone)] +pub struct XcbSurface { + handle: vk::Instance, + fp: vk::KhrXcbSurfaceFn, +} + +impl XcbSurface { + pub fn new(entry: &Entry, instance: &Instance) -> Self { + let handle = instance.handle(); + let fp = vk::KhrXcbSurfaceFn::load(|name| unsafe { + mem::transmute(entry.get_instance_proc_addr(handle, name.as_ptr())) + }); + Self { handle, fp } + } + + /// + #[inline] + pub unsafe fn create_xcb_surface( + &self, + create_info: &vk::XcbSurfaceCreateInfoKHR, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) -> VkResult { + let mut surface = mem::zeroed(); + (self.fp.create_xcb_surface_khr)( + self.handle, + create_info, + allocation_callbacks.as_raw_ptr(), + &mut surface, + ) + .result_with_success(surface) + } + + /// + #[inline] + pub unsafe fn get_physical_device_xcb_presentation_support( + &self, + physical_device: vk::PhysicalDevice, + queue_family_index: u32, + connection: &mut vk::xcb_connection_t, + visual_id: vk::xcb_visualid_t, + ) -> bool { + let b = (self.fp.get_physical_device_xcb_presentation_support_khr)( + physical_device, + queue_family_index, + connection, + visual_id, + ); + + b > 0 + } + + #[inline] + pub const fn name() -> &'static CStr { + vk::KhrXcbSurfaceFn::name() + } + + #[inline] + pub fn fp(&self) -> &vk::KhrXcbSurfaceFn { + &self.fp + } + + #[inline] + pub fn instance(&self) -> vk::Instance { + self.handle + } +} diff --git a/third_party/rust/ash/src/extensions/khr/xlib_surface.rs b/third_party/rust/ash/src/extensions/khr/xlib_surface.rs new file mode 100755 index 0000000000..59ad416e47 --- /dev/null +++ b/third_party/rust/ash/src/extensions/khr/xlib_surface.rs @@ -0,0 +1,73 @@ +use crate::prelude::*; +use crate::vk; +use crate::RawPtr; +use crate::{Entry, Instance}; +use std::ffi::CStr; +use std::mem; + +#[derive(Clone)] +pub struct XlibSurface { + handle: vk::Instance, + fp: vk::KhrXlibSurfaceFn, +} + +impl XlibSurface { + pub fn new(entry: &Entry, instance: &Instance) -> Self { + let handle = instance.handle(); + let fp = vk::KhrXlibSurfaceFn::load(|name| unsafe { + mem::transmute(entry.get_instance_proc_addr(handle, name.as_ptr())) + }); + Self { handle, fp } + } + + /// + #[inline] + pub unsafe fn create_xlib_surface( + &self, + create_info: &vk::XlibSurfaceCreateInfoKHR, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) -> VkResult { + let mut surface = mem::zeroed(); + (self.fp.create_xlib_surface_khr)( + self.handle, + create_info, + allocation_callbacks.as_raw_ptr(), + &mut surface, + ) + .result_with_success(surface) + } + + /// + #[inline] + pub unsafe fn get_physical_device_xlib_presentation_support( + &self, + physical_device: vk::PhysicalDevice, + queue_family_index: u32, + display: &mut vk::Display, + visual_id: vk::VisualID, + ) -> bool { + let b = (self.fp.get_physical_device_xlib_presentation_support_khr)( + physical_device, + queue_family_index, + display, + visual_id, + ); + + b > 0 + } + + #[inline] + pub const fn name() -> &'static CStr { + vk::KhrXlibSurfaceFn::name() + } + + #[inline] + pub fn fp(&self) -> &vk::KhrXlibSurfaceFn { + &self.fp + } + + #[inline] + pub fn instance(&self) -> vk::Instance { + self.handle + } +} diff --git a/third_party/rust/ash/src/extensions/mod.rs b/third_party/rust/ash/src/extensions/mod.rs new file mode 100644 index 0000000000..fefba9b688 --- /dev/null +++ b/third_party/rust/ash/src/extensions/mod.rs @@ -0,0 +1,6 @@ +pub mod experimental; +pub mod ext; +pub mod khr; +pub mod mvk; +pub mod nn; +pub mod nv; diff --git a/third_party/rust/ash/src/extensions/mvk/ios_surface.rs b/third_party/rust/ash/src/extensions/mvk/ios_surface.rs new file mode 100755 index 0000000000..8ae83e98d2 --- /dev/null +++ b/third_party/rust/ash/src/extensions/mvk/ios_surface.rs @@ -0,0 +1,54 @@ +use crate::prelude::*; +use crate::vk; +use crate::RawPtr; +use crate::{Entry, Instance}; +use std::ffi::CStr; +use std::mem; + +#[derive(Clone)] +pub struct IOSSurface { + handle: vk::Instance, + fp: vk::MvkIosSurfaceFn, +} + +impl IOSSurface { + pub fn new(entry: &Entry, instance: &Instance) -> Self { + let handle = instance.handle(); + let fp = vk::MvkIosSurfaceFn::load(|name| unsafe { + mem::transmute(entry.get_instance_proc_addr(handle, name.as_ptr())) + }); + Self { handle, fp } + } + + /// + #[inline] + pub unsafe fn create_ios_surface( + &self, + create_info: &vk::IOSSurfaceCreateInfoMVK, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) -> VkResult { + let mut surface = mem::zeroed(); + (self.fp.create_ios_surface_mvk)( + self.handle, + create_info, + allocation_callbacks.as_raw_ptr(), + &mut surface, + ) + .result_with_success(surface) + } + + #[inline] + pub const fn name() -> &'static CStr { + vk::MvkIosSurfaceFn::name() + } + + #[inline] + pub fn fp(&self) -> &vk::MvkIosSurfaceFn { + &self.fp + } + + #[inline] + pub fn instance(&self) -> vk::Instance { + self.handle + } +} diff --git a/third_party/rust/ash/src/extensions/mvk/macos_surface.rs b/third_party/rust/ash/src/extensions/mvk/macos_surface.rs new file mode 100755 index 0000000000..878829e452 --- /dev/null +++ b/third_party/rust/ash/src/extensions/mvk/macos_surface.rs @@ -0,0 +1,54 @@ +use crate::prelude::*; +use crate::vk; +use crate::RawPtr; +use crate::{Entry, Instance}; +use std::ffi::CStr; +use std::mem; + +#[derive(Clone)] +pub struct MacOSSurface { + handle: vk::Instance, + fp: vk::MvkMacosSurfaceFn, +} + +impl MacOSSurface { + pub fn new(entry: &Entry, instance: &Instance) -> Self { + let handle = instance.handle(); + let fp = vk::MvkMacosSurfaceFn::load(|name| unsafe { + mem::transmute(entry.get_instance_proc_addr(handle, name.as_ptr())) + }); + Self { handle, fp } + } + + /// + #[inline] + pub unsafe fn create_mac_os_surface( + &self, + create_info: &vk::MacOSSurfaceCreateInfoMVK, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) -> VkResult { + let mut surface = mem::zeroed(); + (self.fp.create_mac_os_surface_mvk)( + self.handle, + create_info, + allocation_callbacks.as_raw_ptr(), + &mut surface, + ) + .result_with_success(surface) + } + + #[inline] + pub const fn name() -> &'static CStr { + vk::MvkMacosSurfaceFn::name() + } + + #[inline] + pub fn fp(&self) -> &vk::MvkMacosSurfaceFn { + &self.fp + } + + #[inline] + pub fn instance(&self) -> vk::Instance { + self.handle + } +} diff --git a/third_party/rust/ash/src/extensions/mvk/mod.rs b/third_party/rust/ash/src/extensions/mvk/mod.rs new file mode 100644 index 0000000000..e475d53563 --- /dev/null +++ b/third_party/rust/ash/src/extensions/mvk/mod.rs @@ -0,0 +1,5 @@ +pub use self::ios_surface::IOSSurface; +pub use self::macos_surface::MacOSSurface; + +mod ios_surface; +mod macos_surface; diff --git a/third_party/rust/ash/src/extensions/nn/mod.rs b/third_party/rust/ash/src/extensions/nn/mod.rs new file mode 100644 index 0000000000..e429050a6c --- /dev/null +++ b/third_party/rust/ash/src/extensions/nn/mod.rs @@ -0,0 +1,3 @@ +pub use self::vi_surface::ViSurface; + +mod vi_surface; diff --git a/third_party/rust/ash/src/extensions/nn/vi_surface.rs b/third_party/rust/ash/src/extensions/nn/vi_surface.rs new file mode 100644 index 0000000000..0aa188ac27 --- /dev/null +++ b/third_party/rust/ash/src/extensions/nn/vi_surface.rs @@ -0,0 +1,54 @@ +use crate::prelude::*; +use crate::vk; +use crate::RawPtr; +use crate::{Entry, Instance}; +use std::ffi::CStr; +use std::mem; + +#[derive(Clone)] +pub struct ViSurface { + handle: vk::Instance, + fp: vk::NnViSurfaceFn, +} + +impl ViSurface { + pub fn new(entry: &Entry, instance: &Instance) -> Self { + let handle = instance.handle(); + let fp = vk::NnViSurfaceFn::load(|name| unsafe { + mem::transmute(entry.get_instance_proc_addr(handle, name.as_ptr())) + }); + Self { handle, fp } + } + + /// + #[inline] + pub unsafe fn create_vi_surface( + &self, + create_info: &vk::ViSurfaceCreateInfoNN, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) -> VkResult { + let mut surface = mem::zeroed(); + (self.fp.create_vi_surface_nn)( + self.handle, + create_info, + allocation_callbacks.as_raw_ptr(), + &mut surface, + ) + .result_with_success(surface) + } + + #[inline] + pub const fn name() -> &'static CStr { + vk::NnViSurfaceFn::name() + } + + #[inline] + pub fn fp(&self) -> &vk::NnViSurfaceFn { + &self.fp + } + + #[inline] + pub fn instance(&self) -> vk::Instance { + self.handle + } +} diff --git a/third_party/rust/ash/src/extensions/nv/coverage_reduction_mode.rs b/third_party/rust/ash/src/extensions/nv/coverage_reduction_mode.rs new file mode 100644 index 0000000000..b4304772e3 --- /dev/null +++ b/third_party/rust/ash/src/extensions/nv/coverage_reduction_mode.rs @@ -0,0 +1,70 @@ +use crate::prelude::*; +use crate::vk; +use crate::{Entry, Instance}; +use std::ffi::CStr; +use std::mem; + +/// +#[derive(Clone)] +pub struct CoverageReductionMode { + fp: vk::NvCoverageReductionModeFn, +} + +impl CoverageReductionMode { + pub fn new(entry: &Entry, instance: &Instance) -> Self { + let fp = vk::NvCoverageReductionModeFn::load(|name| unsafe { + mem::transmute(entry.get_instance_proc_addr(instance.handle(), name.as_ptr())) + }); + Self { fp } + } + + /// Retrieve the number of elements to pass to [`get_physical_device_supported_framebuffer_mixed_samples_combinations()`][Self::get_physical_device_supported_framebuffer_mixed_samples_combinations()] + #[inline] + pub unsafe fn get_physical_device_supported_framebuffer_mixed_samples_combinations_len( + &self, + physical_device: vk::PhysicalDevice, + ) -> VkResult { + let mut count = 0; + (self + .fp + .get_physical_device_supported_framebuffer_mixed_samples_combinations_nv)( + physical_device, + &mut count, + std::ptr::null_mut(), + ) + .result_with_success(count as usize) + } + + /// + /// + /// Call [`get_physical_device_supported_framebuffer_mixed_samples_combinations_len()`][Self::get_physical_device_supported_framebuffer_mixed_samples_combinations_len()] to query the number of elements to pass to `out`. + /// Be sure to [`Default::default()`]-initialize these elements and optionally set their `p_next` pointer. + #[inline] + pub unsafe fn get_physical_device_supported_framebuffer_mixed_samples_combinations( + &self, + physical_device: vk::PhysicalDevice, + out: &mut [vk::FramebufferMixedSamplesCombinationNV], + ) -> VkResult<()> { + let mut count = out.len() as u32; + (self + .fp + .get_physical_device_supported_framebuffer_mixed_samples_combinations_nv)( + physical_device, + &mut count, + out.as_mut_ptr(), + ) + .result()?; + assert_eq!(count as usize, out.len()); + Ok(()) + } + + #[inline] + pub const fn name() -> &'static CStr { + vk::NvCoverageReductionModeFn::name() + } + + #[inline] + pub fn fp(&self) -> &vk::NvCoverageReductionModeFn { + &self.fp + } +} diff --git a/third_party/rust/ash/src/extensions/nv/device_diagnostic_checkpoints.rs b/third_party/rust/ash/src/extensions/nv/device_diagnostic_checkpoints.rs new file mode 100644 index 0000000000..ce43d046e6 --- /dev/null +++ b/third_party/rust/ash/src/extensions/nv/device_diagnostic_checkpoints.rs @@ -0,0 +1,63 @@ +use crate::vk; +use crate::{Device, Instance}; +use std::ffi::CStr; +use std::mem; +use std::os::raw::c_void; + +/// +#[derive(Clone)] +pub struct DeviceDiagnosticCheckpoints { + fp: vk::NvDeviceDiagnosticCheckpointsFn, +} + +impl DeviceDiagnosticCheckpoints { + pub fn new(instance: &Instance, device: &Device) -> Self { + let fp = vk::NvDeviceDiagnosticCheckpointsFn::load(|name| unsafe { + mem::transmute(instance.get_device_proc_addr(device.handle(), name.as_ptr())) + }); + Self { fp } + } + + /// + #[inline] + pub unsafe fn cmd_set_checkpoint( + &self, + command_buffer: vk::CommandBuffer, + p_checkpoint_marker: *const c_void, + ) { + (self.fp.cmd_set_checkpoint_nv)(command_buffer, p_checkpoint_marker); + } + + /// Retrieve the number of elements to pass to [`get_queue_checkpoint_data()`][Self::get_queue_checkpoint_data()] + #[inline] + pub unsafe fn get_queue_checkpoint_data_len(&self, queue: vk::Queue) -> usize { + let mut count = 0; + (self.fp.get_queue_checkpoint_data_nv)(queue, &mut count, std::ptr::null_mut()); + count as usize + } + + /// + /// + /// Call [`get_queue_checkpoint_data_len()`][Self::get_queue_checkpoint_data_len()] to query the number of elements to pass to `out`. + /// Be sure to [`Default::default()`]-initialize these elements and optionally set their `p_next` pointer. + #[inline] + pub unsafe fn get_queue_checkpoint_data( + &self, + queue: vk::Queue, + out: &mut [vk::CheckpointDataNV], + ) { + let mut count = out.len() as u32; + (self.fp.get_queue_checkpoint_data_nv)(queue, &mut count, out.as_mut_ptr()); + assert_eq!(count as usize, out.len()); + } + + #[inline] + pub const fn name() -> &'static CStr { + vk::NvDeviceDiagnosticCheckpointsFn::name() + } + + #[inline] + pub fn fp(&self) -> &vk::NvDeviceDiagnosticCheckpointsFn { + &self.fp + } +} diff --git a/third_party/rust/ash/src/extensions/nv/mesh_shader.rs b/third_party/rust/ash/src/extensions/nv/mesh_shader.rs new file mode 100755 index 0000000000..14ef8d44ac --- /dev/null +++ b/third_party/rust/ash/src/extensions/nv/mesh_shader.rs @@ -0,0 +1,81 @@ +use crate::vk; +use crate::{Device, Instance}; +use std::ffi::CStr; +use std::mem; + +#[derive(Clone)] +pub struct MeshShader { + fp: vk::NvMeshShaderFn, +} + +impl MeshShader { + pub fn new(instance: &Instance, device: &Device) -> Self { + let fp = vk::NvMeshShaderFn::load(|name| unsafe { + mem::transmute(instance.get_device_proc_addr(device.handle(), name.as_ptr())) + }); + Self { fp } + } + + /// + #[inline] + pub unsafe fn cmd_draw_mesh_tasks( + &self, + command_buffer: vk::CommandBuffer, + task_count: u32, + first_task: u32, + ) { + (self.fp.cmd_draw_mesh_tasks_nv)(command_buffer, task_count, first_task); + } + + /// + #[inline] + pub unsafe fn cmd_draw_mesh_tasks_indirect( + &self, + command_buffer: vk::CommandBuffer, + buffer: vk::Buffer, + offset: vk::DeviceSize, + draw_count: u32, + stride: u32, + ) { + (self.fp.cmd_draw_mesh_tasks_indirect_nv)( + command_buffer, + buffer, + offset, + draw_count, + stride, + ); + } + + /// + #[inline] + pub unsafe fn cmd_draw_mesh_tasks_indirect_count( + &self, + command_buffer: vk::CommandBuffer, + buffer: vk::Buffer, + offset: vk::DeviceSize, + count_buffer: vk::Buffer, + count_buffer_offset: vk::DeviceSize, + max_draw_count: u32, + stride: u32, + ) { + (self.fp.cmd_draw_mesh_tasks_indirect_count_nv)( + command_buffer, + buffer, + offset, + count_buffer, + count_buffer_offset, + max_draw_count, + stride, + ); + } + + #[inline] + pub const fn name() -> &'static CStr { + vk::NvMeshShaderFn::name() + } + + #[inline] + pub fn fp(&self) -> &vk::NvMeshShaderFn { + &self.fp + } +} diff --git a/third_party/rust/ash/src/extensions/nv/mod.rs b/third_party/rust/ash/src/extensions/nv/mod.rs new file mode 100644 index 0000000000..bfde37a55c --- /dev/null +++ b/third_party/rust/ash/src/extensions/nv/mod.rs @@ -0,0 +1,9 @@ +pub use self::coverage_reduction_mode::CoverageReductionMode; +pub use self::device_diagnostic_checkpoints::DeviceDiagnosticCheckpoints; +pub use self::mesh_shader::MeshShader; +pub use self::ray_tracing::RayTracing; + +mod coverage_reduction_mode; +mod device_diagnostic_checkpoints; +mod mesh_shader; +mod ray_tracing; diff --git a/third_party/rust/ash/src/extensions/nv/ray_tracing.rs b/third_party/rust/ash/src/extensions/nv/ray_tracing.rs new file mode 100755 index 0000000000..d97ec85dfe --- /dev/null +++ b/third_party/rust/ash/src/extensions/nv/ray_tracing.rs @@ -0,0 +1,271 @@ +use crate::prelude::*; +use crate::vk; +use crate::RawPtr; +use crate::{Device, Instance}; +use std::ffi::CStr; +use std::mem; + +#[derive(Clone)] +pub struct RayTracing { + handle: vk::Device, + fp: vk::NvRayTracingFn, +} + +impl RayTracing { + pub fn new(instance: &Instance, device: &Device) -> Self { + let handle = device.handle(); + let fp = vk::NvRayTracingFn::load(|name| unsafe { + mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr())) + }); + Self { handle, fp } + } + + #[inline] + pub unsafe fn get_properties( + instance: &Instance, + pdevice: vk::PhysicalDevice, + ) -> vk::PhysicalDeviceRayTracingPropertiesNV { + let mut props_rt = vk::PhysicalDeviceRayTracingPropertiesNV::default(); + { + let mut props = vk::PhysicalDeviceProperties2::builder().push_next(&mut props_rt); + instance.get_physical_device_properties2(pdevice, &mut props); + } + props_rt + } + + /// + #[inline] + pub unsafe fn create_acceleration_structure( + &self, + create_info: &vk::AccelerationStructureCreateInfoNV, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) -> VkResult { + let mut accel_struct = mem::zeroed(); + (self.fp.create_acceleration_structure_nv)( + self.handle, + create_info, + allocation_callbacks.as_raw_ptr(), + &mut accel_struct, + ) + .result_with_success(accel_struct) + } + + /// + #[inline] + pub unsafe fn destroy_acceleration_structure( + &self, + accel_struct: vk::AccelerationStructureNV, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) { + (self.fp.destroy_acceleration_structure_nv)( + self.handle, + accel_struct, + allocation_callbacks.as_raw_ptr(), + ); + } + + /// + #[inline] + pub unsafe fn get_acceleration_structure_memory_requirements( + &self, + info: &vk::AccelerationStructureMemoryRequirementsInfoNV, + ) -> vk::MemoryRequirements2KHR { + let mut requirements = mem::zeroed(); + (self.fp.get_acceleration_structure_memory_requirements_nv)( + self.handle, + info, + &mut requirements, + ); + requirements + } + + /// + #[inline] + pub unsafe fn bind_acceleration_structure_memory( + &self, + bind_info: &[vk::BindAccelerationStructureMemoryInfoNV], + ) -> VkResult<()> { + (self.fp.bind_acceleration_structure_memory_nv)( + self.handle, + bind_info.len() as u32, + bind_info.as_ptr(), + ) + .result() + } + + /// + #[inline] + pub unsafe fn cmd_build_acceleration_structure( + &self, + command_buffer: vk::CommandBuffer, + info: &vk::AccelerationStructureInfoNV, + instance_data: vk::Buffer, + instance_offset: vk::DeviceSize, + update: bool, + dst: vk::AccelerationStructureNV, + src: vk::AccelerationStructureNV, + scratch: vk::Buffer, + scratch_offset: vk::DeviceSize, + ) { + (self.fp.cmd_build_acceleration_structure_nv)( + command_buffer, + info, + instance_data, + instance_offset, + if update { vk::TRUE } else { vk::FALSE }, + dst, + src, + scratch, + scratch_offset, + ); + } + + /// + #[inline] + pub unsafe fn cmd_copy_acceleration_structure( + &self, + command_buffer: vk::CommandBuffer, + dst: vk::AccelerationStructureNV, + src: vk::AccelerationStructureNV, + mode: vk::CopyAccelerationStructureModeNV, + ) { + (self.fp.cmd_copy_acceleration_structure_nv)(command_buffer, dst, src, mode); + } + + /// + #[inline] + pub unsafe fn cmd_trace_rays( + &self, + command_buffer: vk::CommandBuffer, + raygen_shader_binding_table_buffer: vk::Buffer, + raygen_shader_binding_offset: vk::DeviceSize, + miss_shader_binding_table_buffer: vk::Buffer, + miss_shader_binding_offset: vk::DeviceSize, + miss_shader_binding_stride: vk::DeviceSize, + hit_shader_binding_table_buffer: vk::Buffer, + hit_shader_binding_offset: vk::DeviceSize, + hit_shader_binding_stride: vk::DeviceSize, + callable_shader_binding_table_buffer: vk::Buffer, + callable_shader_binding_offset: vk::DeviceSize, + callable_shader_binding_stride: vk::DeviceSize, + width: u32, + height: u32, + depth: u32, + ) { + (self.fp.cmd_trace_rays_nv)( + command_buffer, + raygen_shader_binding_table_buffer, + raygen_shader_binding_offset, + miss_shader_binding_table_buffer, + miss_shader_binding_offset, + miss_shader_binding_stride, + hit_shader_binding_table_buffer, + hit_shader_binding_offset, + hit_shader_binding_stride, + callable_shader_binding_table_buffer, + callable_shader_binding_offset, + callable_shader_binding_stride, + width, + height, + depth, + ); + } + + /// + #[inline] + pub unsafe fn create_ray_tracing_pipelines( + &self, + pipeline_cache: vk::PipelineCache, + create_info: &[vk::RayTracingPipelineCreateInfoNV], + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) -> VkResult> { + let mut pipelines = vec![mem::zeroed(); create_info.len()]; + (self.fp.create_ray_tracing_pipelines_nv)( + self.handle, + pipeline_cache, + create_info.len() as u32, + create_info.as_ptr(), + allocation_callbacks.as_raw_ptr(), + pipelines.as_mut_ptr(), + ) + .result_with_success(pipelines) + } + + /// + #[inline] + pub unsafe fn get_ray_tracing_shader_group_handles( + &self, + pipeline: vk::Pipeline, + first_group: u32, + group_count: u32, + data: &mut [u8], + ) -> VkResult<()> { + (self.fp.get_ray_tracing_shader_group_handles_nv)( + self.handle, + pipeline, + first_group, + group_count, + data.len(), + data.as_mut_ptr().cast(), + ) + .result() + } + + /// + #[inline] + pub unsafe fn get_acceleration_structure_handle( + &self, + accel_struct: vk::AccelerationStructureNV, + ) -> VkResult { + let mut handle: u64 = 0; + let handle_ptr: *mut u64 = &mut handle; + (self.fp.get_acceleration_structure_handle_nv)( + self.handle, + accel_struct, + std::mem::size_of::(), + handle_ptr.cast(), + ) + .result_with_success(handle) + } + + /// + #[inline] + pub unsafe fn cmd_write_acceleration_structures_properties( + &self, + command_buffer: vk::CommandBuffer, + structures: &[vk::AccelerationStructureNV], + query_type: vk::QueryType, + query_pool: vk::QueryPool, + first_query: u32, + ) { + (self.fp.cmd_write_acceleration_structures_properties_nv)( + command_buffer, + structures.len() as u32, + structures.as_ptr(), + query_type, + query_pool, + first_query, + ); + } + + /// + #[inline] + pub unsafe fn compile_deferred(&self, pipeline: vk::Pipeline, shader: u32) -> VkResult<()> { + (self.fp.compile_deferred_nv)(self.handle, pipeline, shader).result() + } + + #[inline] + pub const fn name() -> &'static CStr { + vk::NvRayTracingFn::name() + } + + #[inline] + pub fn fp(&self) -> &vk::NvRayTracingFn { + &self.fp + } + + #[inline] + pub fn device(&self) -> vk::Device { + self.handle + } +} diff --git a/third_party/rust/ash/src/instance.rs b/third_party/rust/ash/src/instance.rs new file mode 100644 index 0000000000..8e3bd1a8b9 --- /dev/null +++ b/third_party/rust/ash/src/instance.rs @@ -0,0 +1,535 @@ +use crate::device::Device; +use crate::prelude::*; +use crate::vk; +use crate::RawPtr; +use std::mem; +use std::os::raw::c_char; +use std::ptr; + +/// +#[derive(Clone)] +pub struct Instance { + pub(crate) handle: vk::Instance, + + pub(crate) instance_fn_1_0: vk::InstanceFnV1_0, + pub(crate) instance_fn_1_1: vk::InstanceFnV1_1, + pub(crate) instance_fn_1_2: vk::InstanceFnV1_2, + pub(crate) instance_fn_1_3: vk::InstanceFnV1_3, +} + +impl Instance { + pub unsafe fn load(static_fn: &vk::StaticFn, instance: vk::Instance) -> Self { + let load_fn = |name: &std::ffi::CStr| { + mem::transmute((static_fn.get_instance_proc_addr)(instance, name.as_ptr())) + }; + + Self { + handle: instance, + + instance_fn_1_0: vk::InstanceFnV1_0::load(load_fn), + instance_fn_1_1: vk::InstanceFnV1_1::load(load_fn), + instance_fn_1_2: vk::InstanceFnV1_2::load(load_fn), + instance_fn_1_3: vk::InstanceFnV1_3::load(load_fn), + } + } + + #[inline] + pub fn handle(&self) -> vk::Instance { + self.handle + } +} + +/// Vulkan core 1.3 +#[allow(non_camel_case_types)] +impl Instance { + #[inline] + pub fn fp_v1_3(&self) -> &vk::InstanceFnV1_3 { + &self.instance_fn_1_3 + } + + /// Retrieve the number of elements to pass to [`get_physical_device_tool_properties()`][Self::get_physical_device_tool_properties()] + #[inline] + pub unsafe fn get_physical_device_tool_properties_len( + &self, + physical_device: vk::PhysicalDevice, + ) -> VkResult { + let mut count = 0; + (self.instance_fn_1_3.get_physical_device_tool_properties)( + physical_device, + &mut count, + ptr::null_mut(), + ) + .result_with_success(count as usize) + } + + /// + /// + /// Call [`get_physical_device_tool_properties_len()`][Self::get_physical_device_tool_properties_len()] to query the number of elements to pass to `out`. + /// Be sure to [`Default::default()`]-initialize these elements and optionally set their `p_next` pointer. + #[inline] + pub unsafe fn get_physical_device_tool_properties( + &self, + physical_device: vk::PhysicalDevice, + out: &mut [vk::PhysicalDeviceToolProperties], + ) -> VkResult<()> { + let mut count = out.len() as u32; + (self.instance_fn_1_3.get_physical_device_tool_properties)( + physical_device, + &mut count, + out.as_mut_ptr(), + ) + .result()?; + assert_eq!(count as usize, out.len()); + Ok(()) + } +} + +/// Vulkan core 1.2 +#[allow(non_camel_case_types)] +impl Instance { + #[inline] + pub fn fp_v1_2(&self) -> &vk::InstanceFnV1_2 { + &self.instance_fn_1_2 + } +} + +/// Vulkan core 1.1 +#[allow(non_camel_case_types)] +impl Instance { + #[inline] + pub fn fp_v1_1(&self) -> &vk::InstanceFnV1_1 { + &self.instance_fn_1_1 + } + + /// Retrieve the number of elements to pass to [`enumerate_physical_device_groups()`][Self::enumerate_physical_device_groups()] + #[inline] + pub unsafe fn enumerate_physical_device_groups_len(&self) -> VkResult { + let mut group_count = 0; + (self.instance_fn_1_1.enumerate_physical_device_groups)( + self.handle(), + &mut group_count, + ptr::null_mut(), + ) + .result_with_success(group_count as usize) + } + + /// + /// + /// Call [`enumerate_physical_device_groups_len()`][Self::enumerate_physical_device_groups_len()] to query the number of elements to pass to `out`. + /// Be sure to [`Default::default()`]-initialize these elements and optionally set their `p_next` pointer. + #[inline] + pub unsafe fn enumerate_physical_device_groups( + &self, + out: &mut [vk::PhysicalDeviceGroupProperties], + ) -> VkResult<()> { + let mut count = out.len() as u32; + (self.instance_fn_1_1.enumerate_physical_device_groups)( + self.handle(), + &mut count, + out.as_mut_ptr(), + ) + .result()?; + assert_eq!(count as usize, out.len()); + Ok(()) + } + + /// + #[inline] + pub unsafe fn get_physical_device_features2( + &self, + physical_device: vk::PhysicalDevice, + features: &mut vk::PhysicalDeviceFeatures2, + ) { + (self.instance_fn_1_1.get_physical_device_features2)(physical_device, features); + } + + /// + #[inline] + pub unsafe fn get_physical_device_properties2( + &self, + physical_device: vk::PhysicalDevice, + prop: &mut vk::PhysicalDeviceProperties2, + ) { + (self.instance_fn_1_1.get_physical_device_properties2)(physical_device, prop); + } + + /// + #[inline] + pub unsafe fn get_physical_device_format_properties2( + &self, + physical_device: vk::PhysicalDevice, + format: vk::Format, + out: &mut vk::FormatProperties2, + ) { + (self.instance_fn_1_1.get_physical_device_format_properties2)(physical_device, format, out); + } + + /// + #[inline] + pub unsafe fn get_physical_device_image_format_properties2( + &self, + physical_device: vk::PhysicalDevice, + format_info: &vk::PhysicalDeviceImageFormatInfo2, + image_format_prop: &mut vk::ImageFormatProperties2, + ) -> VkResult<()> { + (self + .instance_fn_1_1 + .get_physical_device_image_format_properties2)( + physical_device, + format_info, + image_format_prop, + ) + .result() + } + + /// Retrieve the number of elements to pass to [`get_physical_device_queue_family_properties2()`][Self::get_physical_device_queue_family_properties2()] + #[inline] + pub unsafe fn get_physical_device_queue_family_properties2_len( + &self, + physical_device: vk::PhysicalDevice, + ) -> usize { + let mut queue_count = 0; + (self + .instance_fn_1_1 + .get_physical_device_queue_family_properties2)( + physical_device, + &mut queue_count, + ptr::null_mut(), + ); + queue_count as usize + } + + /// + /// + /// Call [`get_physical_device_queue_family_properties2_len()`][Self::get_physical_device_queue_family_properties2_len()] to query the number of elements to pass to `out`. + /// Be sure to [`Default::default()`]-initialize these elements and optionally set their `p_next` pointer. + #[inline] + pub unsafe fn get_physical_device_queue_family_properties2( + &self, + physical_device: vk::PhysicalDevice, + out: &mut [vk::QueueFamilyProperties2], + ) { + let mut count = out.len() as u32; + (self + .instance_fn_1_1 + .get_physical_device_queue_family_properties2)( + physical_device, + &mut count, + out.as_mut_ptr(), + ); + assert_eq!(count as usize, out.len()); + } + + /// + #[inline] + pub unsafe fn get_physical_device_memory_properties2( + &self, + physical_device: vk::PhysicalDevice, + out: &mut vk::PhysicalDeviceMemoryProperties2, + ) { + (self.instance_fn_1_1.get_physical_device_memory_properties2)(physical_device, out); + } + + /// Retrieve the number of elements to pass to [`get_physical_device_sparse_image_format_properties2()`][Self::get_physical_device_sparse_image_format_properties2()] + #[inline] + pub unsafe fn get_physical_device_sparse_image_format_properties2_len( + &self, + physical_device: vk::PhysicalDevice, + format_info: &vk::PhysicalDeviceSparseImageFormatInfo2, + ) -> usize { + let mut format_count = 0; + (self + .instance_fn_1_1 + .get_physical_device_sparse_image_format_properties2)( + physical_device, + format_info, + &mut format_count, + ptr::null_mut(), + ); + format_count as usize + } + + /// + /// + /// Call [`get_physical_device_sparse_image_format_properties2_len()`][Self::get_physical_device_sparse_image_format_properties2_len()] to query the number of elements to pass to `out`. + /// Be sure to [`Default::default()`]-initialize these elements and optionally set their `p_next` pointer. + #[inline] + pub unsafe fn get_physical_device_sparse_image_format_properties2( + &self, + physical_device: vk::PhysicalDevice, + format_info: &vk::PhysicalDeviceSparseImageFormatInfo2, + out: &mut [vk::SparseImageFormatProperties2], + ) { + let mut count = out.len() as u32; + (self + .instance_fn_1_1 + .get_physical_device_sparse_image_format_properties2)( + physical_device, + format_info, + &mut count, + out.as_mut_ptr(), + ); + assert_eq!(count as usize, out.len()); + } + + /// + #[inline] + pub unsafe fn get_physical_device_external_buffer_properties( + &self, + physical_device: vk::PhysicalDevice, + external_buffer_info: &vk::PhysicalDeviceExternalBufferInfo, + out: &mut vk::ExternalBufferProperties, + ) { + (self + .instance_fn_1_1 + .get_physical_device_external_buffer_properties)( + physical_device, + external_buffer_info, + out, + ); + } + + /// + #[inline] + pub unsafe fn get_physical_device_external_fence_properties( + &self, + physical_device: vk::PhysicalDevice, + external_fence_info: &vk::PhysicalDeviceExternalFenceInfo, + out: &mut vk::ExternalFenceProperties, + ) { + (self + .instance_fn_1_1 + .get_physical_device_external_fence_properties)( + physical_device, + external_fence_info, + out, + ); + } + + /// + #[inline] + pub unsafe fn get_physical_device_external_semaphore_properties( + &self, + physical_device: vk::PhysicalDevice, + external_semaphore_info: &vk::PhysicalDeviceExternalSemaphoreInfo, + out: &mut vk::ExternalSemaphoreProperties, + ) { + (self + .instance_fn_1_1 + .get_physical_device_external_semaphore_properties)( + physical_device, + external_semaphore_info, + out, + ); + } +} + +/// Vulkan core 1.0 +#[allow(non_camel_case_types)] +impl Instance { + #[inline] + pub fn fp_v1_0(&self) -> &vk::InstanceFnV1_0 { + &self.instance_fn_1_0 + } + + /// + /// + /// # Safety + /// In order for the created [`Device`] to be valid for the duration of its + /// usage, the [`Instance`] this was called on must be dropped later than the + /// resulting [`Device`]. + #[inline] + pub unsafe fn create_device( + &self, + physical_device: vk::PhysicalDevice, + create_info: &vk::DeviceCreateInfo, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) -> VkResult { + let mut device = mem::zeroed(); + (self.instance_fn_1_0.create_device)( + physical_device, + create_info, + allocation_callbacks.as_raw_ptr(), + &mut device, + ) + .result()?; + Ok(Device::load(&self.instance_fn_1_0, device)) + } + + /// + #[inline] + pub unsafe fn get_device_proc_addr( + &self, + device: vk::Device, + p_name: *const c_char, + ) -> vk::PFN_vkVoidFunction { + (self.instance_fn_1_0.get_device_proc_addr)(device, p_name) + } + + /// + #[inline] + pub unsafe fn destroy_instance(&self, allocation_callbacks: Option<&vk::AllocationCallbacks>) { + (self.instance_fn_1_0.destroy_instance)(self.handle(), allocation_callbacks.as_raw_ptr()); + } + + /// + #[inline] + pub unsafe fn get_physical_device_format_properties( + &self, + physical_device: vk::PhysicalDevice, + format: vk::Format, + ) -> vk::FormatProperties { + let mut format_prop = mem::zeroed(); + (self.instance_fn_1_0.get_physical_device_format_properties)( + physical_device, + format, + &mut format_prop, + ); + format_prop + } + + /// + #[inline] + pub unsafe fn get_physical_device_image_format_properties( + &self, + physical_device: vk::PhysicalDevice, + format: vk::Format, + typ: vk::ImageType, + tiling: vk::ImageTiling, + usage: vk::ImageUsageFlags, + flags: vk::ImageCreateFlags, + ) -> VkResult { + let mut image_format_prop = mem::zeroed(); + (self + .instance_fn_1_0 + .get_physical_device_image_format_properties)( + physical_device, + format, + typ, + tiling, + usage, + flags, + &mut image_format_prop, + ) + .result_with_success(image_format_prop) + } + + /// + #[inline] + pub unsafe fn get_physical_device_memory_properties( + &self, + physical_device: vk::PhysicalDevice, + ) -> vk::PhysicalDeviceMemoryProperties { + let mut memory_prop = mem::zeroed(); + (self.instance_fn_1_0.get_physical_device_memory_properties)( + physical_device, + &mut memory_prop, + ); + memory_prop + } + + /// + #[inline] + pub unsafe fn get_physical_device_properties( + &self, + physical_device: vk::PhysicalDevice, + ) -> vk::PhysicalDeviceProperties { + let mut prop = mem::zeroed(); + (self.instance_fn_1_0.get_physical_device_properties)(physical_device, &mut prop); + prop + } + + /// + #[inline] + pub unsafe fn get_physical_device_queue_family_properties( + &self, + physical_device: vk::PhysicalDevice, + ) -> Vec { + read_into_uninitialized_vector(|count, data| { + (self + .instance_fn_1_0 + .get_physical_device_queue_family_properties)( + physical_device, count, data + ); + vk::Result::SUCCESS + }) + // The closure always returns SUCCESS + .unwrap() + } + + /// + #[inline] + pub unsafe fn get_physical_device_features( + &self, + physical_device: vk::PhysicalDevice, + ) -> vk::PhysicalDeviceFeatures { + let mut prop = mem::zeroed(); + (self.instance_fn_1_0.get_physical_device_features)(physical_device, &mut prop); + prop + } + + /// + #[inline] + pub unsafe fn enumerate_physical_devices(&self) -> VkResult> { + read_into_uninitialized_vector(|count, data| { + (self.instance_fn_1_0.enumerate_physical_devices)(self.handle(), count, data) + }) + } + + /// + #[inline] + pub unsafe fn enumerate_device_extension_properties( + &self, + device: vk::PhysicalDevice, + ) -> VkResult> { + read_into_uninitialized_vector(|count, data| { + (self.instance_fn_1_0.enumerate_device_extension_properties)( + device, + ptr::null(), + count, + data, + ) + }) + } + + /// + #[inline] + pub unsafe fn enumerate_device_layer_properties( + &self, + device: vk::PhysicalDevice, + ) -> VkResult> { + read_into_uninitialized_vector(|count, data| { + (self.instance_fn_1_0.enumerate_device_layer_properties)(device, count, data) + }) + } + + /// + #[inline] + pub unsafe fn get_physical_device_sparse_image_format_properties( + &self, + physical_device: vk::PhysicalDevice, + format: vk::Format, + typ: vk::ImageType, + samples: vk::SampleCountFlags, + usage: vk::ImageUsageFlags, + tiling: vk::ImageTiling, + ) -> Vec { + read_into_uninitialized_vector(|count, data| { + (self + .instance_fn_1_0 + .get_physical_device_sparse_image_format_properties)( + physical_device, + format, + typ, + samples, + usage, + tiling, + count, + data, + ); + vk::Result::SUCCESS + }) + // The closure always returns SUCCESS + .unwrap() + } +} diff --git a/third_party/rust/ash/src/lib.rs b/third_party/rust/ash/src/lib.rs new file mode 100644 index 0000000000..c900fc6c4d --- /dev/null +++ b/third_party/rust/ash/src/lib.rs @@ -0,0 +1,197 @@ +#![deny(clippy::use_self)] +#![warn(trivial_casts, trivial_numeric_casts)] +#![allow( + clippy::too_many_arguments, + clippy::missing_safety_doc, + clippy::upper_case_acronyms +)] +#![cfg_attr(docsrs, feature(doc_cfg))] +//! # Vulkan API +//! +//! +//! +//! ## Examples +//! +//! ```no_run +//! use ash::{vk, Entry}; +//! # fn main() -> Result<(), Box> { +//! let entry = Entry::linked(); +//! let app_info = vk::ApplicationInfo { +//! api_version: vk::make_api_version(0, 1, 0, 0), +//! ..Default::default() +//! }; +//! let create_info = vk::InstanceCreateInfo { +//! p_application_info: &app_info, +//! ..Default::default() +//! }; +//! let instance = unsafe { entry.create_instance(&create_info, None)? }; +//! # Ok(()) } +//! ``` +//! +//! ## Getting started +//! +//! Load the Vulkan library linked at compile time using [`Entry::linked()`], or load it at runtime +//! using [`Entry::load()`], which uses `libloading`. If you want to perform entry point loading +//! yourself, call [`Entry::from_static_fn()`]. +//! +//! ## Crate features +//! +//! * **debug** (default): Whether Vulkan structs should implement `Debug`. +//! * **loaded** (default): Support searching for the Vulkan loader manually at runtime. +//! * **linked**: Link the Vulkan loader at compile time. + +pub use crate::device::Device; +pub use crate::entry::Entry; +#[cfg(feature = "loaded")] +pub use crate::entry::LoadingError; +pub use crate::instance::Instance; + +mod device; +mod entry; +mod instance; +pub mod prelude; +pub mod util; +/// Raw Vulkan bindings and types, generated from `vk.xml` +#[macro_use] +pub mod vk; + +// macros of vk need to be defined beforehand +/// Wrappers for Vulkan extensions +pub mod extensions; + +pub trait RawPtr { + fn as_raw_ptr(&self) -> *const T; +} + +impl<'r, T> RawPtr for Option<&'r T> { + fn as_raw_ptr(&self) -> *const T { + match *self { + Some(inner) => inner, + _ => ::std::ptr::null(), + } + } +} + +/// Given a mutable raw pointer to a type with an `s_type` member such as [`vk::BaseOutStructure`], +/// match on a set of Vulkan structures. The struct will be rebound to the given variable of the +/// type of the given Vulkan structure. +/// +/// Note that all match bodies have to be enclosed by curly braces due to macro parsing limitations. +/// It is unfortunately not possible to write `x @ ash::vk::SomeStruct => one_line_expression(),`. +/// +/// ``` +/// let mut info = ash::vk::DeviceCreateInfo::default(); +/// let info: *mut ash::vk::BaseOutStructure = <*mut _>::cast(&mut info); +/// unsafe { +/// ash::match_out_struct!(match info { +/// info @ ash::vk::DeviceQueueCreateInfo => { +/// dbg!(&info); // Unreachable +/// } +/// info @ ash::vk::DeviceCreateInfo => { +/// dbg!(&info); +/// } +/// }) +/// } +/// ``` +/// +/// In addition this macro propagates implicit return values just like normal `match` blocks, as +/// long as a default value or expression is provided in the "any" match arm +/// (`_ => { some_value() }`). For the time being said arm must be wrapped in curly braces; an +/// expression like `_ => None` is not yet supported. +/// +/// ``` +/// # let mut info = ash::vk::DeviceCreateInfo::default(); +/// # let info: *mut ash::vk::BaseOutStructure = <*mut _>::cast(&mut info); +/// let device_create_flags: Option = unsafe { +/// ash::match_out_struct!(match info { +/// info @ ash::vk::DeviceQueueCreateInfo => { +/// dbg!(&info); // Unreachable +/// Some(ash::vk::DeviceCreateFlags::empty()) +/// } +/// info @ ash::vk::DeviceCreateInfo => { +/// dbg!(&info); +/// Some(info.flags) +/// } +/// _ => { +/// None +/// } +/// }) +/// }; +/// ``` +#[macro_export] +macro_rules! match_out_struct { + (match $p:ident { $($bind:ident @ $ty:path => $body:block $(,)?)+ $(_ => $any:block $(,)?)? }) => { + match std::ptr::addr_of!((*$p).s_type).read() { + $(<$ty as $crate::vk::TaggedStructure>::STRUCTURE_TYPE => { + let $bind = $p + .cast::<$ty>() + .as_mut() + .unwrap(); + $body + }),+ + _ => { $($any)? } + } + }; +} + +/// Given an immutable raw pointer to a type with an `s_type` member such as [`vk::BaseInStructure`], +/// match on a set of Vulkan structures. The struct will be rebound to the given variable of the +/// type of the given Vulkan structure. +/// +/// Note that all match bodies have to be enclosed by curly braces due to macro parsing limitations. +/// It is unfortunately not possible to write `x @ ash::vk::SomeStruct => one_line_expression(),`. +/// +/// ``` +/// let info = ash::vk::DeviceCreateInfo::default(); +/// let info: *const ash::vk::BaseInStructure = <*const _>::cast(&info); +/// unsafe { +/// ash::match_in_struct!(match info { +/// info @ ash::vk::DeviceQueueCreateInfo => { +/// dbg!(&info); // Unreachable +/// } +/// info @ ash::vk::DeviceCreateInfo => { +/// dbg!(&info); +/// } +/// }) +/// } +/// ``` +/// +/// See the [`match_out_struct!`] documentation for an example with implicit return values. +#[macro_export] +macro_rules! match_in_struct { + (match $p:ident { $($bind:ident @ $ty:path => $body:block $(,)?)+ $(_ => $any:block $(,)?)? }) => { + match std::ptr::addr_of!((*$p).s_type).read() { + $(<$ty as $crate::vk::TaggedStructure>::STRUCTURE_TYPE => { + let $bind = $p + .cast::<$ty>() + .as_ref() + .unwrap(); + $body + }),+ + _ => { $($any)? } + } + }; +} + +#[cfg(test)] +mod tests { + use super::vk; + #[test] + fn test_ptr_chains() { + let mut variable_pointers = vk::PhysicalDeviceVariablePointerFeatures::builder(); + let mut corner = vk::PhysicalDeviceCornerSampledImageFeaturesNV::builder(); + let chain = vec![ + <*mut _>::cast(&mut variable_pointers), + <*mut _>::cast(&mut corner), + ]; + let mut device_create_info = vk::DeviceCreateInfo::builder() + .push_next(&mut corner) + .push_next(&mut variable_pointers); + let chain2: Vec<*mut vk::BaseOutStructure> = unsafe { + vk::ptr_chain_iter(&mut device_create_info) + .skip(1) + .collect() + }; + assert_eq!(chain, chain2); + } +} diff --git a/third_party/rust/ash/src/prelude.rs b/third_party/rust/ash/src/prelude.rs new file mode 100644 index 0000000000..321c3aaddd --- /dev/null +++ b/third_party/rust/ash/src/prelude.rs @@ -0,0 +1,122 @@ +use std::convert::TryInto; +#[cfg(feature = "debug")] +use std::fmt; +use std::mem; + +use crate::vk; +pub type VkResult = Result; + +impl vk::Result { + #[inline] + pub fn result(self) -> VkResult<()> { + self.result_with_success(()) + } + + #[inline] + pub fn result_with_success(self, v: T) -> VkResult { + match self { + Self::SUCCESS => Ok(v), + _ => Err(self), + } + } + + #[inline] + pub unsafe fn assume_init_on_success(self, v: mem::MaybeUninit) -> VkResult { + self.result().map(move |()| v.assume_init()) + } +} + +/// Repeatedly calls `f` until it does not return [`vk::Result::INCOMPLETE`] anymore, +/// ensuring all available data has been read into the vector. +/// +/// See for example [`vkEnumerateInstanceExtensionProperties`]: the number of available +/// items may change between calls; [`vk::Result::INCOMPLETE`] is returned when the count +/// increased (and the vector is not large enough after querying the initial size), +/// requiring Ash to try again. +/// +/// [`vkEnumerateInstanceExtensionProperties`]: https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkEnumerateInstanceExtensionProperties.html +pub(crate) unsafe fn read_into_uninitialized_vector, T>( + f: impl Fn(&mut N, *mut T) -> vk::Result, +) -> VkResult> +where + >::Error: std::fmt::Debug, +{ + loop { + let mut count = N::default(); + f(&mut count, std::ptr::null_mut()).result()?; + let mut data = + Vec::with_capacity(count.try_into().expect("`N` failed to convert to `usize`")); + + let err_code = f(&mut count, data.as_mut_ptr()); + if err_code != vk::Result::INCOMPLETE { + err_code.result()?; + data.set_len(count.try_into().expect("`N` failed to convert to `usize`")); + break Ok(data); + } + } +} + +/// Repeatedly calls `f` until it does not return [`vk::Result::INCOMPLETE`] anymore, +/// ensuring all available data has been read into the vector. +/// +/// Items in the target vector are [`default()`][`Default::default()`]-initialized which +/// is required for [`vk::BaseOutStructure`]-like structs where [`vk::BaseOutStructure::s_type`] +/// needs to be a valid type and [`vk::BaseOutStructure::p_next`] a valid or +/// [`null`][`std::ptr::null_mut()`] pointer. +/// +/// See for example [`vkEnumerateInstanceExtensionProperties`]: the number of available +/// items may change between calls; [`vk::Result::INCOMPLETE`] is returned when the count +/// increased (and the vector is not large enough after querying the initial size), +/// requiring Ash to try again. +/// +/// [`vkEnumerateInstanceExtensionProperties`]: https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkEnumerateInstanceExtensionProperties.html +pub(crate) unsafe fn read_into_defaulted_vector< + N: Copy + Default + TryInto, + T: Default + Clone, +>( + f: impl Fn(&mut N, *mut T) -> vk::Result, +) -> VkResult> +where + >::Error: std::fmt::Debug, +{ + loop { + let mut count = N::default(); + f(&mut count, std::ptr::null_mut()).result()?; + let mut data = + vec![Default::default(); count.try_into().expect("`N` failed to convert to `usize`")]; + + let err_code = f(&mut count, data.as_mut_ptr()); + if err_code != vk::Result::INCOMPLETE { + data.set_len(count.try_into().expect("`N` failed to convert to `usize`")); + break err_code.result_with_success(data); + } + } +} + +#[cfg(feature = "debug")] +pub(crate) fn debug_flags + Copy>( + f: &mut fmt::Formatter, + known: &[(Value, &'static str)], + value: Value, +) -> fmt::Result { + let mut first = true; + let mut accum = value.into(); + for &(bit, name) in known { + let bit = bit.into(); + if bit != 0 && accum & bit == bit { + if !first { + f.write_str(" | ")?; + } + f.write_str(name)?; + first = false; + accum &= !bit; + } + } + if accum != 0 { + if !first { + f.write_str(" | ")?; + } + write!(f, "{:b}", accum)?; + } + Ok(()) +} diff --git a/third_party/rust/ash/src/util.rs b/third_party/rust/ash/src/util.rs new file mode 100644 index 0000000000..119fab9c65 --- /dev/null +++ b/third_party/rust/ash/src/util.rs @@ -0,0 +1,139 @@ +use crate::vk; +use std::iter::Iterator; +use std::marker::PhantomData; +use std::mem::size_of; +use std::os::raw::c_void; +use std::{io, slice}; + +/// [`Align`] handles dynamic alignment. The is useful for dynamic uniform buffers where +/// the alignment might be different. For example a 4x4 f32 matrix has a size of 64 bytes +/// but the min alignment for a dynamic uniform buffer might be 256 bytes. A slice of `&[Mat4x4]` +/// has a memory layout of `[[64 bytes], [64 bytes], [64 bytes]]`, but it might need to have a memory +/// layout of `[[256 bytes], [256 bytes], [256 bytes]]`. +/// [`Align::copy_from_slice`] will copy a slice of `&[T]` directly into the host memory without +/// an additional allocation and with the correct alignment. +#[derive(Debug, Clone)] +pub struct Align { + ptr: *mut c_void, + elem_size: vk::DeviceSize, + size: vk::DeviceSize, + _m: PhantomData, +} + +#[derive(Debug)] +pub struct AlignIter<'a, T: 'a> { + align: &'a mut Align, + current: vk::DeviceSize, +} + +impl Align { + pub fn copy_from_slice(&mut self, slice: &[T]) { + use std::slice::from_raw_parts_mut; + if self.elem_size == size_of::() as u64 { + unsafe { + let mapped_slice = from_raw_parts_mut(self.ptr.cast(), slice.len()); + mapped_slice.copy_from_slice(slice); + } + } else { + for (i, val) in self.iter_mut().enumerate().take(slice.len()) { + *val = slice[i]; + } + } + } +} + +fn calc_padding(adr: vk::DeviceSize, align: vk::DeviceSize) -> vk::DeviceSize { + (align - adr % align) % align +} + +impl Align { + pub unsafe fn new(ptr: *mut c_void, alignment: vk::DeviceSize, size: vk::DeviceSize) -> Self { + let padding = calc_padding(size_of::() as vk::DeviceSize, alignment); + let elem_size = size_of::() as vk::DeviceSize + padding; + assert!(calc_padding(size, alignment) == 0, "size must be aligned"); + Self { + ptr, + elem_size, + size, + _m: PhantomData, + } + } + + pub fn iter_mut(&mut self) -> AlignIter { + AlignIter { + current: 0, + align: self, + } + } +} + +impl<'a, T: Copy + 'a> Iterator for AlignIter<'a, T> { + type Item = &'a mut T; + fn next(&mut self) -> Option { + if self.current == self.align.size { + return None; + } + unsafe { + // Need to cast to *mut u8 because () has size 0 + let ptr = (self.align.ptr.cast::()) + .offset(self.current as isize) + .cast(); + self.current += self.align.elem_size; + Some(&mut *ptr) + } + } +} + +/// Decode SPIR-V from bytes. +/// +/// This function handles SPIR-V of arbitrary endianness gracefully, and returns correctly aligned +/// storage. +/// +/// # Examples +/// ```no_run +/// // Decode SPIR-V from a file +/// let mut file = std::fs::File::open("/path/to/shader.spv").unwrap(); +/// let words = ash::util::read_spv(&mut file).unwrap(); +/// ``` +/// ``` +/// // Decode SPIR-V from memory +/// const SPIRV: &[u8] = &[ +/// // ... +/// # 0x03, 0x02, 0x23, 0x07, +/// ]; +/// let words = ash::util::read_spv(&mut std::io::Cursor::new(&SPIRV[..])).unwrap(); +/// ``` +pub fn read_spv(x: &mut R) -> io::Result> { + let size = x.seek(io::SeekFrom::End(0))?; + if size % 4 != 0 { + return Err(io::Error::new( + io::ErrorKind::InvalidData, + "input length not divisible by 4", + )); + } + if size > usize::max_value() as u64 { + return Err(io::Error::new(io::ErrorKind::InvalidData, "input too long")); + } + let words = (size / 4) as usize; + // https://github.com/MaikKlein/ash/issues/354: + // Zero-initialize the result to prevent read_exact from possibly + // reading uninitialized memory. + let mut result = vec![0u32; words]; + x.seek(io::SeekFrom::Start(0))?; + x.read_exact(unsafe { + slice::from_raw_parts_mut(result.as_mut_ptr().cast::(), words * 4) + })?; + const MAGIC_NUMBER: u32 = 0x0723_0203; + if !result.is_empty() && result[0] == MAGIC_NUMBER.swap_bytes() { + for word in &mut result { + *word = word.swap_bytes(); + } + } + if result.is_empty() || result[0] != MAGIC_NUMBER { + return Err(io::Error::new( + io::ErrorKind::InvalidData, + "input missing SPIR-V magic number", + )); + } + Ok(result) +} diff --git a/third_party/rust/ash/src/vk.rs b/third_party/rust/ash/src/vk.rs new file mode 100644 index 0000000000..02a5e9c627 --- /dev/null +++ b/third_party/rust/ash/src/vk.rs @@ -0,0 +1,52 @@ +#![allow( + clippy::too_many_arguments, + clippy::cognitive_complexity, + clippy::wrong_self_convention +)] +#[macro_use] +mod macros; +pub use macros::*; +mod aliases; +pub use aliases::*; +mod bitflags; +pub use bitflags::*; +#[cfg(feature = "debug")] +mod const_debugs; +mod constants; +pub use constants::*; +mod definitions; +pub use definitions::*; +mod enums; +pub use enums::*; +mod extensions; +pub use extensions::*; +mod feature_extensions; +pub use feature_extensions::*; +mod features; +pub use features::*; +mod prelude; +pub use prelude::*; +/// Native bindings from Vulkan headers, generated by bindgen +#[allow(clippy::useless_transmute, nonstandard_style)] +pub mod native; +mod platform_types; +pub use platform_types::*; +/// Iterates through the pointer chain. Includes the item that is passed into the function. +/// Stops at the last [`BaseOutStructure`] that has a null [`BaseOutStructure::p_next`] field. +pub(crate) unsafe fn ptr_chain_iter(ptr: &mut T) -> impl Iterator { + let ptr = <*mut T>::cast::(ptr); + (0..).scan(ptr, |p_ptr, _| { + if p_ptr.is_null() { + return None; + } + let n_ptr = (**p_ptr).p_next; + let old = *p_ptr; + *p_ptr = n_ptr; + Some(old) + }) +} +pub trait Handle { + const TYPE: ObjectType; + fn as_raw(self) -> u64; + fn from_raw(_: u64) -> Self; +} diff --git a/third_party/rust/ash/src/vk/aliases.rs b/third_party/rust/ash/src/vk/aliases.rs new file mode 100644 index 0000000000..1e5d20fe23 --- /dev/null +++ b/third_party/rust/ash/src/vk/aliases.rs @@ -0,0 +1,251 @@ +use crate::vk::bitflags::*; +use crate::vk::definitions::*; +use crate::vk::enums::*; +pub type GeometryFlagsNV = GeometryFlagsKHR; +pub type GeometryInstanceFlagsNV = GeometryInstanceFlagsKHR; +pub type BuildAccelerationStructureFlagsNV = BuildAccelerationStructureFlagsKHR; +pub type PrivateDataSlotCreateFlagsEXT = PrivateDataSlotCreateFlags; +pub type DescriptorUpdateTemplateCreateFlagsKHR = DescriptorUpdateTemplateCreateFlags; +pub type PipelineCreationFeedbackFlagsEXT = PipelineCreationFeedbackFlags; +pub type SemaphoreWaitFlagsKHR = SemaphoreWaitFlags; +pub type AccessFlags2KHR = AccessFlags2; +pub type PipelineStageFlags2KHR = PipelineStageFlags2; +pub type FormatFeatureFlags2KHR = FormatFeatureFlags2; +pub type RenderingFlagsKHR = RenderingFlags; +pub type PeerMemoryFeatureFlagsKHR = PeerMemoryFeatureFlags; +pub type MemoryAllocateFlagsKHR = MemoryAllocateFlags; +pub type CommandPoolTrimFlagsKHR = CommandPoolTrimFlags; +pub type ExternalMemoryHandleTypeFlagsKHR = ExternalMemoryHandleTypeFlags; +pub type ExternalMemoryFeatureFlagsKHR = ExternalMemoryFeatureFlags; +pub type ExternalSemaphoreHandleTypeFlagsKHR = ExternalSemaphoreHandleTypeFlags; +pub type ExternalSemaphoreFeatureFlagsKHR = ExternalSemaphoreFeatureFlags; +pub type SemaphoreImportFlagsKHR = SemaphoreImportFlags; +pub type ExternalFenceHandleTypeFlagsKHR = ExternalFenceHandleTypeFlags; +pub type ExternalFenceFeatureFlagsKHR = ExternalFenceFeatureFlags; +pub type FenceImportFlagsKHR = FenceImportFlags; +pub type DescriptorBindingFlagsEXT = DescriptorBindingFlags; +pub type ResolveModeFlagsKHR = ResolveModeFlags; +pub type ToolPurposeFlagsEXT = ToolPurposeFlags; +pub type SubmitFlagsKHR = SubmitFlags; +pub type DescriptorUpdateTemplateKHR = DescriptorUpdateTemplate; +pub type SamplerYcbcrConversionKHR = SamplerYcbcrConversion; +pub type PrivateDataSlotEXT = PrivateDataSlot; +pub type DescriptorUpdateTemplateTypeKHR = DescriptorUpdateTemplateType; +pub type PointClippingBehaviorKHR = PointClippingBehavior; +pub type QueueGlobalPriorityEXT = QueueGlobalPriorityKHR; +pub type SemaphoreTypeKHR = SemaphoreType; +pub type CopyAccelerationStructureModeNV = CopyAccelerationStructureModeKHR; +pub type AccelerationStructureTypeNV = AccelerationStructureTypeKHR; +pub type GeometryTypeNV = GeometryTypeKHR; +pub type RayTracingShaderGroupTypeNV = RayTracingShaderGroupTypeKHR; +pub type TessellationDomainOriginKHR = TessellationDomainOrigin; +pub type SamplerYcbcrModelConversionKHR = SamplerYcbcrModelConversion; +pub type SamplerYcbcrRangeKHR = SamplerYcbcrRange; +pub type ChromaLocationKHR = ChromaLocation; +pub type SamplerReductionModeEXT = SamplerReductionMode; +pub type ShaderFloatControlsIndependenceKHR = ShaderFloatControlsIndependence; +pub type DriverIdKHR = DriverId; +pub type DevicePrivateDataCreateInfoEXT = DevicePrivateDataCreateInfo; +pub type PrivateDataSlotCreateInfoEXT = PrivateDataSlotCreateInfo; +pub type PhysicalDevicePrivateDataFeaturesEXT = PhysicalDevicePrivateDataFeatures; +pub type PhysicalDeviceFeatures2KHR = PhysicalDeviceFeatures2; +pub type PhysicalDeviceProperties2KHR = PhysicalDeviceProperties2; +pub type FormatProperties2KHR = FormatProperties2; +pub type ImageFormatProperties2KHR = ImageFormatProperties2; +pub type PhysicalDeviceImageFormatInfo2KHR = PhysicalDeviceImageFormatInfo2; +pub type QueueFamilyProperties2KHR = QueueFamilyProperties2; +pub type PhysicalDeviceMemoryProperties2KHR = PhysicalDeviceMemoryProperties2; +pub type SparseImageFormatProperties2KHR = SparseImageFormatProperties2; +pub type PhysicalDeviceSparseImageFormatInfo2KHR = PhysicalDeviceSparseImageFormatInfo2; +pub type ConformanceVersionKHR = ConformanceVersion; +pub type PhysicalDeviceDriverPropertiesKHR = PhysicalDeviceDriverProperties; +pub type PhysicalDeviceVariablePointersFeaturesKHR = PhysicalDeviceVariablePointersFeatures; +pub type PhysicalDeviceVariablePointerFeaturesKHR = PhysicalDeviceVariablePointersFeatures; +pub type PhysicalDeviceVariablePointerFeatures = PhysicalDeviceVariablePointersFeatures; +pub type ExternalMemoryPropertiesKHR = ExternalMemoryProperties; +pub type PhysicalDeviceExternalImageFormatInfoKHR = PhysicalDeviceExternalImageFormatInfo; +pub type ExternalImageFormatPropertiesKHR = ExternalImageFormatProperties; +pub type PhysicalDeviceExternalBufferInfoKHR = PhysicalDeviceExternalBufferInfo; +pub type ExternalBufferPropertiesKHR = ExternalBufferProperties; +pub type PhysicalDeviceIDPropertiesKHR = PhysicalDeviceIDProperties; +pub type ExternalMemoryImageCreateInfoKHR = ExternalMemoryImageCreateInfo; +pub type ExternalMemoryBufferCreateInfoKHR = ExternalMemoryBufferCreateInfo; +pub type ExportMemoryAllocateInfoKHR = ExportMemoryAllocateInfo; +pub type PhysicalDeviceExternalSemaphoreInfoKHR = PhysicalDeviceExternalSemaphoreInfo; +pub type ExternalSemaphorePropertiesKHR = ExternalSemaphoreProperties; +pub type ExportSemaphoreCreateInfoKHR = ExportSemaphoreCreateInfo; +pub type PhysicalDeviceExternalFenceInfoKHR = PhysicalDeviceExternalFenceInfo; +pub type ExternalFencePropertiesKHR = ExternalFenceProperties; +pub type ExportFenceCreateInfoKHR = ExportFenceCreateInfo; +pub type PhysicalDeviceMultiviewFeaturesKHR = PhysicalDeviceMultiviewFeatures; +pub type PhysicalDeviceMultiviewPropertiesKHR = PhysicalDeviceMultiviewProperties; +pub type RenderPassMultiviewCreateInfoKHR = RenderPassMultiviewCreateInfo; +pub type PhysicalDeviceGroupPropertiesKHR = PhysicalDeviceGroupProperties; +pub type MemoryAllocateFlagsInfoKHR = MemoryAllocateFlagsInfo; +pub type BindBufferMemoryInfoKHR = BindBufferMemoryInfo; +pub type BindBufferMemoryDeviceGroupInfoKHR = BindBufferMemoryDeviceGroupInfo; +pub type BindImageMemoryInfoKHR = BindImageMemoryInfo; +pub type BindImageMemoryDeviceGroupInfoKHR = BindImageMemoryDeviceGroupInfo; +pub type DeviceGroupRenderPassBeginInfoKHR = DeviceGroupRenderPassBeginInfo; +pub type DeviceGroupCommandBufferBeginInfoKHR = DeviceGroupCommandBufferBeginInfo; +pub type DeviceGroupSubmitInfoKHR = DeviceGroupSubmitInfo; +pub type DeviceGroupBindSparseInfoKHR = DeviceGroupBindSparseInfo; +pub type DeviceGroupDeviceCreateInfoKHR = DeviceGroupDeviceCreateInfo; +pub type DescriptorUpdateTemplateEntryKHR = DescriptorUpdateTemplateEntry; +pub type DescriptorUpdateTemplateCreateInfoKHR = DescriptorUpdateTemplateCreateInfo; +pub type InputAttachmentAspectReferenceKHR = InputAttachmentAspectReference; +pub type RenderPassInputAttachmentAspectCreateInfoKHR = RenderPassInputAttachmentAspectCreateInfo; +pub type PhysicalDevice16BitStorageFeaturesKHR = PhysicalDevice16BitStorageFeatures; +pub type PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR = + PhysicalDeviceShaderSubgroupExtendedTypesFeatures; +pub type BufferMemoryRequirementsInfo2KHR = BufferMemoryRequirementsInfo2; +pub type DeviceBufferMemoryRequirementsKHR = DeviceBufferMemoryRequirements; +pub type ImageMemoryRequirementsInfo2KHR = ImageMemoryRequirementsInfo2; +pub type ImageSparseMemoryRequirementsInfo2KHR = ImageSparseMemoryRequirementsInfo2; +pub type DeviceImageMemoryRequirementsKHR = DeviceImageMemoryRequirements; +pub type MemoryRequirements2KHR = MemoryRequirements2; +pub type SparseImageMemoryRequirements2KHR = SparseImageMemoryRequirements2; +pub type PhysicalDevicePointClippingPropertiesKHR = PhysicalDevicePointClippingProperties; +pub type MemoryDedicatedRequirementsKHR = MemoryDedicatedRequirements; +pub type MemoryDedicatedAllocateInfoKHR = MemoryDedicatedAllocateInfo; +pub type ImageViewUsageCreateInfoKHR = ImageViewUsageCreateInfo; +pub type PipelineTessellationDomainOriginStateCreateInfoKHR = + PipelineTessellationDomainOriginStateCreateInfo; +pub type SamplerYcbcrConversionInfoKHR = SamplerYcbcrConversionInfo; +pub type SamplerYcbcrConversionCreateInfoKHR = SamplerYcbcrConversionCreateInfo; +pub type BindImagePlaneMemoryInfoKHR = BindImagePlaneMemoryInfo; +pub type ImagePlaneMemoryRequirementsInfoKHR = ImagePlaneMemoryRequirementsInfo; +pub type PhysicalDeviceSamplerYcbcrConversionFeaturesKHR = + PhysicalDeviceSamplerYcbcrConversionFeatures; +pub type SamplerYcbcrConversionImageFormatPropertiesKHR = + SamplerYcbcrConversionImageFormatProperties; +pub type PhysicalDeviceSamplerFilterMinmaxPropertiesEXT = + PhysicalDeviceSamplerFilterMinmaxProperties; +pub type SamplerReductionModeCreateInfoEXT = SamplerReductionModeCreateInfo; +pub type PhysicalDeviceInlineUniformBlockFeaturesEXT = PhysicalDeviceInlineUniformBlockFeatures; +pub type PhysicalDeviceInlineUniformBlockPropertiesEXT = PhysicalDeviceInlineUniformBlockProperties; +pub type WriteDescriptorSetInlineUniformBlockEXT = WriteDescriptorSetInlineUniformBlock; +pub type DescriptorPoolInlineUniformBlockCreateInfoEXT = DescriptorPoolInlineUniformBlockCreateInfo; +pub type ImageFormatListCreateInfoKHR = ImageFormatListCreateInfo; +pub type PhysicalDeviceMaintenance3PropertiesKHR = PhysicalDeviceMaintenance3Properties; +pub type PhysicalDeviceMaintenance4FeaturesKHR = PhysicalDeviceMaintenance4Features; +pub type PhysicalDeviceMaintenance4PropertiesKHR = PhysicalDeviceMaintenance4Properties; +pub type DescriptorSetLayoutSupportKHR = DescriptorSetLayoutSupport; +pub type PhysicalDeviceShaderDrawParameterFeatures = PhysicalDeviceShaderDrawParametersFeatures; +pub type PhysicalDeviceShaderFloat16Int8FeaturesKHR = PhysicalDeviceShaderFloat16Int8Features; +pub type PhysicalDeviceFloat16Int8FeaturesKHR = PhysicalDeviceShaderFloat16Int8Features; +pub type PhysicalDeviceFloatControlsPropertiesKHR = PhysicalDeviceFloatControlsProperties; +pub type PhysicalDeviceHostQueryResetFeaturesEXT = PhysicalDeviceHostQueryResetFeatures; +pub type DeviceQueueGlobalPriorityCreateInfoEXT = DeviceQueueGlobalPriorityCreateInfoKHR; +pub type PhysicalDeviceGlobalPriorityQueryFeaturesEXT = + PhysicalDeviceGlobalPriorityQueryFeaturesKHR; +pub type QueueFamilyGlobalPriorityPropertiesEXT = QueueFamilyGlobalPriorityPropertiesKHR; +pub type PhysicalDeviceDescriptorIndexingFeaturesEXT = PhysicalDeviceDescriptorIndexingFeatures; +pub type PhysicalDeviceDescriptorIndexingPropertiesEXT = PhysicalDeviceDescriptorIndexingProperties; +pub type DescriptorSetLayoutBindingFlagsCreateInfoEXT = DescriptorSetLayoutBindingFlagsCreateInfo; +pub type DescriptorSetVariableDescriptorCountAllocateInfoEXT = + DescriptorSetVariableDescriptorCountAllocateInfo; +pub type DescriptorSetVariableDescriptorCountLayoutSupportEXT = + DescriptorSetVariableDescriptorCountLayoutSupport; +pub type AttachmentDescription2KHR = AttachmentDescription2; +pub type AttachmentReference2KHR = AttachmentReference2; +pub type SubpassDescription2KHR = SubpassDescription2; +pub type SubpassDependency2KHR = SubpassDependency2; +pub type RenderPassCreateInfo2KHR = RenderPassCreateInfo2; +pub type SubpassBeginInfoKHR = SubpassBeginInfo; +pub type SubpassEndInfoKHR = SubpassEndInfo; +pub type PhysicalDeviceTimelineSemaphoreFeaturesKHR = PhysicalDeviceTimelineSemaphoreFeatures; +pub type PhysicalDeviceTimelineSemaphorePropertiesKHR = PhysicalDeviceTimelineSemaphoreProperties; +pub type SemaphoreTypeCreateInfoKHR = SemaphoreTypeCreateInfo; +pub type TimelineSemaphoreSubmitInfoKHR = TimelineSemaphoreSubmitInfo; +pub type SemaphoreWaitInfoKHR = SemaphoreWaitInfo; +pub type SemaphoreSignalInfoKHR = SemaphoreSignalInfo; +pub type PhysicalDevice8BitStorageFeaturesKHR = PhysicalDevice8BitStorageFeatures; +pub type PhysicalDeviceVulkanMemoryModelFeaturesKHR = PhysicalDeviceVulkanMemoryModelFeatures; +pub type PhysicalDeviceShaderAtomicInt64FeaturesKHR = PhysicalDeviceShaderAtomicInt64Features; +pub type PhysicalDeviceDepthStencilResolvePropertiesKHR = + PhysicalDeviceDepthStencilResolveProperties; +pub type SubpassDescriptionDepthStencilResolveKHR = SubpassDescriptionDepthStencilResolve; +pub type PhysicalDeviceFragmentShaderBarycentricFeaturesNV = + PhysicalDeviceFragmentShaderBarycentricFeaturesKHR; +pub type ImageStencilUsageCreateInfoEXT = ImageStencilUsageCreateInfo; +pub type PhysicalDeviceScalarBlockLayoutFeaturesEXT = PhysicalDeviceScalarBlockLayoutFeatures; +pub type PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR = + PhysicalDeviceUniformBufferStandardLayoutFeatures; +pub type PhysicalDeviceBufferDeviceAddressFeaturesKHR = PhysicalDeviceBufferDeviceAddressFeatures; +pub type PhysicalDeviceBufferAddressFeaturesEXT = PhysicalDeviceBufferDeviceAddressFeaturesEXT; +pub type BufferDeviceAddressInfoKHR = BufferDeviceAddressInfo; +pub type BufferDeviceAddressInfoEXT = BufferDeviceAddressInfo; +pub type BufferOpaqueCaptureAddressCreateInfoKHR = BufferOpaqueCaptureAddressCreateInfo; +pub type PhysicalDeviceImagelessFramebufferFeaturesKHR = PhysicalDeviceImagelessFramebufferFeatures; +pub type FramebufferAttachmentsCreateInfoKHR = FramebufferAttachmentsCreateInfo; +pub type FramebufferAttachmentImageInfoKHR = FramebufferAttachmentImageInfo; +pub type RenderPassAttachmentBeginInfoKHR = RenderPassAttachmentBeginInfo; +pub type PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT = + PhysicalDeviceTextureCompressionASTCHDRFeatures; +pub type PipelineCreationFeedbackEXT = PipelineCreationFeedback; +pub type PipelineCreationFeedbackCreateInfoEXT = PipelineCreationFeedbackCreateInfo; +pub type QueryPoolCreateInfoINTEL = QueryPoolPerformanceQueryCreateInfoINTEL; +pub type PhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR = + PhysicalDeviceSeparateDepthStencilLayoutsFeatures; +pub type AttachmentReferenceStencilLayoutKHR = AttachmentReferenceStencilLayout; +pub type AttachmentDescriptionStencilLayoutKHR = AttachmentDescriptionStencilLayout; +pub type PipelineInfoEXT = PipelineInfoKHR; +pub type PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT = + PhysicalDeviceShaderDemoteToHelperInvocationFeatures; +pub type PhysicalDeviceTexelBufferAlignmentPropertiesEXT = + PhysicalDeviceTexelBufferAlignmentProperties; +pub type PhysicalDeviceSubgroupSizeControlFeaturesEXT = PhysicalDeviceSubgroupSizeControlFeatures; +pub type PhysicalDeviceSubgroupSizeControlPropertiesEXT = + PhysicalDeviceSubgroupSizeControlProperties; +pub type PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT = + PipelineShaderStageRequiredSubgroupSizeCreateInfo; +pub type MemoryOpaqueCaptureAddressAllocateInfoKHR = MemoryOpaqueCaptureAddressAllocateInfo; +pub type DeviceMemoryOpaqueCaptureAddressInfoKHR = DeviceMemoryOpaqueCaptureAddressInfo; +pub type PhysicalDevicePipelineCreationCacheControlFeaturesEXT = + PhysicalDevicePipelineCreationCacheControlFeatures; +pub type PhysicalDeviceToolPropertiesEXT = PhysicalDeviceToolProperties; +pub type AabbPositionsNV = AabbPositionsKHR; +pub type TransformMatrixNV = TransformMatrixKHR; +pub type AccelerationStructureInstanceNV = AccelerationStructureInstanceKHR; +pub type PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR = + PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures; +pub type PhysicalDeviceImageRobustnessFeaturesEXT = PhysicalDeviceImageRobustnessFeatures; +pub type BufferCopy2KHR = BufferCopy2; +pub type ImageCopy2KHR = ImageCopy2; +pub type ImageBlit2KHR = ImageBlit2; +pub type BufferImageCopy2KHR = BufferImageCopy2; +pub type ImageResolve2KHR = ImageResolve2; +pub type CopyBufferInfo2KHR = CopyBufferInfo2; +pub type CopyImageInfo2KHR = CopyImageInfo2; +pub type BlitImageInfo2KHR = BlitImageInfo2; +pub type CopyBufferToImageInfo2KHR = CopyBufferToImageInfo2; +pub type CopyImageToBufferInfo2KHR = CopyImageToBufferInfo2; +pub type ResolveImageInfo2KHR = ResolveImageInfo2; +pub type PhysicalDeviceShaderTerminateInvocationFeaturesKHR = + PhysicalDeviceShaderTerminateInvocationFeatures; +pub type PhysicalDeviceMutableDescriptorTypeFeaturesVALVE = + PhysicalDeviceMutableDescriptorTypeFeaturesEXT; +pub type MutableDescriptorTypeListVALVE = MutableDescriptorTypeListEXT; +pub type MutableDescriptorTypeCreateInfoVALVE = MutableDescriptorTypeCreateInfoEXT; +pub type MemoryBarrier2KHR = MemoryBarrier2; +pub type ImageMemoryBarrier2KHR = ImageMemoryBarrier2; +pub type BufferMemoryBarrier2KHR = BufferMemoryBarrier2; +pub type DependencyInfoKHR = DependencyInfo; +pub type SemaphoreSubmitInfoKHR = SemaphoreSubmitInfo; +pub type CommandBufferSubmitInfoKHR = CommandBufferSubmitInfo; +pub type SubmitInfo2KHR = SubmitInfo2; +pub type PhysicalDeviceSynchronization2FeaturesKHR = PhysicalDeviceSynchronization2Features; +pub type PhysicalDeviceShaderIntegerDotProductFeaturesKHR = + PhysicalDeviceShaderIntegerDotProductFeatures; +pub type PhysicalDeviceShaderIntegerDotProductPropertiesKHR = + PhysicalDeviceShaderIntegerDotProductProperties; +pub type FormatProperties3KHR = FormatProperties3; +pub type PipelineRenderingCreateInfoKHR = PipelineRenderingCreateInfo; +pub type RenderingInfoKHR = RenderingInfo; +pub type RenderingAttachmentInfoKHR = RenderingAttachmentInfo; +pub type PhysicalDeviceDynamicRenderingFeaturesKHR = PhysicalDeviceDynamicRenderingFeatures; +pub type CommandBufferInheritanceRenderingInfoKHR = CommandBufferInheritanceRenderingInfo; +pub type AttachmentSampleCountInfoNV = AttachmentSampleCountInfoAMD; +pub type PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM = + PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT; diff --git a/third_party/rust/ash/src/vk/bitflags.rs b/third_party/rust/ash/src/vk/bitflags.rs new file mode 100644 index 0000000000..66699d7214 --- /dev/null +++ b/third_party/rust/ash/src/vk/bitflags.rs @@ -0,0 +1,1643 @@ +use crate::vk::definitions::*; +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct PipelineCacheCreateFlags(pub(crate) Flags); +vk_bitflags_wrapped!(PipelineCacheCreateFlags, Flags); +impl PipelineCacheCreateFlags {} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct QueueFlags(pub(crate) Flags); +vk_bitflags_wrapped!(QueueFlags, Flags); +impl QueueFlags { + #[doc = "Queue supports graphics operations"] + pub const GRAPHICS: Self = Self(0b1); + #[doc = "Queue supports compute operations"] + pub const COMPUTE: Self = Self(0b10); + #[doc = "Queue supports transfer operations"] + pub const TRANSFER: Self = Self(0b100); + #[doc = "Queue supports sparse resource memory management operations"] + pub const SPARSE_BINDING: Self = Self(0b1000); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct CullModeFlags(pub(crate) Flags); +vk_bitflags_wrapped!(CullModeFlags, Flags); +impl CullModeFlags { + pub const NONE: Self = Self(0); + pub const FRONT: Self = Self(0b1); + pub const BACK: Self = Self(0b10); + pub const FRONT_AND_BACK: Self = Self(0x0000_0003); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct RenderPassCreateFlags(pub(crate) Flags); +vk_bitflags_wrapped!(RenderPassCreateFlags, Flags); +impl RenderPassCreateFlags {} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct DeviceQueueCreateFlags(pub(crate) Flags); +vk_bitflags_wrapped!(DeviceQueueCreateFlags, Flags); +impl DeviceQueueCreateFlags {} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct MemoryPropertyFlags(pub(crate) Flags); +vk_bitflags_wrapped!(MemoryPropertyFlags, Flags); +impl MemoryPropertyFlags { + #[doc = "If otherwise stated, then allocate memory on device"] + pub const DEVICE_LOCAL: Self = Self(0b1); + #[doc = "Memory is mappable by host"] + pub const HOST_VISIBLE: Self = Self(0b10); + #[doc = "Memory will have i/o coherency. If not set, application may need to use vkFlushMappedMemoryRanges and vkInvalidateMappedMemoryRanges to flush/invalidate host cache"] + pub const HOST_COHERENT: Self = Self(0b100); + #[doc = "Memory will be cached by the host"] + pub const HOST_CACHED: Self = Self(0b1000); + #[doc = "Memory may be allocated by the driver when it is required"] + pub const LAZILY_ALLOCATED: Self = Self(0b1_0000); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct MemoryHeapFlags(pub(crate) Flags); +vk_bitflags_wrapped!(MemoryHeapFlags, Flags); +impl MemoryHeapFlags { + #[doc = "If set, heap represents device memory"] + pub const DEVICE_LOCAL: Self = Self(0b1); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct AccessFlags(pub(crate) Flags); +vk_bitflags_wrapped!(AccessFlags, Flags); +impl AccessFlags { + #[doc = "Controls coherency of indirect command reads"] + pub const INDIRECT_COMMAND_READ: Self = Self(0b1); + #[doc = "Controls coherency of index reads"] + pub const INDEX_READ: Self = Self(0b10); + #[doc = "Controls coherency of vertex attribute reads"] + pub const VERTEX_ATTRIBUTE_READ: Self = Self(0b100); + #[doc = "Controls coherency of uniform buffer reads"] + pub const UNIFORM_READ: Self = Self(0b1000); + #[doc = "Controls coherency of input attachment reads"] + pub const INPUT_ATTACHMENT_READ: Self = Self(0b1_0000); + #[doc = "Controls coherency of shader reads"] + pub const SHADER_READ: Self = Self(0b10_0000); + #[doc = "Controls coherency of shader writes"] + pub const SHADER_WRITE: Self = Self(0b100_0000); + #[doc = "Controls coherency of color attachment reads"] + pub const COLOR_ATTACHMENT_READ: Self = Self(0b1000_0000); + #[doc = "Controls coherency of color attachment writes"] + pub const COLOR_ATTACHMENT_WRITE: Self = Self(0b1_0000_0000); + #[doc = "Controls coherency of depth/stencil attachment reads"] + pub const DEPTH_STENCIL_ATTACHMENT_READ: Self = Self(0b10_0000_0000); + #[doc = "Controls coherency of depth/stencil attachment writes"] + pub const DEPTH_STENCIL_ATTACHMENT_WRITE: Self = Self(0b100_0000_0000); + #[doc = "Controls coherency of transfer reads"] + pub const TRANSFER_READ: Self = Self(0b1000_0000_0000); + #[doc = "Controls coherency of transfer writes"] + pub const TRANSFER_WRITE: Self = Self(0b1_0000_0000_0000); + #[doc = "Controls coherency of host reads"] + pub const HOST_READ: Self = Self(0b10_0000_0000_0000); + #[doc = "Controls coherency of host writes"] + pub const HOST_WRITE: Self = Self(0b100_0000_0000_0000); + #[doc = "Controls coherency of memory reads"] + pub const MEMORY_READ: Self = Self(0b1000_0000_0000_0000); + #[doc = "Controls coherency of memory writes"] + pub const MEMORY_WRITE: Self = Self(0b1_0000_0000_0000_0000); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct BufferUsageFlags(pub(crate) Flags); +vk_bitflags_wrapped!(BufferUsageFlags, Flags); +impl BufferUsageFlags { + #[doc = "Can be used as a source of transfer operations"] + pub const TRANSFER_SRC: Self = Self(0b1); + #[doc = "Can be used as a destination of transfer operations"] + pub const TRANSFER_DST: Self = Self(0b10); + #[doc = "Can be used as TBO"] + pub const UNIFORM_TEXEL_BUFFER: Self = Self(0b100); + #[doc = "Can be used as IBO"] + pub const STORAGE_TEXEL_BUFFER: Self = Self(0b1000); + #[doc = "Can be used as UBO"] + pub const UNIFORM_BUFFER: Self = Self(0b1_0000); + #[doc = "Can be used as SSBO"] + pub const STORAGE_BUFFER: Self = Self(0b10_0000); + #[doc = "Can be used as source of fixed-function index fetch (index buffer)"] + pub const INDEX_BUFFER: Self = Self(0b100_0000); + #[doc = "Can be used as source of fixed-function vertex fetch (VBO)"] + pub const VERTEX_BUFFER: Self = Self(0b1000_0000); + #[doc = "Can be the source of indirect parameters (e.g. indirect buffer, parameter buffer)"] + pub const INDIRECT_BUFFER: Self = Self(0b1_0000_0000); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct BufferCreateFlags(pub(crate) Flags); +vk_bitflags_wrapped!(BufferCreateFlags, Flags); +impl BufferCreateFlags { + #[doc = "Buffer should support sparse backing"] + pub const SPARSE_BINDING: Self = Self(0b1); + #[doc = "Buffer should support sparse backing with partial residency"] + pub const SPARSE_RESIDENCY: Self = Self(0b10); + #[doc = "Buffer should support constant data access to physical memory ranges mapped into multiple locations of sparse buffers"] + pub const SPARSE_ALIASED: Self = Self(0b100); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct ShaderStageFlags(pub(crate) Flags); +vk_bitflags_wrapped!(ShaderStageFlags, Flags); +impl ShaderStageFlags { + pub const VERTEX: Self = Self(0b1); + pub const TESSELLATION_CONTROL: Self = Self(0b10); + pub const TESSELLATION_EVALUATION: Self = Self(0b100); + pub const GEOMETRY: Self = Self(0b1000); + pub const FRAGMENT: Self = Self(0b1_0000); + pub const COMPUTE: Self = Self(0b10_0000); + pub const ALL_GRAPHICS: Self = Self(0x0000_001F); + pub const ALL: Self = Self(0x7FFF_FFFF); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct ImageUsageFlags(pub(crate) Flags); +vk_bitflags_wrapped!(ImageUsageFlags, Flags); +impl ImageUsageFlags { + #[doc = "Can be used as a source of transfer operations"] + pub const TRANSFER_SRC: Self = Self(0b1); + #[doc = "Can be used as a destination of transfer operations"] + pub const TRANSFER_DST: Self = Self(0b10); + #[doc = "Can be sampled from (SAMPLED_IMAGE and COMBINED_IMAGE_SAMPLER descriptor types)"] + pub const SAMPLED: Self = Self(0b100); + #[doc = "Can be used as storage image (STORAGE_IMAGE descriptor type)"] + pub const STORAGE: Self = Self(0b1000); + #[doc = "Can be used as framebuffer color attachment"] + pub const COLOR_ATTACHMENT: Self = Self(0b1_0000); + #[doc = "Can be used as framebuffer depth/stencil attachment"] + pub const DEPTH_STENCIL_ATTACHMENT: Self = Self(0b10_0000); + #[doc = "Image data not needed outside of rendering"] + pub const TRANSIENT_ATTACHMENT: Self = Self(0b100_0000); + #[doc = "Can be used as framebuffer input attachment"] + pub const INPUT_ATTACHMENT: Self = Self(0b1000_0000); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct ImageCreateFlags(pub(crate) Flags); +vk_bitflags_wrapped!(ImageCreateFlags, Flags); +impl ImageCreateFlags { + #[doc = "Image should support sparse backing"] + pub const SPARSE_BINDING: Self = Self(0b1); + #[doc = "Image should support sparse backing with partial residency"] + pub const SPARSE_RESIDENCY: Self = Self(0b10); + #[doc = "Image should support constant data access to physical memory ranges mapped into multiple locations of sparse images"] + pub const SPARSE_ALIASED: Self = Self(0b100); + #[doc = "Allows image views to have different format than the base image"] + pub const MUTABLE_FORMAT: Self = Self(0b1000); + #[doc = "Allows creating image views with cube type from the created image"] + pub const CUBE_COMPATIBLE: Self = Self(0b1_0000); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct ImageViewCreateFlags(pub(crate) Flags); +vk_bitflags_wrapped!(ImageViewCreateFlags, Flags); +impl ImageViewCreateFlags {} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct SamplerCreateFlags(pub(crate) Flags); +vk_bitflags_wrapped!(SamplerCreateFlags, Flags); +impl SamplerCreateFlags {} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct PipelineCreateFlags(pub(crate) Flags); +vk_bitflags_wrapped!(PipelineCreateFlags, Flags); +impl PipelineCreateFlags { + pub const DISABLE_OPTIMIZATION: Self = Self(0b1); + pub const ALLOW_DERIVATIVES: Self = Self(0b10); + pub const DERIVATIVE: Self = Self(0b100); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct PipelineShaderStageCreateFlags(pub(crate) Flags); +vk_bitflags_wrapped!(PipelineShaderStageCreateFlags, Flags); +impl PipelineShaderStageCreateFlags {} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct ColorComponentFlags(pub(crate) Flags); +vk_bitflags_wrapped!(ColorComponentFlags, Flags); +impl ColorComponentFlags { + pub const R: Self = Self(0b1); + pub const G: Self = Self(0b10); + pub const B: Self = Self(0b100); + pub const A: Self = Self(0b1000); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct FenceCreateFlags(pub(crate) Flags); +vk_bitflags_wrapped!(FenceCreateFlags, Flags); +impl FenceCreateFlags { + pub const SIGNALED: Self = Self(0b1); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct SemaphoreCreateFlags(pub(crate) Flags); +vk_bitflags_wrapped!(SemaphoreCreateFlags, Flags); +impl SemaphoreCreateFlags {} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct FormatFeatureFlags(pub(crate) Flags); +vk_bitflags_wrapped!(FormatFeatureFlags, Flags); +impl FormatFeatureFlags { + #[doc = "Format can be used for sampled images (SAMPLED_IMAGE and COMBINED_IMAGE_SAMPLER descriptor types)"] + pub const SAMPLED_IMAGE: Self = Self(0b1); + #[doc = "Format can be used for storage images (STORAGE_IMAGE descriptor type)"] + pub const STORAGE_IMAGE: Self = Self(0b10); + #[doc = "Format supports atomic operations in case it is used for storage images"] + pub const STORAGE_IMAGE_ATOMIC: Self = Self(0b100); + #[doc = "Format can be used for uniform texel buffers (TBOs)"] + pub const UNIFORM_TEXEL_BUFFER: Self = Self(0b1000); + #[doc = "Format can be used for storage texel buffers (IBOs)"] + pub const STORAGE_TEXEL_BUFFER: Self = Self(0b1_0000); + #[doc = "Format supports atomic operations in case it is used for storage texel buffers"] + pub const STORAGE_TEXEL_BUFFER_ATOMIC: Self = Self(0b10_0000); + #[doc = "Format can be used for vertex buffers (VBOs)"] + pub const VERTEX_BUFFER: Self = Self(0b100_0000); + #[doc = "Format can be used for color attachment images"] + pub const COLOR_ATTACHMENT: Self = Self(0b1000_0000); + #[doc = "Format supports blending in case it is used for color attachment images"] + pub const COLOR_ATTACHMENT_BLEND: Self = Self(0b1_0000_0000); + #[doc = "Format can be used for depth/stencil attachment images"] + pub const DEPTH_STENCIL_ATTACHMENT: Self = Self(0b10_0000_0000); + #[doc = "Format can be used as the source image of blits with vkCmdBlitImage"] + pub const BLIT_SRC: Self = Self(0b100_0000_0000); + #[doc = "Format can be used as the destination image of blits with vkCmdBlitImage"] + pub const BLIT_DST: Self = Self(0b1000_0000_0000); + #[doc = "Format can be filtered with VK_FILTER_LINEAR when being sampled"] + pub const SAMPLED_IMAGE_FILTER_LINEAR: Self = Self(0b1_0000_0000_0000); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct QueryControlFlags(pub(crate) Flags); +vk_bitflags_wrapped!(QueryControlFlags, Flags); +impl QueryControlFlags { + #[doc = "Require precise results to be collected by the query"] + pub const PRECISE: Self = Self(0b1); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct QueryResultFlags(pub(crate) Flags); +vk_bitflags_wrapped!(QueryResultFlags, Flags); +impl QueryResultFlags { + #[doc = "Results of the queries are written to the destination buffer as 64-bit values"] + pub const TYPE_64: Self = Self(0b1); + #[doc = "Results of the queries are waited on before proceeding with the result copy"] + pub const WAIT: Self = Self(0b10); + #[doc = "Besides the results of the query, the availability of the results is also written"] + pub const WITH_AVAILABILITY: Self = Self(0b100); + #[doc = "Copy the partial results of the query even if the final results are not available"] + pub const PARTIAL: Self = Self(0b1000); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct CommandBufferUsageFlags(pub(crate) Flags); +vk_bitflags_wrapped!(CommandBufferUsageFlags, Flags); +impl CommandBufferUsageFlags { + pub const ONE_TIME_SUBMIT: Self = Self(0b1); + pub const RENDER_PASS_CONTINUE: Self = Self(0b10); + #[doc = "Command buffer may be submitted/executed more than once simultaneously"] + pub const SIMULTANEOUS_USE: Self = Self(0b100); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct QueryPipelineStatisticFlags(pub(crate) Flags); +vk_bitflags_wrapped!(QueryPipelineStatisticFlags, Flags); +impl QueryPipelineStatisticFlags { + #[doc = "Optional"] + pub const INPUT_ASSEMBLY_VERTICES: Self = Self(0b1); + #[doc = "Optional"] + pub const INPUT_ASSEMBLY_PRIMITIVES: Self = Self(0b10); + #[doc = "Optional"] + pub const VERTEX_SHADER_INVOCATIONS: Self = Self(0b100); + #[doc = "Optional"] + pub const GEOMETRY_SHADER_INVOCATIONS: Self = Self(0b1000); + #[doc = "Optional"] + pub const GEOMETRY_SHADER_PRIMITIVES: Self = Self(0b1_0000); + #[doc = "Optional"] + pub const CLIPPING_INVOCATIONS: Self = Self(0b10_0000); + #[doc = "Optional"] + pub const CLIPPING_PRIMITIVES: Self = Self(0b100_0000); + #[doc = "Optional"] + pub const FRAGMENT_SHADER_INVOCATIONS: Self = Self(0b1000_0000); + #[doc = "Optional"] + pub const TESSELLATION_CONTROL_SHADER_PATCHES: Self = Self(0b1_0000_0000); + #[doc = "Optional"] + pub const TESSELLATION_EVALUATION_SHADER_INVOCATIONS: Self = Self(0b10_0000_0000); + #[doc = "Optional"] + pub const COMPUTE_SHADER_INVOCATIONS: Self = Self(0b100_0000_0000); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct ImageAspectFlags(pub(crate) Flags); +vk_bitflags_wrapped!(ImageAspectFlags, Flags); +impl ImageAspectFlags { + pub const COLOR: Self = Self(0b1); + pub const DEPTH: Self = Self(0b10); + pub const STENCIL: Self = Self(0b100); + pub const METADATA: Self = Self(0b1000); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct SparseImageFormatFlags(pub(crate) Flags); +vk_bitflags_wrapped!(SparseImageFormatFlags, Flags); +impl SparseImageFormatFlags { + #[doc = "Image uses a single mip tail region for all array layers"] + pub const SINGLE_MIPTAIL: Self = Self(0b1); + #[doc = "Image requires mip level dimensions to be an integer multiple of the sparse image block dimensions for non-tail mip levels."] + pub const ALIGNED_MIP_SIZE: Self = Self(0b10); + #[doc = "Image uses a non-standard sparse image block dimensions"] + pub const NONSTANDARD_BLOCK_SIZE: Self = Self(0b100); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct SparseMemoryBindFlags(pub(crate) Flags); +vk_bitflags_wrapped!(SparseMemoryBindFlags, Flags); +impl SparseMemoryBindFlags { + #[doc = "Operation binds resource metadata to memory"] + pub const METADATA: Self = Self(0b1); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct PipelineStageFlags(pub(crate) Flags); +vk_bitflags_wrapped!(PipelineStageFlags, Flags); +impl PipelineStageFlags { + #[doc = "Before subsequent commands are processed"] + pub const TOP_OF_PIPE: Self = Self(0b1); + #[doc = "Draw/DispatchIndirect command fetch"] + pub const DRAW_INDIRECT: Self = Self(0b10); + #[doc = "Vertex/index fetch"] + pub const VERTEX_INPUT: Self = Self(0b100); + #[doc = "Vertex shading"] + pub const VERTEX_SHADER: Self = Self(0b1000); + #[doc = "Tessellation control shading"] + pub const TESSELLATION_CONTROL_SHADER: Self = Self(0b1_0000); + #[doc = "Tessellation evaluation shading"] + pub const TESSELLATION_EVALUATION_SHADER: Self = Self(0b10_0000); + #[doc = "Geometry shading"] + pub const GEOMETRY_SHADER: Self = Self(0b100_0000); + #[doc = "Fragment shading"] + pub const FRAGMENT_SHADER: Self = Self(0b1000_0000); + #[doc = "Early fragment (depth and stencil) tests"] + pub const EARLY_FRAGMENT_TESTS: Self = Self(0b1_0000_0000); + #[doc = "Late fragment (depth and stencil) tests"] + pub const LATE_FRAGMENT_TESTS: Self = Self(0b10_0000_0000); + #[doc = "Color attachment writes"] + pub const COLOR_ATTACHMENT_OUTPUT: Self = Self(0b100_0000_0000); + #[doc = "Compute shading"] + pub const COMPUTE_SHADER: Self = Self(0b1000_0000_0000); + #[doc = "Transfer/copy operations"] + pub const TRANSFER: Self = Self(0b1_0000_0000_0000); + #[doc = "After previous commands have completed"] + pub const BOTTOM_OF_PIPE: Self = Self(0b10_0000_0000_0000); + #[doc = "Indicates host (CPU) is a source/sink of the dependency"] + pub const HOST: Self = Self(0b100_0000_0000_0000); + #[doc = "All stages of the graphics pipeline"] + pub const ALL_GRAPHICS: Self = Self(0b1000_0000_0000_0000); + #[doc = "All stages supported on the queue"] + pub const ALL_COMMANDS: Self = Self(0b1_0000_0000_0000_0000); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct CommandPoolCreateFlags(pub(crate) Flags); +vk_bitflags_wrapped!(CommandPoolCreateFlags, Flags); +impl CommandPoolCreateFlags { + #[doc = "Command buffers have a short lifetime"] + pub const TRANSIENT: Self = Self(0b1); + #[doc = "Command buffers may release their memory individually"] + pub const RESET_COMMAND_BUFFER: Self = Self(0b10); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct CommandPoolResetFlags(pub(crate) Flags); +vk_bitflags_wrapped!(CommandPoolResetFlags, Flags); +impl CommandPoolResetFlags { + #[doc = "Release resources owned by the pool"] + pub const RELEASE_RESOURCES: Self = Self(0b1); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct CommandBufferResetFlags(pub(crate) Flags); +vk_bitflags_wrapped!(CommandBufferResetFlags, Flags); +impl CommandBufferResetFlags { + #[doc = "Release resources owned by the buffer"] + pub const RELEASE_RESOURCES: Self = Self(0b1); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct SampleCountFlags(pub(crate) Flags); +vk_bitflags_wrapped!(SampleCountFlags, Flags); +impl SampleCountFlags { + #[doc = "Sample count 1 supported"] + pub const TYPE_1: Self = Self(0b1); + #[doc = "Sample count 2 supported"] + pub const TYPE_2: Self = Self(0b10); + #[doc = "Sample count 4 supported"] + pub const TYPE_4: Self = Self(0b100); + #[doc = "Sample count 8 supported"] + pub const TYPE_8: Self = Self(0b1000); + #[doc = "Sample count 16 supported"] + pub const TYPE_16: Self = Self(0b1_0000); + #[doc = "Sample count 32 supported"] + pub const TYPE_32: Self = Self(0b10_0000); + #[doc = "Sample count 64 supported"] + pub const TYPE_64: Self = Self(0b100_0000); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct AttachmentDescriptionFlags(pub(crate) Flags); +vk_bitflags_wrapped!(AttachmentDescriptionFlags, Flags); +impl AttachmentDescriptionFlags { + #[doc = "The attachment may alias physical memory of another attachment in the same render pass"] + pub const MAY_ALIAS: Self = Self(0b1); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct StencilFaceFlags(pub(crate) Flags); +vk_bitflags_wrapped!(StencilFaceFlags, Flags); +impl StencilFaceFlags { + #[doc = "Front face"] + pub const FRONT: Self = Self(0b1); + #[doc = "Back face"] + pub const BACK: Self = Self(0b10); + #[doc = "Front and back faces"] + pub const FRONT_AND_BACK: Self = Self(0x0000_0003); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct DescriptorPoolCreateFlags(pub(crate) Flags); +vk_bitflags_wrapped!(DescriptorPoolCreateFlags, Flags); +impl DescriptorPoolCreateFlags { + #[doc = "Descriptor sets may be freed individually"] + pub const FREE_DESCRIPTOR_SET: Self = Self(0b1); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct DependencyFlags(pub(crate) Flags); +vk_bitflags_wrapped!(DependencyFlags, Flags); +impl DependencyFlags { + #[doc = "Dependency is per pixel region "] + pub const BY_REGION: Self = Self(0b1); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct SemaphoreWaitFlags(pub(crate) Flags); +vk_bitflags_wrapped!(SemaphoreWaitFlags, Flags); +impl SemaphoreWaitFlags { + pub const ANY: Self = Self(0b1); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct DisplayPlaneAlphaFlagsKHR(pub(crate) Flags); +vk_bitflags_wrapped!(DisplayPlaneAlphaFlagsKHR, Flags); +impl DisplayPlaneAlphaFlagsKHR { + pub const OPAQUE: Self = Self(0b1); + pub const GLOBAL: Self = Self(0b10); + pub const PER_PIXEL: Self = Self(0b100); + pub const PER_PIXEL_PREMULTIPLIED: Self = Self(0b1000); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct CompositeAlphaFlagsKHR(pub(crate) Flags); +vk_bitflags_wrapped!(CompositeAlphaFlagsKHR, Flags); +impl CompositeAlphaFlagsKHR { + pub const OPAQUE: Self = Self(0b1); + pub const PRE_MULTIPLIED: Self = Self(0b10); + pub const POST_MULTIPLIED: Self = Self(0b100); + pub const INHERIT: Self = Self(0b1000); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct SurfaceTransformFlagsKHR(pub(crate) Flags); +vk_bitflags_wrapped!(SurfaceTransformFlagsKHR, Flags); +impl SurfaceTransformFlagsKHR { + pub const IDENTITY: Self = Self(0b1); + pub const ROTATE_90: Self = Self(0b10); + pub const ROTATE_180: Self = Self(0b100); + pub const ROTATE_270: Self = Self(0b1000); + pub const HORIZONTAL_MIRROR: Self = Self(0b1_0000); + pub const HORIZONTAL_MIRROR_ROTATE_90: Self = Self(0b10_0000); + pub const HORIZONTAL_MIRROR_ROTATE_180: Self = Self(0b100_0000); + pub const HORIZONTAL_MIRROR_ROTATE_270: Self = Self(0b1000_0000); + pub const INHERIT: Self = Self(0b1_0000_0000); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct SwapchainImageUsageFlagsANDROID(pub(crate) Flags); +vk_bitflags_wrapped!(SwapchainImageUsageFlagsANDROID, Flags); +impl SwapchainImageUsageFlagsANDROID { + pub const SHARED: Self = Self(0b1); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct DebugReportFlagsEXT(pub(crate) Flags); +vk_bitflags_wrapped!(DebugReportFlagsEXT, Flags); +impl DebugReportFlagsEXT { + pub const INFORMATION: Self = Self(0b1); + pub const WARNING: Self = Self(0b10); + pub const PERFORMANCE_WARNING: Self = Self(0b100); + pub const ERROR: Self = Self(0b1000); + pub const DEBUG: Self = Self(0b1_0000); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct ExternalMemoryHandleTypeFlagsNV(pub(crate) Flags); +vk_bitflags_wrapped!(ExternalMemoryHandleTypeFlagsNV, Flags); +impl ExternalMemoryHandleTypeFlagsNV { + pub const OPAQUE_WIN32: Self = Self(0b1); + pub const OPAQUE_WIN32_KMT: Self = Self(0b10); + pub const D3D11_IMAGE: Self = Self(0b100); + pub const D3D11_IMAGE_KMT: Self = Self(0b1000); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct ExternalMemoryFeatureFlagsNV(pub(crate) Flags); +vk_bitflags_wrapped!(ExternalMemoryFeatureFlagsNV, Flags); +impl ExternalMemoryFeatureFlagsNV { + pub const DEDICATED_ONLY: Self = Self(0b1); + pub const EXPORTABLE: Self = Self(0b10); + pub const IMPORTABLE: Self = Self(0b100); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct SubgroupFeatureFlags(pub(crate) Flags); +vk_bitflags_wrapped!(SubgroupFeatureFlags, Flags); +impl SubgroupFeatureFlags { + #[doc = "Basic subgroup operations"] + pub const BASIC: Self = Self(0b1); + #[doc = "Vote subgroup operations"] + pub const VOTE: Self = Self(0b10); + #[doc = "Arithmetic subgroup operations"] + pub const ARITHMETIC: Self = Self(0b100); + #[doc = "Ballot subgroup operations"] + pub const BALLOT: Self = Self(0b1000); + #[doc = "Shuffle subgroup operations"] + pub const SHUFFLE: Self = Self(0b1_0000); + #[doc = "Shuffle relative subgroup operations"] + pub const SHUFFLE_RELATIVE: Self = Self(0b10_0000); + #[doc = "Clustered subgroup operations"] + pub const CLUSTERED: Self = Self(0b100_0000); + #[doc = "Quad subgroup operations"] + pub const QUAD: Self = Self(0b1000_0000); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct IndirectCommandsLayoutUsageFlagsNV(pub(crate) Flags); +vk_bitflags_wrapped!(IndirectCommandsLayoutUsageFlagsNV, Flags); +impl IndirectCommandsLayoutUsageFlagsNV { + pub const EXPLICIT_PREPROCESS: Self = Self(0b1); + pub const INDEXED_SEQUENCES: Self = Self(0b10); + pub const UNORDERED_SEQUENCES: Self = Self(0b100); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct IndirectStateFlagsNV(pub(crate) Flags); +vk_bitflags_wrapped!(IndirectStateFlagsNV, Flags); +impl IndirectStateFlagsNV { + pub const FLAG_FRONTFACE: Self = Self(0b1); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct PrivateDataSlotCreateFlags(pub(crate) Flags); +vk_bitflags_wrapped!(PrivateDataSlotCreateFlags, Flags); +impl PrivateDataSlotCreateFlags {} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct DescriptorSetLayoutCreateFlags(pub(crate) Flags); +vk_bitflags_wrapped!(DescriptorSetLayoutCreateFlags, Flags); +impl DescriptorSetLayoutCreateFlags {} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct ExternalMemoryHandleTypeFlags(pub(crate) Flags); +vk_bitflags_wrapped!(ExternalMemoryHandleTypeFlags, Flags); +impl ExternalMemoryHandleTypeFlags { + pub const OPAQUE_FD: Self = Self(0b1); + pub const OPAQUE_WIN32: Self = Self(0b10); + pub const OPAQUE_WIN32_KMT: Self = Self(0b100); + pub const D3D11_TEXTURE: Self = Self(0b1000); + pub const D3D11_TEXTURE_KMT: Self = Self(0b1_0000); + pub const D3D12_HEAP: Self = Self(0b10_0000); + pub const D3D12_RESOURCE: Self = Self(0b100_0000); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct ExternalMemoryFeatureFlags(pub(crate) Flags); +vk_bitflags_wrapped!(ExternalMemoryFeatureFlags, Flags); +impl ExternalMemoryFeatureFlags { + pub const DEDICATED_ONLY: Self = Self(0b1); + pub const EXPORTABLE: Self = Self(0b10); + pub const IMPORTABLE: Self = Self(0b100); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct ExternalSemaphoreHandleTypeFlags(pub(crate) Flags); +vk_bitflags_wrapped!(ExternalSemaphoreHandleTypeFlags, Flags); +impl ExternalSemaphoreHandleTypeFlags { + pub const OPAQUE_FD: Self = Self(0b1); + pub const OPAQUE_WIN32: Self = Self(0b10); + pub const OPAQUE_WIN32_KMT: Self = Self(0b100); + pub const D3D12_FENCE: Self = Self(0b1000); + pub const D3D11_FENCE: Self = Self::D3D12_FENCE; + pub const SYNC_FD: Self = Self(0b1_0000); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct ExternalSemaphoreFeatureFlags(pub(crate) Flags); +vk_bitflags_wrapped!(ExternalSemaphoreFeatureFlags, Flags); +impl ExternalSemaphoreFeatureFlags { + pub const EXPORTABLE: Self = Self(0b1); + pub const IMPORTABLE: Self = Self(0b10); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct SemaphoreImportFlags(pub(crate) Flags); +vk_bitflags_wrapped!(SemaphoreImportFlags, Flags); +impl SemaphoreImportFlags { + pub const TEMPORARY: Self = Self(0b1); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct ExternalFenceHandleTypeFlags(pub(crate) Flags); +vk_bitflags_wrapped!(ExternalFenceHandleTypeFlags, Flags); +impl ExternalFenceHandleTypeFlags { + pub const OPAQUE_FD: Self = Self(0b1); + pub const OPAQUE_WIN32: Self = Self(0b10); + pub const OPAQUE_WIN32_KMT: Self = Self(0b100); + pub const SYNC_FD: Self = Self(0b1000); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct ExternalFenceFeatureFlags(pub(crate) Flags); +vk_bitflags_wrapped!(ExternalFenceFeatureFlags, Flags); +impl ExternalFenceFeatureFlags { + pub const EXPORTABLE: Self = Self(0b1); + pub const IMPORTABLE: Self = Self(0b10); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct FenceImportFlags(pub(crate) Flags); +vk_bitflags_wrapped!(FenceImportFlags, Flags); +impl FenceImportFlags { + pub const TEMPORARY: Self = Self(0b1); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct SurfaceCounterFlagsEXT(pub(crate) Flags); +vk_bitflags_wrapped!(SurfaceCounterFlagsEXT, Flags); +impl SurfaceCounterFlagsEXT { + pub const VBLANK: Self = Self(0b1); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct PeerMemoryFeatureFlags(pub(crate) Flags); +vk_bitflags_wrapped!(PeerMemoryFeatureFlags, Flags); +impl PeerMemoryFeatureFlags { + #[doc = "Can read with vkCmdCopy commands"] + pub const COPY_SRC: Self = Self(0b1); + #[doc = "Can write with vkCmdCopy commands"] + pub const COPY_DST: Self = Self(0b10); + #[doc = "Can read with any access type/command"] + pub const GENERIC_SRC: Self = Self(0b100); + #[doc = "Can write with and access type/command"] + pub const GENERIC_DST: Self = Self(0b1000); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct MemoryAllocateFlags(pub(crate) Flags); +vk_bitflags_wrapped!(MemoryAllocateFlags, Flags); +impl MemoryAllocateFlags { + #[doc = "Force allocation on specific devices"] + pub const DEVICE_MASK: Self = Self(0b1); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct DeviceGroupPresentModeFlagsKHR(pub(crate) Flags); +vk_bitflags_wrapped!(DeviceGroupPresentModeFlagsKHR, Flags); +impl DeviceGroupPresentModeFlagsKHR { + #[doc = "Present from local memory"] + pub const LOCAL: Self = Self(0b1); + #[doc = "Present from remote memory"] + pub const REMOTE: Self = Self(0b10); + #[doc = "Present sum of local and/or remote memory"] + pub const SUM: Self = Self(0b100); + #[doc = "Each physical device presents from local memory"] + pub const LOCAL_MULTI_DEVICE: Self = Self(0b1000); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct SwapchainCreateFlagsKHR(pub(crate) Flags); +vk_bitflags_wrapped!(SwapchainCreateFlagsKHR, Flags); +impl SwapchainCreateFlagsKHR {} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct SubpassDescriptionFlags(pub(crate) Flags); +vk_bitflags_wrapped!(SubpassDescriptionFlags, Flags); +impl SubpassDescriptionFlags {} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct DebugUtilsMessageSeverityFlagsEXT(pub(crate) Flags); +vk_bitflags_wrapped!(DebugUtilsMessageSeverityFlagsEXT, Flags); +impl DebugUtilsMessageSeverityFlagsEXT { + pub const VERBOSE: Self = Self(0b1); + pub const INFO: Self = Self(0b1_0000); + pub const WARNING: Self = Self(0b1_0000_0000); + pub const ERROR: Self = Self(0b1_0000_0000_0000); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct DebugUtilsMessageTypeFlagsEXT(pub(crate) Flags); +vk_bitflags_wrapped!(DebugUtilsMessageTypeFlagsEXT, Flags); +impl DebugUtilsMessageTypeFlagsEXT { + pub const GENERAL: Self = Self(0b1); + pub const VALIDATION: Self = Self(0b10); + pub const PERFORMANCE: Self = Self(0b100); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct DescriptorBindingFlags(pub(crate) Flags); +vk_bitflags_wrapped!(DescriptorBindingFlags, Flags); +impl DescriptorBindingFlags { + pub const UPDATE_AFTER_BIND: Self = Self(0b1); + pub const UPDATE_UNUSED_WHILE_PENDING: Self = Self(0b10); + pub const PARTIALLY_BOUND: Self = Self(0b100); + pub const VARIABLE_DESCRIPTOR_COUNT: Self = Self(0b1000); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct ConditionalRenderingFlagsEXT(pub(crate) Flags); +vk_bitflags_wrapped!(ConditionalRenderingFlagsEXT, Flags); +impl ConditionalRenderingFlagsEXT { + pub const INVERTED: Self = Self(0b1); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct ResolveModeFlags(pub(crate) Flags); +vk_bitflags_wrapped!(ResolveModeFlags, Flags); +impl ResolveModeFlags { + pub const NONE: Self = Self(0); + pub const SAMPLE_ZERO: Self = Self(0b1); + pub const AVERAGE: Self = Self(0b10); + pub const MIN: Self = Self(0b100); + pub const MAX: Self = Self(0b1000); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct GeometryInstanceFlagsKHR(pub(crate) Flags); +vk_bitflags_wrapped!(GeometryInstanceFlagsKHR, Flags); +impl GeometryInstanceFlagsKHR { + pub const TRIANGLE_FACING_CULL_DISABLE: Self = Self(0b1); + pub const TRIANGLE_FLIP_FACING: Self = Self(0b10); + pub const FORCE_OPAQUE: Self = Self(0b100); + pub const FORCE_NO_OPAQUE: Self = Self(0b1000); + pub const TRIANGLE_FRONT_COUNTERCLOCKWISE: Self = Self::TRIANGLE_FLIP_FACING; +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct GeometryFlagsKHR(pub(crate) Flags); +vk_bitflags_wrapped!(GeometryFlagsKHR, Flags); +impl GeometryFlagsKHR { + pub const OPAQUE: Self = Self(0b1); + pub const NO_DUPLICATE_ANY_HIT_INVOCATION: Self = Self(0b10); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct BuildAccelerationStructureFlagsKHR(pub(crate) Flags); +vk_bitflags_wrapped!(BuildAccelerationStructureFlagsKHR, Flags); +impl BuildAccelerationStructureFlagsKHR { + pub const ALLOW_UPDATE: Self = Self(0b1); + pub const ALLOW_COMPACTION: Self = Self(0b10); + pub const PREFER_FAST_TRACE: Self = Self(0b100); + pub const PREFER_FAST_BUILD: Self = Self(0b1000); + pub const LOW_MEMORY: Self = Self(0b1_0000); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct AccelerationStructureCreateFlagsKHR(pub(crate) Flags); +vk_bitflags_wrapped!(AccelerationStructureCreateFlagsKHR, Flags); +impl AccelerationStructureCreateFlagsKHR { + pub const DEVICE_ADDRESS_CAPTURE_REPLAY: Self = Self(0b1); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct FramebufferCreateFlags(pub(crate) Flags); +vk_bitflags_wrapped!(FramebufferCreateFlags, Flags); +impl FramebufferCreateFlags {} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct DeviceDiagnosticsConfigFlagsNV(pub(crate) Flags); +vk_bitflags_wrapped!(DeviceDiagnosticsConfigFlagsNV, Flags); +impl DeviceDiagnosticsConfigFlagsNV { + pub const ENABLE_SHADER_DEBUG_INFO: Self = Self(0b1); + pub const ENABLE_RESOURCE_TRACKING: Self = Self(0b10); + pub const ENABLE_AUTOMATIC_CHECKPOINTS: Self = Self(0b100); + pub const ENABLE_SHADER_ERROR_REPORTING: Self = Self(0b1000); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct PipelineCreationFeedbackFlags(pub(crate) Flags); +vk_bitflags_wrapped!(PipelineCreationFeedbackFlags, Flags); +impl PipelineCreationFeedbackFlags { + pub const VALID: Self = Self(0b1); + pub const VALID_EXT: Self = Self::VALID; + pub const APPLICATION_PIPELINE_CACHE_HIT: Self = Self(0b10); + pub const APPLICATION_PIPELINE_CACHE_HIT_EXT: Self = Self::APPLICATION_PIPELINE_CACHE_HIT; + pub const BASE_PIPELINE_ACCELERATION: Self = Self(0b100); + pub const BASE_PIPELINE_ACCELERATION_EXT: Self = Self::BASE_PIPELINE_ACCELERATION; +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct MemoryDecompressionMethodFlagsNV(pub(crate) Flags64); +vk_bitflags_wrapped!(MemoryDecompressionMethodFlagsNV, Flags64); +impl MemoryDecompressionMethodFlagsNV { + pub const GDEFLATE_1_0: Self = Self(0b1); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct PerformanceCounterDescriptionFlagsKHR(pub(crate) Flags); +vk_bitflags_wrapped!(PerformanceCounterDescriptionFlagsKHR, Flags); +impl PerformanceCounterDescriptionFlagsKHR { + pub const PERFORMANCE_IMPACTING: Self = Self(0b1); + pub const CONCURRENTLY_IMPACTED: Self = Self(0b10); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct AcquireProfilingLockFlagsKHR(pub(crate) Flags); +vk_bitflags_wrapped!(AcquireProfilingLockFlagsKHR, Flags); +impl AcquireProfilingLockFlagsKHR {} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct ShaderCorePropertiesFlagsAMD(pub(crate) Flags); +vk_bitflags_wrapped!(ShaderCorePropertiesFlagsAMD, Flags); +impl ShaderCorePropertiesFlagsAMD {} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct ShaderModuleCreateFlags(pub(crate) Flags); +vk_bitflags_wrapped!(ShaderModuleCreateFlags, Flags); +impl ShaderModuleCreateFlags {} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct PipelineCompilerControlFlagsAMD(pub(crate) Flags); +vk_bitflags_wrapped!(PipelineCompilerControlFlagsAMD, Flags); +impl PipelineCompilerControlFlagsAMD {} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct ToolPurposeFlags(pub(crate) Flags); +vk_bitflags_wrapped!(ToolPurposeFlags, Flags); +impl ToolPurposeFlags { + pub const VALIDATION: Self = Self(0b1); + pub const VALIDATION_EXT: Self = Self::VALIDATION; + pub const PROFILING: Self = Self(0b10); + pub const PROFILING_EXT: Self = Self::PROFILING; + pub const TRACING: Self = Self(0b100); + pub const TRACING_EXT: Self = Self::TRACING; + pub const ADDITIONAL_FEATURES: Self = Self(0b1000); + pub const ADDITIONAL_FEATURES_EXT: Self = Self::ADDITIONAL_FEATURES; + pub const MODIFYING_FEATURES: Self = Self(0b1_0000); + pub const MODIFYING_FEATURES_EXT: Self = Self::MODIFYING_FEATURES; +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct AccessFlags2(pub(crate) Flags64); +vk_bitflags_wrapped!(AccessFlags2, Flags64); +impl AccessFlags2 { + pub const NONE: Self = Self(0); + pub const NONE_KHR: Self = Self::NONE; + pub const INDIRECT_COMMAND_READ: Self = Self(0b1); + pub const INDIRECT_COMMAND_READ_KHR: Self = Self::INDIRECT_COMMAND_READ; + pub const INDEX_READ: Self = Self(0b10); + pub const INDEX_READ_KHR: Self = Self::INDEX_READ; + pub const VERTEX_ATTRIBUTE_READ: Self = Self(0b100); + pub const VERTEX_ATTRIBUTE_READ_KHR: Self = Self::VERTEX_ATTRIBUTE_READ; + pub const UNIFORM_READ: Self = Self(0b1000); + pub const UNIFORM_READ_KHR: Self = Self::UNIFORM_READ; + pub const INPUT_ATTACHMENT_READ: Self = Self(0b1_0000); + pub const INPUT_ATTACHMENT_READ_KHR: Self = Self::INPUT_ATTACHMENT_READ; + pub const SHADER_READ: Self = Self(0b10_0000); + pub const SHADER_READ_KHR: Self = Self::SHADER_READ; + pub const SHADER_WRITE: Self = Self(0b100_0000); + pub const SHADER_WRITE_KHR: Self = Self::SHADER_WRITE; + pub const COLOR_ATTACHMENT_READ: Self = Self(0b1000_0000); + pub const COLOR_ATTACHMENT_READ_KHR: Self = Self::COLOR_ATTACHMENT_READ; + pub const COLOR_ATTACHMENT_WRITE: Self = Self(0b1_0000_0000); + pub const COLOR_ATTACHMENT_WRITE_KHR: Self = Self::COLOR_ATTACHMENT_WRITE; + pub const DEPTH_STENCIL_ATTACHMENT_READ: Self = Self(0b10_0000_0000); + pub const DEPTH_STENCIL_ATTACHMENT_READ_KHR: Self = Self::DEPTH_STENCIL_ATTACHMENT_READ; + pub const DEPTH_STENCIL_ATTACHMENT_WRITE: Self = Self(0b100_0000_0000); + pub const DEPTH_STENCIL_ATTACHMENT_WRITE_KHR: Self = Self::DEPTH_STENCIL_ATTACHMENT_WRITE; + pub const TRANSFER_READ: Self = Self(0b1000_0000_0000); + pub const TRANSFER_READ_KHR: Self = Self::TRANSFER_READ; + pub const TRANSFER_WRITE: Self = Self(0b1_0000_0000_0000); + pub const TRANSFER_WRITE_KHR: Self = Self::TRANSFER_WRITE; + pub const HOST_READ: Self = Self(0b10_0000_0000_0000); + pub const HOST_READ_KHR: Self = Self::HOST_READ; + pub const HOST_WRITE: Self = Self(0b100_0000_0000_0000); + pub const HOST_WRITE_KHR: Self = Self::HOST_WRITE; + pub const MEMORY_READ: Self = Self(0b1000_0000_0000_0000); + pub const MEMORY_READ_KHR: Self = Self::MEMORY_READ; + pub const MEMORY_WRITE: Self = Self(0b1_0000_0000_0000_0000); + pub const MEMORY_WRITE_KHR: Self = Self::MEMORY_WRITE; + pub const SHADER_SAMPLED_READ: Self = Self(0b1_0000_0000_0000_0000_0000_0000_0000_0000); + pub const SHADER_SAMPLED_READ_KHR: Self = Self::SHADER_SAMPLED_READ; + pub const SHADER_STORAGE_READ: Self = Self(0b10_0000_0000_0000_0000_0000_0000_0000_0000); + pub const SHADER_STORAGE_READ_KHR: Self = Self::SHADER_STORAGE_READ; + pub const SHADER_STORAGE_WRITE: Self = Self(0b100_0000_0000_0000_0000_0000_0000_0000_0000); + pub const SHADER_STORAGE_WRITE_KHR: Self = Self::SHADER_STORAGE_WRITE; +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct PipelineStageFlags2(pub(crate) Flags64); +vk_bitflags_wrapped!(PipelineStageFlags2, Flags64); +impl PipelineStageFlags2 { + pub const NONE: Self = Self(0); + pub const NONE_KHR: Self = Self::NONE; + pub const TOP_OF_PIPE: Self = Self(0b1); + pub const TOP_OF_PIPE_KHR: Self = Self::TOP_OF_PIPE; + pub const DRAW_INDIRECT: Self = Self(0b10); + pub const DRAW_INDIRECT_KHR: Self = Self::DRAW_INDIRECT; + pub const VERTEX_INPUT: Self = Self(0b100); + pub const VERTEX_INPUT_KHR: Self = Self::VERTEX_INPUT; + pub const VERTEX_SHADER: Self = Self(0b1000); + pub const VERTEX_SHADER_KHR: Self = Self::VERTEX_SHADER; + pub const TESSELLATION_CONTROL_SHADER: Self = Self(0b1_0000); + pub const TESSELLATION_CONTROL_SHADER_KHR: Self = Self::TESSELLATION_CONTROL_SHADER; + pub const TESSELLATION_EVALUATION_SHADER: Self = Self(0b10_0000); + pub const TESSELLATION_EVALUATION_SHADER_KHR: Self = Self::TESSELLATION_EVALUATION_SHADER; + pub const GEOMETRY_SHADER: Self = Self(0b100_0000); + pub const GEOMETRY_SHADER_KHR: Self = Self::GEOMETRY_SHADER; + pub const FRAGMENT_SHADER: Self = Self(0b1000_0000); + pub const FRAGMENT_SHADER_KHR: Self = Self::FRAGMENT_SHADER; + pub const EARLY_FRAGMENT_TESTS: Self = Self(0b1_0000_0000); + pub const EARLY_FRAGMENT_TESTS_KHR: Self = Self::EARLY_FRAGMENT_TESTS; + pub const LATE_FRAGMENT_TESTS: Self = Self(0b10_0000_0000); + pub const LATE_FRAGMENT_TESTS_KHR: Self = Self::LATE_FRAGMENT_TESTS; + pub const COLOR_ATTACHMENT_OUTPUT: Self = Self(0b100_0000_0000); + pub const COLOR_ATTACHMENT_OUTPUT_KHR: Self = Self::COLOR_ATTACHMENT_OUTPUT; + pub const COMPUTE_SHADER: Self = Self(0b1000_0000_0000); + pub const COMPUTE_SHADER_KHR: Self = Self::COMPUTE_SHADER; + pub const ALL_TRANSFER: Self = Self(0b1_0000_0000_0000); + pub const ALL_TRANSFER_KHR: Self = Self::ALL_TRANSFER; + pub const TRANSFER: Self = Self::ALL_TRANSFER_KHR; + pub const TRANSFER_KHR: Self = Self::ALL_TRANSFER; + pub const BOTTOM_OF_PIPE: Self = Self(0b10_0000_0000_0000); + pub const BOTTOM_OF_PIPE_KHR: Self = Self::BOTTOM_OF_PIPE; + pub const HOST: Self = Self(0b100_0000_0000_0000); + pub const HOST_KHR: Self = Self::HOST; + pub const ALL_GRAPHICS: Self = Self(0b1000_0000_0000_0000); + pub const ALL_GRAPHICS_KHR: Self = Self::ALL_GRAPHICS; + pub const ALL_COMMANDS: Self = Self(0b1_0000_0000_0000_0000); + pub const ALL_COMMANDS_KHR: Self = Self::ALL_COMMANDS; + pub const COPY: Self = Self(0b1_0000_0000_0000_0000_0000_0000_0000_0000); + pub const COPY_KHR: Self = Self::COPY; + pub const RESOLVE: Self = Self(0b10_0000_0000_0000_0000_0000_0000_0000_0000); + pub const RESOLVE_KHR: Self = Self::RESOLVE; + pub const BLIT: Self = Self(0b100_0000_0000_0000_0000_0000_0000_0000_0000); + pub const BLIT_KHR: Self = Self::BLIT; + pub const CLEAR: Self = Self(0b1000_0000_0000_0000_0000_0000_0000_0000_0000); + pub const CLEAR_KHR: Self = Self::CLEAR; + pub const INDEX_INPUT: Self = Self(0b1_0000_0000_0000_0000_0000_0000_0000_0000_0000); + pub const INDEX_INPUT_KHR: Self = Self::INDEX_INPUT; + pub const VERTEX_ATTRIBUTE_INPUT: Self = + Self(0b10_0000_0000_0000_0000_0000_0000_0000_0000_0000); + pub const VERTEX_ATTRIBUTE_INPUT_KHR: Self = Self::VERTEX_ATTRIBUTE_INPUT; + pub const PRE_RASTERIZATION_SHADERS: Self = + Self(0b100_0000_0000_0000_0000_0000_0000_0000_0000_0000); + pub const PRE_RASTERIZATION_SHADERS_KHR: Self = Self::PRE_RASTERIZATION_SHADERS; +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct SubmitFlags(pub(crate) Flags); +vk_bitflags_wrapped!(SubmitFlags, Flags); +impl SubmitFlags { + pub const PROTECTED: Self = Self(0b1); + pub const PROTECTED_KHR: Self = Self::PROTECTED; +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct EventCreateFlags(pub(crate) Flags); +vk_bitflags_wrapped!(EventCreateFlags, Flags); +impl EventCreateFlags {} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct PipelineLayoutCreateFlags(pub(crate) Flags); +vk_bitflags_wrapped!(PipelineLayoutCreateFlags, Flags); +impl PipelineLayoutCreateFlags {} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct PipelineColorBlendStateCreateFlags(pub(crate) Flags); +vk_bitflags_wrapped!(PipelineColorBlendStateCreateFlags, Flags); +impl PipelineColorBlendStateCreateFlags {} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct PipelineDepthStencilStateCreateFlags(pub(crate) Flags); +vk_bitflags_wrapped!(PipelineDepthStencilStateCreateFlags, Flags); +impl PipelineDepthStencilStateCreateFlags {} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct GraphicsPipelineLibraryFlagsEXT(pub(crate) Flags); +vk_bitflags_wrapped!(GraphicsPipelineLibraryFlagsEXT, Flags); +impl GraphicsPipelineLibraryFlagsEXT { + pub const VERTEX_INPUT_INTERFACE: Self = Self(0b1); + pub const PRE_RASTERIZATION_SHADERS: Self = Self(0b10); + pub const FRAGMENT_SHADER: Self = Self(0b100); + pub const FRAGMENT_OUTPUT_INTERFACE: Self = Self(0b1000); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct DeviceAddressBindingFlagsEXT(pub(crate) Flags); +vk_bitflags_wrapped!(DeviceAddressBindingFlagsEXT, Flags); +impl DeviceAddressBindingFlagsEXT { + pub const INTERNAL_OBJECT: Self = Self(0b1); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct PresentScalingFlagsEXT(pub(crate) Flags); +vk_bitflags_wrapped!(PresentScalingFlagsEXT, Flags); +impl PresentScalingFlagsEXT { + pub const ONE_TO_ONE: Self = Self(0b1); + pub const ASPECT_RATIO_STRETCH: Self = Self(0b10); + pub const STRETCH: Self = Self(0b100); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct PresentGravityFlagsEXT(pub(crate) Flags); +vk_bitflags_wrapped!(PresentGravityFlagsEXT, Flags); +impl PresentGravityFlagsEXT { + pub const MIN: Self = Self(0b1); + pub const MAX: Self = Self(0b10); + pub const CENTERED: Self = Self(0b100); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct VideoCodecOperationFlagsKHR(pub(crate) Flags); +vk_bitflags_wrapped!(VideoCodecOperationFlagsKHR, Flags); +impl VideoCodecOperationFlagsKHR { + pub const NONE: Self = Self(0); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct VideoChromaSubsamplingFlagsKHR(pub(crate) Flags); +vk_bitflags_wrapped!(VideoChromaSubsamplingFlagsKHR, Flags); +impl VideoChromaSubsamplingFlagsKHR { + pub const INVALID: Self = Self(0); + pub const MONOCHROME: Self = Self(0b1); + pub const TYPE_420: Self = Self(0b10); + pub const TYPE_422: Self = Self(0b100); + pub const TYPE_444: Self = Self(0b1000); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct VideoComponentBitDepthFlagsKHR(pub(crate) Flags); +vk_bitflags_wrapped!(VideoComponentBitDepthFlagsKHR, Flags); +impl VideoComponentBitDepthFlagsKHR { + pub const INVALID: Self = Self(0); + pub const TYPE_8: Self = Self(0b1); + pub const TYPE_10: Self = Self(0b100); + pub const TYPE_12: Self = Self(0b1_0000); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct VideoCapabilityFlagsKHR(pub(crate) Flags); +vk_bitflags_wrapped!(VideoCapabilityFlagsKHR, Flags); +impl VideoCapabilityFlagsKHR { + pub const PROTECTED_CONTENT: Self = Self(0b1); + pub const SEPARATE_REFERENCE_IMAGES: Self = Self(0b10); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct VideoSessionCreateFlagsKHR(pub(crate) Flags); +vk_bitflags_wrapped!(VideoSessionCreateFlagsKHR, Flags); +impl VideoSessionCreateFlagsKHR { + pub const PROTECTED_CONTENT: Self = Self(0b1); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct VideoDecodeH264PictureLayoutFlagsKHR(pub(crate) Flags); +vk_bitflags_wrapped!(VideoDecodeH264PictureLayoutFlagsKHR, Flags); +impl VideoDecodeH264PictureLayoutFlagsKHR { + pub const PROGRESSIVE: Self = Self(0); + pub const INTERLACED_INTERLEAVED_LINES: Self = Self(0b1); + pub const INTERLACED_SEPARATE_PLANES: Self = Self(0b10); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct VideoCodingControlFlagsKHR(pub(crate) Flags); +vk_bitflags_wrapped!(VideoCodingControlFlagsKHR, Flags); +impl VideoCodingControlFlagsKHR { + pub const RESET: Self = Self(0b1); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct VideoDecodeUsageFlagsKHR(pub(crate) Flags); +vk_bitflags_wrapped!(VideoDecodeUsageFlagsKHR, Flags); +impl VideoDecodeUsageFlagsKHR { + pub const DEFAULT: Self = Self(0); + pub const TRANSCODING: Self = Self(0b1); + pub const OFFLINE: Self = Self(0b10); + pub const STREAMING: Self = Self(0b100); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct VideoDecodeCapabilityFlagsKHR(pub(crate) Flags); +vk_bitflags_wrapped!(VideoDecodeCapabilityFlagsKHR, Flags); +impl VideoDecodeCapabilityFlagsKHR { + pub const DPB_AND_OUTPUT_COINCIDE: Self = Self(0b1); + pub const DPB_AND_OUTPUT_DISTINCT: Self = Self(0b10); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct VideoEncodeUsageFlagsKHR(pub(crate) Flags); +vk_bitflags_wrapped!(VideoEncodeUsageFlagsKHR, Flags); +impl VideoEncodeUsageFlagsKHR { + pub const DEFAULT: Self = Self(0); + pub const TRANSCODING: Self = Self(0b1); + pub const STREAMING: Self = Self(0b10); + pub const RECORDING: Self = Self(0b100); + pub const CONFERENCING: Self = Self(0b1000); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct VideoEncodeContentFlagsKHR(pub(crate) Flags); +vk_bitflags_wrapped!(VideoEncodeContentFlagsKHR, Flags); +impl VideoEncodeContentFlagsKHR { + pub const DEFAULT: Self = Self(0); + pub const CAMERA: Self = Self(0b1); + pub const DESKTOP: Self = Self(0b10); + pub const RENDERED: Self = Self(0b100); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct VideoEncodeCapabilityFlagsKHR(pub(crate) Flags); +vk_bitflags_wrapped!(VideoEncodeCapabilityFlagsKHR, Flags); +impl VideoEncodeCapabilityFlagsKHR { + pub const PRECEDING_EXTERNALLY_ENCODED_BYTES: Self = Self(0b1); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct VideoEncodeRateControlModeFlagsKHR(pub(crate) Flags); +vk_bitflags_wrapped!(VideoEncodeRateControlModeFlagsKHR, Flags); +impl VideoEncodeRateControlModeFlagsKHR { + pub const NONE: Self = Self(0); + pub const CBR: Self = Self(1); + pub const VBR: Self = Self(2); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct VideoEncodeH264CapabilityFlagsEXT(pub(crate) Flags); +vk_bitflags_wrapped!(VideoEncodeH264CapabilityFlagsEXT, Flags); +impl VideoEncodeH264CapabilityFlagsEXT { + pub const DIRECT_8X8_INFERENCE_ENABLED: Self = Self(0b1); + pub const DIRECT_8X8_INFERENCE_DISABLED: Self = Self(0b10); + pub const SEPARATE_COLOUR_PLANE: Self = Self(0b100); + pub const QPPRIME_Y_ZERO_TRANSFORM_BYPASS: Self = Self(0b1000); + pub const SCALING_LISTS: Self = Self(0b1_0000); + pub const HRD_COMPLIANCE: Self = Self(0b10_0000); + pub const CHROMA_QP_OFFSET: Self = Self(0b100_0000); + pub const SECOND_CHROMA_QP_OFFSET: Self = Self(0b1000_0000); + pub const PIC_INIT_QP_MINUS26: Self = Self(0b1_0000_0000); + pub const WEIGHTED_PRED: Self = Self(0b10_0000_0000); + pub const WEIGHTED_BIPRED_EXPLICIT: Self = Self(0b100_0000_0000); + pub const WEIGHTED_BIPRED_IMPLICIT: Self = Self(0b1000_0000_0000); + pub const WEIGHTED_PRED_NO_TABLE: Self = Self(0b1_0000_0000_0000); + pub const TRANSFORM_8X8: Self = Self(0b10_0000_0000_0000); + pub const CABAC: Self = Self(0b100_0000_0000_0000); + pub const CAVLC: Self = Self(0b1000_0000_0000_0000); + pub const DEBLOCKING_FILTER_DISABLED: Self = Self(0b1_0000_0000_0000_0000); + pub const DEBLOCKING_FILTER_ENABLED: Self = Self(0b10_0000_0000_0000_0000); + pub const DEBLOCKING_FILTER_PARTIAL: Self = Self(0b100_0000_0000_0000_0000); + pub const DISABLE_DIRECT_SPATIAL_MV_PRED: Self = Self(0b1000_0000_0000_0000_0000); + pub const MULTIPLE_SLICE_PER_FRAME: Self = Self(0b1_0000_0000_0000_0000_0000); + pub const SLICE_MB_COUNT: Self = Self(0b10_0000_0000_0000_0000_0000); + pub const ROW_UNALIGNED_SLICE: Self = Self(0b100_0000_0000_0000_0000_0000); + pub const DIFFERENT_SLICE_TYPE: Self = Self(0b1000_0000_0000_0000_0000_0000); + pub const B_FRAME_IN_L1_LIST: Self = Self(0b1_0000_0000_0000_0000_0000_0000); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct VideoEncodeH264InputModeFlagsEXT(pub(crate) Flags); +vk_bitflags_wrapped!(VideoEncodeH264InputModeFlagsEXT, Flags); +impl VideoEncodeH264InputModeFlagsEXT { + pub const FRAME: Self = Self(0b1); + pub const SLICE: Self = Self(0b10); + pub const NON_VCL: Self = Self(0b100); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct VideoEncodeH264OutputModeFlagsEXT(pub(crate) Flags); +vk_bitflags_wrapped!(VideoEncodeH264OutputModeFlagsEXT, Flags); +impl VideoEncodeH264OutputModeFlagsEXT { + pub const FRAME: Self = Self(0b1); + pub const SLICE: Self = Self(0b10); + pub const NON_VCL: Self = Self(0b100); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct ImageFormatConstraintsFlagsFUCHSIA(pub(crate) Flags); +vk_bitflags_wrapped!(ImageFormatConstraintsFlagsFUCHSIA, Flags); +impl ImageFormatConstraintsFlagsFUCHSIA {} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct ImageConstraintsInfoFlagsFUCHSIA(pub(crate) Flags); +vk_bitflags_wrapped!(ImageConstraintsInfoFlagsFUCHSIA, Flags); +impl ImageConstraintsInfoFlagsFUCHSIA { + pub const CPU_READ_RARELY: Self = Self(0b1); + pub const CPU_READ_OFTEN: Self = Self(0b10); + pub const CPU_WRITE_RARELY: Self = Self(0b100); + pub const CPU_WRITE_OFTEN: Self = Self(0b1000); + pub const PROTECTED_OPTIONAL: Self = Self(0b1_0000); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct FormatFeatureFlags2(pub(crate) Flags64); +vk_bitflags_wrapped!(FormatFeatureFlags2, Flags64); +impl FormatFeatureFlags2 { + pub const SAMPLED_IMAGE: Self = Self(0b1); + pub const SAMPLED_IMAGE_KHR: Self = Self::SAMPLED_IMAGE; + pub const STORAGE_IMAGE: Self = Self(0b10); + pub const STORAGE_IMAGE_KHR: Self = Self::STORAGE_IMAGE; + pub const STORAGE_IMAGE_ATOMIC: Self = Self(0b100); + pub const STORAGE_IMAGE_ATOMIC_KHR: Self = Self::STORAGE_IMAGE_ATOMIC; + pub const UNIFORM_TEXEL_BUFFER: Self = Self(0b1000); + pub const UNIFORM_TEXEL_BUFFER_KHR: Self = Self::UNIFORM_TEXEL_BUFFER; + pub const STORAGE_TEXEL_BUFFER: Self = Self(0b1_0000); + pub const STORAGE_TEXEL_BUFFER_KHR: Self = Self::STORAGE_TEXEL_BUFFER; + pub const STORAGE_TEXEL_BUFFER_ATOMIC: Self = Self(0b10_0000); + pub const STORAGE_TEXEL_BUFFER_ATOMIC_KHR: Self = Self::STORAGE_TEXEL_BUFFER_ATOMIC; + pub const VERTEX_BUFFER: Self = Self(0b100_0000); + pub const VERTEX_BUFFER_KHR: Self = Self::VERTEX_BUFFER; + pub const COLOR_ATTACHMENT: Self = Self(0b1000_0000); + pub const COLOR_ATTACHMENT_KHR: Self = Self::COLOR_ATTACHMENT; + pub const COLOR_ATTACHMENT_BLEND: Self = Self(0b1_0000_0000); + pub const COLOR_ATTACHMENT_BLEND_KHR: Self = Self::COLOR_ATTACHMENT_BLEND; + pub const DEPTH_STENCIL_ATTACHMENT: Self = Self(0b10_0000_0000); + pub const DEPTH_STENCIL_ATTACHMENT_KHR: Self = Self::DEPTH_STENCIL_ATTACHMENT; + pub const BLIT_SRC: Self = Self(0b100_0000_0000); + pub const BLIT_SRC_KHR: Self = Self::BLIT_SRC; + pub const BLIT_DST: Self = Self(0b1000_0000_0000); + pub const BLIT_DST_KHR: Self = Self::BLIT_DST; + pub const SAMPLED_IMAGE_FILTER_LINEAR: Self = Self(0b1_0000_0000_0000); + pub const SAMPLED_IMAGE_FILTER_LINEAR_KHR: Self = Self::SAMPLED_IMAGE_FILTER_LINEAR; + pub const SAMPLED_IMAGE_FILTER_CUBIC: Self = Self(0b10_0000_0000_0000); + pub const SAMPLED_IMAGE_FILTER_CUBIC_EXT: Self = Self::SAMPLED_IMAGE_FILTER_CUBIC; + pub const TRANSFER_SRC: Self = Self(0b100_0000_0000_0000); + pub const TRANSFER_SRC_KHR: Self = Self::TRANSFER_SRC; + pub const TRANSFER_DST: Self = Self(0b1000_0000_0000_0000); + pub const TRANSFER_DST_KHR: Self = Self::TRANSFER_DST; + pub const SAMPLED_IMAGE_FILTER_MINMAX: Self = Self(0b1_0000_0000_0000_0000); + pub const SAMPLED_IMAGE_FILTER_MINMAX_KHR: Self = Self::SAMPLED_IMAGE_FILTER_MINMAX; + pub const MIDPOINT_CHROMA_SAMPLES: Self = Self(0b10_0000_0000_0000_0000); + pub const MIDPOINT_CHROMA_SAMPLES_KHR: Self = Self::MIDPOINT_CHROMA_SAMPLES; + pub const SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER: Self = Self(0b100_0000_0000_0000_0000); + pub const SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_KHR: Self = + Self::SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER; + pub const SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER: Self = + Self(0b1000_0000_0000_0000_0000); + pub const SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_KHR: Self = + Self::SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER; + pub const SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT: Self = + Self(0b1_0000_0000_0000_0000_0000); + pub const SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_KHR: Self = + Self::SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT; + pub const SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE: Self = + Self(0b10_0000_0000_0000_0000_0000); + pub const SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_KHR: Self = + Self::SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE; + pub const DISJOINT: Self = Self(0b100_0000_0000_0000_0000_0000); + pub const DISJOINT_KHR: Self = Self::DISJOINT; + pub const COSITED_CHROMA_SAMPLES: Self = Self(0b1000_0000_0000_0000_0000_0000); + pub const COSITED_CHROMA_SAMPLES_KHR: Self = Self::COSITED_CHROMA_SAMPLES; + pub const STORAGE_READ_WITHOUT_FORMAT: Self = Self(0b1000_0000_0000_0000_0000_0000_0000_0000); + pub const STORAGE_READ_WITHOUT_FORMAT_KHR: Self = Self::STORAGE_READ_WITHOUT_FORMAT; + pub const STORAGE_WRITE_WITHOUT_FORMAT: Self = + Self(0b1_0000_0000_0000_0000_0000_0000_0000_0000); + pub const STORAGE_WRITE_WITHOUT_FORMAT_KHR: Self = Self::STORAGE_WRITE_WITHOUT_FORMAT; + pub const SAMPLED_IMAGE_DEPTH_COMPARISON: Self = + Self(0b10_0000_0000_0000_0000_0000_0000_0000_0000); + pub const SAMPLED_IMAGE_DEPTH_COMPARISON_KHR: Self = Self::SAMPLED_IMAGE_DEPTH_COMPARISON; +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct RenderingFlags(pub(crate) Flags); +vk_bitflags_wrapped!(RenderingFlags, Flags); +impl RenderingFlags { + pub const CONTENTS_SECONDARY_COMMAND_BUFFERS: Self = Self(0b1); + pub const CONTENTS_SECONDARY_COMMAND_BUFFERS_KHR: Self = + Self::CONTENTS_SECONDARY_COMMAND_BUFFERS; + pub const SUSPENDING: Self = Self(0b10); + pub const SUSPENDING_KHR: Self = Self::SUSPENDING; + pub const RESUMING: Self = Self(0b100); + pub const RESUMING_KHR: Self = Self::RESUMING; +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct VideoEncodeH265CapabilityFlagsEXT(pub(crate) Flags); +vk_bitflags_wrapped!(VideoEncodeH265CapabilityFlagsEXT, Flags); +impl VideoEncodeH265CapabilityFlagsEXT { + pub const SEPARATE_COLOUR_PLANE: Self = Self(0b1); + pub const SCALING_LISTS: Self = Self(0b10); + pub const SAMPLE_ADAPTIVE_OFFSET_ENABLED: Self = Self(0b100); + pub const PCM_ENABLE: Self = Self(0b1000); + pub const SPS_TEMPORAL_MVP_ENABLED: Self = Self(0b1_0000); + pub const HRD_COMPLIANCE: Self = Self(0b10_0000); + pub const INIT_QP_MINUS26: Self = Self(0b100_0000); + pub const LOG2_PARALLEL_MERGE_LEVEL_MINUS2: Self = Self(0b1000_0000); + pub const SIGN_DATA_HIDING_ENABLED: Self = Self(0b1_0000_0000); + pub const TRANSFORM_SKIP_ENABLED: Self = Self(0b10_0000_0000); + pub const TRANSFORM_SKIP_DISABLED: Self = Self(0b100_0000_0000); + pub const PPS_SLICE_CHROMA_QP_OFFSETS_PRESENT: Self = Self(0b1000_0000_0000); + pub const WEIGHTED_PRED: Self = Self(0b1_0000_0000_0000); + pub const WEIGHTED_BIPRED: Self = Self(0b10_0000_0000_0000); + pub const WEIGHTED_PRED_NO_TABLE: Self = Self(0b100_0000_0000_0000); + pub const TRANSQUANT_BYPASS_ENABLED: Self = Self(0b1000_0000_0000_0000); + pub const ENTROPY_CODING_SYNC_ENABLED: Self = Self(0b1_0000_0000_0000_0000); + pub const DEBLOCKING_FILTER_OVERRIDE_ENABLED: Self = Self(0b10_0000_0000_0000_0000); + pub const MULTIPLE_TILE_PER_FRAME: Self = Self(0b100_0000_0000_0000_0000); + pub const MULTIPLE_SLICE_PER_TILE: Self = Self(0b1000_0000_0000_0000_0000); + pub const MULTIPLE_TILE_PER_SLICE: Self = Self(0b1_0000_0000_0000_0000_0000); + pub const SLICE_SEGMENT_CTB_COUNT: Self = Self(0b10_0000_0000_0000_0000_0000); + pub const ROW_UNALIGNED_SLICE_SEGMENT: Self = Self(0b100_0000_0000_0000_0000_0000); + pub const DEPENDENT_SLICE_SEGMENT: Self = Self(0b1000_0000_0000_0000_0000_0000); + pub const DIFFERENT_SLICE_TYPE: Self = Self(0b1_0000_0000_0000_0000_0000_0000); + pub const B_FRAME_IN_L1_LIST: Self = Self(0b10_0000_0000_0000_0000_0000_0000); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct VideoEncodeH265InputModeFlagsEXT(pub(crate) Flags); +vk_bitflags_wrapped!(VideoEncodeH265InputModeFlagsEXT, Flags); +impl VideoEncodeH265InputModeFlagsEXT { + pub const FRAME: Self = Self(0b1); + pub const SLICE_SEGMENT: Self = Self(0b10); + pub const NON_VCL: Self = Self(0b100); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct VideoEncodeH265OutputModeFlagsEXT(pub(crate) Flags); +vk_bitflags_wrapped!(VideoEncodeH265OutputModeFlagsEXT, Flags); +impl VideoEncodeH265OutputModeFlagsEXT { + pub const FRAME: Self = Self(0b1); + pub const SLICE_SEGMENT: Self = Self(0b10); + pub const NON_VCL: Self = Self(0b100); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct VideoEncodeH265CtbSizeFlagsEXT(pub(crate) Flags); +vk_bitflags_wrapped!(VideoEncodeH265CtbSizeFlagsEXT, Flags); +impl VideoEncodeH265CtbSizeFlagsEXT { + pub const TYPE_16: Self = Self(0b1); + pub const TYPE_32: Self = Self(0b10); + pub const TYPE_64: Self = Self(0b100); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct VideoEncodeH265TransformBlockSizeFlagsEXT(pub(crate) Flags); +vk_bitflags_wrapped!(VideoEncodeH265TransformBlockSizeFlagsEXT, Flags); +impl VideoEncodeH265TransformBlockSizeFlagsEXT { + pub const TYPE_4: Self = Self(0b1); + pub const TYPE_8: Self = Self(0b10); + pub const TYPE_16: Self = Self(0b100); + pub const TYPE_32: Self = Self(0b1000); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct ExportMetalObjectTypeFlagsEXT(pub(crate) Flags); +vk_bitflags_wrapped!(ExportMetalObjectTypeFlagsEXT, Flags); +impl ExportMetalObjectTypeFlagsEXT { + pub const METAL_DEVICE: Self = Self(0b1); + pub const METAL_COMMAND_QUEUE: Self = Self(0b10); + pub const METAL_BUFFER: Self = Self(0b100); + pub const METAL_TEXTURE: Self = Self(0b1000); + pub const METAL_IOSURFACE: Self = Self(0b1_0000); + pub const METAL_SHARED_EVENT: Self = Self(0b10_0000); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct InstanceCreateFlags(pub(crate) Flags); +vk_bitflags_wrapped!(InstanceCreateFlags, Flags); +impl InstanceCreateFlags {} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct ImageCompressionFlagsEXT(pub(crate) Flags); +vk_bitflags_wrapped!(ImageCompressionFlagsEXT, Flags); +impl ImageCompressionFlagsEXT { + pub const DEFAULT: Self = Self(0); + pub const FIXED_RATE_DEFAULT: Self = Self(0b1); + pub const FIXED_RATE_EXPLICIT: Self = Self(0b10); + pub const DISABLED: Self = Self(0b100); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct ImageCompressionFixedRateFlagsEXT(pub(crate) Flags); +vk_bitflags_wrapped!(ImageCompressionFixedRateFlagsEXT, Flags); +impl ImageCompressionFixedRateFlagsEXT { + pub const NONE: Self = Self(0); + pub const TYPE_1BPC: Self = Self(0b1); + pub const TYPE_2BPC: Self = Self(0b10); + pub const TYPE_3BPC: Self = Self(0b100); + pub const TYPE_4BPC: Self = Self(0b1000); + pub const TYPE_5BPC: Self = Self(0b1_0000); + pub const TYPE_6BPC: Self = Self(0b10_0000); + pub const TYPE_7BPC: Self = Self(0b100_0000); + pub const TYPE_8BPC: Self = Self(0b1000_0000); + pub const TYPE_9BPC: Self = Self(0b1_0000_0000); + pub const TYPE_10BPC: Self = Self(0b10_0000_0000); + pub const TYPE_11BPC: Self = Self(0b100_0000_0000); + pub const TYPE_12BPC: Self = Self(0b1000_0000_0000); + pub const TYPE_13BPC: Self = Self(0b1_0000_0000_0000); + pub const TYPE_14BPC: Self = Self(0b10_0000_0000_0000); + pub const TYPE_15BPC: Self = Self(0b100_0000_0000_0000); + pub const TYPE_16BPC: Self = Self(0b1000_0000_0000_0000); + pub const TYPE_17BPC: Self = Self(0b1_0000_0000_0000_0000); + pub const TYPE_18BPC: Self = Self(0b10_0000_0000_0000_0000); + pub const TYPE_19BPC: Self = Self(0b100_0000_0000_0000_0000); + pub const TYPE_20BPC: Self = Self(0b1000_0000_0000_0000_0000); + pub const TYPE_21BPC: Self = Self(0b1_0000_0000_0000_0000_0000); + pub const TYPE_22BPC: Self = Self(0b10_0000_0000_0000_0000_0000); + pub const TYPE_23BPC: Self = Self(0b100_0000_0000_0000_0000_0000); + pub const TYPE_24BPC: Self = Self(0b1000_0000_0000_0000_0000_0000); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct OpticalFlowGridSizeFlagsNV(pub(crate) Flags); +vk_bitflags_wrapped!(OpticalFlowGridSizeFlagsNV, Flags); +impl OpticalFlowGridSizeFlagsNV { + pub const UNKNOWN: Self = Self(0); + pub const TYPE_1X1: Self = Self(0b1); + pub const TYPE_2X2: Self = Self(0b10); + pub const TYPE_4X4: Self = Self(0b100); + pub const TYPE_8X8: Self = Self(0b1000); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct OpticalFlowUsageFlagsNV(pub(crate) Flags); +vk_bitflags_wrapped!(OpticalFlowUsageFlagsNV, Flags); +impl OpticalFlowUsageFlagsNV { + pub const UNKNOWN: Self = Self(0); + pub const INPUT: Self = Self(0b1); + pub const OUTPUT: Self = Self(0b10); + pub const HINT: Self = Self(0b100); + pub const COST: Self = Self(0b1000); + pub const GLOBAL_FLOW: Self = Self(0b1_0000); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct OpticalFlowSessionCreateFlagsNV(pub(crate) Flags); +vk_bitflags_wrapped!(OpticalFlowSessionCreateFlagsNV, Flags); +impl OpticalFlowSessionCreateFlagsNV { + pub const ENABLE_HINT: Self = Self(0b1); + pub const ENABLE_COST: Self = Self(0b10); + pub const ENABLE_GLOBAL_FLOW: Self = Self(0b100); + pub const ALLOW_REGIONS: Self = Self(0b1000); + pub const BOTH_DIRECTIONS: Self = Self(0b1_0000); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct OpticalFlowExecuteFlagsNV(pub(crate) Flags); +vk_bitflags_wrapped!(OpticalFlowExecuteFlagsNV, Flags); +impl OpticalFlowExecuteFlagsNV { + pub const DISABLE_TEMPORAL_HINTS: Self = Self(0b1); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct BuildMicromapFlagsEXT(pub(crate) Flags); +vk_bitflags_wrapped!(BuildMicromapFlagsEXT, Flags); +impl BuildMicromapFlagsEXT { + pub const PREFER_FAST_TRACE: Self = Self(0b1); + pub const PREFER_FAST_BUILD: Self = Self(0b10); + pub const ALLOW_COMPACTION: Self = Self(0b100); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct MicromapCreateFlagsEXT(pub(crate) Flags); +vk_bitflags_wrapped!(MicromapCreateFlagsEXT, Flags); +impl MicromapCreateFlagsEXT { + pub const DEVICE_ADDRESS_CAPTURE_REPLAY: Self = Self(0b1); +} diff --git a/third_party/rust/ash/src/vk/const_debugs.rs b/third_party/rust/ash/src/vk/const_debugs.rs new file mode 100644 index 0000000000..6508306e30 --- /dev/null +++ b/third_party/rust/ash/src/vk/const_debugs.rs @@ -0,0 +1,7167 @@ +use crate::prelude::debug_flags; +use crate::vk::bitflags::*; +use crate::vk::definitions::*; +use crate::vk::enums::*; +use std::fmt; +impl fmt::Debug for AccelerationStructureBuildTypeKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::HOST => Some("HOST"), + Self::DEVICE => Some("DEVICE"), + Self::HOST_OR_DEVICE => Some("HOST_OR_DEVICE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for AccelerationStructureCompatibilityKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::COMPATIBLE => Some("COMPATIBLE"), + Self::INCOMPATIBLE => Some("INCOMPATIBLE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for AccelerationStructureCreateFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + AccelerationStructureCreateFlagsKHR::DEVICE_ADDRESS_CAPTURE_REPLAY.0, + "DEVICE_ADDRESS_CAPTURE_REPLAY", + ), + ( + AccelerationStructureCreateFlagsKHR::DESCRIPTOR_BUFFER_CAPTURE_REPLAY_EXT.0, + "DESCRIPTOR_BUFFER_CAPTURE_REPLAY_EXT", + ), + ( + AccelerationStructureCreateFlagsKHR::MOTION_NV.0, + "MOTION_NV", + ), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for AccelerationStructureMemoryRequirementsTypeNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::OBJECT => Some("OBJECT"), + Self::BUILD_SCRATCH => Some("BUILD_SCRATCH"), + Self::UPDATE_SCRATCH => Some("UPDATE_SCRATCH"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for AccelerationStructureMotionInfoFlagsNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for AccelerationStructureMotionInstanceFlagsNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for AccelerationStructureMotionInstanceTypeNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::STATIC => Some("STATIC"), + Self::MATRIX_MOTION => Some("MATRIX_MOTION"), + Self::SRT_MOTION => Some("SRT_MOTION"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for AccelerationStructureTypeKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::TOP_LEVEL => Some("TOP_LEVEL"), + Self::BOTTOM_LEVEL => Some("BOTTOM_LEVEL"), + Self::GENERIC => Some("GENERIC"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for AccessFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + AccessFlags::INDIRECT_COMMAND_READ.0, + "INDIRECT_COMMAND_READ", + ), + (AccessFlags::INDEX_READ.0, "INDEX_READ"), + ( + AccessFlags::VERTEX_ATTRIBUTE_READ.0, + "VERTEX_ATTRIBUTE_READ", + ), + (AccessFlags::UNIFORM_READ.0, "UNIFORM_READ"), + ( + AccessFlags::INPUT_ATTACHMENT_READ.0, + "INPUT_ATTACHMENT_READ", + ), + (AccessFlags::SHADER_READ.0, "SHADER_READ"), + (AccessFlags::SHADER_WRITE.0, "SHADER_WRITE"), + ( + AccessFlags::COLOR_ATTACHMENT_READ.0, + "COLOR_ATTACHMENT_READ", + ), + ( + AccessFlags::COLOR_ATTACHMENT_WRITE.0, + "COLOR_ATTACHMENT_WRITE", + ), + ( + AccessFlags::DEPTH_STENCIL_ATTACHMENT_READ.0, + "DEPTH_STENCIL_ATTACHMENT_READ", + ), + ( + AccessFlags::DEPTH_STENCIL_ATTACHMENT_WRITE.0, + "DEPTH_STENCIL_ATTACHMENT_WRITE", + ), + (AccessFlags::TRANSFER_READ.0, "TRANSFER_READ"), + (AccessFlags::TRANSFER_WRITE.0, "TRANSFER_WRITE"), + (AccessFlags::HOST_READ.0, "HOST_READ"), + (AccessFlags::HOST_WRITE.0, "HOST_WRITE"), + (AccessFlags::MEMORY_READ.0, "MEMORY_READ"), + (AccessFlags::MEMORY_WRITE.0, "MEMORY_WRITE"), + ( + AccessFlags::TRANSFORM_FEEDBACK_WRITE_EXT.0, + "TRANSFORM_FEEDBACK_WRITE_EXT", + ), + ( + AccessFlags::TRANSFORM_FEEDBACK_COUNTER_READ_EXT.0, + "TRANSFORM_FEEDBACK_COUNTER_READ_EXT", + ), + ( + AccessFlags::TRANSFORM_FEEDBACK_COUNTER_WRITE_EXT.0, + "TRANSFORM_FEEDBACK_COUNTER_WRITE_EXT", + ), + ( + AccessFlags::CONDITIONAL_RENDERING_READ_EXT.0, + "CONDITIONAL_RENDERING_READ_EXT", + ), + ( + AccessFlags::COLOR_ATTACHMENT_READ_NONCOHERENT_EXT.0, + "COLOR_ATTACHMENT_READ_NONCOHERENT_EXT", + ), + ( + AccessFlags::ACCELERATION_STRUCTURE_READ_KHR.0, + "ACCELERATION_STRUCTURE_READ_KHR", + ), + ( + AccessFlags::ACCELERATION_STRUCTURE_WRITE_KHR.0, + "ACCELERATION_STRUCTURE_WRITE_KHR", + ), + ( + AccessFlags::FRAGMENT_DENSITY_MAP_READ_EXT.0, + "FRAGMENT_DENSITY_MAP_READ_EXT", + ), + ( + AccessFlags::FRAGMENT_SHADING_RATE_ATTACHMENT_READ_KHR.0, + "FRAGMENT_SHADING_RATE_ATTACHMENT_READ_KHR", + ), + ( + AccessFlags::COMMAND_PREPROCESS_READ_NV.0, + "COMMAND_PREPROCESS_READ_NV", + ), + ( + AccessFlags::COMMAND_PREPROCESS_WRITE_NV.0, + "COMMAND_PREPROCESS_WRITE_NV", + ), + (AccessFlags::NONE.0, "NONE"), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for AccessFlags2 { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags64, &str)] = &[ + (AccessFlags2::NONE.0, "NONE"), + ( + AccessFlags2::INDIRECT_COMMAND_READ.0, + "INDIRECT_COMMAND_READ", + ), + (AccessFlags2::INDEX_READ.0, "INDEX_READ"), + ( + AccessFlags2::VERTEX_ATTRIBUTE_READ.0, + "VERTEX_ATTRIBUTE_READ", + ), + (AccessFlags2::UNIFORM_READ.0, "UNIFORM_READ"), + ( + AccessFlags2::INPUT_ATTACHMENT_READ.0, + "INPUT_ATTACHMENT_READ", + ), + (AccessFlags2::SHADER_READ.0, "SHADER_READ"), + (AccessFlags2::SHADER_WRITE.0, "SHADER_WRITE"), + ( + AccessFlags2::COLOR_ATTACHMENT_READ.0, + "COLOR_ATTACHMENT_READ", + ), + ( + AccessFlags2::COLOR_ATTACHMENT_WRITE.0, + "COLOR_ATTACHMENT_WRITE", + ), + ( + AccessFlags2::DEPTH_STENCIL_ATTACHMENT_READ.0, + "DEPTH_STENCIL_ATTACHMENT_READ", + ), + ( + AccessFlags2::DEPTH_STENCIL_ATTACHMENT_WRITE.0, + "DEPTH_STENCIL_ATTACHMENT_WRITE", + ), + (AccessFlags2::TRANSFER_READ.0, "TRANSFER_READ"), + (AccessFlags2::TRANSFER_WRITE.0, "TRANSFER_WRITE"), + (AccessFlags2::HOST_READ.0, "HOST_READ"), + (AccessFlags2::HOST_WRITE.0, "HOST_WRITE"), + (AccessFlags2::MEMORY_READ.0, "MEMORY_READ"), + (AccessFlags2::MEMORY_WRITE.0, "MEMORY_WRITE"), + (AccessFlags2::SHADER_SAMPLED_READ.0, "SHADER_SAMPLED_READ"), + (AccessFlags2::SHADER_STORAGE_READ.0, "SHADER_STORAGE_READ"), + (AccessFlags2::SHADER_STORAGE_WRITE.0, "SHADER_STORAGE_WRITE"), + ( + AccessFlags2::VIDEO_DECODE_READ_KHR.0, + "VIDEO_DECODE_READ_KHR", + ), + ( + AccessFlags2::VIDEO_DECODE_WRITE_KHR.0, + "VIDEO_DECODE_WRITE_KHR", + ), + (AccessFlags2::RESERVED_46_EXT.0, "RESERVED_46_EXT"), + ( + AccessFlags2::VIDEO_ENCODE_READ_KHR.0, + "VIDEO_ENCODE_READ_KHR", + ), + ( + AccessFlags2::VIDEO_ENCODE_WRITE_KHR.0, + "VIDEO_ENCODE_WRITE_KHR", + ), + ( + AccessFlags2::TRANSFORM_FEEDBACK_WRITE_EXT.0, + "TRANSFORM_FEEDBACK_WRITE_EXT", + ), + ( + AccessFlags2::TRANSFORM_FEEDBACK_COUNTER_READ_EXT.0, + "TRANSFORM_FEEDBACK_COUNTER_READ_EXT", + ), + ( + AccessFlags2::TRANSFORM_FEEDBACK_COUNTER_WRITE_EXT.0, + "TRANSFORM_FEEDBACK_COUNTER_WRITE_EXT", + ), + ( + AccessFlags2::CONDITIONAL_RENDERING_READ_EXT.0, + "CONDITIONAL_RENDERING_READ_EXT", + ), + ( + AccessFlags2::COMMAND_PREPROCESS_READ_NV.0, + "COMMAND_PREPROCESS_READ_NV", + ), + ( + AccessFlags2::COMMAND_PREPROCESS_WRITE_NV.0, + "COMMAND_PREPROCESS_WRITE_NV", + ), + ( + AccessFlags2::FRAGMENT_SHADING_RATE_ATTACHMENT_READ_KHR.0, + "FRAGMENT_SHADING_RATE_ATTACHMENT_READ_KHR", + ), + ( + AccessFlags2::ACCELERATION_STRUCTURE_READ_KHR.0, + "ACCELERATION_STRUCTURE_READ_KHR", + ), + ( + AccessFlags2::ACCELERATION_STRUCTURE_WRITE_KHR.0, + "ACCELERATION_STRUCTURE_WRITE_KHR", + ), + ( + AccessFlags2::FRAGMENT_DENSITY_MAP_READ_EXT.0, + "FRAGMENT_DENSITY_MAP_READ_EXT", + ), + ( + AccessFlags2::COLOR_ATTACHMENT_READ_NONCOHERENT_EXT.0, + "COLOR_ATTACHMENT_READ_NONCOHERENT_EXT", + ), + ( + AccessFlags2::DESCRIPTOR_BUFFER_READ_EXT.0, + "DESCRIPTOR_BUFFER_READ_EXT", + ), + ( + AccessFlags2::INVOCATION_MASK_READ_HUAWEI.0, + "INVOCATION_MASK_READ_HUAWEI", + ), + ( + AccessFlags2::SHADER_BINDING_TABLE_READ_KHR.0, + "SHADER_BINDING_TABLE_READ_KHR", + ), + (AccessFlags2::MICROMAP_READ_EXT.0, "MICROMAP_READ_EXT"), + (AccessFlags2::MICROMAP_WRITE_EXT.0, "MICROMAP_WRITE_EXT"), + (AccessFlags2::OPTICAL_FLOW_READ_NV.0, "OPTICAL_FLOW_READ_NV"), + ( + AccessFlags2::OPTICAL_FLOW_WRITE_NV.0, + "OPTICAL_FLOW_WRITE_NV", + ), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for AcquireProfilingLockFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for AndroidSurfaceCreateFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for AttachmentDescriptionFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(AttachmentDescriptionFlags::MAY_ALIAS.0, "MAY_ALIAS")]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for AttachmentLoadOp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::LOAD => Some("LOAD"), + Self::CLEAR => Some("CLEAR"), + Self::DONT_CARE => Some("DONT_CARE"), + Self::NONE_EXT => Some("NONE_EXT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for AttachmentStoreOp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::STORE => Some("STORE"), + Self::DONT_CARE => Some("DONT_CARE"), + Self::NONE => Some("NONE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for BlendFactor { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ZERO => Some("ZERO"), + Self::ONE => Some("ONE"), + Self::SRC_COLOR => Some("SRC_COLOR"), + Self::ONE_MINUS_SRC_COLOR => Some("ONE_MINUS_SRC_COLOR"), + Self::DST_COLOR => Some("DST_COLOR"), + Self::ONE_MINUS_DST_COLOR => Some("ONE_MINUS_DST_COLOR"), + Self::SRC_ALPHA => Some("SRC_ALPHA"), + Self::ONE_MINUS_SRC_ALPHA => Some("ONE_MINUS_SRC_ALPHA"), + Self::DST_ALPHA => Some("DST_ALPHA"), + Self::ONE_MINUS_DST_ALPHA => Some("ONE_MINUS_DST_ALPHA"), + Self::CONSTANT_COLOR => Some("CONSTANT_COLOR"), + Self::ONE_MINUS_CONSTANT_COLOR => Some("ONE_MINUS_CONSTANT_COLOR"), + Self::CONSTANT_ALPHA => Some("CONSTANT_ALPHA"), + Self::ONE_MINUS_CONSTANT_ALPHA => Some("ONE_MINUS_CONSTANT_ALPHA"), + Self::SRC_ALPHA_SATURATE => Some("SRC_ALPHA_SATURATE"), + Self::SRC1_COLOR => Some("SRC1_COLOR"), + Self::ONE_MINUS_SRC1_COLOR => Some("ONE_MINUS_SRC1_COLOR"), + Self::SRC1_ALPHA => Some("SRC1_ALPHA"), + Self::ONE_MINUS_SRC1_ALPHA => Some("ONE_MINUS_SRC1_ALPHA"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for BlendOp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ADD => Some("ADD"), + Self::SUBTRACT => Some("SUBTRACT"), + Self::REVERSE_SUBTRACT => Some("REVERSE_SUBTRACT"), + Self::MIN => Some("MIN"), + Self::MAX => Some("MAX"), + Self::ZERO_EXT => Some("ZERO_EXT"), + Self::SRC_EXT => Some("SRC_EXT"), + Self::DST_EXT => Some("DST_EXT"), + Self::SRC_OVER_EXT => Some("SRC_OVER_EXT"), + Self::DST_OVER_EXT => Some("DST_OVER_EXT"), + Self::SRC_IN_EXT => Some("SRC_IN_EXT"), + Self::DST_IN_EXT => Some("DST_IN_EXT"), + Self::SRC_OUT_EXT => Some("SRC_OUT_EXT"), + Self::DST_OUT_EXT => Some("DST_OUT_EXT"), + Self::SRC_ATOP_EXT => Some("SRC_ATOP_EXT"), + Self::DST_ATOP_EXT => Some("DST_ATOP_EXT"), + Self::XOR_EXT => Some("XOR_EXT"), + Self::MULTIPLY_EXT => Some("MULTIPLY_EXT"), + Self::SCREEN_EXT => Some("SCREEN_EXT"), + Self::OVERLAY_EXT => Some("OVERLAY_EXT"), + Self::DARKEN_EXT => Some("DARKEN_EXT"), + Self::LIGHTEN_EXT => Some("LIGHTEN_EXT"), + Self::COLORDODGE_EXT => Some("COLORDODGE_EXT"), + Self::COLORBURN_EXT => Some("COLORBURN_EXT"), + Self::HARDLIGHT_EXT => Some("HARDLIGHT_EXT"), + Self::SOFTLIGHT_EXT => Some("SOFTLIGHT_EXT"), + Self::DIFFERENCE_EXT => Some("DIFFERENCE_EXT"), + Self::EXCLUSION_EXT => Some("EXCLUSION_EXT"), + Self::INVERT_EXT => Some("INVERT_EXT"), + Self::INVERT_RGB_EXT => Some("INVERT_RGB_EXT"), + Self::LINEARDODGE_EXT => Some("LINEARDODGE_EXT"), + Self::LINEARBURN_EXT => Some("LINEARBURN_EXT"), + Self::VIVIDLIGHT_EXT => Some("VIVIDLIGHT_EXT"), + Self::LINEARLIGHT_EXT => Some("LINEARLIGHT_EXT"), + Self::PINLIGHT_EXT => Some("PINLIGHT_EXT"), + Self::HARDMIX_EXT => Some("HARDMIX_EXT"), + Self::HSL_HUE_EXT => Some("HSL_HUE_EXT"), + Self::HSL_SATURATION_EXT => Some("HSL_SATURATION_EXT"), + Self::HSL_COLOR_EXT => Some("HSL_COLOR_EXT"), + Self::HSL_LUMINOSITY_EXT => Some("HSL_LUMINOSITY_EXT"), + Self::PLUS_EXT => Some("PLUS_EXT"), + Self::PLUS_CLAMPED_EXT => Some("PLUS_CLAMPED_EXT"), + Self::PLUS_CLAMPED_ALPHA_EXT => Some("PLUS_CLAMPED_ALPHA_EXT"), + Self::PLUS_DARKER_EXT => Some("PLUS_DARKER_EXT"), + Self::MINUS_EXT => Some("MINUS_EXT"), + Self::MINUS_CLAMPED_EXT => Some("MINUS_CLAMPED_EXT"), + Self::CONTRAST_EXT => Some("CONTRAST_EXT"), + Self::INVERT_OVG_EXT => Some("INVERT_OVG_EXT"), + Self::RED_EXT => Some("RED_EXT"), + Self::GREEN_EXT => Some("GREEN_EXT"), + Self::BLUE_EXT => Some("BLUE_EXT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for BlendOverlapEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UNCORRELATED => Some("UNCORRELATED"), + Self::DISJOINT => Some("DISJOINT"), + Self::CONJOINT => Some("CONJOINT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for BorderColor { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::FLOAT_TRANSPARENT_BLACK => Some("FLOAT_TRANSPARENT_BLACK"), + Self::INT_TRANSPARENT_BLACK => Some("INT_TRANSPARENT_BLACK"), + Self::FLOAT_OPAQUE_BLACK => Some("FLOAT_OPAQUE_BLACK"), + Self::INT_OPAQUE_BLACK => Some("INT_OPAQUE_BLACK"), + Self::FLOAT_OPAQUE_WHITE => Some("FLOAT_OPAQUE_WHITE"), + Self::INT_OPAQUE_WHITE => Some("INT_OPAQUE_WHITE"), + Self::FLOAT_CUSTOM_EXT => Some("FLOAT_CUSTOM_EXT"), + Self::INT_CUSTOM_EXT => Some("INT_CUSTOM_EXT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for BufferCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (BufferCreateFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), + (BufferCreateFlags::SPARSE_RESIDENCY.0, "SPARSE_RESIDENCY"), + (BufferCreateFlags::SPARSE_ALIASED.0, "SPARSE_ALIASED"), + ( + BufferCreateFlags::DESCRIPTOR_BUFFER_CAPTURE_REPLAY_EXT.0, + "DESCRIPTOR_BUFFER_CAPTURE_REPLAY_EXT", + ), + (BufferCreateFlags::PROTECTED.0, "PROTECTED"), + ( + BufferCreateFlags::DEVICE_ADDRESS_CAPTURE_REPLAY.0, + "DEVICE_ADDRESS_CAPTURE_REPLAY", + ), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for BufferUsageFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (BufferUsageFlags::TRANSFER_SRC.0, "TRANSFER_SRC"), + (BufferUsageFlags::TRANSFER_DST.0, "TRANSFER_DST"), + ( + BufferUsageFlags::UNIFORM_TEXEL_BUFFER.0, + "UNIFORM_TEXEL_BUFFER", + ), + ( + BufferUsageFlags::STORAGE_TEXEL_BUFFER.0, + "STORAGE_TEXEL_BUFFER", + ), + (BufferUsageFlags::UNIFORM_BUFFER.0, "UNIFORM_BUFFER"), + (BufferUsageFlags::STORAGE_BUFFER.0, "STORAGE_BUFFER"), + (BufferUsageFlags::INDEX_BUFFER.0, "INDEX_BUFFER"), + (BufferUsageFlags::VERTEX_BUFFER.0, "VERTEX_BUFFER"), + (BufferUsageFlags::INDIRECT_BUFFER.0, "INDIRECT_BUFFER"), + ( + BufferUsageFlags::VIDEO_DECODE_SRC_KHR.0, + "VIDEO_DECODE_SRC_KHR", + ), + ( + BufferUsageFlags::VIDEO_DECODE_DST_KHR.0, + "VIDEO_DECODE_DST_KHR", + ), + ( + BufferUsageFlags::TRANSFORM_FEEDBACK_BUFFER_EXT.0, + "TRANSFORM_FEEDBACK_BUFFER_EXT", + ), + ( + BufferUsageFlags::TRANSFORM_FEEDBACK_COUNTER_BUFFER_EXT.0, + "TRANSFORM_FEEDBACK_COUNTER_BUFFER_EXT", + ), + ( + BufferUsageFlags::CONDITIONAL_RENDERING_EXT.0, + "CONDITIONAL_RENDERING_EXT", + ), + (BufferUsageFlags::RESERVED_25_AMD.0, "RESERVED_25_AMD"), + ( + BufferUsageFlags::ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_KHR.0, + "ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_KHR", + ), + ( + BufferUsageFlags::ACCELERATION_STRUCTURE_STORAGE_KHR.0, + "ACCELERATION_STRUCTURE_STORAGE_KHR", + ), + ( + BufferUsageFlags::SHADER_BINDING_TABLE_KHR.0, + "SHADER_BINDING_TABLE_KHR", + ), + (BufferUsageFlags::RESERVED_18_QCOM.0, "RESERVED_18_QCOM"), + ( + BufferUsageFlags::VIDEO_ENCODE_DST_KHR.0, + "VIDEO_ENCODE_DST_KHR", + ), + ( + BufferUsageFlags::VIDEO_ENCODE_SRC_KHR.0, + "VIDEO_ENCODE_SRC_KHR", + ), + ( + BufferUsageFlags::SAMPLER_DESCRIPTOR_BUFFER_EXT.0, + "SAMPLER_DESCRIPTOR_BUFFER_EXT", + ), + ( + BufferUsageFlags::RESOURCE_DESCRIPTOR_BUFFER_EXT.0, + "RESOURCE_DESCRIPTOR_BUFFER_EXT", + ), + ( + BufferUsageFlags::PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER_EXT.0, + "PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER_EXT", + ), + ( + BufferUsageFlags::MICROMAP_BUILD_INPUT_READ_ONLY_EXT.0, + "MICROMAP_BUILD_INPUT_READ_ONLY_EXT", + ), + ( + BufferUsageFlags::MICROMAP_STORAGE_EXT.0, + "MICROMAP_STORAGE_EXT", + ), + ( + BufferUsageFlags::SHADER_DEVICE_ADDRESS.0, + "SHADER_DEVICE_ADDRESS", + ), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for BufferViewCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for BuildAccelerationStructureFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + BuildAccelerationStructureFlagsKHR::ALLOW_UPDATE.0, + "ALLOW_UPDATE", + ), + ( + BuildAccelerationStructureFlagsKHR::ALLOW_COMPACTION.0, + "ALLOW_COMPACTION", + ), + ( + BuildAccelerationStructureFlagsKHR::PREFER_FAST_TRACE.0, + "PREFER_FAST_TRACE", + ), + ( + BuildAccelerationStructureFlagsKHR::PREFER_FAST_BUILD.0, + "PREFER_FAST_BUILD", + ), + ( + BuildAccelerationStructureFlagsKHR::LOW_MEMORY.0, + "LOW_MEMORY", + ), + (BuildAccelerationStructureFlagsKHR::MOTION_NV.0, "MOTION_NV"), + ( + BuildAccelerationStructureFlagsKHR::ALLOW_OPACITY_MICROMAP_UPDATE_EXT.0, + "ALLOW_OPACITY_MICROMAP_UPDATE_EXT", + ), + ( + BuildAccelerationStructureFlagsKHR::ALLOW_DISABLE_OPACITY_MICROMAPS_EXT.0, + "ALLOW_DISABLE_OPACITY_MICROMAPS_EXT", + ), + ( + BuildAccelerationStructureFlagsKHR::ALLOW_OPACITY_MICROMAP_DATA_UPDATE_EXT.0, + "ALLOW_OPACITY_MICROMAP_DATA_UPDATE_EXT", + ), + ( + BuildAccelerationStructureFlagsKHR::RESERVED_9_NV.0, + "RESERVED_9_NV", + ), + ( + BuildAccelerationStructureFlagsKHR::RESERVED_10_NV.0, + "RESERVED_10_NV", + ), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for BuildAccelerationStructureModeKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::BUILD => Some("BUILD"), + Self::UPDATE => Some("UPDATE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for BuildMicromapFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + BuildMicromapFlagsEXT::PREFER_FAST_TRACE.0, + "PREFER_FAST_TRACE", + ), + ( + BuildMicromapFlagsEXT::PREFER_FAST_BUILD.0, + "PREFER_FAST_BUILD", + ), + ( + BuildMicromapFlagsEXT::ALLOW_COMPACTION.0, + "ALLOW_COMPACTION", + ), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for BuildMicromapModeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::BUILD => Some("BUILD"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for ChromaLocation { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::COSITED_EVEN => Some("COSITED_EVEN"), + Self::MIDPOINT => Some("MIDPOINT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for CoarseSampleOrderTypeNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DEFAULT => Some("DEFAULT"), + Self::CUSTOM => Some("CUSTOM"), + Self::PIXEL_MAJOR => Some("PIXEL_MAJOR"), + Self::SAMPLE_MAJOR => Some("SAMPLE_MAJOR"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for ColorComponentFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ColorComponentFlags::R.0, "R"), + (ColorComponentFlags::G.0, "G"), + (ColorComponentFlags::B.0, "B"), + (ColorComponentFlags::A.0, "A"), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for ColorSpaceKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::SRGB_NONLINEAR => Some("SRGB_NONLINEAR"), + Self::DISPLAY_P3_NONLINEAR_EXT => Some("DISPLAY_P3_NONLINEAR_EXT"), + Self::EXTENDED_SRGB_LINEAR_EXT => Some("EXTENDED_SRGB_LINEAR_EXT"), + Self::DISPLAY_P3_LINEAR_EXT => Some("DISPLAY_P3_LINEAR_EXT"), + Self::DCI_P3_NONLINEAR_EXT => Some("DCI_P3_NONLINEAR_EXT"), + Self::BT709_LINEAR_EXT => Some("BT709_LINEAR_EXT"), + Self::BT709_NONLINEAR_EXT => Some("BT709_NONLINEAR_EXT"), + Self::BT2020_LINEAR_EXT => Some("BT2020_LINEAR_EXT"), + Self::HDR10_ST2084_EXT => Some("HDR10_ST2084_EXT"), + Self::DOLBYVISION_EXT => Some("DOLBYVISION_EXT"), + Self::HDR10_HLG_EXT => Some("HDR10_HLG_EXT"), + Self::ADOBERGB_LINEAR_EXT => Some("ADOBERGB_LINEAR_EXT"), + Self::ADOBERGB_NONLINEAR_EXT => Some("ADOBERGB_NONLINEAR_EXT"), + Self::PASS_THROUGH_EXT => Some("PASS_THROUGH_EXT"), + Self::EXTENDED_SRGB_NONLINEAR_EXT => Some("EXTENDED_SRGB_NONLINEAR_EXT"), + Self::DISPLAY_NATIVE_AMD => Some("DISPLAY_NATIVE_AMD"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for CommandBufferLevel { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::PRIMARY => Some("PRIMARY"), + Self::SECONDARY => Some("SECONDARY"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for CommandBufferResetFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[( + CommandBufferResetFlags::RELEASE_RESOURCES.0, + "RELEASE_RESOURCES", + )]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for CommandBufferUsageFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + CommandBufferUsageFlags::ONE_TIME_SUBMIT.0, + "ONE_TIME_SUBMIT", + ), + ( + CommandBufferUsageFlags::RENDER_PASS_CONTINUE.0, + "RENDER_PASS_CONTINUE", + ), + ( + CommandBufferUsageFlags::SIMULTANEOUS_USE.0, + "SIMULTANEOUS_USE", + ), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for CommandPoolCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (CommandPoolCreateFlags::TRANSIENT.0, "TRANSIENT"), + ( + CommandPoolCreateFlags::RESET_COMMAND_BUFFER.0, + "RESET_COMMAND_BUFFER", + ), + (CommandPoolCreateFlags::PROTECTED.0, "PROTECTED"), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for CommandPoolResetFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + CommandPoolResetFlags::RELEASE_RESOURCES.0, + "RELEASE_RESOURCES", + ), + ( + CommandPoolResetFlags::RESERVED_1_COREAVI.0, + "RESERVED_1_COREAVI", + ), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for CommandPoolTrimFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for CompareOp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::NEVER => Some("NEVER"), + Self::LESS => Some("LESS"), + Self::EQUAL => Some("EQUAL"), + Self::LESS_OR_EQUAL => Some("LESS_OR_EQUAL"), + Self::GREATER => Some("GREATER"), + Self::NOT_EQUAL => Some("NOT_EQUAL"), + Self::GREATER_OR_EQUAL => Some("GREATER_OR_EQUAL"), + Self::ALWAYS => Some("ALWAYS"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for ComponentSwizzle { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::IDENTITY => Some("IDENTITY"), + Self::ZERO => Some("ZERO"), + Self::ONE => Some("ONE"), + Self::R => Some("R"), + Self::G => Some("G"), + Self::B => Some("B"), + Self::A => Some("A"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for ComponentTypeNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::FLOAT16 => Some("FLOAT16"), + Self::FLOAT32 => Some("FLOAT32"), + Self::FLOAT64 => Some("FLOAT64"), + Self::SINT8 => Some("SINT8"), + Self::SINT16 => Some("SINT16"), + Self::SINT32 => Some("SINT32"), + Self::SINT64 => Some("SINT64"), + Self::UINT8 => Some("UINT8"), + Self::UINT16 => Some("UINT16"), + Self::UINT32 => Some("UINT32"), + Self::UINT64 => Some("UINT64"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for CompositeAlphaFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (CompositeAlphaFlagsKHR::OPAQUE.0, "OPAQUE"), + (CompositeAlphaFlagsKHR::PRE_MULTIPLIED.0, "PRE_MULTIPLIED"), + (CompositeAlphaFlagsKHR::POST_MULTIPLIED.0, "POST_MULTIPLIED"), + (CompositeAlphaFlagsKHR::INHERIT.0, "INHERIT"), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for ConditionalRenderingFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(ConditionalRenderingFlagsEXT::INVERTED.0, "INVERTED")]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for ConservativeRasterizationModeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DISABLED => Some("DISABLED"), + Self::OVERESTIMATE => Some("OVERESTIMATE"), + Self::UNDERESTIMATE => Some("UNDERESTIMATE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for CopyAccelerationStructureModeKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::CLONE => Some("CLONE"), + Self::COMPACT => Some("COMPACT"), + Self::SERIALIZE => Some("SERIALIZE"), + Self::DESERIALIZE => Some("DESERIALIZE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for CopyMicromapModeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::CLONE => Some("CLONE"), + Self::SERIALIZE => Some("SERIALIZE"), + Self::DESERIALIZE => Some("DESERIALIZE"), + Self::COMPACT => Some("COMPACT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for CoverageModulationModeNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::NONE => Some("NONE"), + Self::RGB => Some("RGB"), + Self::ALPHA => Some("ALPHA"), + Self::RGBA => Some("RGBA"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for CoverageReductionModeNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::MERGE => Some("MERGE"), + Self::TRUNCATE => Some("TRUNCATE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for CullModeFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (CullModeFlags::NONE.0, "NONE"), + (CullModeFlags::FRONT.0, "FRONT"), + (CullModeFlags::BACK.0, "BACK"), + (CullModeFlags::FRONT_AND_BACK.0, "FRONT_AND_BACK"), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for DebugReportFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DebugReportFlagsEXT::INFORMATION.0, "INFORMATION"), + (DebugReportFlagsEXT::WARNING.0, "WARNING"), + ( + DebugReportFlagsEXT::PERFORMANCE_WARNING.0, + "PERFORMANCE_WARNING", + ), + (DebugReportFlagsEXT::ERROR.0, "ERROR"), + (DebugReportFlagsEXT::DEBUG.0, "DEBUG"), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for DebugReportObjectTypeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UNKNOWN => Some("UNKNOWN"), + Self::INSTANCE => Some("INSTANCE"), + Self::PHYSICAL_DEVICE => Some("PHYSICAL_DEVICE"), + Self::DEVICE => Some("DEVICE"), + Self::QUEUE => Some("QUEUE"), + Self::SEMAPHORE => Some("SEMAPHORE"), + Self::COMMAND_BUFFER => Some("COMMAND_BUFFER"), + Self::FENCE => Some("FENCE"), + Self::DEVICE_MEMORY => Some("DEVICE_MEMORY"), + Self::BUFFER => Some("BUFFER"), + Self::IMAGE => Some("IMAGE"), + Self::EVENT => Some("EVENT"), + Self::QUERY_POOL => Some("QUERY_POOL"), + Self::BUFFER_VIEW => Some("BUFFER_VIEW"), + Self::IMAGE_VIEW => Some("IMAGE_VIEW"), + Self::SHADER_MODULE => Some("SHADER_MODULE"), + Self::PIPELINE_CACHE => Some("PIPELINE_CACHE"), + Self::PIPELINE_LAYOUT => Some("PIPELINE_LAYOUT"), + Self::RENDER_PASS => Some("RENDER_PASS"), + Self::PIPELINE => Some("PIPELINE"), + Self::DESCRIPTOR_SET_LAYOUT => Some("DESCRIPTOR_SET_LAYOUT"), + Self::SAMPLER => Some("SAMPLER"), + Self::DESCRIPTOR_POOL => Some("DESCRIPTOR_POOL"), + Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), + Self::FRAMEBUFFER => Some("FRAMEBUFFER"), + Self::COMMAND_POOL => Some("COMMAND_POOL"), + Self::SURFACE_KHR => Some("SURFACE_KHR"), + Self::SWAPCHAIN_KHR => Some("SWAPCHAIN_KHR"), + Self::DEBUG_REPORT_CALLBACK_EXT => Some("DEBUG_REPORT_CALLBACK_EXT"), + Self::DISPLAY_KHR => Some("DISPLAY_KHR"), + Self::DISPLAY_MODE_KHR => Some("DISPLAY_MODE_KHR"), + Self::VALIDATION_CACHE_EXT => Some("VALIDATION_CACHE_EXT"), + Self::SAMPLER_YCBCR_CONVERSION => Some("SAMPLER_YCBCR_CONVERSION"), + Self::DESCRIPTOR_UPDATE_TEMPLATE => Some("DESCRIPTOR_UPDATE_TEMPLATE"), + Self::CU_MODULE_NVX => Some("CU_MODULE_NVX"), + Self::CU_FUNCTION_NVX => Some("CU_FUNCTION_NVX"), + Self::ACCELERATION_STRUCTURE_KHR => Some("ACCELERATION_STRUCTURE_KHR"), + Self::ACCELERATION_STRUCTURE_NV => Some("ACCELERATION_STRUCTURE_NV"), + Self::BUFFER_COLLECTION_FUCHSIA => Some("BUFFER_COLLECTION_FUCHSIA"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for DebugUtilsMessageSeverityFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DebugUtilsMessageSeverityFlagsEXT::VERBOSE.0, "VERBOSE"), + (DebugUtilsMessageSeverityFlagsEXT::INFO.0, "INFO"), + (DebugUtilsMessageSeverityFlagsEXT::WARNING.0, "WARNING"), + (DebugUtilsMessageSeverityFlagsEXT::ERROR.0, "ERROR"), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for DebugUtilsMessageTypeFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DebugUtilsMessageTypeFlagsEXT::GENERAL.0, "GENERAL"), + (DebugUtilsMessageTypeFlagsEXT::VALIDATION.0, "VALIDATION"), + (DebugUtilsMessageTypeFlagsEXT::PERFORMANCE.0, "PERFORMANCE"), + ( + DebugUtilsMessageTypeFlagsEXT::DEVICE_ADDRESS_BINDING.0, + "DEVICE_ADDRESS_BINDING", + ), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for DebugUtilsMessengerCallbackDataFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for DebugUtilsMessengerCreateFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for DependencyFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DependencyFlags::BY_REGION.0, "BY_REGION"), + (DependencyFlags::FEEDBACK_LOOP_EXT.0, "FEEDBACK_LOOP_EXT"), + (DependencyFlags::DEVICE_GROUP.0, "DEVICE_GROUP"), + (DependencyFlags::VIEW_LOCAL.0, "VIEW_LOCAL"), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for DescriptorBindingFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + DescriptorBindingFlags::UPDATE_AFTER_BIND.0, + "UPDATE_AFTER_BIND", + ), + ( + DescriptorBindingFlags::UPDATE_UNUSED_WHILE_PENDING.0, + "UPDATE_UNUSED_WHILE_PENDING", + ), + (DescriptorBindingFlags::PARTIALLY_BOUND.0, "PARTIALLY_BOUND"), + ( + DescriptorBindingFlags::VARIABLE_DESCRIPTOR_COUNT.0, + "VARIABLE_DESCRIPTOR_COUNT", + ), + (DescriptorBindingFlags::RESERVED_4_QCOM.0, "RESERVED_4_QCOM"), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for DescriptorPoolCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + DescriptorPoolCreateFlags::FREE_DESCRIPTOR_SET.0, + "FREE_DESCRIPTOR_SET", + ), + (DescriptorPoolCreateFlags::HOST_ONLY_EXT.0, "HOST_ONLY_EXT"), + ( + DescriptorPoolCreateFlags::UPDATE_AFTER_BIND.0, + "UPDATE_AFTER_BIND", + ), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for DescriptorPoolResetFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for DescriptorSetLayoutCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + DescriptorSetLayoutCreateFlags::PUSH_DESCRIPTOR_KHR.0, + "PUSH_DESCRIPTOR_KHR", + ), + ( + DescriptorSetLayoutCreateFlags::DESCRIPTOR_BUFFER_EXT.0, + "DESCRIPTOR_BUFFER_EXT", + ), + ( + DescriptorSetLayoutCreateFlags::EMBEDDED_IMMUTABLE_SAMPLERS_EXT.0, + "EMBEDDED_IMMUTABLE_SAMPLERS_EXT", + ), + ( + DescriptorSetLayoutCreateFlags::RESERVED_3_AMD.0, + "RESERVED_3_AMD", + ), + ( + DescriptorSetLayoutCreateFlags::HOST_ONLY_POOL_EXT.0, + "HOST_ONLY_POOL_EXT", + ), + ( + DescriptorSetLayoutCreateFlags::UPDATE_AFTER_BIND_POOL.0, + "UPDATE_AFTER_BIND_POOL", + ), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for DescriptorType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::SAMPLER => Some("SAMPLER"), + Self::COMBINED_IMAGE_SAMPLER => Some("COMBINED_IMAGE_SAMPLER"), + Self::SAMPLED_IMAGE => Some("SAMPLED_IMAGE"), + Self::STORAGE_IMAGE => Some("STORAGE_IMAGE"), + Self::UNIFORM_TEXEL_BUFFER => Some("UNIFORM_TEXEL_BUFFER"), + Self::STORAGE_TEXEL_BUFFER => Some("STORAGE_TEXEL_BUFFER"), + Self::UNIFORM_BUFFER => Some("UNIFORM_BUFFER"), + Self::STORAGE_BUFFER => Some("STORAGE_BUFFER"), + Self::UNIFORM_BUFFER_DYNAMIC => Some("UNIFORM_BUFFER_DYNAMIC"), + Self::STORAGE_BUFFER_DYNAMIC => Some("STORAGE_BUFFER_DYNAMIC"), + Self::INPUT_ATTACHMENT => Some("INPUT_ATTACHMENT"), + Self::ACCELERATION_STRUCTURE_KHR => Some("ACCELERATION_STRUCTURE_KHR"), + Self::ACCELERATION_STRUCTURE_NV => Some("ACCELERATION_STRUCTURE_NV"), + Self::SAMPLE_WEIGHT_IMAGE_QCOM => Some("SAMPLE_WEIGHT_IMAGE_QCOM"), + Self::BLOCK_MATCH_IMAGE_QCOM => Some("BLOCK_MATCH_IMAGE_QCOM"), + Self::MUTABLE_EXT => Some("MUTABLE_EXT"), + Self::INLINE_UNIFORM_BLOCK => Some("INLINE_UNIFORM_BLOCK"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for DescriptorUpdateTemplateCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for DescriptorUpdateTemplateType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), + Self::PUSH_DESCRIPTORS_KHR => Some("PUSH_DESCRIPTORS_KHR"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for DeviceAddressBindingFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[( + DeviceAddressBindingFlagsEXT::INTERNAL_OBJECT.0, + "INTERNAL_OBJECT", + )]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for DeviceAddressBindingTypeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::BIND => Some("BIND"), + Self::UNBIND => Some("UNBIND"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for DeviceCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for DeviceDiagnosticsConfigFlagsNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + DeviceDiagnosticsConfigFlagsNV::ENABLE_SHADER_DEBUG_INFO.0, + "ENABLE_SHADER_DEBUG_INFO", + ), + ( + DeviceDiagnosticsConfigFlagsNV::ENABLE_RESOURCE_TRACKING.0, + "ENABLE_RESOURCE_TRACKING", + ), + ( + DeviceDiagnosticsConfigFlagsNV::ENABLE_AUTOMATIC_CHECKPOINTS.0, + "ENABLE_AUTOMATIC_CHECKPOINTS", + ), + ( + DeviceDiagnosticsConfigFlagsNV::ENABLE_SHADER_ERROR_REPORTING.0, + "ENABLE_SHADER_ERROR_REPORTING", + ), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for DeviceEventTypeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DISPLAY_HOTPLUG => Some("DISPLAY_HOTPLUG"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for DeviceFaultAddressTypeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::NONE => Some("NONE"), + Self::READ_INVALID => Some("READ_INVALID"), + Self::WRITE_INVALID => Some("WRITE_INVALID"), + Self::EXECUTE_INVALID => Some("EXECUTE_INVALID"), + Self::INSTRUCTION_POINTER_UNKNOWN => Some("INSTRUCTION_POINTER_UNKNOWN"), + Self::INSTRUCTION_POINTER_INVALID => Some("INSTRUCTION_POINTER_INVALID"), + Self::INSTRUCTION_POINTER_FAULT => Some("INSTRUCTION_POINTER_FAULT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for DeviceFaultVendorBinaryHeaderVersionEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ONE => Some("ONE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for DeviceGroupPresentModeFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DeviceGroupPresentModeFlagsKHR::LOCAL.0, "LOCAL"), + (DeviceGroupPresentModeFlagsKHR::REMOTE.0, "REMOTE"), + (DeviceGroupPresentModeFlagsKHR::SUM.0, "SUM"), + ( + DeviceGroupPresentModeFlagsKHR::LOCAL_MULTI_DEVICE.0, + "LOCAL_MULTI_DEVICE", + ), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for DeviceMemoryReportEventTypeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ALLOCATE => Some("ALLOCATE"), + Self::FREE => Some("FREE"), + Self::IMPORT => Some("IMPORT"), + Self::UNIMPORT => Some("UNIMPORT"), + Self::ALLOCATION_FAILED => Some("ALLOCATION_FAILED"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for DeviceMemoryReportFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for DeviceQueueCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DeviceQueueCreateFlags::RESERVED_1_QCOM.0, "RESERVED_1_QCOM"), + (DeviceQueueCreateFlags::PROTECTED.0, "PROTECTED"), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for DirectDriverLoadingFlagsLUNARG { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for DirectDriverLoadingModeLUNARG { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::EXCLUSIVE => Some("EXCLUSIVE"), + Self::INCLUSIVE => Some("INCLUSIVE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for DirectFBSurfaceCreateFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for DiscardRectangleModeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::INCLUSIVE => Some("INCLUSIVE"), + Self::EXCLUSIVE => Some("EXCLUSIVE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for DisplayEventTypeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::FIRST_PIXEL_OUT => Some("FIRST_PIXEL_OUT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for DisplayModeCreateFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for DisplayPlaneAlphaFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (DisplayPlaneAlphaFlagsKHR::OPAQUE.0, "OPAQUE"), + (DisplayPlaneAlphaFlagsKHR::GLOBAL.0, "GLOBAL"), + (DisplayPlaneAlphaFlagsKHR::PER_PIXEL.0, "PER_PIXEL"), + ( + DisplayPlaneAlphaFlagsKHR::PER_PIXEL_PREMULTIPLIED.0, + "PER_PIXEL_PREMULTIPLIED", + ), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for DisplayPowerStateEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::OFF => Some("OFF"), + Self::SUSPEND => Some("SUSPEND"), + Self::ON => Some("ON"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for DisplaySurfaceCreateFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for DriverId { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::AMD_PROPRIETARY => Some("AMD_PROPRIETARY"), + Self::AMD_OPEN_SOURCE => Some("AMD_OPEN_SOURCE"), + Self::MESA_RADV => Some("MESA_RADV"), + Self::NVIDIA_PROPRIETARY => Some("NVIDIA_PROPRIETARY"), + Self::INTEL_PROPRIETARY_WINDOWS => Some("INTEL_PROPRIETARY_WINDOWS"), + Self::INTEL_OPEN_SOURCE_MESA => Some("INTEL_OPEN_SOURCE_MESA"), + Self::IMAGINATION_PROPRIETARY => Some("IMAGINATION_PROPRIETARY"), + Self::QUALCOMM_PROPRIETARY => Some("QUALCOMM_PROPRIETARY"), + Self::ARM_PROPRIETARY => Some("ARM_PROPRIETARY"), + Self::GOOGLE_SWIFTSHADER => Some("GOOGLE_SWIFTSHADER"), + Self::GGP_PROPRIETARY => Some("GGP_PROPRIETARY"), + Self::BROADCOM_PROPRIETARY => Some("BROADCOM_PROPRIETARY"), + Self::MESA_LLVMPIPE => Some("MESA_LLVMPIPE"), + Self::MOLTENVK => Some("MOLTENVK"), + Self::COREAVI_PROPRIETARY => Some("COREAVI_PROPRIETARY"), + Self::JUICE_PROPRIETARY => Some("JUICE_PROPRIETARY"), + Self::VERISILICON_PROPRIETARY => Some("VERISILICON_PROPRIETARY"), + Self::MESA_TURNIP => Some("MESA_TURNIP"), + Self::MESA_V3DV => Some("MESA_V3DV"), + Self::MESA_PANVK => Some("MESA_PANVK"), + Self::SAMSUNG_PROPRIETARY => Some("SAMSUNG_PROPRIETARY"), + Self::MESA_VENUS => Some("MESA_VENUS"), + Self::MESA_DOZEN => Some("MESA_DOZEN"), + Self::MESA_NVK => Some("MESA_NVK"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for DynamicState { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::VIEWPORT => Some("VIEWPORT"), + Self::SCISSOR => Some("SCISSOR"), + Self::LINE_WIDTH => Some("LINE_WIDTH"), + Self::DEPTH_BIAS => Some("DEPTH_BIAS"), + Self::BLEND_CONSTANTS => Some("BLEND_CONSTANTS"), + Self::DEPTH_BOUNDS => Some("DEPTH_BOUNDS"), + Self::STENCIL_COMPARE_MASK => Some("STENCIL_COMPARE_MASK"), + Self::STENCIL_WRITE_MASK => Some("STENCIL_WRITE_MASK"), + Self::STENCIL_REFERENCE => Some("STENCIL_REFERENCE"), + Self::VIEWPORT_W_SCALING_NV => Some("VIEWPORT_W_SCALING_NV"), + Self::DISCARD_RECTANGLE_EXT => Some("DISCARD_RECTANGLE_EXT"), + Self::SAMPLE_LOCATIONS_EXT => Some("SAMPLE_LOCATIONS_EXT"), + Self::RAY_TRACING_PIPELINE_STACK_SIZE_KHR => { + Some("RAY_TRACING_PIPELINE_STACK_SIZE_KHR") + } + Self::VIEWPORT_SHADING_RATE_PALETTE_NV => Some("VIEWPORT_SHADING_RATE_PALETTE_NV"), + Self::VIEWPORT_COARSE_SAMPLE_ORDER_NV => Some("VIEWPORT_COARSE_SAMPLE_ORDER_NV"), + Self::EXCLUSIVE_SCISSOR_NV => Some("EXCLUSIVE_SCISSOR_NV"), + Self::FRAGMENT_SHADING_RATE_KHR => Some("FRAGMENT_SHADING_RATE_KHR"), + Self::LINE_STIPPLE_EXT => Some("LINE_STIPPLE_EXT"), + Self::VERTEX_INPUT_EXT => Some("VERTEX_INPUT_EXT"), + Self::PATCH_CONTROL_POINTS_EXT => Some("PATCH_CONTROL_POINTS_EXT"), + Self::LOGIC_OP_EXT => Some("LOGIC_OP_EXT"), + Self::COLOR_WRITE_ENABLE_EXT => Some("COLOR_WRITE_ENABLE_EXT"), + Self::TESSELLATION_DOMAIN_ORIGIN_EXT => Some("TESSELLATION_DOMAIN_ORIGIN_EXT"), + Self::DEPTH_CLAMP_ENABLE_EXT => Some("DEPTH_CLAMP_ENABLE_EXT"), + Self::POLYGON_MODE_EXT => Some("POLYGON_MODE_EXT"), + Self::RASTERIZATION_SAMPLES_EXT => Some("RASTERIZATION_SAMPLES_EXT"), + Self::SAMPLE_MASK_EXT => Some("SAMPLE_MASK_EXT"), + Self::ALPHA_TO_COVERAGE_ENABLE_EXT => Some("ALPHA_TO_COVERAGE_ENABLE_EXT"), + Self::ALPHA_TO_ONE_ENABLE_EXT => Some("ALPHA_TO_ONE_ENABLE_EXT"), + Self::LOGIC_OP_ENABLE_EXT => Some("LOGIC_OP_ENABLE_EXT"), + Self::COLOR_BLEND_ENABLE_EXT => Some("COLOR_BLEND_ENABLE_EXT"), + Self::COLOR_BLEND_EQUATION_EXT => Some("COLOR_BLEND_EQUATION_EXT"), + Self::COLOR_WRITE_MASK_EXT => Some("COLOR_WRITE_MASK_EXT"), + Self::RASTERIZATION_STREAM_EXT => Some("RASTERIZATION_STREAM_EXT"), + Self::CONSERVATIVE_RASTERIZATION_MODE_EXT => { + Some("CONSERVATIVE_RASTERIZATION_MODE_EXT") + } + Self::EXTRA_PRIMITIVE_OVERESTIMATION_SIZE_EXT => { + Some("EXTRA_PRIMITIVE_OVERESTIMATION_SIZE_EXT") + } + Self::DEPTH_CLIP_ENABLE_EXT => Some("DEPTH_CLIP_ENABLE_EXT"), + Self::SAMPLE_LOCATIONS_ENABLE_EXT => Some("SAMPLE_LOCATIONS_ENABLE_EXT"), + Self::COLOR_BLEND_ADVANCED_EXT => Some("COLOR_BLEND_ADVANCED_EXT"), + Self::PROVOKING_VERTEX_MODE_EXT => Some("PROVOKING_VERTEX_MODE_EXT"), + Self::LINE_RASTERIZATION_MODE_EXT => Some("LINE_RASTERIZATION_MODE_EXT"), + Self::LINE_STIPPLE_ENABLE_EXT => Some("LINE_STIPPLE_ENABLE_EXT"), + Self::DEPTH_CLIP_NEGATIVE_ONE_TO_ONE_EXT => Some("DEPTH_CLIP_NEGATIVE_ONE_TO_ONE_EXT"), + Self::VIEWPORT_W_SCALING_ENABLE_NV => Some("VIEWPORT_W_SCALING_ENABLE_NV"), + Self::VIEWPORT_SWIZZLE_NV => Some("VIEWPORT_SWIZZLE_NV"), + Self::COVERAGE_TO_COLOR_ENABLE_NV => Some("COVERAGE_TO_COLOR_ENABLE_NV"), + Self::COVERAGE_TO_COLOR_LOCATION_NV => Some("COVERAGE_TO_COLOR_LOCATION_NV"), + Self::COVERAGE_MODULATION_MODE_NV => Some("COVERAGE_MODULATION_MODE_NV"), + Self::COVERAGE_MODULATION_TABLE_ENABLE_NV => { + Some("COVERAGE_MODULATION_TABLE_ENABLE_NV") + } + Self::COVERAGE_MODULATION_TABLE_NV => Some("COVERAGE_MODULATION_TABLE_NV"), + Self::SHADING_RATE_IMAGE_ENABLE_NV => Some("SHADING_RATE_IMAGE_ENABLE_NV"), + Self::REPRESENTATIVE_FRAGMENT_TEST_ENABLE_NV => { + Some("REPRESENTATIVE_FRAGMENT_TEST_ENABLE_NV") + } + Self::COVERAGE_REDUCTION_MODE_NV => Some("COVERAGE_REDUCTION_MODE_NV"), + Self::CULL_MODE => Some("CULL_MODE"), + Self::FRONT_FACE => Some("FRONT_FACE"), + Self::PRIMITIVE_TOPOLOGY => Some("PRIMITIVE_TOPOLOGY"), + Self::VIEWPORT_WITH_COUNT => Some("VIEWPORT_WITH_COUNT"), + Self::SCISSOR_WITH_COUNT => Some("SCISSOR_WITH_COUNT"), + Self::VERTEX_INPUT_BINDING_STRIDE => Some("VERTEX_INPUT_BINDING_STRIDE"), + Self::DEPTH_TEST_ENABLE => Some("DEPTH_TEST_ENABLE"), + Self::DEPTH_WRITE_ENABLE => Some("DEPTH_WRITE_ENABLE"), + Self::DEPTH_COMPARE_OP => Some("DEPTH_COMPARE_OP"), + Self::DEPTH_BOUNDS_TEST_ENABLE => Some("DEPTH_BOUNDS_TEST_ENABLE"), + Self::STENCIL_TEST_ENABLE => Some("STENCIL_TEST_ENABLE"), + Self::STENCIL_OP => Some("STENCIL_OP"), + Self::RASTERIZER_DISCARD_ENABLE => Some("RASTERIZER_DISCARD_ENABLE"), + Self::DEPTH_BIAS_ENABLE => Some("DEPTH_BIAS_ENABLE"), + Self::PRIMITIVE_RESTART_ENABLE => Some("PRIMITIVE_RESTART_ENABLE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for EventCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(EventCreateFlags::DEVICE_ONLY.0, "DEVICE_ONLY")]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for ExportMetalObjectTypeFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExportMetalObjectTypeFlagsEXT::METAL_DEVICE.0, + "METAL_DEVICE", + ), + ( + ExportMetalObjectTypeFlagsEXT::METAL_COMMAND_QUEUE.0, + "METAL_COMMAND_QUEUE", + ), + ( + ExportMetalObjectTypeFlagsEXT::METAL_BUFFER.0, + "METAL_BUFFER", + ), + ( + ExportMetalObjectTypeFlagsEXT::METAL_TEXTURE.0, + "METAL_TEXTURE", + ), + ( + ExportMetalObjectTypeFlagsEXT::METAL_IOSURFACE.0, + "METAL_IOSURFACE", + ), + ( + ExportMetalObjectTypeFlagsEXT::METAL_SHARED_EVENT.0, + "METAL_SHARED_EVENT", + ), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for ExternalFenceFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ExternalFenceFeatureFlags::EXPORTABLE.0, "EXPORTABLE"), + (ExternalFenceFeatureFlags::IMPORTABLE.0, "IMPORTABLE"), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for ExternalFenceHandleTypeFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ExternalFenceHandleTypeFlags::OPAQUE_FD.0, "OPAQUE_FD"), + (ExternalFenceHandleTypeFlags::OPAQUE_WIN32.0, "OPAQUE_WIN32"), + ( + ExternalFenceHandleTypeFlags::OPAQUE_WIN32_KMT.0, + "OPAQUE_WIN32_KMT", + ), + (ExternalFenceHandleTypeFlags::SYNC_FD.0, "SYNC_FD"), + ( + ExternalFenceHandleTypeFlags::RESERVED_4_NV.0, + "RESERVED_4_NV", + ), + ( + ExternalFenceHandleTypeFlags::RESERVED_5_NV.0, + "RESERVED_5_NV", + ), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for ExternalMemoryFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalMemoryFeatureFlags::DEDICATED_ONLY.0, + "DEDICATED_ONLY", + ), + (ExternalMemoryFeatureFlags::EXPORTABLE.0, "EXPORTABLE"), + (ExternalMemoryFeatureFlags::IMPORTABLE.0, "IMPORTABLE"), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for ExternalMemoryFeatureFlagsNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalMemoryFeatureFlagsNV::DEDICATED_ONLY.0, + "DEDICATED_ONLY", + ), + (ExternalMemoryFeatureFlagsNV::EXPORTABLE.0, "EXPORTABLE"), + (ExternalMemoryFeatureFlagsNV::IMPORTABLE.0, "IMPORTABLE"), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for ExternalMemoryHandleTypeFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ExternalMemoryHandleTypeFlags::OPAQUE_FD.0, "OPAQUE_FD"), + ( + ExternalMemoryHandleTypeFlags::OPAQUE_WIN32.0, + "OPAQUE_WIN32", + ), + ( + ExternalMemoryHandleTypeFlags::OPAQUE_WIN32_KMT.0, + "OPAQUE_WIN32_KMT", + ), + ( + ExternalMemoryHandleTypeFlags::D3D11_TEXTURE.0, + "D3D11_TEXTURE", + ), + ( + ExternalMemoryHandleTypeFlags::D3D11_TEXTURE_KMT.0, + "D3D11_TEXTURE_KMT", + ), + (ExternalMemoryHandleTypeFlags::D3D12_HEAP.0, "D3D12_HEAP"), + ( + ExternalMemoryHandleTypeFlags::D3D12_RESOURCE.0, + "D3D12_RESOURCE", + ), + (ExternalMemoryHandleTypeFlags::DMA_BUF_EXT.0, "DMA_BUF_EXT"), + ( + ExternalMemoryHandleTypeFlags::ANDROID_HARDWARE_BUFFER_ANDROID.0, + "ANDROID_HARDWARE_BUFFER_ANDROID", + ), + ( + ExternalMemoryHandleTypeFlags::HOST_ALLOCATION_EXT.0, + "HOST_ALLOCATION_EXT", + ), + ( + ExternalMemoryHandleTypeFlags::HOST_MAPPED_FOREIGN_MEMORY_EXT.0, + "HOST_MAPPED_FOREIGN_MEMORY_EXT", + ), + ( + ExternalMemoryHandleTypeFlags::ZIRCON_VMO_FUCHSIA.0, + "ZIRCON_VMO_FUCHSIA", + ), + ( + ExternalMemoryHandleTypeFlags::RDMA_ADDRESS_NV.0, + "RDMA_ADDRESS_NV", + ), + ( + ExternalMemoryHandleTypeFlags::RESERVED_13_NV.0, + "RESERVED_13_NV", + ), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for ExternalMemoryHandleTypeFlagsNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ExternalMemoryHandleTypeFlagsNV::OPAQUE_WIN32.0, + "OPAQUE_WIN32", + ), + ( + ExternalMemoryHandleTypeFlagsNV::OPAQUE_WIN32_KMT.0, + "OPAQUE_WIN32_KMT", + ), + ( + ExternalMemoryHandleTypeFlagsNV::D3D11_IMAGE.0, + "D3D11_IMAGE", + ), + ( + ExternalMemoryHandleTypeFlagsNV::D3D11_IMAGE_KMT.0, + "D3D11_IMAGE_KMT", + ), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for ExternalSemaphoreFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ExternalSemaphoreFeatureFlags::EXPORTABLE.0, "EXPORTABLE"), + (ExternalSemaphoreFeatureFlags::IMPORTABLE.0, "IMPORTABLE"), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for ExternalSemaphoreHandleTypeFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ExternalSemaphoreHandleTypeFlags::OPAQUE_FD.0, "OPAQUE_FD"), + ( + ExternalSemaphoreHandleTypeFlags::OPAQUE_WIN32.0, + "OPAQUE_WIN32", + ), + ( + ExternalSemaphoreHandleTypeFlags::OPAQUE_WIN32_KMT.0, + "OPAQUE_WIN32_KMT", + ), + ( + ExternalSemaphoreHandleTypeFlags::D3D12_FENCE.0, + "D3D12_FENCE", + ), + (ExternalSemaphoreHandleTypeFlags::SYNC_FD.0, "SYNC_FD"), + ( + ExternalSemaphoreHandleTypeFlags::ZIRCON_EVENT_FUCHSIA.0, + "ZIRCON_EVENT_FUCHSIA", + ), + ( + ExternalSemaphoreHandleTypeFlags::RESERVED_5_NV.0, + "RESERVED_5_NV", + ), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for FenceCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(FenceCreateFlags::SIGNALED.0, "SIGNALED")]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for FenceImportFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(FenceImportFlags::TEMPORARY.0, "TEMPORARY")]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for Filter { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::NEAREST => Some("NEAREST"), + Self::LINEAR => Some("LINEAR"), + Self::CUBIC_EXT => Some("CUBIC_EXT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for Format { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UNDEFINED => Some("UNDEFINED"), + Self::R4G4_UNORM_PACK8 => Some("R4G4_UNORM_PACK8"), + Self::R4G4B4A4_UNORM_PACK16 => Some("R4G4B4A4_UNORM_PACK16"), + Self::B4G4R4A4_UNORM_PACK16 => Some("B4G4R4A4_UNORM_PACK16"), + Self::R5G6B5_UNORM_PACK16 => Some("R5G6B5_UNORM_PACK16"), + Self::B5G6R5_UNORM_PACK16 => Some("B5G6R5_UNORM_PACK16"), + Self::R5G5B5A1_UNORM_PACK16 => Some("R5G5B5A1_UNORM_PACK16"), + Self::B5G5R5A1_UNORM_PACK16 => Some("B5G5R5A1_UNORM_PACK16"), + Self::A1R5G5B5_UNORM_PACK16 => Some("A1R5G5B5_UNORM_PACK16"), + Self::R8_UNORM => Some("R8_UNORM"), + Self::R8_SNORM => Some("R8_SNORM"), + Self::R8_USCALED => Some("R8_USCALED"), + Self::R8_SSCALED => Some("R8_SSCALED"), + Self::R8_UINT => Some("R8_UINT"), + Self::R8_SINT => Some("R8_SINT"), + Self::R8_SRGB => Some("R8_SRGB"), + Self::R8G8_UNORM => Some("R8G8_UNORM"), + Self::R8G8_SNORM => Some("R8G8_SNORM"), + Self::R8G8_USCALED => Some("R8G8_USCALED"), + Self::R8G8_SSCALED => Some("R8G8_SSCALED"), + Self::R8G8_UINT => Some("R8G8_UINT"), + Self::R8G8_SINT => Some("R8G8_SINT"), + Self::R8G8_SRGB => Some("R8G8_SRGB"), + Self::R8G8B8_UNORM => Some("R8G8B8_UNORM"), + Self::R8G8B8_SNORM => Some("R8G8B8_SNORM"), + Self::R8G8B8_USCALED => Some("R8G8B8_USCALED"), + Self::R8G8B8_SSCALED => Some("R8G8B8_SSCALED"), + Self::R8G8B8_UINT => Some("R8G8B8_UINT"), + Self::R8G8B8_SINT => Some("R8G8B8_SINT"), + Self::R8G8B8_SRGB => Some("R8G8B8_SRGB"), + Self::B8G8R8_UNORM => Some("B8G8R8_UNORM"), + Self::B8G8R8_SNORM => Some("B8G8R8_SNORM"), + Self::B8G8R8_USCALED => Some("B8G8R8_USCALED"), + Self::B8G8R8_SSCALED => Some("B8G8R8_SSCALED"), + Self::B8G8R8_UINT => Some("B8G8R8_UINT"), + Self::B8G8R8_SINT => Some("B8G8R8_SINT"), + Self::B8G8R8_SRGB => Some("B8G8R8_SRGB"), + Self::R8G8B8A8_UNORM => Some("R8G8B8A8_UNORM"), + Self::R8G8B8A8_SNORM => Some("R8G8B8A8_SNORM"), + Self::R8G8B8A8_USCALED => Some("R8G8B8A8_USCALED"), + Self::R8G8B8A8_SSCALED => Some("R8G8B8A8_SSCALED"), + Self::R8G8B8A8_UINT => Some("R8G8B8A8_UINT"), + Self::R8G8B8A8_SINT => Some("R8G8B8A8_SINT"), + Self::R8G8B8A8_SRGB => Some("R8G8B8A8_SRGB"), + Self::B8G8R8A8_UNORM => Some("B8G8R8A8_UNORM"), + Self::B8G8R8A8_SNORM => Some("B8G8R8A8_SNORM"), + Self::B8G8R8A8_USCALED => Some("B8G8R8A8_USCALED"), + Self::B8G8R8A8_SSCALED => Some("B8G8R8A8_SSCALED"), + Self::B8G8R8A8_UINT => Some("B8G8R8A8_UINT"), + Self::B8G8R8A8_SINT => Some("B8G8R8A8_SINT"), + Self::B8G8R8A8_SRGB => Some("B8G8R8A8_SRGB"), + Self::A8B8G8R8_UNORM_PACK32 => Some("A8B8G8R8_UNORM_PACK32"), + Self::A8B8G8R8_SNORM_PACK32 => Some("A8B8G8R8_SNORM_PACK32"), + Self::A8B8G8R8_USCALED_PACK32 => Some("A8B8G8R8_USCALED_PACK32"), + Self::A8B8G8R8_SSCALED_PACK32 => Some("A8B8G8R8_SSCALED_PACK32"), + Self::A8B8G8R8_UINT_PACK32 => Some("A8B8G8R8_UINT_PACK32"), + Self::A8B8G8R8_SINT_PACK32 => Some("A8B8G8R8_SINT_PACK32"), + Self::A8B8G8R8_SRGB_PACK32 => Some("A8B8G8R8_SRGB_PACK32"), + Self::A2R10G10B10_UNORM_PACK32 => Some("A2R10G10B10_UNORM_PACK32"), + Self::A2R10G10B10_SNORM_PACK32 => Some("A2R10G10B10_SNORM_PACK32"), + Self::A2R10G10B10_USCALED_PACK32 => Some("A2R10G10B10_USCALED_PACK32"), + Self::A2R10G10B10_SSCALED_PACK32 => Some("A2R10G10B10_SSCALED_PACK32"), + Self::A2R10G10B10_UINT_PACK32 => Some("A2R10G10B10_UINT_PACK32"), + Self::A2R10G10B10_SINT_PACK32 => Some("A2R10G10B10_SINT_PACK32"), + Self::A2B10G10R10_UNORM_PACK32 => Some("A2B10G10R10_UNORM_PACK32"), + Self::A2B10G10R10_SNORM_PACK32 => Some("A2B10G10R10_SNORM_PACK32"), + Self::A2B10G10R10_USCALED_PACK32 => Some("A2B10G10R10_USCALED_PACK32"), + Self::A2B10G10R10_SSCALED_PACK32 => Some("A2B10G10R10_SSCALED_PACK32"), + Self::A2B10G10R10_UINT_PACK32 => Some("A2B10G10R10_UINT_PACK32"), + Self::A2B10G10R10_SINT_PACK32 => Some("A2B10G10R10_SINT_PACK32"), + Self::R16_UNORM => Some("R16_UNORM"), + Self::R16_SNORM => Some("R16_SNORM"), + Self::R16_USCALED => Some("R16_USCALED"), + Self::R16_SSCALED => Some("R16_SSCALED"), + Self::R16_UINT => Some("R16_UINT"), + Self::R16_SINT => Some("R16_SINT"), + Self::R16_SFLOAT => Some("R16_SFLOAT"), + Self::R16G16_UNORM => Some("R16G16_UNORM"), + Self::R16G16_SNORM => Some("R16G16_SNORM"), + Self::R16G16_USCALED => Some("R16G16_USCALED"), + Self::R16G16_SSCALED => Some("R16G16_SSCALED"), + Self::R16G16_UINT => Some("R16G16_UINT"), + Self::R16G16_SINT => Some("R16G16_SINT"), + Self::R16G16_SFLOAT => Some("R16G16_SFLOAT"), + Self::R16G16B16_UNORM => Some("R16G16B16_UNORM"), + Self::R16G16B16_SNORM => Some("R16G16B16_SNORM"), + Self::R16G16B16_USCALED => Some("R16G16B16_USCALED"), + Self::R16G16B16_SSCALED => Some("R16G16B16_SSCALED"), + Self::R16G16B16_UINT => Some("R16G16B16_UINT"), + Self::R16G16B16_SINT => Some("R16G16B16_SINT"), + Self::R16G16B16_SFLOAT => Some("R16G16B16_SFLOAT"), + Self::R16G16B16A16_UNORM => Some("R16G16B16A16_UNORM"), + Self::R16G16B16A16_SNORM => Some("R16G16B16A16_SNORM"), + Self::R16G16B16A16_USCALED => Some("R16G16B16A16_USCALED"), + Self::R16G16B16A16_SSCALED => Some("R16G16B16A16_SSCALED"), + Self::R16G16B16A16_UINT => Some("R16G16B16A16_UINT"), + Self::R16G16B16A16_SINT => Some("R16G16B16A16_SINT"), + Self::R16G16B16A16_SFLOAT => Some("R16G16B16A16_SFLOAT"), + Self::R32_UINT => Some("R32_UINT"), + Self::R32_SINT => Some("R32_SINT"), + Self::R32_SFLOAT => Some("R32_SFLOAT"), + Self::R32G32_UINT => Some("R32G32_UINT"), + Self::R32G32_SINT => Some("R32G32_SINT"), + Self::R32G32_SFLOAT => Some("R32G32_SFLOAT"), + Self::R32G32B32_UINT => Some("R32G32B32_UINT"), + Self::R32G32B32_SINT => Some("R32G32B32_SINT"), + Self::R32G32B32_SFLOAT => Some("R32G32B32_SFLOAT"), + Self::R32G32B32A32_UINT => Some("R32G32B32A32_UINT"), + Self::R32G32B32A32_SINT => Some("R32G32B32A32_SINT"), + Self::R32G32B32A32_SFLOAT => Some("R32G32B32A32_SFLOAT"), + Self::R64_UINT => Some("R64_UINT"), + Self::R64_SINT => Some("R64_SINT"), + Self::R64_SFLOAT => Some("R64_SFLOAT"), + Self::R64G64_UINT => Some("R64G64_UINT"), + Self::R64G64_SINT => Some("R64G64_SINT"), + Self::R64G64_SFLOAT => Some("R64G64_SFLOAT"), + Self::R64G64B64_UINT => Some("R64G64B64_UINT"), + Self::R64G64B64_SINT => Some("R64G64B64_SINT"), + Self::R64G64B64_SFLOAT => Some("R64G64B64_SFLOAT"), + Self::R64G64B64A64_UINT => Some("R64G64B64A64_UINT"), + Self::R64G64B64A64_SINT => Some("R64G64B64A64_SINT"), + Self::R64G64B64A64_SFLOAT => Some("R64G64B64A64_SFLOAT"), + Self::B10G11R11_UFLOAT_PACK32 => Some("B10G11R11_UFLOAT_PACK32"), + Self::E5B9G9R9_UFLOAT_PACK32 => Some("E5B9G9R9_UFLOAT_PACK32"), + Self::D16_UNORM => Some("D16_UNORM"), + Self::X8_D24_UNORM_PACK32 => Some("X8_D24_UNORM_PACK32"), + Self::D32_SFLOAT => Some("D32_SFLOAT"), + Self::S8_UINT => Some("S8_UINT"), + Self::D16_UNORM_S8_UINT => Some("D16_UNORM_S8_UINT"), + Self::D24_UNORM_S8_UINT => Some("D24_UNORM_S8_UINT"), + Self::D32_SFLOAT_S8_UINT => Some("D32_SFLOAT_S8_UINT"), + Self::BC1_RGB_UNORM_BLOCK => Some("BC1_RGB_UNORM_BLOCK"), + Self::BC1_RGB_SRGB_BLOCK => Some("BC1_RGB_SRGB_BLOCK"), + Self::BC1_RGBA_UNORM_BLOCK => Some("BC1_RGBA_UNORM_BLOCK"), + Self::BC1_RGBA_SRGB_BLOCK => Some("BC1_RGBA_SRGB_BLOCK"), + Self::BC2_UNORM_BLOCK => Some("BC2_UNORM_BLOCK"), + Self::BC2_SRGB_BLOCK => Some("BC2_SRGB_BLOCK"), + Self::BC3_UNORM_BLOCK => Some("BC3_UNORM_BLOCK"), + Self::BC3_SRGB_BLOCK => Some("BC3_SRGB_BLOCK"), + Self::BC4_UNORM_BLOCK => Some("BC4_UNORM_BLOCK"), + Self::BC4_SNORM_BLOCK => Some("BC4_SNORM_BLOCK"), + Self::BC5_UNORM_BLOCK => Some("BC5_UNORM_BLOCK"), + Self::BC5_SNORM_BLOCK => Some("BC5_SNORM_BLOCK"), + Self::BC6H_UFLOAT_BLOCK => Some("BC6H_UFLOAT_BLOCK"), + Self::BC6H_SFLOAT_BLOCK => Some("BC6H_SFLOAT_BLOCK"), + Self::BC7_UNORM_BLOCK => Some("BC7_UNORM_BLOCK"), + Self::BC7_SRGB_BLOCK => Some("BC7_SRGB_BLOCK"), + Self::ETC2_R8G8B8_UNORM_BLOCK => Some("ETC2_R8G8B8_UNORM_BLOCK"), + Self::ETC2_R8G8B8_SRGB_BLOCK => Some("ETC2_R8G8B8_SRGB_BLOCK"), + Self::ETC2_R8G8B8A1_UNORM_BLOCK => Some("ETC2_R8G8B8A1_UNORM_BLOCK"), + Self::ETC2_R8G8B8A1_SRGB_BLOCK => Some("ETC2_R8G8B8A1_SRGB_BLOCK"), + Self::ETC2_R8G8B8A8_UNORM_BLOCK => Some("ETC2_R8G8B8A8_UNORM_BLOCK"), + Self::ETC2_R8G8B8A8_SRGB_BLOCK => Some("ETC2_R8G8B8A8_SRGB_BLOCK"), + Self::EAC_R11_UNORM_BLOCK => Some("EAC_R11_UNORM_BLOCK"), + Self::EAC_R11_SNORM_BLOCK => Some("EAC_R11_SNORM_BLOCK"), + Self::EAC_R11G11_UNORM_BLOCK => Some("EAC_R11G11_UNORM_BLOCK"), + Self::EAC_R11G11_SNORM_BLOCK => Some("EAC_R11G11_SNORM_BLOCK"), + Self::ASTC_4X4_UNORM_BLOCK => Some("ASTC_4X4_UNORM_BLOCK"), + Self::ASTC_4X4_SRGB_BLOCK => Some("ASTC_4X4_SRGB_BLOCK"), + Self::ASTC_5X4_UNORM_BLOCK => Some("ASTC_5X4_UNORM_BLOCK"), + Self::ASTC_5X4_SRGB_BLOCK => Some("ASTC_5X4_SRGB_BLOCK"), + Self::ASTC_5X5_UNORM_BLOCK => Some("ASTC_5X5_UNORM_BLOCK"), + Self::ASTC_5X5_SRGB_BLOCK => Some("ASTC_5X5_SRGB_BLOCK"), + Self::ASTC_6X5_UNORM_BLOCK => Some("ASTC_6X5_UNORM_BLOCK"), + Self::ASTC_6X5_SRGB_BLOCK => Some("ASTC_6X5_SRGB_BLOCK"), + Self::ASTC_6X6_UNORM_BLOCK => Some("ASTC_6X6_UNORM_BLOCK"), + Self::ASTC_6X6_SRGB_BLOCK => Some("ASTC_6X6_SRGB_BLOCK"), + Self::ASTC_8X5_UNORM_BLOCK => Some("ASTC_8X5_UNORM_BLOCK"), + Self::ASTC_8X5_SRGB_BLOCK => Some("ASTC_8X5_SRGB_BLOCK"), + Self::ASTC_8X6_UNORM_BLOCK => Some("ASTC_8X6_UNORM_BLOCK"), + Self::ASTC_8X6_SRGB_BLOCK => Some("ASTC_8X6_SRGB_BLOCK"), + Self::ASTC_8X8_UNORM_BLOCK => Some("ASTC_8X8_UNORM_BLOCK"), + Self::ASTC_8X8_SRGB_BLOCK => Some("ASTC_8X8_SRGB_BLOCK"), + Self::ASTC_10X5_UNORM_BLOCK => Some("ASTC_10X5_UNORM_BLOCK"), + Self::ASTC_10X5_SRGB_BLOCK => Some("ASTC_10X5_SRGB_BLOCK"), + Self::ASTC_10X6_UNORM_BLOCK => Some("ASTC_10X6_UNORM_BLOCK"), + Self::ASTC_10X6_SRGB_BLOCK => Some("ASTC_10X6_SRGB_BLOCK"), + Self::ASTC_10X8_UNORM_BLOCK => Some("ASTC_10X8_UNORM_BLOCK"), + Self::ASTC_10X8_SRGB_BLOCK => Some("ASTC_10X8_SRGB_BLOCK"), + Self::ASTC_10X10_UNORM_BLOCK => Some("ASTC_10X10_UNORM_BLOCK"), + Self::ASTC_10X10_SRGB_BLOCK => Some("ASTC_10X10_SRGB_BLOCK"), + Self::ASTC_12X10_UNORM_BLOCK => Some("ASTC_12X10_UNORM_BLOCK"), + Self::ASTC_12X10_SRGB_BLOCK => Some("ASTC_12X10_SRGB_BLOCK"), + Self::ASTC_12X12_UNORM_BLOCK => Some("ASTC_12X12_UNORM_BLOCK"), + Self::ASTC_12X12_SRGB_BLOCK => Some("ASTC_12X12_SRGB_BLOCK"), + Self::PVRTC1_2BPP_UNORM_BLOCK_IMG => Some("PVRTC1_2BPP_UNORM_BLOCK_IMG"), + Self::PVRTC1_4BPP_UNORM_BLOCK_IMG => Some("PVRTC1_4BPP_UNORM_BLOCK_IMG"), + Self::PVRTC2_2BPP_UNORM_BLOCK_IMG => Some("PVRTC2_2BPP_UNORM_BLOCK_IMG"), + Self::PVRTC2_4BPP_UNORM_BLOCK_IMG => Some("PVRTC2_4BPP_UNORM_BLOCK_IMG"), + Self::PVRTC1_2BPP_SRGB_BLOCK_IMG => Some("PVRTC1_2BPP_SRGB_BLOCK_IMG"), + Self::PVRTC1_4BPP_SRGB_BLOCK_IMG => Some("PVRTC1_4BPP_SRGB_BLOCK_IMG"), + Self::PVRTC2_2BPP_SRGB_BLOCK_IMG => Some("PVRTC2_2BPP_SRGB_BLOCK_IMG"), + Self::PVRTC2_4BPP_SRGB_BLOCK_IMG => Some("PVRTC2_4BPP_SRGB_BLOCK_IMG"), + Self::ASTC_3X3X3_UNORM_BLOCK_EXT => Some("ASTC_3X3X3_UNORM_BLOCK_EXT"), + Self::ASTC_3X3X3_SRGB_BLOCK_EXT => Some("ASTC_3X3X3_SRGB_BLOCK_EXT"), + Self::ASTC_3X3X3_SFLOAT_BLOCK_EXT => Some("ASTC_3X3X3_SFLOAT_BLOCK_EXT"), + Self::ASTC_4X3X3_UNORM_BLOCK_EXT => Some("ASTC_4X3X3_UNORM_BLOCK_EXT"), + Self::ASTC_4X3X3_SRGB_BLOCK_EXT => Some("ASTC_4X3X3_SRGB_BLOCK_EXT"), + Self::ASTC_4X3X3_SFLOAT_BLOCK_EXT => Some("ASTC_4X3X3_SFLOAT_BLOCK_EXT"), + Self::ASTC_4X4X3_UNORM_BLOCK_EXT => Some("ASTC_4X4X3_UNORM_BLOCK_EXT"), + Self::ASTC_4X4X3_SRGB_BLOCK_EXT => Some("ASTC_4X4X3_SRGB_BLOCK_EXT"), + Self::ASTC_4X4X3_SFLOAT_BLOCK_EXT => Some("ASTC_4X4X3_SFLOAT_BLOCK_EXT"), + Self::ASTC_4X4X4_UNORM_BLOCK_EXT => Some("ASTC_4X4X4_UNORM_BLOCK_EXT"), + Self::ASTC_4X4X4_SRGB_BLOCK_EXT => Some("ASTC_4X4X4_SRGB_BLOCK_EXT"), + Self::ASTC_4X4X4_SFLOAT_BLOCK_EXT => Some("ASTC_4X4X4_SFLOAT_BLOCK_EXT"), + Self::ASTC_5X4X4_UNORM_BLOCK_EXT => Some("ASTC_5X4X4_UNORM_BLOCK_EXT"), + Self::ASTC_5X4X4_SRGB_BLOCK_EXT => Some("ASTC_5X4X4_SRGB_BLOCK_EXT"), + Self::ASTC_5X4X4_SFLOAT_BLOCK_EXT => Some("ASTC_5X4X4_SFLOAT_BLOCK_EXT"), + Self::ASTC_5X5X4_UNORM_BLOCK_EXT => Some("ASTC_5X5X4_UNORM_BLOCK_EXT"), + Self::ASTC_5X5X4_SRGB_BLOCK_EXT => Some("ASTC_5X5X4_SRGB_BLOCK_EXT"), + Self::ASTC_5X5X4_SFLOAT_BLOCK_EXT => Some("ASTC_5X5X4_SFLOAT_BLOCK_EXT"), + Self::ASTC_5X5X5_UNORM_BLOCK_EXT => Some("ASTC_5X5X5_UNORM_BLOCK_EXT"), + Self::ASTC_5X5X5_SRGB_BLOCK_EXT => Some("ASTC_5X5X5_SRGB_BLOCK_EXT"), + Self::ASTC_5X5X5_SFLOAT_BLOCK_EXT => Some("ASTC_5X5X5_SFLOAT_BLOCK_EXT"), + Self::ASTC_6X5X5_UNORM_BLOCK_EXT => Some("ASTC_6X5X5_UNORM_BLOCK_EXT"), + Self::ASTC_6X5X5_SRGB_BLOCK_EXT => Some("ASTC_6X5X5_SRGB_BLOCK_EXT"), + Self::ASTC_6X5X5_SFLOAT_BLOCK_EXT => Some("ASTC_6X5X5_SFLOAT_BLOCK_EXT"), + Self::ASTC_6X6X5_UNORM_BLOCK_EXT => Some("ASTC_6X6X5_UNORM_BLOCK_EXT"), + Self::ASTC_6X6X5_SRGB_BLOCK_EXT => Some("ASTC_6X6X5_SRGB_BLOCK_EXT"), + Self::ASTC_6X6X5_SFLOAT_BLOCK_EXT => Some("ASTC_6X6X5_SFLOAT_BLOCK_EXT"), + Self::ASTC_6X6X6_UNORM_BLOCK_EXT => Some("ASTC_6X6X6_UNORM_BLOCK_EXT"), + Self::ASTC_6X6X6_SRGB_BLOCK_EXT => Some("ASTC_6X6X6_SRGB_BLOCK_EXT"), + Self::ASTC_6X6X6_SFLOAT_BLOCK_EXT => Some("ASTC_6X6X6_SFLOAT_BLOCK_EXT"), + Self::R16G16_S10_5_NV => Some("R16G16_S10_5_NV"), + Self::G8B8G8R8_422_UNORM => Some("G8B8G8R8_422_UNORM"), + Self::B8G8R8G8_422_UNORM => Some("B8G8R8G8_422_UNORM"), + Self::G8_B8_R8_3PLANE_420_UNORM => Some("G8_B8_R8_3PLANE_420_UNORM"), + Self::G8_B8R8_2PLANE_420_UNORM => Some("G8_B8R8_2PLANE_420_UNORM"), + Self::G8_B8_R8_3PLANE_422_UNORM => Some("G8_B8_R8_3PLANE_422_UNORM"), + Self::G8_B8R8_2PLANE_422_UNORM => Some("G8_B8R8_2PLANE_422_UNORM"), + Self::G8_B8_R8_3PLANE_444_UNORM => Some("G8_B8_R8_3PLANE_444_UNORM"), + Self::R10X6_UNORM_PACK16 => Some("R10X6_UNORM_PACK16"), + Self::R10X6G10X6_UNORM_2PACK16 => Some("R10X6G10X6_UNORM_2PACK16"), + Self::R10X6G10X6B10X6A10X6_UNORM_4PACK16 => Some("R10X6G10X6B10X6A10X6_UNORM_4PACK16"), + Self::G10X6B10X6G10X6R10X6_422_UNORM_4PACK16 => { + Some("G10X6B10X6G10X6R10X6_422_UNORM_4PACK16") + } + Self::B10X6G10X6R10X6G10X6_422_UNORM_4PACK16 => { + Some("B10X6G10X6R10X6G10X6_422_UNORM_4PACK16") + } + Self::G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16 => { + Some("G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16") + } + Self::G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16 => { + Some("G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16") + } + Self::G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16 => { + Some("G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16") + } + Self::G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16 => { + Some("G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16") + } + Self::G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16 => { + Some("G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16") + } + Self::R12X4_UNORM_PACK16 => Some("R12X4_UNORM_PACK16"), + Self::R12X4G12X4_UNORM_2PACK16 => Some("R12X4G12X4_UNORM_2PACK16"), + Self::R12X4G12X4B12X4A12X4_UNORM_4PACK16 => Some("R12X4G12X4B12X4A12X4_UNORM_4PACK16"), + Self::G12X4B12X4G12X4R12X4_422_UNORM_4PACK16 => { + Some("G12X4B12X4G12X4R12X4_422_UNORM_4PACK16") + } + Self::B12X4G12X4R12X4G12X4_422_UNORM_4PACK16 => { + Some("B12X4G12X4R12X4G12X4_422_UNORM_4PACK16") + } + Self::G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16 => { + Some("G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16") + } + Self::G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16 => { + Some("G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16") + } + Self::G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16 => { + Some("G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16") + } + Self::G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16 => { + Some("G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16") + } + Self::G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16 => { + Some("G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16") + } + Self::G16B16G16R16_422_UNORM => Some("G16B16G16R16_422_UNORM"), + Self::B16G16R16G16_422_UNORM => Some("B16G16R16G16_422_UNORM"), + Self::G16_B16_R16_3PLANE_420_UNORM => Some("G16_B16_R16_3PLANE_420_UNORM"), + Self::G16_B16R16_2PLANE_420_UNORM => Some("G16_B16R16_2PLANE_420_UNORM"), + Self::G16_B16_R16_3PLANE_422_UNORM => Some("G16_B16_R16_3PLANE_422_UNORM"), + Self::G16_B16R16_2PLANE_422_UNORM => Some("G16_B16R16_2PLANE_422_UNORM"), + Self::G16_B16_R16_3PLANE_444_UNORM => Some("G16_B16_R16_3PLANE_444_UNORM"), + Self::G8_B8R8_2PLANE_444_UNORM => Some("G8_B8R8_2PLANE_444_UNORM"), + Self::G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16 => { + Some("G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16") + } + Self::G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16 => { + Some("G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16") + } + Self::G16_B16R16_2PLANE_444_UNORM => Some("G16_B16R16_2PLANE_444_UNORM"), + Self::A4R4G4B4_UNORM_PACK16 => Some("A4R4G4B4_UNORM_PACK16"), + Self::A4B4G4R4_UNORM_PACK16 => Some("A4B4G4R4_UNORM_PACK16"), + Self::ASTC_4X4_SFLOAT_BLOCK => Some("ASTC_4X4_SFLOAT_BLOCK"), + Self::ASTC_5X4_SFLOAT_BLOCK => Some("ASTC_5X4_SFLOAT_BLOCK"), + Self::ASTC_5X5_SFLOAT_BLOCK => Some("ASTC_5X5_SFLOAT_BLOCK"), + Self::ASTC_6X5_SFLOAT_BLOCK => Some("ASTC_6X5_SFLOAT_BLOCK"), + Self::ASTC_6X6_SFLOAT_BLOCK => Some("ASTC_6X6_SFLOAT_BLOCK"), + Self::ASTC_8X5_SFLOAT_BLOCK => Some("ASTC_8X5_SFLOAT_BLOCK"), + Self::ASTC_8X6_SFLOAT_BLOCK => Some("ASTC_8X6_SFLOAT_BLOCK"), + Self::ASTC_8X8_SFLOAT_BLOCK => Some("ASTC_8X8_SFLOAT_BLOCK"), + Self::ASTC_10X5_SFLOAT_BLOCK => Some("ASTC_10X5_SFLOAT_BLOCK"), + Self::ASTC_10X6_SFLOAT_BLOCK => Some("ASTC_10X6_SFLOAT_BLOCK"), + Self::ASTC_10X8_SFLOAT_BLOCK => Some("ASTC_10X8_SFLOAT_BLOCK"), + Self::ASTC_10X10_SFLOAT_BLOCK => Some("ASTC_10X10_SFLOAT_BLOCK"), + Self::ASTC_12X10_SFLOAT_BLOCK => Some("ASTC_12X10_SFLOAT_BLOCK"), + Self::ASTC_12X12_SFLOAT_BLOCK => Some("ASTC_12X12_SFLOAT_BLOCK"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for FormatFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN : & [(Flags , & str)] = & [(FormatFeatureFlags :: SAMPLED_IMAGE . 0 , "SAMPLED_IMAGE") , (FormatFeatureFlags :: STORAGE_IMAGE . 0 , "STORAGE_IMAGE") , (FormatFeatureFlags :: STORAGE_IMAGE_ATOMIC . 0 , "STORAGE_IMAGE_ATOMIC") , (FormatFeatureFlags :: UNIFORM_TEXEL_BUFFER . 0 , "UNIFORM_TEXEL_BUFFER") , (FormatFeatureFlags :: STORAGE_TEXEL_BUFFER . 0 , "STORAGE_TEXEL_BUFFER") , (FormatFeatureFlags :: STORAGE_TEXEL_BUFFER_ATOMIC . 0 , "STORAGE_TEXEL_BUFFER_ATOMIC") , (FormatFeatureFlags :: VERTEX_BUFFER . 0 , "VERTEX_BUFFER") , (FormatFeatureFlags :: COLOR_ATTACHMENT . 0 , "COLOR_ATTACHMENT") , (FormatFeatureFlags :: COLOR_ATTACHMENT_BLEND . 0 , "COLOR_ATTACHMENT_BLEND") , (FormatFeatureFlags :: DEPTH_STENCIL_ATTACHMENT . 0 , "DEPTH_STENCIL_ATTACHMENT") , (FormatFeatureFlags :: BLIT_SRC . 0 , "BLIT_SRC") , (FormatFeatureFlags :: BLIT_DST . 0 , "BLIT_DST") , (FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_LINEAR . 0 , "SAMPLED_IMAGE_FILTER_LINEAR") , (FormatFeatureFlags :: VIDEO_DECODE_OUTPUT_KHR . 0 , "VIDEO_DECODE_OUTPUT_KHR") , (FormatFeatureFlags :: VIDEO_DECODE_DPB_KHR . 0 , "VIDEO_DECODE_DPB_KHR") , (FormatFeatureFlags :: ACCELERATION_STRUCTURE_VERTEX_BUFFER_KHR . 0 , "ACCELERATION_STRUCTURE_VERTEX_BUFFER_KHR") , (FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_CUBIC_EXT . 0 , "SAMPLED_IMAGE_FILTER_CUBIC_EXT") , (FormatFeatureFlags :: FRAGMENT_DENSITY_MAP_EXT . 0 , "FRAGMENT_DENSITY_MAP_EXT") , (FormatFeatureFlags :: FRAGMENT_SHADING_RATE_ATTACHMENT_KHR . 0 , "FRAGMENT_SHADING_RATE_ATTACHMENT_KHR") , (FormatFeatureFlags :: VIDEO_ENCODE_INPUT_KHR . 0 , "VIDEO_ENCODE_INPUT_KHR") , (FormatFeatureFlags :: VIDEO_ENCODE_DPB_KHR . 0 , "VIDEO_ENCODE_DPB_KHR") , (FormatFeatureFlags :: TRANSFER_SRC . 0 , "TRANSFER_SRC") , (FormatFeatureFlags :: TRANSFER_DST . 0 , "TRANSFER_DST") , (FormatFeatureFlags :: MIDPOINT_CHROMA_SAMPLES . 0 , "MIDPOINT_CHROMA_SAMPLES") , (FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER") , (FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER") , (FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT") , (FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE") , (FormatFeatureFlags :: DISJOINT . 0 , "DISJOINT") , (FormatFeatureFlags :: COSITED_CHROMA_SAMPLES . 0 , "COSITED_CHROMA_SAMPLES") , (FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_MINMAX . 0 , "SAMPLED_IMAGE_FILTER_MINMAX")] ; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for FormatFeatureFlags2 { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN : & [(Flags64 , & str)] = & [(FormatFeatureFlags2 :: SAMPLED_IMAGE . 0 , "SAMPLED_IMAGE") , (FormatFeatureFlags2 :: STORAGE_IMAGE . 0 , "STORAGE_IMAGE") , (FormatFeatureFlags2 :: STORAGE_IMAGE_ATOMIC . 0 , "STORAGE_IMAGE_ATOMIC") , (FormatFeatureFlags2 :: UNIFORM_TEXEL_BUFFER . 0 , "UNIFORM_TEXEL_BUFFER") , (FormatFeatureFlags2 :: STORAGE_TEXEL_BUFFER . 0 , "STORAGE_TEXEL_BUFFER") , (FormatFeatureFlags2 :: STORAGE_TEXEL_BUFFER_ATOMIC . 0 , "STORAGE_TEXEL_BUFFER_ATOMIC") , (FormatFeatureFlags2 :: VERTEX_BUFFER . 0 , "VERTEX_BUFFER") , (FormatFeatureFlags2 :: COLOR_ATTACHMENT . 0 , "COLOR_ATTACHMENT") , (FormatFeatureFlags2 :: COLOR_ATTACHMENT_BLEND . 0 , "COLOR_ATTACHMENT_BLEND") , (FormatFeatureFlags2 :: DEPTH_STENCIL_ATTACHMENT . 0 , "DEPTH_STENCIL_ATTACHMENT") , (FormatFeatureFlags2 :: BLIT_SRC . 0 , "BLIT_SRC") , (FormatFeatureFlags2 :: BLIT_DST . 0 , "BLIT_DST") , (FormatFeatureFlags2 :: SAMPLED_IMAGE_FILTER_LINEAR . 0 , "SAMPLED_IMAGE_FILTER_LINEAR") , (FormatFeatureFlags2 :: SAMPLED_IMAGE_FILTER_CUBIC . 0 , "SAMPLED_IMAGE_FILTER_CUBIC") , (FormatFeatureFlags2 :: TRANSFER_SRC . 0 , "TRANSFER_SRC") , (FormatFeatureFlags2 :: TRANSFER_DST . 0 , "TRANSFER_DST") , (FormatFeatureFlags2 :: SAMPLED_IMAGE_FILTER_MINMAX . 0 , "SAMPLED_IMAGE_FILTER_MINMAX") , (FormatFeatureFlags2 :: MIDPOINT_CHROMA_SAMPLES . 0 , "MIDPOINT_CHROMA_SAMPLES") , (FormatFeatureFlags2 :: SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER") , (FormatFeatureFlags2 :: SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER") , (FormatFeatureFlags2 :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT") , (FormatFeatureFlags2 :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE") , (FormatFeatureFlags2 :: DISJOINT . 0 , "DISJOINT") , (FormatFeatureFlags2 :: COSITED_CHROMA_SAMPLES . 0 , "COSITED_CHROMA_SAMPLES") , (FormatFeatureFlags2 :: STORAGE_READ_WITHOUT_FORMAT . 0 , "STORAGE_READ_WITHOUT_FORMAT") , (FormatFeatureFlags2 :: STORAGE_WRITE_WITHOUT_FORMAT . 0 , "STORAGE_WRITE_WITHOUT_FORMAT") , (FormatFeatureFlags2 :: SAMPLED_IMAGE_DEPTH_COMPARISON . 0 , "SAMPLED_IMAGE_DEPTH_COMPARISON") , (FormatFeatureFlags2 :: VIDEO_DECODE_OUTPUT_KHR . 0 , "VIDEO_DECODE_OUTPUT_KHR") , (FormatFeatureFlags2 :: VIDEO_DECODE_DPB_KHR . 0 , "VIDEO_DECODE_DPB_KHR") , (FormatFeatureFlags2 :: ACCELERATION_STRUCTURE_VERTEX_BUFFER_KHR . 0 , "ACCELERATION_STRUCTURE_VERTEX_BUFFER_KHR") , (FormatFeatureFlags2 :: FRAGMENT_DENSITY_MAP_EXT . 0 , "FRAGMENT_DENSITY_MAP_EXT") , (FormatFeatureFlags2 :: FRAGMENT_SHADING_RATE_ATTACHMENT_KHR . 0 , "FRAGMENT_SHADING_RATE_ATTACHMENT_KHR") , (FormatFeatureFlags2 :: RESERVED_44_EXT . 0 , "RESERVED_44_EXT") , (FormatFeatureFlags2 :: RESERVED_45_EXT . 0 , "RESERVED_45_EXT") , (FormatFeatureFlags2 :: VIDEO_ENCODE_INPUT_KHR . 0 , "VIDEO_ENCODE_INPUT_KHR") , (FormatFeatureFlags2 :: VIDEO_ENCODE_DPB_KHR . 0 , "VIDEO_ENCODE_DPB_KHR") , (FormatFeatureFlags2 :: LINEAR_COLOR_ATTACHMENT_NV . 0 , "LINEAR_COLOR_ATTACHMENT_NV") , (FormatFeatureFlags2 :: WEIGHT_IMAGE_QCOM . 0 , "WEIGHT_IMAGE_QCOM") , (FormatFeatureFlags2 :: WEIGHT_SAMPLED_IMAGE_QCOM . 0 , "WEIGHT_SAMPLED_IMAGE_QCOM") , (FormatFeatureFlags2 :: BLOCK_MATCHING_QCOM . 0 , "BLOCK_MATCHING_QCOM") , (FormatFeatureFlags2 :: BOX_FILTER_SAMPLED_QCOM . 0 , "BOX_FILTER_SAMPLED_QCOM") , (FormatFeatureFlags2 :: RESERVED_39_EXT . 0 , "RESERVED_39_EXT") , (FormatFeatureFlags2 :: OPTICAL_FLOW_IMAGE_NV . 0 , "OPTICAL_FLOW_IMAGE_NV") , (FormatFeatureFlags2 :: OPTICAL_FLOW_VECTOR_NV . 0 , "OPTICAL_FLOW_VECTOR_NV") , (FormatFeatureFlags2 :: OPTICAL_FLOW_COST_NV . 0 , "OPTICAL_FLOW_COST_NV")] ; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for FragmentShadingRateCombinerOpKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::KEEP => Some("KEEP"), + Self::REPLACE => Some("REPLACE"), + Self::MIN => Some("MIN"), + Self::MAX => Some("MAX"), + Self::MUL => Some("MUL"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for FragmentShadingRateNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::TYPE_1_INVOCATION_PER_PIXEL => Some("TYPE_1_INVOCATION_PER_PIXEL"), + Self::TYPE_1_INVOCATION_PER_1X2_PIXELS => Some("TYPE_1_INVOCATION_PER_1X2_PIXELS"), + Self::TYPE_1_INVOCATION_PER_2X1_PIXELS => Some("TYPE_1_INVOCATION_PER_2X1_PIXELS"), + Self::TYPE_1_INVOCATION_PER_2X2_PIXELS => Some("TYPE_1_INVOCATION_PER_2X2_PIXELS"), + Self::TYPE_1_INVOCATION_PER_2X4_PIXELS => Some("TYPE_1_INVOCATION_PER_2X4_PIXELS"), + Self::TYPE_1_INVOCATION_PER_4X2_PIXELS => Some("TYPE_1_INVOCATION_PER_4X2_PIXELS"), + Self::TYPE_1_INVOCATION_PER_4X4_PIXELS => Some("TYPE_1_INVOCATION_PER_4X4_PIXELS"), + Self::TYPE_2_INVOCATIONS_PER_PIXEL => Some("TYPE_2_INVOCATIONS_PER_PIXEL"), + Self::TYPE_4_INVOCATIONS_PER_PIXEL => Some("TYPE_4_INVOCATIONS_PER_PIXEL"), + Self::TYPE_8_INVOCATIONS_PER_PIXEL => Some("TYPE_8_INVOCATIONS_PER_PIXEL"), + Self::TYPE_16_INVOCATIONS_PER_PIXEL => Some("TYPE_16_INVOCATIONS_PER_PIXEL"), + Self::NO_INVOCATIONS => Some("NO_INVOCATIONS"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for FragmentShadingRateTypeNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::FRAGMENT_SIZE => Some("FRAGMENT_SIZE"), + Self::ENUMS => Some("ENUMS"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for FramebufferCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(FramebufferCreateFlags::IMAGELESS.0, "IMAGELESS")]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for FrontFace { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::COUNTER_CLOCKWISE => Some("COUNTER_CLOCKWISE"), + Self::CLOCKWISE => Some("CLOCKWISE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for FullScreenExclusiveEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DEFAULT => Some("DEFAULT"), + Self::ALLOWED => Some("ALLOWED"), + Self::DISALLOWED => Some("DISALLOWED"), + Self::APPLICATION_CONTROLLED => Some("APPLICATION_CONTROLLED"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for GeometryFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (GeometryFlagsKHR::OPAQUE.0, "OPAQUE"), + ( + GeometryFlagsKHR::NO_DUPLICATE_ANY_HIT_INVOCATION.0, + "NO_DUPLICATE_ANY_HIT_INVOCATION", + ), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for GeometryInstanceFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + GeometryInstanceFlagsKHR::TRIANGLE_FACING_CULL_DISABLE.0, + "TRIANGLE_FACING_CULL_DISABLE", + ), + ( + GeometryInstanceFlagsKHR::TRIANGLE_FLIP_FACING.0, + "TRIANGLE_FLIP_FACING", + ), + (GeometryInstanceFlagsKHR::FORCE_OPAQUE.0, "FORCE_OPAQUE"), + ( + GeometryInstanceFlagsKHR::FORCE_NO_OPAQUE.0, + "FORCE_NO_OPAQUE", + ), + ( + GeometryInstanceFlagsKHR::FORCE_OPACITY_MICROMAP_2_STATE_EXT.0, + "FORCE_OPACITY_MICROMAP_2_STATE_EXT", + ), + ( + GeometryInstanceFlagsKHR::DISABLE_OPACITY_MICROMAPS_EXT.0, + "DISABLE_OPACITY_MICROMAPS_EXT", + ), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for GeometryTypeKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::TRIANGLES => Some("TRIANGLES"), + Self::AABBS => Some("AABBS"), + Self::INSTANCES => Some("INSTANCES"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for GraphicsPipelineLibraryFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + GraphicsPipelineLibraryFlagsEXT::VERTEX_INPUT_INTERFACE.0, + "VERTEX_INPUT_INTERFACE", + ), + ( + GraphicsPipelineLibraryFlagsEXT::PRE_RASTERIZATION_SHADERS.0, + "PRE_RASTERIZATION_SHADERS", + ), + ( + GraphicsPipelineLibraryFlagsEXT::FRAGMENT_SHADER.0, + "FRAGMENT_SHADER", + ), + ( + GraphicsPipelineLibraryFlagsEXT::FRAGMENT_OUTPUT_INTERFACE.0, + "FRAGMENT_OUTPUT_INTERFACE", + ), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for HeadlessSurfaceCreateFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for IOSSurfaceCreateFlagsMVK { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for ImageAspectFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ImageAspectFlags::COLOR.0, "COLOR"), + (ImageAspectFlags::DEPTH.0, "DEPTH"), + (ImageAspectFlags::STENCIL.0, "STENCIL"), + (ImageAspectFlags::METADATA.0, "METADATA"), + (ImageAspectFlags::MEMORY_PLANE_0_EXT.0, "MEMORY_PLANE_0_EXT"), + (ImageAspectFlags::MEMORY_PLANE_1_EXT.0, "MEMORY_PLANE_1_EXT"), + (ImageAspectFlags::MEMORY_PLANE_2_EXT.0, "MEMORY_PLANE_2_EXT"), + (ImageAspectFlags::MEMORY_PLANE_3_EXT.0, "MEMORY_PLANE_3_EXT"), + (ImageAspectFlags::PLANE_0.0, "PLANE_0"), + (ImageAspectFlags::PLANE_1.0, "PLANE_1"), + (ImageAspectFlags::PLANE_2.0, "PLANE_2"), + (ImageAspectFlags::NONE.0, "NONE"), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for ImageCompressionFixedRateFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ImageCompressionFixedRateFlagsEXT::NONE.0, "NONE"), + (ImageCompressionFixedRateFlagsEXT::TYPE_1BPC.0, "TYPE_1BPC"), + (ImageCompressionFixedRateFlagsEXT::TYPE_2BPC.0, "TYPE_2BPC"), + (ImageCompressionFixedRateFlagsEXT::TYPE_3BPC.0, "TYPE_3BPC"), + (ImageCompressionFixedRateFlagsEXT::TYPE_4BPC.0, "TYPE_4BPC"), + (ImageCompressionFixedRateFlagsEXT::TYPE_5BPC.0, "TYPE_5BPC"), + (ImageCompressionFixedRateFlagsEXT::TYPE_6BPC.0, "TYPE_6BPC"), + (ImageCompressionFixedRateFlagsEXT::TYPE_7BPC.0, "TYPE_7BPC"), + (ImageCompressionFixedRateFlagsEXT::TYPE_8BPC.0, "TYPE_8BPC"), + (ImageCompressionFixedRateFlagsEXT::TYPE_9BPC.0, "TYPE_9BPC"), + ( + ImageCompressionFixedRateFlagsEXT::TYPE_10BPC.0, + "TYPE_10BPC", + ), + ( + ImageCompressionFixedRateFlagsEXT::TYPE_11BPC.0, + "TYPE_11BPC", + ), + ( + ImageCompressionFixedRateFlagsEXT::TYPE_12BPC.0, + "TYPE_12BPC", + ), + ( + ImageCompressionFixedRateFlagsEXT::TYPE_13BPC.0, + "TYPE_13BPC", + ), + ( + ImageCompressionFixedRateFlagsEXT::TYPE_14BPC.0, + "TYPE_14BPC", + ), + ( + ImageCompressionFixedRateFlagsEXT::TYPE_15BPC.0, + "TYPE_15BPC", + ), + ( + ImageCompressionFixedRateFlagsEXT::TYPE_16BPC.0, + "TYPE_16BPC", + ), + ( + ImageCompressionFixedRateFlagsEXT::TYPE_17BPC.0, + "TYPE_17BPC", + ), + ( + ImageCompressionFixedRateFlagsEXT::TYPE_18BPC.0, + "TYPE_18BPC", + ), + ( + ImageCompressionFixedRateFlagsEXT::TYPE_19BPC.0, + "TYPE_19BPC", + ), + ( + ImageCompressionFixedRateFlagsEXT::TYPE_20BPC.0, + "TYPE_20BPC", + ), + ( + ImageCompressionFixedRateFlagsEXT::TYPE_21BPC.0, + "TYPE_21BPC", + ), + ( + ImageCompressionFixedRateFlagsEXT::TYPE_22BPC.0, + "TYPE_22BPC", + ), + ( + ImageCompressionFixedRateFlagsEXT::TYPE_23BPC.0, + "TYPE_23BPC", + ), + ( + ImageCompressionFixedRateFlagsEXT::TYPE_24BPC.0, + "TYPE_24BPC", + ), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for ImageCompressionFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ImageCompressionFlagsEXT::DEFAULT.0, "DEFAULT"), + ( + ImageCompressionFlagsEXT::FIXED_RATE_DEFAULT.0, + "FIXED_RATE_DEFAULT", + ), + ( + ImageCompressionFlagsEXT::FIXED_RATE_EXPLICIT.0, + "FIXED_RATE_EXPLICIT", + ), + (ImageCompressionFlagsEXT::DISABLED.0, "DISABLED"), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for ImageConstraintsInfoFlagsFUCHSIA { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ImageConstraintsInfoFlagsFUCHSIA::CPU_READ_RARELY.0, + "CPU_READ_RARELY", + ), + ( + ImageConstraintsInfoFlagsFUCHSIA::CPU_READ_OFTEN.0, + "CPU_READ_OFTEN", + ), + ( + ImageConstraintsInfoFlagsFUCHSIA::CPU_WRITE_RARELY.0, + "CPU_WRITE_RARELY", + ), + ( + ImageConstraintsInfoFlagsFUCHSIA::CPU_WRITE_OFTEN.0, + "CPU_WRITE_OFTEN", + ), + ( + ImageConstraintsInfoFlagsFUCHSIA::PROTECTED_OPTIONAL.0, + "PROTECTED_OPTIONAL", + ), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for ImageCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ImageCreateFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), + (ImageCreateFlags::SPARSE_RESIDENCY.0, "SPARSE_RESIDENCY"), + (ImageCreateFlags::SPARSE_ALIASED.0, "SPARSE_ALIASED"), + (ImageCreateFlags::MUTABLE_FORMAT.0, "MUTABLE_FORMAT"), + (ImageCreateFlags::CUBE_COMPATIBLE.0, "CUBE_COMPATIBLE"), + (ImageCreateFlags::CORNER_SAMPLED_NV.0, "CORNER_SAMPLED_NV"), + ( + ImageCreateFlags::SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_EXT.0, + "SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_EXT", + ), + (ImageCreateFlags::SUBSAMPLED_EXT.0, "SUBSAMPLED_EXT"), + (ImageCreateFlags::RESERVED_19_EXT.0, "RESERVED_19_EXT"), + ( + ImageCreateFlags::DESCRIPTOR_BUFFER_CAPTURE_REPLAY_EXT.0, + "DESCRIPTOR_BUFFER_CAPTURE_REPLAY_EXT", + ), + ( + ImageCreateFlags::MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_EXT.0, + "MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_EXT", + ), + ( + ImageCreateFlags::TYPE_2D_VIEW_COMPATIBLE_EXT.0, + "TYPE_2D_VIEW_COMPATIBLE_EXT", + ), + ( + ImageCreateFlags::FRAGMENT_DENSITY_MAP_OFFSET_QCOM.0, + "FRAGMENT_DENSITY_MAP_OFFSET_QCOM", + ), + (ImageCreateFlags::ALIAS.0, "ALIAS"), + ( + ImageCreateFlags::SPLIT_INSTANCE_BIND_REGIONS.0, + "SPLIT_INSTANCE_BIND_REGIONS", + ), + ( + ImageCreateFlags::TYPE_2D_ARRAY_COMPATIBLE.0, + "TYPE_2D_ARRAY_COMPATIBLE", + ), + ( + ImageCreateFlags::BLOCK_TEXEL_VIEW_COMPATIBLE.0, + "BLOCK_TEXEL_VIEW_COMPATIBLE", + ), + (ImageCreateFlags::EXTENDED_USAGE.0, "EXTENDED_USAGE"), + (ImageCreateFlags::PROTECTED.0, "PROTECTED"), + (ImageCreateFlags::DISJOINT.0, "DISJOINT"), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for ImageFormatConstraintsFlagsFUCHSIA { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for ImageLayout { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UNDEFINED => Some("UNDEFINED"), + Self::GENERAL => Some("GENERAL"), + Self::COLOR_ATTACHMENT_OPTIMAL => Some("COLOR_ATTACHMENT_OPTIMAL"), + Self::DEPTH_STENCIL_ATTACHMENT_OPTIMAL => Some("DEPTH_STENCIL_ATTACHMENT_OPTIMAL"), + Self::DEPTH_STENCIL_READ_ONLY_OPTIMAL => Some("DEPTH_STENCIL_READ_ONLY_OPTIMAL"), + Self::SHADER_READ_ONLY_OPTIMAL => Some("SHADER_READ_ONLY_OPTIMAL"), + Self::TRANSFER_SRC_OPTIMAL => Some("TRANSFER_SRC_OPTIMAL"), + Self::TRANSFER_DST_OPTIMAL => Some("TRANSFER_DST_OPTIMAL"), + Self::PREINITIALIZED => Some("PREINITIALIZED"), + Self::PRESENT_SRC_KHR => Some("PRESENT_SRC_KHR"), + Self::VIDEO_DECODE_DST_KHR => Some("VIDEO_DECODE_DST_KHR"), + Self::VIDEO_DECODE_SRC_KHR => Some("VIDEO_DECODE_SRC_KHR"), + Self::VIDEO_DECODE_DPB_KHR => Some("VIDEO_DECODE_DPB_KHR"), + Self::SHARED_PRESENT_KHR => Some("SHARED_PRESENT_KHR"), + Self::FRAGMENT_DENSITY_MAP_OPTIMAL_EXT => Some("FRAGMENT_DENSITY_MAP_OPTIMAL_EXT"), + Self::FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR => { + Some("FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR") + } + Self::VIDEO_ENCODE_DST_KHR => Some("VIDEO_ENCODE_DST_KHR"), + Self::VIDEO_ENCODE_SRC_KHR => Some("VIDEO_ENCODE_SRC_KHR"), + Self::VIDEO_ENCODE_DPB_KHR => Some("VIDEO_ENCODE_DPB_KHR"), + Self::ATTACHMENT_FEEDBACK_LOOP_OPTIMAL_EXT => { + Some("ATTACHMENT_FEEDBACK_LOOP_OPTIMAL_EXT") + } + Self::DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL => { + Some("DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL") + } + Self::DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL => { + Some("DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL") + } + Self::DEPTH_ATTACHMENT_OPTIMAL => Some("DEPTH_ATTACHMENT_OPTIMAL"), + Self::DEPTH_READ_ONLY_OPTIMAL => Some("DEPTH_READ_ONLY_OPTIMAL"), + Self::STENCIL_ATTACHMENT_OPTIMAL => Some("STENCIL_ATTACHMENT_OPTIMAL"), + Self::STENCIL_READ_ONLY_OPTIMAL => Some("STENCIL_READ_ONLY_OPTIMAL"), + Self::READ_ONLY_OPTIMAL => Some("READ_ONLY_OPTIMAL"), + Self::ATTACHMENT_OPTIMAL => Some("ATTACHMENT_OPTIMAL"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for ImagePipeSurfaceCreateFlagsFUCHSIA { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for ImageTiling { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::OPTIMAL => Some("OPTIMAL"), + Self::LINEAR => Some("LINEAR"), + Self::DRM_FORMAT_MODIFIER_EXT => Some("DRM_FORMAT_MODIFIER_EXT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for ImageType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::TYPE_1D => Some("TYPE_1D"), + Self::TYPE_2D => Some("TYPE_2D"), + Self::TYPE_3D => Some("TYPE_3D"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for ImageUsageFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ImageUsageFlags::TRANSFER_SRC.0, "TRANSFER_SRC"), + (ImageUsageFlags::TRANSFER_DST.0, "TRANSFER_DST"), + (ImageUsageFlags::SAMPLED.0, "SAMPLED"), + (ImageUsageFlags::STORAGE.0, "STORAGE"), + (ImageUsageFlags::COLOR_ATTACHMENT.0, "COLOR_ATTACHMENT"), + ( + ImageUsageFlags::DEPTH_STENCIL_ATTACHMENT.0, + "DEPTH_STENCIL_ATTACHMENT", + ), + ( + ImageUsageFlags::TRANSIENT_ATTACHMENT.0, + "TRANSIENT_ATTACHMENT", + ), + (ImageUsageFlags::INPUT_ATTACHMENT.0, "INPUT_ATTACHMENT"), + ( + ImageUsageFlags::VIDEO_DECODE_DST_KHR.0, + "VIDEO_DECODE_DST_KHR", + ), + ( + ImageUsageFlags::VIDEO_DECODE_SRC_KHR.0, + "VIDEO_DECODE_SRC_KHR", + ), + ( + ImageUsageFlags::VIDEO_DECODE_DPB_KHR.0, + "VIDEO_DECODE_DPB_KHR", + ), + (ImageUsageFlags::RESERVED_16_QCOM.0, "RESERVED_16_QCOM"), + (ImageUsageFlags::RESERVED_17_QCOM.0, "RESERVED_17_QCOM"), + ( + ImageUsageFlags::FRAGMENT_DENSITY_MAP_EXT.0, + "FRAGMENT_DENSITY_MAP_EXT", + ), + ( + ImageUsageFlags::FRAGMENT_SHADING_RATE_ATTACHMENT_KHR.0, + "FRAGMENT_SHADING_RATE_ATTACHMENT_KHR", + ), + (ImageUsageFlags::RESERVED_22_EXT.0, "RESERVED_22_EXT"), + ( + ImageUsageFlags::VIDEO_ENCODE_DST_KHR.0, + "VIDEO_ENCODE_DST_KHR", + ), + ( + ImageUsageFlags::VIDEO_ENCODE_SRC_KHR.0, + "VIDEO_ENCODE_SRC_KHR", + ), + ( + ImageUsageFlags::VIDEO_ENCODE_DPB_KHR.0, + "VIDEO_ENCODE_DPB_KHR", + ), + ( + ImageUsageFlags::ATTACHMENT_FEEDBACK_LOOP_EXT.0, + "ATTACHMENT_FEEDBACK_LOOP_EXT", + ), + ( + ImageUsageFlags::INVOCATION_MASK_HUAWEI.0, + "INVOCATION_MASK_HUAWEI", + ), + (ImageUsageFlags::SAMPLE_WEIGHT_QCOM.0, "SAMPLE_WEIGHT_QCOM"), + ( + ImageUsageFlags::SAMPLE_BLOCK_MATCH_QCOM.0, + "SAMPLE_BLOCK_MATCH_QCOM", + ), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for ImageViewCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + ImageViewCreateFlags::FRAGMENT_DENSITY_MAP_DYNAMIC_EXT.0, + "FRAGMENT_DENSITY_MAP_DYNAMIC_EXT", + ), + ( + ImageViewCreateFlags::DESCRIPTOR_BUFFER_CAPTURE_REPLAY_EXT.0, + "DESCRIPTOR_BUFFER_CAPTURE_REPLAY_EXT", + ), + ( + ImageViewCreateFlags::FRAGMENT_DENSITY_MAP_DEFERRED_EXT.0, + "FRAGMENT_DENSITY_MAP_DEFERRED_EXT", + ), + (ImageViewCreateFlags::RESERVED_3_EXT.0, "RESERVED_3_EXT"), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for ImageViewType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::TYPE_1D => Some("TYPE_1D"), + Self::TYPE_2D => Some("TYPE_2D"), + Self::TYPE_3D => Some("TYPE_3D"), + Self::CUBE => Some("CUBE"), + Self::TYPE_1D_ARRAY => Some("TYPE_1D_ARRAY"), + Self::TYPE_2D_ARRAY => Some("TYPE_2D_ARRAY"), + Self::CUBE_ARRAY => Some("CUBE_ARRAY"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for IndexType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UINT16 => Some("UINT16"), + Self::UINT32 => Some("UINT32"), + Self::NONE_KHR => Some("NONE_KHR"), + Self::UINT8_EXT => Some("UINT8_EXT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for IndirectCommandsLayoutUsageFlagsNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + IndirectCommandsLayoutUsageFlagsNV::EXPLICIT_PREPROCESS.0, + "EXPLICIT_PREPROCESS", + ), + ( + IndirectCommandsLayoutUsageFlagsNV::INDEXED_SEQUENCES.0, + "INDEXED_SEQUENCES", + ), + ( + IndirectCommandsLayoutUsageFlagsNV::UNORDERED_SEQUENCES.0, + "UNORDERED_SEQUENCES", + ), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for IndirectCommandsTokenTypeNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::SHADER_GROUP => Some("SHADER_GROUP"), + Self::STATE_FLAGS => Some("STATE_FLAGS"), + Self::INDEX_BUFFER => Some("INDEX_BUFFER"), + Self::VERTEX_BUFFER => Some("VERTEX_BUFFER"), + Self::PUSH_CONSTANT => Some("PUSH_CONSTANT"), + Self::DRAW_INDEXED => Some("DRAW_INDEXED"), + Self::DRAW => Some("DRAW"), + Self::DRAW_TASKS => Some("DRAW_TASKS"), + Self::DRAW_MESH_TASKS => Some("DRAW_MESH_TASKS"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for IndirectStateFlagsNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = + &[(IndirectStateFlagsNV::FLAG_FRONTFACE.0, "FLAG_FRONTFACE")]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for InstanceCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[( + InstanceCreateFlags::ENUMERATE_PORTABILITY_KHR.0, + "ENUMERATE_PORTABILITY_KHR", + )]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for InternalAllocationType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::EXECUTABLE => Some("EXECUTABLE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for LineRasterizationModeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DEFAULT => Some("DEFAULT"), + Self::RECTANGULAR => Some("RECTANGULAR"), + Self::BRESENHAM => Some("BRESENHAM"), + Self::RECTANGULAR_SMOOTH => Some("RECTANGULAR_SMOOTH"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for LogicOp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::CLEAR => Some("CLEAR"), + Self::AND => Some("AND"), + Self::AND_REVERSE => Some("AND_REVERSE"), + Self::COPY => Some("COPY"), + Self::AND_INVERTED => Some("AND_INVERTED"), + Self::NO_OP => Some("NO_OP"), + Self::XOR => Some("XOR"), + Self::OR => Some("OR"), + Self::NOR => Some("NOR"), + Self::EQUIVALENT => Some("EQUIVALENT"), + Self::INVERT => Some("INVERT"), + Self::OR_REVERSE => Some("OR_REVERSE"), + Self::COPY_INVERTED => Some("COPY_INVERTED"), + Self::OR_INVERTED => Some("OR_INVERTED"), + Self::NAND => Some("NAND"), + Self::SET => Some("SET"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for MacOSSurfaceCreateFlagsMVK { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for MemoryAllocateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (MemoryAllocateFlags::DEVICE_MASK.0, "DEVICE_MASK"), + (MemoryAllocateFlags::DEVICE_ADDRESS.0, "DEVICE_ADDRESS"), + ( + MemoryAllocateFlags::DEVICE_ADDRESS_CAPTURE_REPLAY.0, + "DEVICE_ADDRESS_CAPTURE_REPLAY", + ), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for MemoryDecompressionMethodFlagsNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags64, &str)] = &[( + MemoryDecompressionMethodFlagsNV::GDEFLATE_1_0.0, + "GDEFLATE_1_0", + )]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for MemoryHeapFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (MemoryHeapFlags::DEVICE_LOCAL.0, "DEVICE_LOCAL"), + (MemoryHeapFlags::RESERVED_2_KHR.0, "RESERVED_2_KHR"), + (MemoryHeapFlags::MULTI_INSTANCE.0, "MULTI_INSTANCE"), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for MemoryMapFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for MemoryOverallocationBehaviorAMD { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DEFAULT => Some("DEFAULT"), + Self::ALLOWED => Some("ALLOWED"), + Self::DISALLOWED => Some("DISALLOWED"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for MemoryPropertyFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (MemoryPropertyFlags::DEVICE_LOCAL.0, "DEVICE_LOCAL"), + (MemoryPropertyFlags::HOST_VISIBLE.0, "HOST_VISIBLE"), + (MemoryPropertyFlags::HOST_COHERENT.0, "HOST_COHERENT"), + (MemoryPropertyFlags::HOST_CACHED.0, "HOST_CACHED"), + (MemoryPropertyFlags::LAZILY_ALLOCATED.0, "LAZILY_ALLOCATED"), + ( + MemoryPropertyFlags::DEVICE_COHERENT_AMD.0, + "DEVICE_COHERENT_AMD", + ), + ( + MemoryPropertyFlags::DEVICE_UNCACHED_AMD.0, + "DEVICE_UNCACHED_AMD", + ), + (MemoryPropertyFlags::RDMA_CAPABLE_NV.0, "RDMA_CAPABLE_NV"), + (MemoryPropertyFlags::PROTECTED.0, "PROTECTED"), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for MetalSurfaceCreateFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for MicromapCreateFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[( + MicromapCreateFlagsEXT::DEVICE_ADDRESS_CAPTURE_REPLAY.0, + "DEVICE_ADDRESS_CAPTURE_REPLAY", + )]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for MicromapTypeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::OPACITY_MICROMAP => Some("OPACITY_MICROMAP"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for OpacityMicromapFormatEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::TYPE_2_STATE => Some("TYPE_2_STATE"), + Self::TYPE_4_STATE => Some("TYPE_4_STATE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for OpacityMicromapSpecialIndexEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::FULLY_TRANSPARENT => Some("FULLY_TRANSPARENT"), + Self::FULLY_OPAQUE => Some("FULLY_OPAQUE"), + Self::FULLY_UNKNOWN_TRANSPARENT => Some("FULLY_UNKNOWN_TRANSPARENT"), + Self::FULLY_UNKNOWN_OPAQUE => Some("FULLY_UNKNOWN_OPAQUE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for OpticalFlowExecuteFlagsNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[( + OpticalFlowExecuteFlagsNV::DISABLE_TEMPORAL_HINTS.0, + "DISABLE_TEMPORAL_HINTS", + )]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for OpticalFlowGridSizeFlagsNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (OpticalFlowGridSizeFlagsNV::UNKNOWN.0, "UNKNOWN"), + (OpticalFlowGridSizeFlagsNV::TYPE_1X1.0, "TYPE_1X1"), + (OpticalFlowGridSizeFlagsNV::TYPE_2X2.0, "TYPE_2X2"), + (OpticalFlowGridSizeFlagsNV::TYPE_4X4.0, "TYPE_4X4"), + (OpticalFlowGridSizeFlagsNV::TYPE_8X8.0, "TYPE_8X8"), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for OpticalFlowPerformanceLevelNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UNKNOWN => Some("UNKNOWN"), + Self::SLOW => Some("SLOW"), + Self::MEDIUM => Some("MEDIUM"), + Self::FAST => Some("FAST"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for OpticalFlowSessionBindingPointNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UNKNOWN => Some("UNKNOWN"), + Self::INPUT => Some("INPUT"), + Self::REFERENCE => Some("REFERENCE"), + Self::HINT => Some("HINT"), + Self::FLOW_VECTOR => Some("FLOW_VECTOR"), + Self::BACKWARD_FLOW_VECTOR => Some("BACKWARD_FLOW_VECTOR"), + Self::COST => Some("COST"), + Self::BACKWARD_COST => Some("BACKWARD_COST"), + Self::GLOBAL_FLOW => Some("GLOBAL_FLOW"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for OpticalFlowSessionCreateFlagsNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + OpticalFlowSessionCreateFlagsNV::ENABLE_HINT.0, + "ENABLE_HINT", + ), + ( + OpticalFlowSessionCreateFlagsNV::ENABLE_COST.0, + "ENABLE_COST", + ), + ( + OpticalFlowSessionCreateFlagsNV::ENABLE_GLOBAL_FLOW.0, + "ENABLE_GLOBAL_FLOW", + ), + ( + OpticalFlowSessionCreateFlagsNV::ALLOW_REGIONS.0, + "ALLOW_REGIONS", + ), + ( + OpticalFlowSessionCreateFlagsNV::BOTH_DIRECTIONS.0, + "BOTH_DIRECTIONS", + ), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for OpticalFlowUsageFlagsNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (OpticalFlowUsageFlagsNV::UNKNOWN.0, "UNKNOWN"), + (OpticalFlowUsageFlagsNV::INPUT.0, "INPUT"), + (OpticalFlowUsageFlagsNV::OUTPUT.0, "OUTPUT"), + (OpticalFlowUsageFlagsNV::HINT.0, "HINT"), + (OpticalFlowUsageFlagsNV::COST.0, "COST"), + (OpticalFlowUsageFlagsNV::GLOBAL_FLOW.0, "GLOBAL_FLOW"), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for PeerMemoryFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (PeerMemoryFeatureFlags::COPY_SRC.0, "COPY_SRC"), + (PeerMemoryFeatureFlags::COPY_DST.0, "COPY_DST"), + (PeerMemoryFeatureFlags::GENERIC_SRC.0, "GENERIC_SRC"), + (PeerMemoryFeatureFlags::GENERIC_DST.0, "GENERIC_DST"), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for PerformanceConfigurationTypeINTEL { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::COMMAND_QUEUE_METRICS_DISCOVERY_ACTIVATED => { + Some("COMMAND_QUEUE_METRICS_DISCOVERY_ACTIVATED") + } + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for PerformanceCounterDescriptionFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + PerformanceCounterDescriptionFlagsKHR::PERFORMANCE_IMPACTING.0, + "PERFORMANCE_IMPACTING", + ), + ( + PerformanceCounterDescriptionFlagsKHR::CONCURRENTLY_IMPACTED.0, + "CONCURRENTLY_IMPACTED", + ), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for PerformanceCounterScopeKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::COMMAND_BUFFER => Some("COMMAND_BUFFER"), + Self::RENDER_PASS => Some("RENDER_PASS"), + Self::COMMAND => Some("COMMAND"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for PerformanceCounterStorageKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::INT32 => Some("INT32"), + Self::INT64 => Some("INT64"), + Self::UINT32 => Some("UINT32"), + Self::UINT64 => Some("UINT64"), + Self::FLOAT32 => Some("FLOAT32"), + Self::FLOAT64 => Some("FLOAT64"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for PerformanceCounterUnitKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::GENERIC => Some("GENERIC"), + Self::PERCENTAGE => Some("PERCENTAGE"), + Self::NANOSECONDS => Some("NANOSECONDS"), + Self::BYTES => Some("BYTES"), + Self::BYTES_PER_SECOND => Some("BYTES_PER_SECOND"), + Self::KELVIN => Some("KELVIN"), + Self::WATTS => Some("WATTS"), + Self::VOLTS => Some("VOLTS"), + Self::AMPS => Some("AMPS"), + Self::HERTZ => Some("HERTZ"), + Self::CYCLES => Some("CYCLES"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for PerformanceOverrideTypeINTEL { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::NULL_HARDWARE => Some("NULL_HARDWARE"), + Self::FLUSH_GPU_CACHES => Some("FLUSH_GPU_CACHES"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for PerformanceParameterTypeINTEL { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::HW_COUNTERS_SUPPORTED => Some("HW_COUNTERS_SUPPORTED"), + Self::STREAM_MARKER_VALIDS => Some("STREAM_MARKER_VALIDS"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for PerformanceValueTypeINTEL { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UINT32 => Some("UINT32"), + Self::UINT64 => Some("UINT64"), + Self::FLOAT => Some("FLOAT"), + Self::BOOL => Some("BOOL"), + Self::STRING => Some("STRING"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for PhysicalDeviceType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::OTHER => Some("OTHER"), + Self::INTEGRATED_GPU => Some("INTEGRATED_GPU"), + Self::DISCRETE_GPU => Some("DISCRETE_GPU"), + Self::VIRTUAL_GPU => Some("VIRTUAL_GPU"), + Self::CPU => Some("CPU"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for PipelineBindPoint { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::GRAPHICS => Some("GRAPHICS"), + Self::COMPUTE => Some("COMPUTE"), + Self::RAY_TRACING_KHR => Some("RAY_TRACING_KHR"), + Self::SUBPASS_SHADING_HUAWEI => Some("SUBPASS_SHADING_HUAWEI"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for PipelineCacheCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (PipelineCacheCreateFlags::RESERVED_1_EXT.0, "RESERVED_1_EXT"), + (PipelineCacheCreateFlags::RESERVED_2_KHR.0, "RESERVED_2_KHR"), + ( + PipelineCacheCreateFlags::EXTERNALLY_SYNCHRONIZED.0, + "EXTERNALLY_SYNCHRONIZED", + ), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for PipelineCacheHeaderVersion { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ONE => Some("ONE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for PipelineColorBlendStateCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[( + PipelineColorBlendStateCreateFlags::RASTERIZATION_ORDER_ATTACHMENT_ACCESS_EXT.0, + "RASTERIZATION_ORDER_ATTACHMENT_ACCESS_EXT", + )]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for PipelineCompilerControlFlagsAMD { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for PipelineCoverageModulationStateCreateFlagsNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for PipelineCoverageReductionStateCreateFlagsNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for PipelineCoverageToColorStateCreateFlagsNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for PipelineCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + PipelineCreateFlags::DISABLE_OPTIMIZATION.0, + "DISABLE_OPTIMIZATION", + ), + ( + PipelineCreateFlags::ALLOW_DERIVATIVES.0, + "ALLOW_DERIVATIVES", + ), + (PipelineCreateFlags::DERIVATIVE.0, "DERIVATIVE"), + ( + PipelineCreateFlags::RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_KHR.0, + "RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_KHR", + ), + ( + PipelineCreateFlags::RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_EXT.0, + "RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_EXT", + ), + ( + PipelineCreateFlags::RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_KHR.0, + "RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_KHR", + ), + ( + PipelineCreateFlags::RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS_KHR.0, + "RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS_KHR", + ), + ( + PipelineCreateFlags::RAY_TRACING_NO_NULL_MISS_SHADERS_KHR.0, + "RAY_TRACING_NO_NULL_MISS_SHADERS_KHR", + ), + ( + PipelineCreateFlags::RAY_TRACING_NO_NULL_INTERSECTION_SHADERS_KHR.0, + "RAY_TRACING_NO_NULL_INTERSECTION_SHADERS_KHR", + ), + ( + PipelineCreateFlags::RAY_TRACING_SKIP_TRIANGLES_KHR.0, + "RAY_TRACING_SKIP_TRIANGLES_KHR", + ), + ( + PipelineCreateFlags::RAY_TRACING_SKIP_AABBS_KHR.0, + "RAY_TRACING_SKIP_AABBS_KHR", + ), + ( + PipelineCreateFlags::RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY_KHR.0, + "RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY_KHR", + ), + (PipelineCreateFlags::DEFER_COMPILE_NV.0, "DEFER_COMPILE_NV"), + ( + PipelineCreateFlags::CAPTURE_STATISTICS_KHR.0, + "CAPTURE_STATISTICS_KHR", + ), + ( + PipelineCreateFlags::CAPTURE_INTERNAL_REPRESENTATIONS_KHR.0, + "CAPTURE_INTERNAL_REPRESENTATIONS_KHR", + ), + ( + PipelineCreateFlags::INDIRECT_BINDABLE_NV.0, + "INDIRECT_BINDABLE_NV", + ), + (PipelineCreateFlags::LIBRARY_KHR.0, "LIBRARY_KHR"), + ( + PipelineCreateFlags::DESCRIPTOR_BUFFER_EXT.0, + "DESCRIPTOR_BUFFER_EXT", + ), + ( + PipelineCreateFlags::RETAIN_LINK_TIME_OPTIMIZATION_INFO_EXT.0, + "RETAIN_LINK_TIME_OPTIMIZATION_INFO_EXT", + ), + ( + PipelineCreateFlags::LINK_TIME_OPTIMIZATION_EXT.0, + "LINK_TIME_OPTIMIZATION_EXT", + ), + ( + PipelineCreateFlags::RAY_TRACING_ALLOW_MOTION_NV.0, + "RAY_TRACING_ALLOW_MOTION_NV", + ), + ( + PipelineCreateFlags::COLOR_ATTACHMENT_FEEDBACK_LOOP_EXT.0, + "COLOR_ATTACHMENT_FEEDBACK_LOOP_EXT", + ), + ( + PipelineCreateFlags::DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP_EXT.0, + "DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP_EXT", + ), + ( + PipelineCreateFlags::RAY_TRACING_OPACITY_MICROMAP_EXT.0, + "RAY_TRACING_OPACITY_MICROMAP_EXT", + ), + (PipelineCreateFlags::RESERVED_28_NV.0, "RESERVED_28_NV"), + ( + PipelineCreateFlags::NO_PROTECTED_ACCESS_EXT.0, + "NO_PROTECTED_ACCESS_EXT", + ), + ( + PipelineCreateFlags::PROTECTED_ACCESS_ONLY_EXT.0, + "PROTECTED_ACCESS_ONLY_EXT", + ), + ( + PipelineCreateFlags::VIEW_INDEX_FROM_DEVICE_INDEX.0, + "VIEW_INDEX_FROM_DEVICE_INDEX", + ), + (PipelineCreateFlags::DISPATCH_BASE.0, "DISPATCH_BASE"), + ( + PipelineCreateFlags::FAIL_ON_PIPELINE_COMPILE_REQUIRED.0, + "FAIL_ON_PIPELINE_COMPILE_REQUIRED", + ), + ( + PipelineCreateFlags::EARLY_RETURN_ON_FAILURE.0, + "EARLY_RETURN_ON_FAILURE", + ), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for PipelineCreationFeedbackFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (PipelineCreationFeedbackFlags::VALID.0, "VALID"), + ( + PipelineCreationFeedbackFlags::APPLICATION_PIPELINE_CACHE_HIT.0, + "APPLICATION_PIPELINE_CACHE_HIT", + ), + ( + PipelineCreationFeedbackFlags::BASE_PIPELINE_ACCELERATION.0, + "BASE_PIPELINE_ACCELERATION", + ), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for PipelineDepthStencilStateCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN : & [(Flags , & str)] = & [(PipelineDepthStencilStateCreateFlags :: RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_EXT . 0 , "RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_EXT") , (PipelineDepthStencilStateCreateFlags :: RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_EXT . 0 , "RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_EXT")] ; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for PipelineDiscardRectangleStateCreateFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for PipelineDynamicStateCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for PipelineExecutableStatisticFormatKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::BOOL32 => Some("BOOL32"), + Self::INT64 => Some("INT64"), + Self::UINT64 => Some("UINT64"), + Self::FLOAT64 => Some("FLOAT64"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for PipelineInputAssemblyStateCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for PipelineLayoutCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + PipelineLayoutCreateFlags::RESERVED_0_AMD.0, + "RESERVED_0_AMD", + ), + ( + PipelineLayoutCreateFlags::INDEPENDENT_SETS_EXT.0, + "INDEPENDENT_SETS_EXT", + ), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for PipelineMultisampleStateCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for PipelineRasterizationConservativeStateCreateFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for PipelineRasterizationDepthClipStateCreateFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for PipelineRasterizationStateCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for PipelineRasterizationStateStreamCreateFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for PipelineRobustnessBufferBehaviorEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DEVICE_DEFAULT => Some("DEVICE_DEFAULT"), + Self::DISABLED => Some("DISABLED"), + Self::ROBUST_BUFFER_ACCESS => Some("ROBUST_BUFFER_ACCESS"), + Self::ROBUST_BUFFER_ACCESS_2 => Some("ROBUST_BUFFER_ACCESS_2"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for PipelineRobustnessImageBehaviorEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DEVICE_DEFAULT => Some("DEVICE_DEFAULT"), + Self::DISABLED => Some("DISABLED"), + Self::ROBUST_IMAGE_ACCESS => Some("ROBUST_IMAGE_ACCESS"), + Self::ROBUST_IMAGE_ACCESS_2 => Some("ROBUST_IMAGE_ACCESS_2"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for PipelineShaderStageCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + PipelineShaderStageCreateFlags::RESERVED_3_KHR.0, + "RESERVED_3_KHR", + ), + ( + PipelineShaderStageCreateFlags::ALLOW_VARYING_SUBGROUP_SIZE.0, + "ALLOW_VARYING_SUBGROUP_SIZE", + ), + ( + PipelineShaderStageCreateFlags::REQUIRE_FULL_SUBGROUPS.0, + "REQUIRE_FULL_SUBGROUPS", + ), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for PipelineStageFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (PipelineStageFlags::TOP_OF_PIPE.0, "TOP_OF_PIPE"), + (PipelineStageFlags::DRAW_INDIRECT.0, "DRAW_INDIRECT"), + (PipelineStageFlags::VERTEX_INPUT.0, "VERTEX_INPUT"), + (PipelineStageFlags::VERTEX_SHADER.0, "VERTEX_SHADER"), + ( + PipelineStageFlags::TESSELLATION_CONTROL_SHADER.0, + "TESSELLATION_CONTROL_SHADER", + ), + ( + PipelineStageFlags::TESSELLATION_EVALUATION_SHADER.0, + "TESSELLATION_EVALUATION_SHADER", + ), + (PipelineStageFlags::GEOMETRY_SHADER.0, "GEOMETRY_SHADER"), + (PipelineStageFlags::FRAGMENT_SHADER.0, "FRAGMENT_SHADER"), + ( + PipelineStageFlags::EARLY_FRAGMENT_TESTS.0, + "EARLY_FRAGMENT_TESTS", + ), + ( + PipelineStageFlags::LATE_FRAGMENT_TESTS.0, + "LATE_FRAGMENT_TESTS", + ), + ( + PipelineStageFlags::COLOR_ATTACHMENT_OUTPUT.0, + "COLOR_ATTACHMENT_OUTPUT", + ), + (PipelineStageFlags::COMPUTE_SHADER.0, "COMPUTE_SHADER"), + (PipelineStageFlags::TRANSFER.0, "TRANSFER"), + (PipelineStageFlags::BOTTOM_OF_PIPE.0, "BOTTOM_OF_PIPE"), + (PipelineStageFlags::HOST.0, "HOST"), + (PipelineStageFlags::ALL_GRAPHICS.0, "ALL_GRAPHICS"), + (PipelineStageFlags::ALL_COMMANDS.0, "ALL_COMMANDS"), + ( + PipelineStageFlags::TRANSFORM_FEEDBACK_EXT.0, + "TRANSFORM_FEEDBACK_EXT", + ), + ( + PipelineStageFlags::CONDITIONAL_RENDERING_EXT.0, + "CONDITIONAL_RENDERING_EXT", + ), + ( + PipelineStageFlags::ACCELERATION_STRUCTURE_BUILD_KHR.0, + "ACCELERATION_STRUCTURE_BUILD_KHR", + ), + ( + PipelineStageFlags::RAY_TRACING_SHADER_KHR.0, + "RAY_TRACING_SHADER_KHR", + ), + ( + PipelineStageFlags::FRAGMENT_DENSITY_PROCESS_EXT.0, + "FRAGMENT_DENSITY_PROCESS_EXT", + ), + ( + PipelineStageFlags::FRAGMENT_SHADING_RATE_ATTACHMENT_KHR.0, + "FRAGMENT_SHADING_RATE_ATTACHMENT_KHR", + ), + ( + PipelineStageFlags::COMMAND_PREPROCESS_NV.0, + "COMMAND_PREPROCESS_NV", + ), + (PipelineStageFlags::TASK_SHADER_EXT.0, "TASK_SHADER_EXT"), + (PipelineStageFlags::MESH_SHADER_EXT.0, "MESH_SHADER_EXT"), + (PipelineStageFlags::NONE.0, "NONE"), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for PipelineStageFlags2 { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags64, &str)] = &[ + (PipelineStageFlags2::NONE.0, "NONE"), + (PipelineStageFlags2::TOP_OF_PIPE.0, "TOP_OF_PIPE"), + (PipelineStageFlags2::DRAW_INDIRECT.0, "DRAW_INDIRECT"), + (PipelineStageFlags2::VERTEX_INPUT.0, "VERTEX_INPUT"), + (PipelineStageFlags2::VERTEX_SHADER.0, "VERTEX_SHADER"), + ( + PipelineStageFlags2::TESSELLATION_CONTROL_SHADER.0, + "TESSELLATION_CONTROL_SHADER", + ), + ( + PipelineStageFlags2::TESSELLATION_EVALUATION_SHADER.0, + "TESSELLATION_EVALUATION_SHADER", + ), + (PipelineStageFlags2::GEOMETRY_SHADER.0, "GEOMETRY_SHADER"), + (PipelineStageFlags2::FRAGMENT_SHADER.0, "FRAGMENT_SHADER"), + ( + PipelineStageFlags2::EARLY_FRAGMENT_TESTS.0, + "EARLY_FRAGMENT_TESTS", + ), + ( + PipelineStageFlags2::LATE_FRAGMENT_TESTS.0, + "LATE_FRAGMENT_TESTS", + ), + ( + PipelineStageFlags2::COLOR_ATTACHMENT_OUTPUT.0, + "COLOR_ATTACHMENT_OUTPUT", + ), + (PipelineStageFlags2::COMPUTE_SHADER.0, "COMPUTE_SHADER"), + (PipelineStageFlags2::ALL_TRANSFER.0, "ALL_TRANSFER"), + (PipelineStageFlags2::BOTTOM_OF_PIPE.0, "BOTTOM_OF_PIPE"), + (PipelineStageFlags2::HOST.0, "HOST"), + (PipelineStageFlags2::ALL_GRAPHICS.0, "ALL_GRAPHICS"), + (PipelineStageFlags2::ALL_COMMANDS.0, "ALL_COMMANDS"), + (PipelineStageFlags2::COPY.0, "COPY"), + (PipelineStageFlags2::RESOLVE.0, "RESOLVE"), + (PipelineStageFlags2::BLIT.0, "BLIT"), + (PipelineStageFlags2::CLEAR.0, "CLEAR"), + (PipelineStageFlags2::INDEX_INPUT.0, "INDEX_INPUT"), + ( + PipelineStageFlags2::VERTEX_ATTRIBUTE_INPUT.0, + "VERTEX_ATTRIBUTE_INPUT", + ), + ( + PipelineStageFlags2::PRE_RASTERIZATION_SHADERS.0, + "PRE_RASTERIZATION_SHADERS", + ), + (PipelineStageFlags2::VIDEO_DECODE_KHR.0, "VIDEO_DECODE_KHR"), + (PipelineStageFlags2::VIDEO_ENCODE_KHR.0, "VIDEO_ENCODE_KHR"), + ( + PipelineStageFlags2::TRANSFORM_FEEDBACK_EXT.0, + "TRANSFORM_FEEDBACK_EXT", + ), + ( + PipelineStageFlags2::CONDITIONAL_RENDERING_EXT.0, + "CONDITIONAL_RENDERING_EXT", + ), + ( + PipelineStageFlags2::COMMAND_PREPROCESS_NV.0, + "COMMAND_PREPROCESS_NV", + ), + ( + PipelineStageFlags2::FRAGMENT_SHADING_RATE_ATTACHMENT_KHR.0, + "FRAGMENT_SHADING_RATE_ATTACHMENT_KHR", + ), + ( + PipelineStageFlags2::ACCELERATION_STRUCTURE_BUILD_KHR.0, + "ACCELERATION_STRUCTURE_BUILD_KHR", + ), + ( + PipelineStageFlags2::RAY_TRACING_SHADER_KHR.0, + "RAY_TRACING_SHADER_KHR", + ), + ( + PipelineStageFlags2::FRAGMENT_DENSITY_PROCESS_EXT.0, + "FRAGMENT_DENSITY_PROCESS_EXT", + ), + (PipelineStageFlags2::TASK_SHADER_EXT.0, "TASK_SHADER_EXT"), + (PipelineStageFlags2::MESH_SHADER_EXT.0, "MESH_SHADER_EXT"), + ( + PipelineStageFlags2::SUBPASS_SHADING_HUAWEI.0, + "SUBPASS_SHADING_HUAWEI", + ), + ( + PipelineStageFlags2::INVOCATION_MASK_HUAWEI.0, + "INVOCATION_MASK_HUAWEI", + ), + ( + PipelineStageFlags2::ACCELERATION_STRUCTURE_COPY_KHR.0, + "ACCELERATION_STRUCTURE_COPY_KHR", + ), + ( + PipelineStageFlags2::MICROMAP_BUILD_EXT.0, + "MICROMAP_BUILD_EXT", + ), + ( + PipelineStageFlags2::RESEVED_41_HUAWEI.0, + "RESEVED_41_HUAWEI", + ), + (PipelineStageFlags2::OPTICAL_FLOW_NV.0, "OPTICAL_FLOW_NV"), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for PipelineTessellationStateCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for PipelineVertexInputStateCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for PipelineViewportStateCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for PipelineViewportSwizzleStateCreateFlagsNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for PointClippingBehavior { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ALL_CLIP_PLANES => Some("ALL_CLIP_PLANES"), + Self::USER_CLIP_PLANES_ONLY => Some("USER_CLIP_PLANES_ONLY"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for PolygonMode { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::FILL => Some("FILL"), + Self::LINE => Some("LINE"), + Self::POINT => Some("POINT"), + Self::FILL_RECTANGLE_NV => Some("FILL_RECTANGLE_NV"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for PresentGravityFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (PresentGravityFlagsEXT::MIN.0, "MIN"), + (PresentGravityFlagsEXT::MAX.0, "MAX"), + (PresentGravityFlagsEXT::CENTERED.0, "CENTERED"), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for PresentModeKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::IMMEDIATE => Some("IMMEDIATE"), + Self::MAILBOX => Some("MAILBOX"), + Self::FIFO => Some("FIFO"), + Self::FIFO_RELAXED => Some("FIFO_RELAXED"), + Self::SHARED_DEMAND_REFRESH => Some("SHARED_DEMAND_REFRESH"), + Self::SHARED_CONTINUOUS_REFRESH => Some("SHARED_CONTINUOUS_REFRESH"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for PresentScalingFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (PresentScalingFlagsEXT::ONE_TO_ONE.0, "ONE_TO_ONE"), + ( + PresentScalingFlagsEXT::ASPECT_RATIO_STRETCH.0, + "ASPECT_RATIO_STRETCH", + ), + (PresentScalingFlagsEXT::STRETCH.0, "STRETCH"), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for PrimitiveTopology { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::POINT_LIST => Some("POINT_LIST"), + Self::LINE_LIST => Some("LINE_LIST"), + Self::LINE_STRIP => Some("LINE_STRIP"), + Self::TRIANGLE_LIST => Some("TRIANGLE_LIST"), + Self::TRIANGLE_STRIP => Some("TRIANGLE_STRIP"), + Self::TRIANGLE_FAN => Some("TRIANGLE_FAN"), + Self::LINE_LIST_WITH_ADJACENCY => Some("LINE_LIST_WITH_ADJACENCY"), + Self::LINE_STRIP_WITH_ADJACENCY => Some("LINE_STRIP_WITH_ADJACENCY"), + Self::TRIANGLE_LIST_WITH_ADJACENCY => Some("TRIANGLE_LIST_WITH_ADJACENCY"), + Self::TRIANGLE_STRIP_WITH_ADJACENCY => Some("TRIANGLE_STRIP_WITH_ADJACENCY"), + Self::PATCH_LIST => Some("PATCH_LIST"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for PrivateDataSlotCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for ProvokingVertexModeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::FIRST_VERTEX => Some("FIRST_VERTEX"), + Self::LAST_VERTEX => Some("LAST_VERTEX"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for QueryControlFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(QueryControlFlags::PRECISE.0, "PRECISE")]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for QueryPipelineStatisticFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + QueryPipelineStatisticFlags::INPUT_ASSEMBLY_VERTICES.0, + "INPUT_ASSEMBLY_VERTICES", + ), + ( + QueryPipelineStatisticFlags::INPUT_ASSEMBLY_PRIMITIVES.0, + "INPUT_ASSEMBLY_PRIMITIVES", + ), + ( + QueryPipelineStatisticFlags::VERTEX_SHADER_INVOCATIONS.0, + "VERTEX_SHADER_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::GEOMETRY_SHADER_INVOCATIONS.0, + "GEOMETRY_SHADER_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::GEOMETRY_SHADER_PRIMITIVES.0, + "GEOMETRY_SHADER_PRIMITIVES", + ), + ( + QueryPipelineStatisticFlags::CLIPPING_INVOCATIONS.0, + "CLIPPING_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::CLIPPING_PRIMITIVES.0, + "CLIPPING_PRIMITIVES", + ), + ( + QueryPipelineStatisticFlags::FRAGMENT_SHADER_INVOCATIONS.0, + "FRAGMENT_SHADER_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::TESSELLATION_CONTROL_SHADER_PATCHES.0, + "TESSELLATION_CONTROL_SHADER_PATCHES", + ), + ( + QueryPipelineStatisticFlags::TESSELLATION_EVALUATION_SHADER_INVOCATIONS.0, + "TESSELLATION_EVALUATION_SHADER_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::COMPUTE_SHADER_INVOCATIONS.0, + "COMPUTE_SHADER_INVOCATIONS", + ), + ( + QueryPipelineStatisticFlags::TASK_SHADER_INVOCATIONS_EXT.0, + "TASK_SHADER_INVOCATIONS_EXT", + ), + ( + QueryPipelineStatisticFlags::MESH_SHADER_INVOCATIONS_EXT.0, + "MESH_SHADER_INVOCATIONS_EXT", + ), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for QueryPoolCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for QueryPoolSamplingModeINTEL { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::MANUAL => Some("MANUAL"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for QueryResultFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (QueryResultFlags::TYPE_64.0, "TYPE_64"), + (QueryResultFlags::WAIT.0, "WAIT"), + (QueryResultFlags::WITH_AVAILABILITY.0, "WITH_AVAILABILITY"), + (QueryResultFlags::PARTIAL.0, "PARTIAL"), + (QueryResultFlags::WITH_STATUS_KHR.0, "WITH_STATUS_KHR"), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for QueryResultStatusKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ERROR => Some("ERROR"), + Self::NOT_READY => Some("NOT_READY"), + Self::COMPLETE => Some("COMPLETE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for QueryType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::OCCLUSION => Some("OCCLUSION"), + Self::PIPELINE_STATISTICS => Some("PIPELINE_STATISTICS"), + Self::TIMESTAMP => Some("TIMESTAMP"), + Self::RESULT_STATUS_ONLY_KHR => Some("RESULT_STATUS_ONLY_KHR"), + Self::TRANSFORM_FEEDBACK_STREAM_EXT => Some("TRANSFORM_FEEDBACK_STREAM_EXT"), + Self::PERFORMANCE_QUERY_KHR => Some("PERFORMANCE_QUERY_KHR"), + Self::ACCELERATION_STRUCTURE_COMPACTED_SIZE_KHR => { + Some("ACCELERATION_STRUCTURE_COMPACTED_SIZE_KHR") + } + Self::ACCELERATION_STRUCTURE_SERIALIZATION_SIZE_KHR => { + Some("ACCELERATION_STRUCTURE_SERIALIZATION_SIZE_KHR") + } + Self::ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV => { + Some("ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV") + } + Self::PERFORMANCE_QUERY_INTEL => Some("PERFORMANCE_QUERY_INTEL"), + Self::VIDEO_ENCODESTREAM_BUFFER_RANGE_KHR => { + Some("VIDEO_ENCODESTREAM_BUFFER_RANGE_KHR") + } + Self::MESH_PRIMITIVES_GENERATED_EXT => Some("MESH_PRIMITIVES_GENERATED_EXT"), + Self::PRIMITIVES_GENERATED_EXT => Some("PRIMITIVES_GENERATED_EXT"), + Self::ACCELERATION_STRUCTURE_SERIALIZATION_BOTTOM_LEVEL_POINTERS_KHR => { + Some("ACCELERATION_STRUCTURE_SERIALIZATION_BOTTOM_LEVEL_POINTERS_KHR") + } + Self::ACCELERATION_STRUCTURE_SIZE_KHR => Some("ACCELERATION_STRUCTURE_SIZE_KHR"), + Self::MICROMAP_SERIALIZATION_SIZE_EXT => Some("MICROMAP_SERIALIZATION_SIZE_EXT"), + Self::MICROMAP_COMPACTED_SIZE_EXT => Some("MICROMAP_COMPACTED_SIZE_EXT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for QueueFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (QueueFlags::GRAPHICS.0, "GRAPHICS"), + (QueueFlags::COMPUTE.0, "COMPUTE"), + (QueueFlags::TRANSFER.0, "TRANSFER"), + (QueueFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), + (QueueFlags::VIDEO_DECODE_KHR.0, "VIDEO_DECODE_KHR"), + (QueueFlags::RESERVED_9_EXT.0, "RESERVED_9_EXT"), + (QueueFlags::VIDEO_ENCODE_KHR.0, "VIDEO_ENCODE_KHR"), + (QueueFlags::RESERVED_7_QCOM.0, "RESERVED_7_QCOM"), + (QueueFlags::OPTICAL_FLOW_NV.0, "OPTICAL_FLOW_NV"), + (QueueFlags::PROTECTED.0, "PROTECTED"), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for QueueGlobalPriorityKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::LOW => Some("LOW"), + Self::MEDIUM => Some("MEDIUM"), + Self::HIGH => Some("HIGH"), + Self::REALTIME => Some("REALTIME"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for RasterizationOrderAMD { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::STRICT => Some("STRICT"), + Self::RELAXED => Some("RELAXED"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for RayTracingInvocationReorderModeNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::NONE => Some("NONE"), + Self::REORDER => Some("REORDER"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for RayTracingShaderGroupTypeKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::GENERAL => Some("GENERAL"), + Self::TRIANGLES_HIT_GROUP => Some("TRIANGLES_HIT_GROUP"), + Self::PROCEDURAL_HIT_GROUP => Some("PROCEDURAL_HIT_GROUP"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for RenderPassCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (RenderPassCreateFlags::RESERVED_0_KHR.0, "RESERVED_0_KHR"), + (RenderPassCreateFlags::TRANSFORM_QCOM.0, "TRANSFORM_QCOM"), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for RenderingFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + RenderingFlags::CONTENTS_SECONDARY_COMMAND_BUFFERS.0, + "CONTENTS_SECONDARY_COMMAND_BUFFERS", + ), + (RenderingFlags::SUSPENDING.0, "SUSPENDING"), + (RenderingFlags::RESUMING.0, "RESUMING"), + ( + RenderingFlags::ENABLE_LEGACY_DITHERING_EXT.0, + "ENABLE_LEGACY_DITHERING_EXT", + ), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for ResolveModeFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ResolveModeFlags::NONE.0, "NONE"), + (ResolveModeFlags::SAMPLE_ZERO.0, "SAMPLE_ZERO"), + (ResolveModeFlags::AVERAGE.0, "AVERAGE"), + (ResolveModeFlags::MIN.0, "MIN"), + (ResolveModeFlags::MAX.0, "MAX"), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for SampleCountFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (SampleCountFlags::TYPE_1.0, "TYPE_1"), + (SampleCountFlags::TYPE_2.0, "TYPE_2"), + (SampleCountFlags::TYPE_4.0, "TYPE_4"), + (SampleCountFlags::TYPE_8.0, "TYPE_8"), + (SampleCountFlags::TYPE_16.0, "TYPE_16"), + (SampleCountFlags::TYPE_32.0, "TYPE_32"), + (SampleCountFlags::TYPE_64.0, "TYPE_64"), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for SamplerAddressMode { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::REPEAT => Some("REPEAT"), + Self::MIRRORED_REPEAT => Some("MIRRORED_REPEAT"), + Self::CLAMP_TO_EDGE => Some("CLAMP_TO_EDGE"), + Self::CLAMP_TO_BORDER => Some("CLAMP_TO_BORDER"), + Self::MIRROR_CLAMP_TO_EDGE => Some("MIRROR_CLAMP_TO_EDGE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for SamplerCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (SamplerCreateFlags::SUBSAMPLED_EXT.0, "SUBSAMPLED_EXT"), + ( + SamplerCreateFlags::SUBSAMPLED_COARSE_RECONSTRUCTION_EXT.0, + "SUBSAMPLED_COARSE_RECONSTRUCTION_EXT", + ), + ( + SamplerCreateFlags::DESCRIPTOR_BUFFER_CAPTURE_REPLAY_EXT.0, + "DESCRIPTOR_BUFFER_CAPTURE_REPLAY_EXT", + ), + ( + SamplerCreateFlags::NON_SEAMLESS_CUBE_MAP_EXT.0, + "NON_SEAMLESS_CUBE_MAP_EXT", + ), + ( + SamplerCreateFlags::IMAGE_PROCESSING_QCOM.0, + "IMAGE_PROCESSING_QCOM", + ), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for SamplerMipmapMode { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::NEAREST => Some("NEAREST"), + Self::LINEAR => Some("LINEAR"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for SamplerReductionMode { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::WEIGHTED_AVERAGE => Some("WEIGHTED_AVERAGE"), + Self::MIN => Some("MIN"), + Self::MAX => Some("MAX"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for SamplerYcbcrModelConversion { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::RGB_IDENTITY => Some("RGB_IDENTITY"), + Self::YCBCR_IDENTITY => Some("YCBCR_IDENTITY"), + Self::YCBCR_709 => Some("YCBCR_709"), + Self::YCBCR_601 => Some("YCBCR_601"), + Self::YCBCR_2020 => Some("YCBCR_2020"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for SamplerYcbcrRange { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ITU_FULL => Some("ITU_FULL"), + Self::ITU_NARROW => Some("ITU_NARROW"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for ScopeNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DEVICE => Some("DEVICE"), + Self::WORKGROUP => Some("WORKGROUP"), + Self::SUBGROUP => Some("SUBGROUP"), + Self::QUEUE_FAMILY => Some("QUEUE_FAMILY"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for ScreenSurfaceCreateFlagsQNX { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for SemaphoreCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for SemaphoreImportFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(SemaphoreImportFlags::TEMPORARY.0, "TEMPORARY")]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for SemaphoreType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::BINARY => Some("BINARY"), + Self::TIMELINE => Some("TIMELINE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for SemaphoreWaitFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(SemaphoreWaitFlags::ANY.0, "ANY")]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for ShaderCorePropertiesFlagsAMD { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for ShaderFloatControlsIndependence { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::TYPE_32_ONLY => Some("TYPE_32_ONLY"), + Self::ALL => Some("ALL"), + Self::NONE => Some("NONE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for ShaderGroupShaderKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::GENERAL => Some("GENERAL"), + Self::CLOSEST_HIT => Some("CLOSEST_HIT"), + Self::ANY_HIT => Some("ANY_HIT"), + Self::INTERSECTION => Some("INTERSECTION"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for ShaderInfoTypeAMD { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::STATISTICS => Some("STATISTICS"), + Self::BINARY => Some("BINARY"), + Self::DISASSEMBLY => Some("DISASSEMBLY"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for ShaderModuleCreateFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for ShaderStageFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ShaderStageFlags::VERTEX.0, "VERTEX"), + ( + ShaderStageFlags::TESSELLATION_CONTROL.0, + "TESSELLATION_CONTROL", + ), + ( + ShaderStageFlags::TESSELLATION_EVALUATION.0, + "TESSELLATION_EVALUATION", + ), + (ShaderStageFlags::GEOMETRY.0, "GEOMETRY"), + (ShaderStageFlags::FRAGMENT.0, "FRAGMENT"), + (ShaderStageFlags::COMPUTE.0, "COMPUTE"), + (ShaderStageFlags::ALL_GRAPHICS.0, "ALL_GRAPHICS"), + (ShaderStageFlags::ALL.0, "ALL"), + (ShaderStageFlags::RAYGEN_KHR.0, "RAYGEN_KHR"), + (ShaderStageFlags::ANY_HIT_KHR.0, "ANY_HIT_KHR"), + (ShaderStageFlags::CLOSEST_HIT_KHR.0, "CLOSEST_HIT_KHR"), + (ShaderStageFlags::MISS_KHR.0, "MISS_KHR"), + (ShaderStageFlags::INTERSECTION_KHR.0, "INTERSECTION_KHR"), + (ShaderStageFlags::CALLABLE_KHR.0, "CALLABLE_KHR"), + (ShaderStageFlags::TASK_EXT.0, "TASK_EXT"), + (ShaderStageFlags::MESH_EXT.0, "MESH_EXT"), + ( + ShaderStageFlags::SUBPASS_SHADING_HUAWEI.0, + "SUBPASS_SHADING_HUAWEI", + ), + (ShaderStageFlags::RESERVED_19_HUAWEI.0, "RESERVED_19_HUAWEI"), + (ShaderStageFlags::EXT_483_RESERVE_15.0, "EXT_483_RESERVE_15"), + (ShaderStageFlags::EXT_483_RESERVE_16.0, "EXT_483_RESERVE_16"), + (ShaderStageFlags::EXT_483_RESERVE_17.0, "EXT_483_RESERVE_17"), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for ShadingRatePaletteEntryNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::NO_INVOCATIONS => Some("NO_INVOCATIONS"), + Self::TYPE_16_INVOCATIONS_PER_PIXEL => Some("TYPE_16_INVOCATIONS_PER_PIXEL"), + Self::TYPE_8_INVOCATIONS_PER_PIXEL => Some("TYPE_8_INVOCATIONS_PER_PIXEL"), + Self::TYPE_4_INVOCATIONS_PER_PIXEL => Some("TYPE_4_INVOCATIONS_PER_PIXEL"), + Self::TYPE_2_INVOCATIONS_PER_PIXEL => Some("TYPE_2_INVOCATIONS_PER_PIXEL"), + Self::TYPE_1_INVOCATION_PER_PIXEL => Some("TYPE_1_INVOCATION_PER_PIXEL"), + Self::TYPE_1_INVOCATION_PER_2X1_PIXELS => Some("TYPE_1_INVOCATION_PER_2X1_PIXELS"), + Self::TYPE_1_INVOCATION_PER_1X2_PIXELS => Some("TYPE_1_INVOCATION_PER_1X2_PIXELS"), + Self::TYPE_1_INVOCATION_PER_2X2_PIXELS => Some("TYPE_1_INVOCATION_PER_2X2_PIXELS"), + Self::TYPE_1_INVOCATION_PER_4X2_PIXELS => Some("TYPE_1_INVOCATION_PER_4X2_PIXELS"), + Self::TYPE_1_INVOCATION_PER_2X4_PIXELS => Some("TYPE_1_INVOCATION_PER_2X4_PIXELS"), + Self::TYPE_1_INVOCATION_PER_4X4_PIXELS => Some("TYPE_1_INVOCATION_PER_4X4_PIXELS"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for SharingMode { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::EXCLUSIVE => Some("EXCLUSIVE"), + Self::CONCURRENT => Some("CONCURRENT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for SparseImageFormatFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (SparseImageFormatFlags::SINGLE_MIPTAIL.0, "SINGLE_MIPTAIL"), + ( + SparseImageFormatFlags::ALIGNED_MIP_SIZE.0, + "ALIGNED_MIP_SIZE", + ), + ( + SparseImageFormatFlags::NONSTANDARD_BLOCK_SIZE.0, + "NONSTANDARD_BLOCK_SIZE", + ), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for SparseMemoryBindFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(SparseMemoryBindFlags::METADATA.0, "METADATA")]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for StencilFaceFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (StencilFaceFlags::FRONT.0, "FRONT"), + (StencilFaceFlags::BACK.0, "BACK"), + (StencilFaceFlags::FRONT_AND_BACK.0, "FRONT_AND_BACK"), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for StencilOp { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::KEEP => Some("KEEP"), + Self::ZERO => Some("ZERO"), + Self::REPLACE => Some("REPLACE"), + Self::INCREMENT_AND_CLAMP => Some("INCREMENT_AND_CLAMP"), + Self::DECREMENT_AND_CLAMP => Some("DECREMENT_AND_CLAMP"), + Self::INVERT => Some("INVERT"), + Self::INCREMENT_AND_WRAP => Some("INCREMENT_AND_WRAP"), + Self::DECREMENT_AND_WRAP => Some("DECREMENT_AND_WRAP"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for StreamDescriptorSurfaceCreateFlagsGGP { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for StructureType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::APPLICATION_INFO => Some("APPLICATION_INFO"), + Self::INSTANCE_CREATE_INFO => Some("INSTANCE_CREATE_INFO"), + Self::DEVICE_QUEUE_CREATE_INFO => Some("DEVICE_QUEUE_CREATE_INFO"), + Self::DEVICE_CREATE_INFO => Some("DEVICE_CREATE_INFO"), + Self::SUBMIT_INFO => Some("SUBMIT_INFO"), + Self::MEMORY_ALLOCATE_INFO => Some("MEMORY_ALLOCATE_INFO"), + Self::MAPPED_MEMORY_RANGE => Some("MAPPED_MEMORY_RANGE"), + Self::BIND_SPARSE_INFO => Some("BIND_SPARSE_INFO"), + Self::FENCE_CREATE_INFO => Some("FENCE_CREATE_INFO"), + Self::SEMAPHORE_CREATE_INFO => Some("SEMAPHORE_CREATE_INFO"), + Self::EVENT_CREATE_INFO => Some("EVENT_CREATE_INFO"), + Self::QUERY_POOL_CREATE_INFO => Some("QUERY_POOL_CREATE_INFO"), + Self::BUFFER_CREATE_INFO => Some("BUFFER_CREATE_INFO"), + Self::BUFFER_VIEW_CREATE_INFO => Some("BUFFER_VIEW_CREATE_INFO"), + Self::IMAGE_CREATE_INFO => Some("IMAGE_CREATE_INFO"), + Self::IMAGE_VIEW_CREATE_INFO => Some("IMAGE_VIEW_CREATE_INFO"), + Self::SHADER_MODULE_CREATE_INFO => Some("SHADER_MODULE_CREATE_INFO"), + Self::PIPELINE_CACHE_CREATE_INFO => Some("PIPELINE_CACHE_CREATE_INFO"), + Self::PIPELINE_SHADER_STAGE_CREATE_INFO => Some("PIPELINE_SHADER_STAGE_CREATE_INFO"), + Self::PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO => { + Some("PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO") + } + Self::PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO => { + Some("PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO") + } + Self::PIPELINE_TESSELLATION_STATE_CREATE_INFO => { + Some("PIPELINE_TESSELLATION_STATE_CREATE_INFO") + } + Self::PIPELINE_VIEWPORT_STATE_CREATE_INFO => { + Some("PIPELINE_VIEWPORT_STATE_CREATE_INFO") + } + Self::PIPELINE_RASTERIZATION_STATE_CREATE_INFO => { + Some("PIPELINE_RASTERIZATION_STATE_CREATE_INFO") + } + Self::PIPELINE_MULTISAMPLE_STATE_CREATE_INFO => { + Some("PIPELINE_MULTISAMPLE_STATE_CREATE_INFO") + } + Self::PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO => { + Some("PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO") + } + Self::PIPELINE_COLOR_BLEND_STATE_CREATE_INFO => { + Some("PIPELINE_COLOR_BLEND_STATE_CREATE_INFO") + } + Self::PIPELINE_DYNAMIC_STATE_CREATE_INFO => Some("PIPELINE_DYNAMIC_STATE_CREATE_INFO"), + Self::GRAPHICS_PIPELINE_CREATE_INFO => Some("GRAPHICS_PIPELINE_CREATE_INFO"), + Self::COMPUTE_PIPELINE_CREATE_INFO => Some("COMPUTE_PIPELINE_CREATE_INFO"), + Self::PIPELINE_LAYOUT_CREATE_INFO => Some("PIPELINE_LAYOUT_CREATE_INFO"), + Self::SAMPLER_CREATE_INFO => Some("SAMPLER_CREATE_INFO"), + Self::DESCRIPTOR_SET_LAYOUT_CREATE_INFO => Some("DESCRIPTOR_SET_LAYOUT_CREATE_INFO"), + Self::DESCRIPTOR_POOL_CREATE_INFO => Some("DESCRIPTOR_POOL_CREATE_INFO"), + Self::DESCRIPTOR_SET_ALLOCATE_INFO => Some("DESCRIPTOR_SET_ALLOCATE_INFO"), + Self::WRITE_DESCRIPTOR_SET => Some("WRITE_DESCRIPTOR_SET"), + Self::COPY_DESCRIPTOR_SET => Some("COPY_DESCRIPTOR_SET"), + Self::FRAMEBUFFER_CREATE_INFO => Some("FRAMEBUFFER_CREATE_INFO"), + Self::RENDER_PASS_CREATE_INFO => Some("RENDER_PASS_CREATE_INFO"), + Self::COMMAND_POOL_CREATE_INFO => Some("COMMAND_POOL_CREATE_INFO"), + Self::COMMAND_BUFFER_ALLOCATE_INFO => Some("COMMAND_BUFFER_ALLOCATE_INFO"), + Self::COMMAND_BUFFER_INHERITANCE_INFO => Some("COMMAND_BUFFER_INHERITANCE_INFO"), + Self::COMMAND_BUFFER_BEGIN_INFO => Some("COMMAND_BUFFER_BEGIN_INFO"), + Self::RENDER_PASS_BEGIN_INFO => Some("RENDER_PASS_BEGIN_INFO"), + Self::BUFFER_MEMORY_BARRIER => Some("BUFFER_MEMORY_BARRIER"), + Self::IMAGE_MEMORY_BARRIER => Some("IMAGE_MEMORY_BARRIER"), + Self::MEMORY_BARRIER => Some("MEMORY_BARRIER"), + Self::LOADER_INSTANCE_CREATE_INFO => Some("LOADER_INSTANCE_CREATE_INFO"), + Self::LOADER_DEVICE_CREATE_INFO => Some("LOADER_DEVICE_CREATE_INFO"), + Self::SWAPCHAIN_CREATE_INFO_KHR => Some("SWAPCHAIN_CREATE_INFO_KHR"), + Self::PRESENT_INFO_KHR => Some("PRESENT_INFO_KHR"), + Self::DEVICE_GROUP_PRESENT_CAPABILITIES_KHR => { + Some("DEVICE_GROUP_PRESENT_CAPABILITIES_KHR") + } + Self::IMAGE_SWAPCHAIN_CREATE_INFO_KHR => Some("IMAGE_SWAPCHAIN_CREATE_INFO_KHR"), + Self::BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR => { + Some("BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR") + } + Self::ACQUIRE_NEXT_IMAGE_INFO_KHR => Some("ACQUIRE_NEXT_IMAGE_INFO_KHR"), + Self::DEVICE_GROUP_PRESENT_INFO_KHR => Some("DEVICE_GROUP_PRESENT_INFO_KHR"), + Self::DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR => { + Some("DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR") + } + Self::DISPLAY_MODE_CREATE_INFO_KHR => Some("DISPLAY_MODE_CREATE_INFO_KHR"), + Self::DISPLAY_SURFACE_CREATE_INFO_KHR => Some("DISPLAY_SURFACE_CREATE_INFO_KHR"), + Self::DISPLAY_PRESENT_INFO_KHR => Some("DISPLAY_PRESENT_INFO_KHR"), + Self::XLIB_SURFACE_CREATE_INFO_KHR => Some("XLIB_SURFACE_CREATE_INFO_KHR"), + Self::XCB_SURFACE_CREATE_INFO_KHR => Some("XCB_SURFACE_CREATE_INFO_KHR"), + Self::WAYLAND_SURFACE_CREATE_INFO_KHR => Some("WAYLAND_SURFACE_CREATE_INFO_KHR"), + Self::ANDROID_SURFACE_CREATE_INFO_KHR => Some("ANDROID_SURFACE_CREATE_INFO_KHR"), + Self::WIN32_SURFACE_CREATE_INFO_KHR => Some("WIN32_SURFACE_CREATE_INFO_KHR"), + Self::NATIVE_BUFFER_ANDROID => Some("NATIVE_BUFFER_ANDROID"), + Self::SWAPCHAIN_IMAGE_CREATE_INFO_ANDROID => { + Some("SWAPCHAIN_IMAGE_CREATE_INFO_ANDROID") + } + Self::PHYSICAL_DEVICE_PRESENTATION_PROPERTIES_ANDROID => { + Some("PHYSICAL_DEVICE_PRESENTATION_PROPERTIES_ANDROID") + } + Self::DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT => { + Some("DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT") + } + Self::PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD => { + Some("PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD") + } + Self::DEBUG_MARKER_OBJECT_NAME_INFO_EXT => Some("DEBUG_MARKER_OBJECT_NAME_INFO_EXT"), + Self::DEBUG_MARKER_OBJECT_TAG_INFO_EXT => Some("DEBUG_MARKER_OBJECT_TAG_INFO_EXT"), + Self::DEBUG_MARKER_MARKER_INFO_EXT => Some("DEBUG_MARKER_MARKER_INFO_EXT"), + Self::VIDEO_PROFILE_INFO_KHR => Some("VIDEO_PROFILE_INFO_KHR"), + Self::VIDEO_CAPABILITIES_KHR => Some("VIDEO_CAPABILITIES_KHR"), + Self::VIDEO_PICTURE_RESOURCE_INFO_KHR => Some("VIDEO_PICTURE_RESOURCE_INFO_KHR"), + Self::VIDEO_SESSION_MEMORY_REQUIREMENTS_KHR => { + Some("VIDEO_SESSION_MEMORY_REQUIREMENTS_KHR") + } + Self::BIND_VIDEO_SESSION_MEMORY_INFO_KHR => Some("BIND_VIDEO_SESSION_MEMORY_INFO_KHR"), + Self::VIDEO_SESSION_CREATE_INFO_KHR => Some("VIDEO_SESSION_CREATE_INFO_KHR"), + Self::VIDEO_SESSION_PARAMETERS_CREATE_INFO_KHR => { + Some("VIDEO_SESSION_PARAMETERS_CREATE_INFO_KHR") + } + Self::VIDEO_SESSION_PARAMETERS_UPDATE_INFO_KHR => { + Some("VIDEO_SESSION_PARAMETERS_UPDATE_INFO_KHR") + } + Self::VIDEO_BEGIN_CODING_INFO_KHR => Some("VIDEO_BEGIN_CODING_INFO_KHR"), + Self::VIDEO_END_CODING_INFO_KHR => Some("VIDEO_END_CODING_INFO_KHR"), + Self::VIDEO_CODING_CONTROL_INFO_KHR => Some("VIDEO_CODING_CONTROL_INFO_KHR"), + Self::VIDEO_REFERENCE_SLOT_INFO_KHR => Some("VIDEO_REFERENCE_SLOT_INFO_KHR"), + Self::QUEUE_FAMILY_VIDEO_PROPERTIES_KHR => Some("QUEUE_FAMILY_VIDEO_PROPERTIES_KHR"), + Self::VIDEO_PROFILE_LIST_INFO_KHR => Some("VIDEO_PROFILE_LIST_INFO_KHR"), + Self::PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR => { + Some("PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR") + } + Self::VIDEO_FORMAT_PROPERTIES_KHR => Some("VIDEO_FORMAT_PROPERTIES_KHR"), + Self::QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_KHR => { + Some("QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_KHR") + } + Self::VIDEO_DECODE_INFO_KHR => Some("VIDEO_DECODE_INFO_KHR"), + Self::VIDEO_DECODE_CAPABILITIES_KHR => Some("VIDEO_DECODE_CAPABILITIES_KHR"), + Self::VIDEO_DECODE_USAGE_INFO_KHR => Some("VIDEO_DECODE_USAGE_INFO_KHR"), + Self::DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV => { + Some("DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV") + } + Self::DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV => { + Some("DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV") + } + Self::DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV => { + Some("DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV") + } + Self::PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT") + } + Self::PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT => { + Some("PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT") + } + Self::PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT => { + Some("PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT") + } + Self::CU_MODULE_CREATE_INFO_NVX => Some("CU_MODULE_CREATE_INFO_NVX"), + Self::CU_FUNCTION_CREATE_INFO_NVX => Some("CU_FUNCTION_CREATE_INFO_NVX"), + Self::CU_LAUNCH_INFO_NVX => Some("CU_LAUNCH_INFO_NVX"), + Self::IMAGE_VIEW_HANDLE_INFO_NVX => Some("IMAGE_VIEW_HANDLE_INFO_NVX"), + Self::IMAGE_VIEW_ADDRESS_PROPERTIES_NVX => Some("IMAGE_VIEW_ADDRESS_PROPERTIES_NVX"), + Self::VIDEO_ENCODE_H264_CAPABILITIES_EXT => Some("VIDEO_ENCODE_H264_CAPABILITIES_EXT"), + Self::VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT => { + Some("VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT") + } + Self::VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT => { + Some("VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT") + } + Self::VIDEO_ENCODE_H264_VCL_FRAME_INFO_EXT => { + Some("VIDEO_ENCODE_H264_VCL_FRAME_INFO_EXT") + } + Self::VIDEO_ENCODE_H264_DPB_SLOT_INFO_EXT => { + Some("VIDEO_ENCODE_H264_DPB_SLOT_INFO_EXT") + } + Self::VIDEO_ENCODE_H264_NALU_SLICE_INFO_EXT => { + Some("VIDEO_ENCODE_H264_NALU_SLICE_INFO_EXT") + } + Self::VIDEO_ENCODE_H264_EMIT_PICTURE_PARAMETERS_INFO_EXT => { + Some("VIDEO_ENCODE_H264_EMIT_PICTURE_PARAMETERS_INFO_EXT") + } + Self::VIDEO_ENCODE_H264_PROFILE_INFO_EXT => Some("VIDEO_ENCODE_H264_PROFILE_INFO_EXT"), + Self::VIDEO_ENCODE_H264_RATE_CONTROL_INFO_EXT => { + Some("VIDEO_ENCODE_H264_RATE_CONTROL_INFO_EXT") + } + Self::VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_EXT => { + Some("VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_EXT") + } + Self::VIDEO_ENCODE_H264_REFERENCE_LISTS_INFO_EXT => { + Some("VIDEO_ENCODE_H264_REFERENCE_LISTS_INFO_EXT") + } + Self::VIDEO_ENCODE_H265_CAPABILITIES_EXT => Some("VIDEO_ENCODE_H265_CAPABILITIES_EXT"), + Self::VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT => { + Some("VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT") + } + Self::VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT => { + Some("VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT") + } + Self::VIDEO_ENCODE_H265_VCL_FRAME_INFO_EXT => { + Some("VIDEO_ENCODE_H265_VCL_FRAME_INFO_EXT") + } + Self::VIDEO_ENCODE_H265_DPB_SLOT_INFO_EXT => { + Some("VIDEO_ENCODE_H265_DPB_SLOT_INFO_EXT") + } + Self::VIDEO_ENCODE_H265_NALU_SLICE_SEGMENT_INFO_EXT => { + Some("VIDEO_ENCODE_H265_NALU_SLICE_SEGMENT_INFO_EXT") + } + Self::VIDEO_ENCODE_H265_EMIT_PICTURE_PARAMETERS_INFO_EXT => { + Some("VIDEO_ENCODE_H265_EMIT_PICTURE_PARAMETERS_INFO_EXT") + } + Self::VIDEO_ENCODE_H265_PROFILE_INFO_EXT => Some("VIDEO_ENCODE_H265_PROFILE_INFO_EXT"), + Self::VIDEO_ENCODE_H265_REFERENCE_LISTS_INFO_EXT => { + Some("VIDEO_ENCODE_H265_REFERENCE_LISTS_INFO_EXT") + } + Self::VIDEO_ENCODE_H265_RATE_CONTROL_INFO_EXT => { + Some("VIDEO_ENCODE_H265_RATE_CONTROL_INFO_EXT") + } + Self::VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_EXT => { + Some("VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_EXT") + } + Self::VIDEO_DECODE_H264_CAPABILITIES_KHR => Some("VIDEO_DECODE_H264_CAPABILITIES_KHR"), + Self::VIDEO_DECODE_H264_PICTURE_INFO_KHR => Some("VIDEO_DECODE_H264_PICTURE_INFO_KHR"), + Self::VIDEO_DECODE_H264_PROFILE_INFO_KHR => Some("VIDEO_DECODE_H264_PROFILE_INFO_KHR"), + Self::VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR => { + Some("VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR") + } + Self::VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR => { + Some("VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR") + } + Self::VIDEO_DECODE_H264_DPB_SLOT_INFO_KHR => { + Some("VIDEO_DECODE_H264_DPB_SLOT_INFO_KHR") + } + Self::TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD => { + Some("TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD") + } + Self::RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR => { + Some("RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR") + } + Self::RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT => { + Some("RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT") + } + Self::ATTACHMENT_SAMPLE_COUNT_INFO_AMD => Some("ATTACHMENT_SAMPLE_COUNT_INFO_AMD"), + Self::MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX => { + Some("MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX") + } + Self::STREAM_DESCRIPTOR_SURFACE_CREATE_INFO_GGP => { + Some("STREAM_DESCRIPTOR_SURFACE_CREATE_INFO_GGP") + } + Self::PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV => { + Some("PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV") + } + Self::EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV => { + Some("EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV") + } + Self::EXPORT_MEMORY_ALLOCATE_INFO_NV => Some("EXPORT_MEMORY_ALLOCATE_INFO_NV"), + Self::IMPORT_MEMORY_WIN32_HANDLE_INFO_NV => Some("IMPORT_MEMORY_WIN32_HANDLE_INFO_NV"), + Self::EXPORT_MEMORY_WIN32_HANDLE_INFO_NV => Some("EXPORT_MEMORY_WIN32_HANDLE_INFO_NV"), + Self::WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV => { + Some("WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV") + } + Self::VALIDATION_FLAGS_EXT => Some("VALIDATION_FLAGS_EXT"), + Self::VI_SURFACE_CREATE_INFO_NN => Some("VI_SURFACE_CREATE_INFO_NN"), + Self::IMAGE_VIEW_ASTC_DECODE_MODE_EXT => Some("IMAGE_VIEW_ASTC_DECODE_MODE_EXT"), + Self::PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT") + } + Self::PIPELINE_ROBUSTNESS_CREATE_INFO_EXT => { + Some("PIPELINE_ROBUSTNESS_CREATE_INFO_EXT") + } + Self::PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT") + } + Self::PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES_EXT => { + Some("PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES_EXT") + } + Self::IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR => { + Some("IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR") + } + Self::EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR => { + Some("EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR") + } + Self::MEMORY_WIN32_HANDLE_PROPERTIES_KHR => Some("MEMORY_WIN32_HANDLE_PROPERTIES_KHR"), + Self::MEMORY_GET_WIN32_HANDLE_INFO_KHR => Some("MEMORY_GET_WIN32_HANDLE_INFO_KHR"), + Self::IMPORT_MEMORY_FD_INFO_KHR => Some("IMPORT_MEMORY_FD_INFO_KHR"), + Self::MEMORY_FD_PROPERTIES_KHR => Some("MEMORY_FD_PROPERTIES_KHR"), + Self::MEMORY_GET_FD_INFO_KHR => Some("MEMORY_GET_FD_INFO_KHR"), + Self::WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR => { + Some("WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR") + } + Self::IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR => { + Some("IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR") + } + Self::EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR => { + Some("EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR") + } + Self::D3D12_FENCE_SUBMIT_INFO_KHR => Some("D3D12_FENCE_SUBMIT_INFO_KHR"), + Self::SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR => { + Some("SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR") + } + Self::IMPORT_SEMAPHORE_FD_INFO_KHR => Some("IMPORT_SEMAPHORE_FD_INFO_KHR"), + Self::SEMAPHORE_GET_FD_INFO_KHR => Some("SEMAPHORE_GET_FD_INFO_KHR"), + Self::PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR => { + Some("PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR") + } + Self::COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT => { + Some("COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT") + } + Self::PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT") + } + Self::CONDITIONAL_RENDERING_BEGIN_INFO_EXT => { + Some("CONDITIONAL_RENDERING_BEGIN_INFO_EXT") + } + Self::PRESENT_REGIONS_KHR => Some("PRESENT_REGIONS_KHR"), + Self::PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV => { + Some("PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV") + } + Self::SURFACE_CAPABILITIES_2_EXT => Some("SURFACE_CAPABILITIES_2_EXT"), + Self::DISPLAY_POWER_INFO_EXT => Some("DISPLAY_POWER_INFO_EXT"), + Self::DEVICE_EVENT_INFO_EXT => Some("DEVICE_EVENT_INFO_EXT"), + Self::DISPLAY_EVENT_INFO_EXT => Some("DISPLAY_EVENT_INFO_EXT"), + Self::SWAPCHAIN_COUNTER_CREATE_INFO_EXT => Some("SWAPCHAIN_COUNTER_CREATE_INFO_EXT"), + Self::PRESENT_TIMES_INFO_GOOGLE => Some("PRESENT_TIMES_INFO_GOOGLE"), + Self::PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX => { + Some("PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX") + } + Self::PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV => { + Some("PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV") + } + Self::PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT => { + Some("PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT") + } + Self::PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT => { + Some("PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT") + } + Self::PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT => { + Some("PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT") + } + Self::PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT => { + Some("PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT") + } + Self::PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT") + } + Self::PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT => { + Some("PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT") + } + Self::HDR_METADATA_EXT => Some("HDR_METADATA_EXT"), + Self::SHARED_PRESENT_SURFACE_CAPABILITIES_KHR => { + Some("SHARED_PRESENT_SURFACE_CAPABILITIES_KHR") + } + Self::IMPORT_FENCE_WIN32_HANDLE_INFO_KHR => Some("IMPORT_FENCE_WIN32_HANDLE_INFO_KHR"), + Self::EXPORT_FENCE_WIN32_HANDLE_INFO_KHR => Some("EXPORT_FENCE_WIN32_HANDLE_INFO_KHR"), + Self::FENCE_GET_WIN32_HANDLE_INFO_KHR => Some("FENCE_GET_WIN32_HANDLE_INFO_KHR"), + Self::IMPORT_FENCE_FD_INFO_KHR => Some("IMPORT_FENCE_FD_INFO_KHR"), + Self::FENCE_GET_FD_INFO_KHR => Some("FENCE_GET_FD_INFO_KHR"), + Self::PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR => { + Some("PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR") + } + Self::PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR => { + Some("PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR") + } + Self::QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR => { + Some("QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR") + } + Self::PERFORMANCE_QUERY_SUBMIT_INFO_KHR => Some("PERFORMANCE_QUERY_SUBMIT_INFO_KHR"), + Self::ACQUIRE_PROFILING_LOCK_INFO_KHR => Some("ACQUIRE_PROFILING_LOCK_INFO_KHR"), + Self::PERFORMANCE_COUNTER_KHR => Some("PERFORMANCE_COUNTER_KHR"), + Self::PERFORMANCE_COUNTER_DESCRIPTION_KHR => { + Some("PERFORMANCE_COUNTER_DESCRIPTION_KHR") + } + Self::PHYSICAL_DEVICE_SURFACE_INFO_2_KHR => Some("PHYSICAL_DEVICE_SURFACE_INFO_2_KHR"), + Self::SURFACE_CAPABILITIES_2_KHR => Some("SURFACE_CAPABILITIES_2_KHR"), + Self::SURFACE_FORMAT_2_KHR => Some("SURFACE_FORMAT_2_KHR"), + Self::DISPLAY_PROPERTIES_2_KHR => Some("DISPLAY_PROPERTIES_2_KHR"), + Self::DISPLAY_PLANE_PROPERTIES_2_KHR => Some("DISPLAY_PLANE_PROPERTIES_2_KHR"), + Self::DISPLAY_MODE_PROPERTIES_2_KHR => Some("DISPLAY_MODE_PROPERTIES_2_KHR"), + Self::DISPLAY_PLANE_INFO_2_KHR => Some("DISPLAY_PLANE_INFO_2_KHR"), + Self::DISPLAY_PLANE_CAPABILITIES_2_KHR => Some("DISPLAY_PLANE_CAPABILITIES_2_KHR"), + Self::IOS_SURFACE_CREATE_INFO_MVK => Some("IOS_SURFACE_CREATE_INFO_MVK"), + Self::MACOS_SURFACE_CREATE_INFO_MVK => Some("MACOS_SURFACE_CREATE_INFO_MVK"), + Self::DEBUG_UTILS_OBJECT_NAME_INFO_EXT => Some("DEBUG_UTILS_OBJECT_NAME_INFO_EXT"), + Self::DEBUG_UTILS_OBJECT_TAG_INFO_EXT => Some("DEBUG_UTILS_OBJECT_TAG_INFO_EXT"), + Self::DEBUG_UTILS_LABEL_EXT => Some("DEBUG_UTILS_LABEL_EXT"), + Self::DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT => { + Some("DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT") + } + Self::DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT => { + Some("DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT") + } + Self::ANDROID_HARDWARE_BUFFER_USAGE_ANDROID => { + Some("ANDROID_HARDWARE_BUFFER_USAGE_ANDROID") + } + Self::ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID => { + Some("ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID") + } + Self::ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID => { + Some("ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID") + } + Self::IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID => { + Some("IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID") + } + Self::MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID => { + Some("MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID") + } + Self::EXTERNAL_FORMAT_ANDROID => Some("EXTERNAL_FORMAT_ANDROID"), + Self::ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID => { + Some("ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID") + } + Self::SAMPLE_LOCATIONS_INFO_EXT => Some("SAMPLE_LOCATIONS_INFO_EXT"), + Self::RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT => { + Some("RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT") + } + Self::PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT => { + Some("PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT") + } + Self::PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT => { + Some("PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT") + } + Self::MULTISAMPLE_PROPERTIES_EXT => Some("MULTISAMPLE_PROPERTIES_EXT"), + Self::PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT") + } + Self::PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT => { + Some("PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT") + } + Self::PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT => { + Some("PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT") + } + Self::PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV => { + Some("PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV") + } + Self::WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR => { + Some("WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR") + } + Self::ACCELERATION_STRUCTURE_BUILD_GEOMETRY_INFO_KHR => { + Some("ACCELERATION_STRUCTURE_BUILD_GEOMETRY_INFO_KHR") + } + Self::ACCELERATION_STRUCTURE_DEVICE_ADDRESS_INFO_KHR => { + Some("ACCELERATION_STRUCTURE_DEVICE_ADDRESS_INFO_KHR") + } + Self::ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA_KHR => { + Some("ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA_KHR") + } + Self::ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR => { + Some("ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR") + } + Self::ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR => { + Some("ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR") + } + Self::ACCELERATION_STRUCTURE_GEOMETRY_KHR => { + Some("ACCELERATION_STRUCTURE_GEOMETRY_KHR") + } + Self::ACCELERATION_STRUCTURE_VERSION_INFO_KHR => { + Some("ACCELERATION_STRUCTURE_VERSION_INFO_KHR") + } + Self::COPY_ACCELERATION_STRUCTURE_INFO_KHR => { + Some("COPY_ACCELERATION_STRUCTURE_INFO_KHR") + } + Self::COPY_ACCELERATION_STRUCTURE_TO_MEMORY_INFO_KHR => { + Some("COPY_ACCELERATION_STRUCTURE_TO_MEMORY_INFO_KHR") + } + Self::COPY_MEMORY_TO_ACCELERATION_STRUCTURE_INFO_KHR => { + Some("COPY_MEMORY_TO_ACCELERATION_STRUCTURE_INFO_KHR") + } + Self::PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR => { + Some("PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR") + } + Self::PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR => { + Some("PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR") + } + Self::ACCELERATION_STRUCTURE_CREATE_INFO_KHR => { + Some("ACCELERATION_STRUCTURE_CREATE_INFO_KHR") + } + Self::ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR => { + Some("ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR") + } + Self::PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR => { + Some("PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR") + } + Self::PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR => { + Some("PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR") + } + Self::RAY_TRACING_PIPELINE_CREATE_INFO_KHR => { + Some("RAY_TRACING_PIPELINE_CREATE_INFO_KHR") + } + Self::RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR => { + Some("RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR") + } + Self::RAY_TRACING_PIPELINE_INTERFACE_CREATE_INFO_KHR => { + Some("RAY_TRACING_PIPELINE_INTERFACE_CREATE_INFO_KHR") + } + Self::PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR => { + Some("PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR") + } + Self::PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV => { + Some("PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV") + } + Self::PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV => { + Some("PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV") + } + Self::PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV => { + Some("PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV") + } + Self::DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT => { + Some("DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT") + } + Self::PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT => { + Some("PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT") + } + Self::IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT => { + Some("IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT") + } + Self::IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT => { + Some("IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT") + } + Self::IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT => { + Some("IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT") + } + Self::DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT => { + Some("DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT") + } + Self::VALIDATION_CACHE_CREATE_INFO_EXT => Some("VALIDATION_CACHE_CREATE_INFO_EXT"), + Self::SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT => { + Some("SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT") + } + Self::PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR => { + Some("PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR") + } + Self::PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR => { + Some("PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR") + } + Self::PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV => { + Some("PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV") + } + Self::PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV => { + Some("PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV") + } + Self::PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV => { + Some("PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV") + } + Self::PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV => { + Some("PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV") + } + Self::RAY_TRACING_PIPELINE_CREATE_INFO_NV => { + Some("RAY_TRACING_PIPELINE_CREATE_INFO_NV") + } + Self::ACCELERATION_STRUCTURE_CREATE_INFO_NV => { + Some("ACCELERATION_STRUCTURE_CREATE_INFO_NV") + } + Self::GEOMETRY_NV => Some("GEOMETRY_NV"), + Self::GEOMETRY_TRIANGLES_NV => Some("GEOMETRY_TRIANGLES_NV"), + Self::GEOMETRY_AABB_NV => Some("GEOMETRY_AABB_NV"), + Self::BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NV => { + Some("BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NV") + } + Self::WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV => { + Some("WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV") + } + Self::ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV => { + Some("ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV") + } + Self::PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV => { + Some("PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV") + } + Self::RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV => { + Some("RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV") + } + Self::ACCELERATION_STRUCTURE_INFO_NV => Some("ACCELERATION_STRUCTURE_INFO_NV"), + Self::PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV => { + Some("PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV") + } + Self::PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV => { + Some("PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV") + } + Self::PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT => { + Some("PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT") + } + Self::FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT => { + Some("FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT") + } + Self::IMPORT_MEMORY_HOST_POINTER_INFO_EXT => { + Some("IMPORT_MEMORY_HOST_POINTER_INFO_EXT") + } + Self::MEMORY_HOST_POINTER_PROPERTIES_EXT => Some("MEMORY_HOST_POINTER_PROPERTIES_EXT"), + Self::PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT => { + Some("PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT") + } + Self::PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR => { + Some("PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR") + } + Self::PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD => { + Some("PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD") + } + Self::CALIBRATED_TIMESTAMP_INFO_EXT => Some("CALIBRATED_TIMESTAMP_INFO_EXT"), + Self::PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD => { + Some("PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD") + } + Self::VIDEO_DECODE_H265_CAPABILITIES_KHR => Some("VIDEO_DECODE_H265_CAPABILITIES_KHR"), + Self::VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR => { + Some("VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR") + } + Self::VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR => { + Some("VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR") + } + Self::VIDEO_DECODE_H265_PROFILE_INFO_KHR => Some("VIDEO_DECODE_H265_PROFILE_INFO_KHR"), + Self::VIDEO_DECODE_H265_PICTURE_INFO_KHR => Some("VIDEO_DECODE_H265_PICTURE_INFO_KHR"), + Self::VIDEO_DECODE_H265_DPB_SLOT_INFO_KHR => { + Some("VIDEO_DECODE_H265_DPB_SLOT_INFO_KHR") + } + Self::DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_KHR => { + Some("DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_KHR") + } + Self::PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR => { + Some("PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR") + } + Self::QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR => { + Some("QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR") + } + Self::DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD => { + Some("DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD") + } + Self::PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT => { + Some("PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT") + } + Self::PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT => { + Some("PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT") + } + Self::PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT") + } + Self::PRESENT_FRAME_TOKEN_GGP => Some("PRESENT_FRAME_TOKEN_GGP"), + Self::PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV => { + Some("PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV") + } + Self::PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV => { + Some("PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV") + } + Self::PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV => { + Some("PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV") + } + Self::PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV => { + Some("PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV") + } + Self::PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV => { + Some("PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV") + } + Self::PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV => { + Some("PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV") + } + Self::CHECKPOINT_DATA_NV => Some("CHECKPOINT_DATA_NV"), + Self::QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV => { + Some("QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV") + } + Self::PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL => { + Some("PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL") + } + Self::QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL => { + Some("QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL") + } + Self::INITIALIZE_PERFORMANCE_API_INFO_INTEL => { + Some("INITIALIZE_PERFORMANCE_API_INFO_INTEL") + } + Self::PERFORMANCE_MARKER_INFO_INTEL => Some("PERFORMANCE_MARKER_INFO_INTEL"), + Self::PERFORMANCE_STREAM_MARKER_INFO_INTEL => { + Some("PERFORMANCE_STREAM_MARKER_INFO_INTEL") + } + Self::PERFORMANCE_OVERRIDE_INFO_INTEL => Some("PERFORMANCE_OVERRIDE_INFO_INTEL"), + Self::PERFORMANCE_CONFIGURATION_ACQUIRE_INFO_INTEL => { + Some("PERFORMANCE_CONFIGURATION_ACQUIRE_INFO_INTEL") + } + Self::PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT => { + Some("PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT") + } + Self::DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD => { + Some("DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD") + } + Self::SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD => { + Some("SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD") + } + Self::IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA => { + Some("IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA") + } + Self::METAL_SURFACE_CREATE_INFO_EXT => Some("METAL_SURFACE_CREATE_INFO_EXT"), + Self::PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT") + } + Self::PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT => { + Some("PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT") + } + Self::RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT => { + Some("RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT") + } + Self::FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR => { + Some("FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR") + } + Self::PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR => { + Some("PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR") + } + Self::PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR => { + Some("PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR") + } + Self::PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR => { + Some("PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR") + } + Self::PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR => { + Some("PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR") + } + Self::PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD => { + Some("PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD") + } + Self::PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD => { + Some("PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD") + } + Self::PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT") + } + Self::PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT => { + Some("PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT") + } + Self::PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT") + } + Self::MEMORY_PRIORITY_ALLOCATE_INFO_EXT => Some("MEMORY_PRIORITY_ALLOCATE_INFO_EXT"), + Self::SURFACE_PROTECTED_CAPABILITIES_KHR => Some("SURFACE_PROTECTED_CAPABILITIES_KHR"), + Self::PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV => { + Some("PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV") + } + Self::PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT") + } + Self::BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT => { + Some("BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT") + } + Self::VALIDATION_FEATURES_EXT => Some("VALIDATION_FEATURES_EXT"), + Self::PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR => { + Some("PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR") + } + Self::PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV => { + Some("PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV") + } + Self::COOPERATIVE_MATRIX_PROPERTIES_NV => Some("COOPERATIVE_MATRIX_PROPERTIES_NV"), + Self::PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV => { + Some("PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV") + } + Self::PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV => { + Some("PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV") + } + Self::PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV => { + Some("PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV") + } + Self::FRAMEBUFFER_MIXED_SAMPLES_COMBINATION_NV => { + Some("FRAMEBUFFER_MIXED_SAMPLES_COMBINATION_NV") + } + Self::PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT") + } + Self::PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT") + } + Self::PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT") + } + Self::PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT => { + Some("PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT") + } + Self::PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT => { + Some("PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT") + } + Self::SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT => { + Some("SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT") + } + Self::SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT => { + Some("SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT") + } + Self::SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT => { + Some("SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT") + } + Self::HEADLESS_SURFACE_CREATE_INFO_EXT => Some("HEADLESS_SURFACE_CREATE_INFO_EXT"), + Self::PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT") + } + Self::PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT => { + Some("PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT") + } + Self::PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT => { + Some("PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT") + } + Self::PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT") + } + Self::PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT") + } + Self::PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT") + } + Self::PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR => { + Some("PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR") + } + Self::PIPELINE_INFO_KHR => Some("PIPELINE_INFO_KHR"), + Self::PIPELINE_EXECUTABLE_PROPERTIES_KHR => Some("PIPELINE_EXECUTABLE_PROPERTIES_KHR"), + Self::PIPELINE_EXECUTABLE_INFO_KHR => Some("PIPELINE_EXECUTABLE_INFO_KHR"), + Self::PIPELINE_EXECUTABLE_STATISTIC_KHR => Some("PIPELINE_EXECUTABLE_STATISTIC_KHR"), + Self::PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR => { + Some("PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR") + } + Self::PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT") + } + Self::SURFACE_PRESENT_MODE_EXT => Some("SURFACE_PRESENT_MODE_EXT"), + Self::SURFACE_PRESENT_SCALING_CAPABILITIES_EXT => { + Some("SURFACE_PRESENT_SCALING_CAPABILITIES_EXT") + } + Self::SURFACE_PRESENT_MODE_COMPATIBILITY_EXT => { + Some("SURFACE_PRESENT_MODE_COMPATIBILITY_EXT") + } + Self::PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT") + } + Self::SWAPCHAIN_PRESENT_FENCE_INFO_EXT => Some("SWAPCHAIN_PRESENT_FENCE_INFO_EXT"), + Self::SWAPCHAIN_PRESENT_MODES_CREATE_INFO_EXT => { + Some("SWAPCHAIN_PRESENT_MODES_CREATE_INFO_EXT") + } + Self::SWAPCHAIN_PRESENT_MODE_INFO_EXT => Some("SWAPCHAIN_PRESENT_MODE_INFO_EXT"), + Self::SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_EXT => { + Some("SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_EXT") + } + Self::RELEASE_SWAPCHAIN_IMAGES_INFO_EXT => Some("RELEASE_SWAPCHAIN_IMAGES_INFO_EXT"), + Self::PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV => { + Some("PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV") + } + Self::GRAPHICS_SHADER_GROUP_CREATE_INFO_NV => { + Some("GRAPHICS_SHADER_GROUP_CREATE_INFO_NV") + } + Self::GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV => { + Some("GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV") + } + Self::INDIRECT_COMMANDS_LAYOUT_TOKEN_NV => Some("INDIRECT_COMMANDS_LAYOUT_TOKEN_NV"), + Self::INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NV => { + Some("INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NV") + } + Self::GENERATED_COMMANDS_INFO_NV => Some("GENERATED_COMMANDS_INFO_NV"), + Self::GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_NV => { + Some("GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_NV") + } + Self::PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV => { + Some("PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV") + } + Self::PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV => { + Some("PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV") + } + Self::COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV => { + Some("COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV") + } + Self::PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT") + } + Self::COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM => { + Some("COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM") + } + Self::RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM => { + Some("RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM") + } + Self::PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT") + } + Self::DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT => { + Some("DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT") + } + Self::DEVICE_MEMORY_REPORT_CALLBACK_DATA_EXT => { + Some("DEVICE_MEMORY_REPORT_CALLBACK_DATA_EXT") + } + Self::PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT") + } + Self::PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT => { + Some("PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT") + } + Self::SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT => { + Some("SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT") + } + Self::PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT => { + Some("PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT") + } + Self::PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT") + } + Self::PIPELINE_LIBRARY_CREATE_INFO_KHR => Some("PIPELINE_LIBRARY_CREATE_INFO_KHR"), + Self::PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV => { + Some("PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV") + } + Self::SURFACE_CAPABILITIES_PRESENT_BARRIER_NV => { + Some("SURFACE_CAPABILITIES_PRESENT_BARRIER_NV") + } + Self::SWAPCHAIN_PRESENT_BARRIER_CREATE_INFO_NV => { + Some("SWAPCHAIN_PRESENT_BARRIER_CREATE_INFO_NV") + } + Self::PRESENT_ID_KHR => Some("PRESENT_ID_KHR"), + Self::PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR => { + Some("PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR") + } + Self::VIDEO_ENCODE_INFO_KHR => Some("VIDEO_ENCODE_INFO_KHR"), + Self::VIDEO_ENCODE_RATE_CONTROL_INFO_KHR => Some("VIDEO_ENCODE_RATE_CONTROL_INFO_KHR"), + Self::VIDEO_ENCODE_RATE_CONTROL_LAYER_INFO_KHR => { + Some("VIDEO_ENCODE_RATE_CONTROL_LAYER_INFO_KHR") + } + Self::VIDEO_ENCODE_CAPABILITIES_KHR => Some("VIDEO_ENCODE_CAPABILITIES_KHR"), + Self::VIDEO_ENCODE_USAGE_INFO_KHR => Some("VIDEO_ENCODE_USAGE_INFO_KHR"), + Self::PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV => { + Some("PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV") + } + Self::DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV => { + Some("DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV") + } + Self::RESERVED_QCOM => Some("RESERVED_QCOM"), + Self::EXPORT_METAL_OBJECT_CREATE_INFO_EXT => { + Some("EXPORT_METAL_OBJECT_CREATE_INFO_EXT") + } + Self::EXPORT_METAL_OBJECTS_INFO_EXT => Some("EXPORT_METAL_OBJECTS_INFO_EXT"), + Self::EXPORT_METAL_DEVICE_INFO_EXT => Some("EXPORT_METAL_DEVICE_INFO_EXT"), + Self::EXPORT_METAL_COMMAND_QUEUE_INFO_EXT => { + Some("EXPORT_METAL_COMMAND_QUEUE_INFO_EXT") + } + Self::EXPORT_METAL_BUFFER_INFO_EXT => Some("EXPORT_METAL_BUFFER_INFO_EXT"), + Self::IMPORT_METAL_BUFFER_INFO_EXT => Some("IMPORT_METAL_BUFFER_INFO_EXT"), + Self::EXPORT_METAL_TEXTURE_INFO_EXT => Some("EXPORT_METAL_TEXTURE_INFO_EXT"), + Self::IMPORT_METAL_TEXTURE_INFO_EXT => Some("IMPORT_METAL_TEXTURE_INFO_EXT"), + Self::EXPORT_METAL_IO_SURFACE_INFO_EXT => Some("EXPORT_METAL_IO_SURFACE_INFO_EXT"), + Self::IMPORT_METAL_IO_SURFACE_INFO_EXT => Some("IMPORT_METAL_IO_SURFACE_INFO_EXT"), + Self::EXPORT_METAL_SHARED_EVENT_INFO_EXT => Some("EXPORT_METAL_SHARED_EVENT_INFO_EXT"), + Self::IMPORT_METAL_SHARED_EVENT_INFO_EXT => Some("IMPORT_METAL_SHARED_EVENT_INFO_EXT"), + Self::QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV => { + Some("QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV") + } + Self::CHECKPOINT_DATA_2_NV => Some("CHECKPOINT_DATA_2_NV"), + Self::PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT => { + Some("PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT") + } + Self::PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT => { + Some("PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT") + } + Self::PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT") + } + Self::DESCRIPTOR_ADDRESS_INFO_EXT => Some("DESCRIPTOR_ADDRESS_INFO_EXT"), + Self::DESCRIPTOR_GET_INFO_EXT => Some("DESCRIPTOR_GET_INFO_EXT"), + Self::BUFFER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT => { + Some("BUFFER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT") + } + Self::IMAGE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT => { + Some("IMAGE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT") + } + Self::IMAGE_VIEW_CAPTURE_DESCRIPTOR_DATA_INFO_EXT => { + Some("IMAGE_VIEW_CAPTURE_DESCRIPTOR_DATA_INFO_EXT") + } + Self::SAMPLER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT => { + Some("SAMPLER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT") + } + Self::OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT => { + Some("OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT") + } + Self::DESCRIPTOR_BUFFER_BINDING_INFO_EXT => Some("DESCRIPTOR_BUFFER_BINDING_INFO_EXT"), + Self::DESCRIPTOR_BUFFER_BINDING_PUSH_DESCRIPTOR_BUFFER_HANDLE_EXT => { + Some("DESCRIPTOR_BUFFER_BINDING_PUSH_DESCRIPTOR_BUFFER_HANDLE_EXT") + } + Self::ACCELERATION_STRUCTURE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT => { + Some("ACCELERATION_STRUCTURE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT") + } + Self::PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT") + } + Self::PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT => { + Some("PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT") + } + Self::GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT => { + Some("GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT") + } + Self::PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD => { + Some("PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD") + } + Self::PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR => { + Some("PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR") + } + Self::PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR => { + Some("PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR") + } + Self::PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR => { + Some("PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR") + } + Self::PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV => { + Some("PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV") + } + Self::PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV => { + Some("PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV") + } + Self::PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV => { + Some("PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV") + } + Self::ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV => { + Some("ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV") + } + Self::PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV => { + Some("PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV") + } + Self::ACCELERATION_STRUCTURE_MOTION_INFO_NV => { + Some("ACCELERATION_STRUCTURE_MOTION_INFO_NV") + } + Self::PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT") + } + Self::PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT => { + Some("PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT") + } + Self::PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT") + } + Self::PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT") + } + Self::PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT => { + Some("PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT") + } + Self::COPY_COMMAND_TRANSFORM_INFO_QCOM => Some("COPY_COMMAND_TRANSFORM_INFO_QCOM"), + Self::PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR => { + Some("PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR") + } + Self::PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT") + } + Self::IMAGE_COMPRESSION_CONTROL_EXT => Some("IMAGE_COMPRESSION_CONTROL_EXT"), + Self::SUBRESOURCE_LAYOUT_2_EXT => Some("SUBRESOURCE_LAYOUT_2_EXT"), + Self::IMAGE_SUBRESOURCE_2_EXT => Some("IMAGE_SUBRESOURCE_2_EXT"), + Self::IMAGE_COMPRESSION_PROPERTIES_EXT => Some("IMAGE_COMPRESSION_PROPERTIES_EXT"), + Self::PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT") + } + Self::PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT") + } + Self::PHYSICAL_DEVICE_FAULT_FEATURES_EXT => Some("PHYSICAL_DEVICE_FAULT_FEATURES_EXT"), + Self::DEVICE_FAULT_COUNTS_EXT => Some("DEVICE_FAULT_COUNTS_EXT"), + Self::DEVICE_FAULT_INFO_EXT => Some("DEVICE_FAULT_INFO_EXT"), + Self::PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT") + } + Self::DIRECTFB_SURFACE_CREATE_INFO_EXT => Some("DIRECTFB_SURFACE_CREATE_INFO_EXT"), + Self::PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT") + } + Self::VERTEX_INPUT_BINDING_DESCRIPTION_2_EXT => { + Some("VERTEX_INPUT_BINDING_DESCRIPTION_2_EXT") + } + Self::VERTEX_INPUT_ATTRIBUTE_DESCRIPTION_2_EXT => { + Some("VERTEX_INPUT_ATTRIBUTE_DESCRIPTION_2_EXT") + } + Self::PHYSICAL_DEVICE_DRM_PROPERTIES_EXT => Some("PHYSICAL_DEVICE_DRM_PROPERTIES_EXT"), + Self::PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT") + } + Self::DEVICE_ADDRESS_BINDING_CALLBACK_DATA_EXT => { + Some("DEVICE_ADDRESS_BINDING_CALLBACK_DATA_EXT") + } + Self::PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT") + } + Self::PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT => { + Some("PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT") + } + Self::PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT") + } + Self::IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA => { + Some("IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA") + } + Self::MEMORY_ZIRCON_HANDLE_PROPERTIES_FUCHSIA => { + Some("MEMORY_ZIRCON_HANDLE_PROPERTIES_FUCHSIA") + } + Self::MEMORY_GET_ZIRCON_HANDLE_INFO_FUCHSIA => { + Some("MEMORY_GET_ZIRCON_HANDLE_INFO_FUCHSIA") + } + Self::IMPORT_SEMAPHORE_ZIRCON_HANDLE_INFO_FUCHSIA => { + Some("IMPORT_SEMAPHORE_ZIRCON_HANDLE_INFO_FUCHSIA") + } + Self::SEMAPHORE_GET_ZIRCON_HANDLE_INFO_FUCHSIA => { + Some("SEMAPHORE_GET_ZIRCON_HANDLE_INFO_FUCHSIA") + } + Self::BUFFER_COLLECTION_CREATE_INFO_FUCHSIA => { + Some("BUFFER_COLLECTION_CREATE_INFO_FUCHSIA") + } + Self::IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA => { + Some("IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA") + } + Self::BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA => { + Some("BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA") + } + Self::BUFFER_COLLECTION_PROPERTIES_FUCHSIA => { + Some("BUFFER_COLLECTION_PROPERTIES_FUCHSIA") + } + Self::BUFFER_CONSTRAINTS_INFO_FUCHSIA => Some("BUFFER_CONSTRAINTS_INFO_FUCHSIA"), + Self::BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA => { + Some("BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA") + } + Self::IMAGE_CONSTRAINTS_INFO_FUCHSIA => Some("IMAGE_CONSTRAINTS_INFO_FUCHSIA"), + Self::IMAGE_FORMAT_CONSTRAINTS_INFO_FUCHSIA => { + Some("IMAGE_FORMAT_CONSTRAINTS_INFO_FUCHSIA") + } + Self::SYSMEM_COLOR_SPACE_FUCHSIA => Some("SYSMEM_COLOR_SPACE_FUCHSIA"), + Self::BUFFER_COLLECTION_CONSTRAINTS_INFO_FUCHSIA => { + Some("BUFFER_COLLECTION_CONSTRAINTS_INFO_FUCHSIA") + } + Self::SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI => { + Some("SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI") + } + Self::PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI => { + Some("PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI") + } + Self::PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI => { + Some("PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI") + } + Self::PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI => { + Some("PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI") + } + Self::MEMORY_GET_REMOTE_ADDRESS_INFO_NV => Some("MEMORY_GET_REMOTE_ADDRESS_INFO_NV"), + Self::PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV => { + Some("PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV") + } + Self::PIPELINE_PROPERTIES_IDENTIFIER_EXT => Some("PIPELINE_PROPERTIES_IDENTIFIER_EXT"), + Self::PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT") + } + Self::PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT") + } + Self::SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT => { + Some("SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT") + } + Self::MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT => { + Some("MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT") + } + Self::PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT") + } + Self::SCREEN_SURFACE_CREATE_INFO_QNX => Some("SCREEN_SURFACE_CREATE_INFO_QNX"), + Self::PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT") + } + Self::PIPELINE_COLOR_WRITE_CREATE_INFO_EXT => { + Some("PIPELINE_COLOR_WRITE_CREATE_INFO_EXT") + } + Self::PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT") + } + Self::PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR => { + Some("PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR") + } + Self::PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT") + } + Self::IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT => Some("IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT"), + Self::PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT") + } + Self::PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT => { + Some("PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT") + } + Self::PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT") + } + Self::MICROMAP_BUILD_INFO_EXT => Some("MICROMAP_BUILD_INFO_EXT"), + Self::MICROMAP_VERSION_INFO_EXT => Some("MICROMAP_VERSION_INFO_EXT"), + Self::COPY_MICROMAP_INFO_EXT => Some("COPY_MICROMAP_INFO_EXT"), + Self::COPY_MICROMAP_TO_MEMORY_INFO_EXT => Some("COPY_MICROMAP_TO_MEMORY_INFO_EXT"), + Self::COPY_MEMORY_TO_MICROMAP_INFO_EXT => Some("COPY_MEMORY_TO_MICROMAP_INFO_EXT"), + Self::PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT") + } + Self::PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT => { + Some("PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT") + } + Self::MICROMAP_CREATE_INFO_EXT => Some("MICROMAP_CREATE_INFO_EXT"), + Self::MICROMAP_BUILD_SIZES_INFO_EXT => Some("MICROMAP_BUILD_SIZES_INFO_EXT"), + Self::ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_EXT => { + Some("ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_EXT") + } + Self::PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT") + } + Self::SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT => { + Some("SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT") + } + Self::PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT") + } + Self::PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE => { + Some("PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE") + } + Self::DESCRIPTOR_SET_BINDING_REFERENCE_VALVE => { + Some("DESCRIPTOR_SET_BINDING_REFERENCE_VALVE") + } + Self::DESCRIPTOR_SET_LAYOUT_HOST_MAPPING_INFO_VALVE => { + Some("DESCRIPTOR_SET_LAYOUT_HOST_MAPPING_INFO_VALVE") + } + Self::PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT") + } + Self::PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT") + } + Self::PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM => { + Some("PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM") + } + Self::PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM => { + Some("PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM") + } + Self::SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM => { + Some("SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM") + } + Self::PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV => { + Some("PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV") + } + Self::PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV => { + Some("PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV") + } + Self::PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV => { + Some("PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV") + } + Self::PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV => { + Some("PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV") + } + Self::PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV => { + Some("PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV") + } + Self::PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT") + } + Self::PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM => { + Some("PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM") + } + Self::PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM => { + Some("PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM") + } + Self::IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM => { + Some("IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM") + } + Self::PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT") + } + Self::PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT => { + Some("PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT") + } + Self::PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT") + } + Self::RENDER_PASS_CREATION_CONTROL_EXT => Some("RENDER_PASS_CREATION_CONTROL_EXT"), + Self::RENDER_PASS_CREATION_FEEDBACK_CREATE_INFO_EXT => { + Some("RENDER_PASS_CREATION_FEEDBACK_CREATE_INFO_EXT") + } + Self::RENDER_PASS_SUBPASS_FEEDBACK_CREATE_INFO_EXT => { + Some("RENDER_PASS_SUBPASS_FEEDBACK_CREATE_INFO_EXT") + } + Self::DIRECT_DRIVER_LOADING_INFO_LUNARG => Some("DIRECT_DRIVER_LOADING_INFO_LUNARG"), + Self::DIRECT_DRIVER_LOADING_LIST_LUNARG => Some("DIRECT_DRIVER_LOADING_LIST_LUNARG"), + Self::PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT") + } + Self::PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT => { + Some("PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT") + } + Self::PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT => { + Some("PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT") + } + Self::SHADER_MODULE_IDENTIFIER_EXT => Some("SHADER_MODULE_IDENTIFIER_EXT"), + Self::PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT") + } + Self::PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV => { + Some("PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV") + } + Self::PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV => { + Some("PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV") + } + Self::OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV => Some("OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV"), + Self::OPTICAL_FLOW_IMAGE_FORMAT_PROPERTIES_NV => { + Some("OPTICAL_FLOW_IMAGE_FORMAT_PROPERTIES_NV") + } + Self::OPTICAL_FLOW_SESSION_CREATE_INFO_NV => { + Some("OPTICAL_FLOW_SESSION_CREATE_INFO_NV") + } + Self::OPTICAL_FLOW_EXECUTE_INFO_NV => Some("OPTICAL_FLOW_EXECUTE_INFO_NV"), + Self::OPTICAL_FLOW_SESSION_CREATE_PRIVATE_DATA_INFO_NV => { + Some("OPTICAL_FLOW_SESSION_CREATE_PRIVATE_DATA_INFO_NV") + } + Self::PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT") + } + Self::PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT") + } + Self::PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM => { + Some("PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM") + } + Self::TILE_PROPERTIES_QCOM => Some("TILE_PROPERTIES_QCOM"), + Self::PHYSICAL_DEVICE_AMIGO_PROFILING_FEATURES_SEC => { + Some("PHYSICAL_DEVICE_AMIGO_PROFILING_FEATURES_SEC") + } + Self::AMIGO_PROFILING_SUBMIT_INFO_SEC => Some("AMIGO_PROFILING_SUBMIT_INFO_SEC"), + Self::PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM => { + Some("PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM") + } + Self::PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV => { + Some("PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV") + } + Self::PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV => { + Some("PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV") + } + Self::PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT") + } + Self::MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT => { + Some("MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT") + } + Self::PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM => { + Some("PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM") + } + Self::PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM => { + Some("PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM") + } + Self::PHYSICAL_DEVICE_SUBGROUP_PROPERTIES => { + Some("PHYSICAL_DEVICE_SUBGROUP_PROPERTIES") + } + Self::BIND_BUFFER_MEMORY_INFO => Some("BIND_BUFFER_MEMORY_INFO"), + Self::BIND_IMAGE_MEMORY_INFO => Some("BIND_IMAGE_MEMORY_INFO"), + Self::PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES => { + Some("PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES") + } + Self::MEMORY_DEDICATED_REQUIREMENTS => Some("MEMORY_DEDICATED_REQUIREMENTS"), + Self::MEMORY_DEDICATED_ALLOCATE_INFO => Some("MEMORY_DEDICATED_ALLOCATE_INFO"), + Self::MEMORY_ALLOCATE_FLAGS_INFO => Some("MEMORY_ALLOCATE_FLAGS_INFO"), + Self::DEVICE_GROUP_RENDER_PASS_BEGIN_INFO => { + Some("DEVICE_GROUP_RENDER_PASS_BEGIN_INFO") + } + Self::DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO => { + Some("DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO") + } + Self::DEVICE_GROUP_SUBMIT_INFO => Some("DEVICE_GROUP_SUBMIT_INFO"), + Self::DEVICE_GROUP_BIND_SPARSE_INFO => Some("DEVICE_GROUP_BIND_SPARSE_INFO"), + Self::BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO => { + Some("BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO") + } + Self::BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO => { + Some("BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO") + } + Self::PHYSICAL_DEVICE_GROUP_PROPERTIES => Some("PHYSICAL_DEVICE_GROUP_PROPERTIES"), + Self::DEVICE_GROUP_DEVICE_CREATE_INFO => Some("DEVICE_GROUP_DEVICE_CREATE_INFO"), + Self::BUFFER_MEMORY_REQUIREMENTS_INFO_2 => Some("BUFFER_MEMORY_REQUIREMENTS_INFO_2"), + Self::IMAGE_MEMORY_REQUIREMENTS_INFO_2 => Some("IMAGE_MEMORY_REQUIREMENTS_INFO_2"), + Self::IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2 => { + Some("IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2") + } + Self::MEMORY_REQUIREMENTS_2 => Some("MEMORY_REQUIREMENTS_2"), + Self::SPARSE_IMAGE_MEMORY_REQUIREMENTS_2 => Some("SPARSE_IMAGE_MEMORY_REQUIREMENTS_2"), + Self::PHYSICAL_DEVICE_FEATURES_2 => Some("PHYSICAL_DEVICE_FEATURES_2"), + Self::PHYSICAL_DEVICE_PROPERTIES_2 => Some("PHYSICAL_DEVICE_PROPERTIES_2"), + Self::FORMAT_PROPERTIES_2 => Some("FORMAT_PROPERTIES_2"), + Self::IMAGE_FORMAT_PROPERTIES_2 => Some("IMAGE_FORMAT_PROPERTIES_2"), + Self::PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2 => { + Some("PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2") + } + Self::QUEUE_FAMILY_PROPERTIES_2 => Some("QUEUE_FAMILY_PROPERTIES_2"), + Self::PHYSICAL_DEVICE_MEMORY_PROPERTIES_2 => { + Some("PHYSICAL_DEVICE_MEMORY_PROPERTIES_2") + } + Self::SPARSE_IMAGE_FORMAT_PROPERTIES_2 => Some("SPARSE_IMAGE_FORMAT_PROPERTIES_2"), + Self::PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2 => { + Some("PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2") + } + Self::PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES => { + Some("PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES") + } + Self::RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO => { + Some("RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO") + } + Self::IMAGE_VIEW_USAGE_CREATE_INFO => Some("IMAGE_VIEW_USAGE_CREATE_INFO"), + Self::PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO => { + Some("PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO") + } + Self::RENDER_PASS_MULTIVIEW_CREATE_INFO => Some("RENDER_PASS_MULTIVIEW_CREATE_INFO"), + Self::PHYSICAL_DEVICE_MULTIVIEW_FEATURES => Some("PHYSICAL_DEVICE_MULTIVIEW_FEATURES"), + Self::PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES => { + Some("PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES") + } + Self::PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES => { + Some("PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES") + } + Self::PROTECTED_SUBMIT_INFO => Some("PROTECTED_SUBMIT_INFO"), + Self::PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES => { + Some("PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES") + } + Self::PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES => { + Some("PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES") + } + Self::DEVICE_QUEUE_INFO_2 => Some("DEVICE_QUEUE_INFO_2"), + Self::SAMPLER_YCBCR_CONVERSION_CREATE_INFO => { + Some("SAMPLER_YCBCR_CONVERSION_CREATE_INFO") + } + Self::SAMPLER_YCBCR_CONVERSION_INFO => Some("SAMPLER_YCBCR_CONVERSION_INFO"), + Self::BIND_IMAGE_PLANE_MEMORY_INFO => Some("BIND_IMAGE_PLANE_MEMORY_INFO"), + Self::IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO => { + Some("IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO") + } + Self::PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES => { + Some("PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES") + } + Self::SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES => { + Some("SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES") + } + Self::DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO => { + Some("DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO") + } + Self::PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO => { + Some("PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO") + } + Self::EXTERNAL_IMAGE_FORMAT_PROPERTIES => Some("EXTERNAL_IMAGE_FORMAT_PROPERTIES"), + Self::PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO => { + Some("PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO") + } + Self::EXTERNAL_BUFFER_PROPERTIES => Some("EXTERNAL_BUFFER_PROPERTIES"), + Self::PHYSICAL_DEVICE_ID_PROPERTIES => Some("PHYSICAL_DEVICE_ID_PROPERTIES"), + Self::EXTERNAL_MEMORY_BUFFER_CREATE_INFO => Some("EXTERNAL_MEMORY_BUFFER_CREATE_INFO"), + Self::EXTERNAL_MEMORY_IMAGE_CREATE_INFO => Some("EXTERNAL_MEMORY_IMAGE_CREATE_INFO"), + Self::EXPORT_MEMORY_ALLOCATE_INFO => Some("EXPORT_MEMORY_ALLOCATE_INFO"), + Self::PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO => { + Some("PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO") + } + Self::EXTERNAL_FENCE_PROPERTIES => Some("EXTERNAL_FENCE_PROPERTIES"), + Self::EXPORT_FENCE_CREATE_INFO => Some("EXPORT_FENCE_CREATE_INFO"), + Self::EXPORT_SEMAPHORE_CREATE_INFO => Some("EXPORT_SEMAPHORE_CREATE_INFO"), + Self::PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO => { + Some("PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO") + } + Self::EXTERNAL_SEMAPHORE_PROPERTIES => Some("EXTERNAL_SEMAPHORE_PROPERTIES"), + Self::PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES => { + Some("PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES") + } + Self::DESCRIPTOR_SET_LAYOUT_SUPPORT => Some("DESCRIPTOR_SET_LAYOUT_SUPPORT"), + Self::PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES => { + Some("PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES") + } + Self::PHYSICAL_DEVICE_VULKAN_1_1_FEATURES => { + Some("PHYSICAL_DEVICE_VULKAN_1_1_FEATURES") + } + Self::PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES => { + Some("PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES") + } + Self::PHYSICAL_DEVICE_VULKAN_1_2_FEATURES => { + Some("PHYSICAL_DEVICE_VULKAN_1_2_FEATURES") + } + Self::PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES => { + Some("PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES") + } + Self::IMAGE_FORMAT_LIST_CREATE_INFO => Some("IMAGE_FORMAT_LIST_CREATE_INFO"), + Self::ATTACHMENT_DESCRIPTION_2 => Some("ATTACHMENT_DESCRIPTION_2"), + Self::ATTACHMENT_REFERENCE_2 => Some("ATTACHMENT_REFERENCE_2"), + Self::SUBPASS_DESCRIPTION_2 => Some("SUBPASS_DESCRIPTION_2"), + Self::SUBPASS_DEPENDENCY_2 => Some("SUBPASS_DEPENDENCY_2"), + Self::RENDER_PASS_CREATE_INFO_2 => Some("RENDER_PASS_CREATE_INFO_2"), + Self::SUBPASS_BEGIN_INFO => Some("SUBPASS_BEGIN_INFO"), + Self::SUBPASS_END_INFO => Some("SUBPASS_END_INFO"), + Self::PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES => { + Some("PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES") + } + Self::PHYSICAL_DEVICE_DRIVER_PROPERTIES => Some("PHYSICAL_DEVICE_DRIVER_PROPERTIES"), + Self::PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES => { + Some("PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES") + } + Self::PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES => { + Some("PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES") + } + Self::PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES => { + Some("PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES") + } + Self::DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO => { + Some("DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO") + } + Self::PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES => { + Some("PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES") + } + Self::PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES => { + Some("PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES") + } + Self::DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO => { + Some("DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO") + } + Self::DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT => { + Some("DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT") + } + Self::PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES => { + Some("PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES") + } + Self::SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE => { + Some("SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE") + } + Self::PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES => { + Some("PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES") + } + Self::IMAGE_STENCIL_USAGE_CREATE_INFO => Some("IMAGE_STENCIL_USAGE_CREATE_INFO"), + Self::PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES => { + Some("PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES") + } + Self::SAMPLER_REDUCTION_MODE_CREATE_INFO => Some("SAMPLER_REDUCTION_MODE_CREATE_INFO"), + Self::PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES => { + Some("PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES") + } + Self::PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES => { + Some("PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES") + } + Self::FRAMEBUFFER_ATTACHMENTS_CREATE_INFO => { + Some("FRAMEBUFFER_ATTACHMENTS_CREATE_INFO") + } + Self::FRAMEBUFFER_ATTACHMENT_IMAGE_INFO => Some("FRAMEBUFFER_ATTACHMENT_IMAGE_INFO"), + Self::RENDER_PASS_ATTACHMENT_BEGIN_INFO => Some("RENDER_PASS_ATTACHMENT_BEGIN_INFO"), + Self::PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES => { + Some("PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES") + } + Self::PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES => { + Some("PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES") + } + Self::PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES => { + Some("PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES") + } + Self::ATTACHMENT_REFERENCE_STENCIL_LAYOUT => { + Some("ATTACHMENT_REFERENCE_STENCIL_LAYOUT") + } + Self::ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT => { + Some("ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT") + } + Self::PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES => { + Some("PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES") + } + Self::PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES => { + Some("PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES") + } + Self::PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES => { + Some("PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES") + } + Self::SEMAPHORE_TYPE_CREATE_INFO => Some("SEMAPHORE_TYPE_CREATE_INFO"), + Self::TIMELINE_SEMAPHORE_SUBMIT_INFO => Some("TIMELINE_SEMAPHORE_SUBMIT_INFO"), + Self::SEMAPHORE_WAIT_INFO => Some("SEMAPHORE_WAIT_INFO"), + Self::SEMAPHORE_SIGNAL_INFO => Some("SEMAPHORE_SIGNAL_INFO"), + Self::PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES => { + Some("PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES") + } + Self::BUFFER_DEVICE_ADDRESS_INFO => Some("BUFFER_DEVICE_ADDRESS_INFO"), + Self::BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO => { + Some("BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO") + } + Self::MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO => { + Some("MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO") + } + Self::DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO => { + Some("DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO") + } + Self::PHYSICAL_DEVICE_VULKAN_1_3_FEATURES => { + Some("PHYSICAL_DEVICE_VULKAN_1_3_FEATURES") + } + Self::PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES => { + Some("PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES") + } + Self::PIPELINE_CREATION_FEEDBACK_CREATE_INFO => { + Some("PIPELINE_CREATION_FEEDBACK_CREATE_INFO") + } + Self::PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES => { + Some("PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES") + } + Self::PHYSICAL_DEVICE_TOOL_PROPERTIES => Some("PHYSICAL_DEVICE_TOOL_PROPERTIES"), + Self::PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES => { + Some("PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES") + } + Self::PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES => { + Some("PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES") + } + Self::DEVICE_PRIVATE_DATA_CREATE_INFO => Some("DEVICE_PRIVATE_DATA_CREATE_INFO"), + Self::PRIVATE_DATA_SLOT_CREATE_INFO => Some("PRIVATE_DATA_SLOT_CREATE_INFO"), + Self::PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES => { + Some("PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES") + } + Self::MEMORY_BARRIER_2 => Some("MEMORY_BARRIER_2"), + Self::BUFFER_MEMORY_BARRIER_2 => Some("BUFFER_MEMORY_BARRIER_2"), + Self::IMAGE_MEMORY_BARRIER_2 => Some("IMAGE_MEMORY_BARRIER_2"), + Self::DEPENDENCY_INFO => Some("DEPENDENCY_INFO"), + Self::SUBMIT_INFO_2 => Some("SUBMIT_INFO_2"), + Self::SEMAPHORE_SUBMIT_INFO => Some("SEMAPHORE_SUBMIT_INFO"), + Self::COMMAND_BUFFER_SUBMIT_INFO => Some("COMMAND_BUFFER_SUBMIT_INFO"), + Self::PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES => { + Some("PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES") + } + Self::PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES => { + Some("PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES") + } + Self::PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES => { + Some("PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES") + } + Self::COPY_BUFFER_INFO_2 => Some("COPY_BUFFER_INFO_2"), + Self::COPY_IMAGE_INFO_2 => Some("COPY_IMAGE_INFO_2"), + Self::COPY_BUFFER_TO_IMAGE_INFO_2 => Some("COPY_BUFFER_TO_IMAGE_INFO_2"), + Self::COPY_IMAGE_TO_BUFFER_INFO_2 => Some("COPY_IMAGE_TO_BUFFER_INFO_2"), + Self::BLIT_IMAGE_INFO_2 => Some("BLIT_IMAGE_INFO_2"), + Self::RESOLVE_IMAGE_INFO_2 => Some("RESOLVE_IMAGE_INFO_2"), + Self::BUFFER_COPY_2 => Some("BUFFER_COPY_2"), + Self::IMAGE_COPY_2 => Some("IMAGE_COPY_2"), + Self::IMAGE_BLIT_2 => Some("IMAGE_BLIT_2"), + Self::BUFFER_IMAGE_COPY_2 => Some("BUFFER_IMAGE_COPY_2"), + Self::IMAGE_RESOLVE_2 => Some("IMAGE_RESOLVE_2"), + Self::PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES => { + Some("PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES") + } + Self::PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO => { + Some("PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO") + } + Self::PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES => { + Some("PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES") + } + Self::PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES => { + Some("PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES") + } + Self::PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES => { + Some("PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES") + } + Self::WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK => { + Some("WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK") + } + Self::DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO => { + Some("DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO") + } + Self::PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES => { + Some("PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES") + } + Self::RENDERING_INFO => Some("RENDERING_INFO"), + Self::RENDERING_ATTACHMENT_INFO => Some("RENDERING_ATTACHMENT_INFO"), + Self::PIPELINE_RENDERING_CREATE_INFO => Some("PIPELINE_RENDERING_CREATE_INFO"), + Self::PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES => { + Some("PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES") + } + Self::COMMAND_BUFFER_INHERITANCE_RENDERING_INFO => { + Some("COMMAND_BUFFER_INHERITANCE_RENDERING_INFO") + } + Self::PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES => { + Some("PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES") + } + Self::PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES => { + Some("PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES") + } + Self::PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES => { + Some("PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES") + } + Self::FORMAT_PROPERTIES_3 => Some("FORMAT_PROPERTIES_3"), + Self::PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES => { + Some("PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES") + } + Self::PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES => { + Some("PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES") + } + Self::DEVICE_BUFFER_MEMORY_REQUIREMENTS => Some("DEVICE_BUFFER_MEMORY_REQUIREMENTS"), + Self::DEVICE_IMAGE_MEMORY_REQUIREMENTS => Some("DEVICE_IMAGE_MEMORY_REQUIREMENTS"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for SubgroupFeatureFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (SubgroupFeatureFlags::BASIC.0, "BASIC"), + (SubgroupFeatureFlags::VOTE.0, "VOTE"), + (SubgroupFeatureFlags::ARITHMETIC.0, "ARITHMETIC"), + (SubgroupFeatureFlags::BALLOT.0, "BALLOT"), + (SubgroupFeatureFlags::SHUFFLE.0, "SHUFFLE"), + (SubgroupFeatureFlags::SHUFFLE_RELATIVE.0, "SHUFFLE_RELATIVE"), + (SubgroupFeatureFlags::CLUSTERED.0, "CLUSTERED"), + (SubgroupFeatureFlags::QUAD.0, "QUAD"), + (SubgroupFeatureFlags::PARTITIONED_NV.0, "PARTITIONED_NV"), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for SubmitFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(SubmitFlags::PROTECTED.0, "PROTECTED")]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for SubpassContents { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::INLINE => Some("INLINE"), + Self::SECONDARY_COMMAND_BUFFERS => Some("SECONDARY_COMMAND_BUFFERS"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for SubpassDescriptionFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + SubpassDescriptionFlags::PER_VIEW_ATTRIBUTES_NVX.0, + "PER_VIEW_ATTRIBUTES_NVX", + ), + ( + SubpassDescriptionFlags::PER_VIEW_POSITION_X_ONLY_NVX.0, + "PER_VIEW_POSITION_X_ONLY_NVX", + ), + ( + SubpassDescriptionFlags::FRAGMENT_REGION_QCOM.0, + "FRAGMENT_REGION_QCOM", + ), + ( + SubpassDescriptionFlags::SHADER_RESOLVE_QCOM.0, + "SHADER_RESOLVE_QCOM", + ), + ( + SubpassDescriptionFlags::RASTERIZATION_ORDER_ATTACHMENT_COLOR_ACCESS_EXT.0, + "RASTERIZATION_ORDER_ATTACHMENT_COLOR_ACCESS_EXT", + ), + ( + SubpassDescriptionFlags::RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_EXT.0, + "RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_EXT", + ), + ( + SubpassDescriptionFlags::RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_EXT.0, + "RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_EXT", + ), + ( + SubpassDescriptionFlags::ENABLE_LEGACY_DITHERING_EXT.0, + "ENABLE_LEGACY_DITHERING_EXT", + ), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for SubpassMergeStatusEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::MERGED => Some("MERGED"), + Self::DISALLOWED => Some("DISALLOWED"), + Self::NOT_MERGED_SIDE_EFFECTS => Some("NOT_MERGED_SIDE_EFFECTS"), + Self::NOT_MERGED_SAMPLES_MISMATCH => Some("NOT_MERGED_SAMPLES_MISMATCH"), + Self::NOT_MERGED_VIEWS_MISMATCH => Some("NOT_MERGED_VIEWS_MISMATCH"), + Self::NOT_MERGED_ALIASING => Some("NOT_MERGED_ALIASING"), + Self::NOT_MERGED_DEPENDENCIES => Some("NOT_MERGED_DEPENDENCIES"), + Self::NOT_MERGED_INCOMPATIBLE_INPUT_ATTACHMENT => { + Some("NOT_MERGED_INCOMPATIBLE_INPUT_ATTACHMENT") + } + Self::NOT_MERGED_TOO_MANY_ATTACHMENTS => Some("NOT_MERGED_TOO_MANY_ATTACHMENTS"), + Self::NOT_MERGED_INSUFFICIENT_STORAGE => Some("NOT_MERGED_INSUFFICIENT_STORAGE"), + Self::NOT_MERGED_DEPTH_STENCIL_COUNT => Some("NOT_MERGED_DEPTH_STENCIL_COUNT"), + Self::NOT_MERGED_RESOLVE_ATTACHMENT_REUSE => { + Some("NOT_MERGED_RESOLVE_ATTACHMENT_REUSE") + } + Self::NOT_MERGED_SINGLE_SUBPASS => Some("NOT_MERGED_SINGLE_SUBPASS"), + Self::NOT_MERGED_UNSPECIFIED => Some("NOT_MERGED_UNSPECIFIED"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for SurfaceCounterFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(SurfaceCounterFlagsEXT::VBLANK.0, "VBLANK")]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for SurfaceTransformFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (SurfaceTransformFlagsKHR::IDENTITY.0, "IDENTITY"), + (SurfaceTransformFlagsKHR::ROTATE_90.0, "ROTATE_90"), + (SurfaceTransformFlagsKHR::ROTATE_180.0, "ROTATE_180"), + (SurfaceTransformFlagsKHR::ROTATE_270.0, "ROTATE_270"), + ( + SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR.0, + "HORIZONTAL_MIRROR", + ), + ( + SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_90.0, + "HORIZONTAL_MIRROR_ROTATE_90", + ), + ( + SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_180.0, + "HORIZONTAL_MIRROR_ROTATE_180", + ), + ( + SurfaceTransformFlagsKHR::HORIZONTAL_MIRROR_ROTATE_270.0, + "HORIZONTAL_MIRROR_ROTATE_270", + ), + (SurfaceTransformFlagsKHR::INHERIT.0, "INHERIT"), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for SwapchainCreateFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + SwapchainCreateFlagsKHR::SPLIT_INSTANCE_BIND_REGIONS.0, + "SPLIT_INSTANCE_BIND_REGIONS", + ), + (SwapchainCreateFlagsKHR::PROTECTED.0, "PROTECTED"), + (SwapchainCreateFlagsKHR::MUTABLE_FORMAT.0, "MUTABLE_FORMAT"), + ( + SwapchainCreateFlagsKHR::DEFERRED_MEMORY_ALLOCATION_EXT.0, + "DEFERRED_MEMORY_ALLOCATION_EXT", + ), + (SwapchainCreateFlagsKHR::RESERVED_4_EXT.0, "RESERVED_4_EXT"), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for SwapchainImageUsageFlagsANDROID { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(SwapchainImageUsageFlagsANDROID::SHARED.0, "SHARED")]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for SystemAllocationScope { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::COMMAND => Some("COMMAND"), + Self::OBJECT => Some("OBJECT"), + Self::CACHE => Some("CACHE"), + Self::DEVICE => Some("DEVICE"), + Self::INSTANCE => Some("INSTANCE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for TessellationDomainOrigin { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UPPER_LEFT => Some("UPPER_LEFT"), + Self::LOWER_LEFT => Some("LOWER_LEFT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for TimeDomainEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DEVICE => Some("DEVICE"), + Self::CLOCK_MONOTONIC => Some("CLOCK_MONOTONIC"), + Self::CLOCK_MONOTONIC_RAW => Some("CLOCK_MONOTONIC_RAW"), + Self::QUERY_PERFORMANCE_COUNTER => Some("QUERY_PERFORMANCE_COUNTER"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for ToolPurposeFlags { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (ToolPurposeFlags::VALIDATION.0, "VALIDATION"), + (ToolPurposeFlags::PROFILING.0, "PROFILING"), + (ToolPurposeFlags::TRACING.0, "TRACING"), + ( + ToolPurposeFlags::ADDITIONAL_FEATURES.0, + "ADDITIONAL_FEATURES", + ), + (ToolPurposeFlags::MODIFYING_FEATURES.0, "MODIFYING_FEATURES"), + ( + ToolPurposeFlags::DEBUG_REPORTING_EXT.0, + "DEBUG_REPORTING_EXT", + ), + (ToolPurposeFlags::DEBUG_MARKERS_EXT.0, "DEBUG_MARKERS_EXT"), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for ValidationCacheCreateFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for ValidationCacheHeaderVersionEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ONE => Some("ONE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for ValidationCheckEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ALL => Some("ALL"), + Self::SHADERS => Some("SHADERS"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for ValidationFeatureDisableEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ALL => Some("ALL"), + Self::SHADERS => Some("SHADERS"), + Self::THREAD_SAFETY => Some("THREAD_SAFETY"), + Self::API_PARAMETERS => Some("API_PARAMETERS"), + Self::OBJECT_LIFETIMES => Some("OBJECT_LIFETIMES"), + Self::CORE_CHECKS => Some("CORE_CHECKS"), + Self::UNIQUE_HANDLES => Some("UNIQUE_HANDLES"), + Self::SHADER_VALIDATION_CACHE => Some("SHADER_VALIDATION_CACHE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for ValidationFeatureEnableEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::GPU_ASSISTED => Some("GPU_ASSISTED"), + Self::GPU_ASSISTED_RESERVE_BINDING_SLOT => Some("GPU_ASSISTED_RESERVE_BINDING_SLOT"), + Self::BEST_PRACTICES => Some("BEST_PRACTICES"), + Self::DEBUG_PRINTF => Some("DEBUG_PRINTF"), + Self::SYNCHRONIZATION_VALIDATION => Some("SYNCHRONIZATION_VALIDATION"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for VendorId { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::VIV => Some("VIV"), + Self::VSI => Some("VSI"), + Self::KAZAN => Some("KAZAN"), + Self::CODEPLAY => Some("CODEPLAY"), + Self::MESA => Some("MESA"), + Self::POCL => Some("POCL"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for VertexInputRate { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::VERTEX => Some("VERTEX"), + Self::INSTANCE => Some("INSTANCE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for ViSurfaceCreateFlagsNN { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for VideoBeginCodingFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for VideoCapabilityFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + VideoCapabilityFlagsKHR::PROTECTED_CONTENT.0, + "PROTECTED_CONTENT", + ), + ( + VideoCapabilityFlagsKHR::SEPARATE_REFERENCE_IMAGES.0, + "SEPARATE_REFERENCE_IMAGES", + ), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for VideoChromaSubsamplingFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (VideoChromaSubsamplingFlagsKHR::INVALID.0, "INVALID"), + (VideoChromaSubsamplingFlagsKHR::MONOCHROME.0, "MONOCHROME"), + (VideoChromaSubsamplingFlagsKHR::TYPE_420.0, "TYPE_420"), + (VideoChromaSubsamplingFlagsKHR::TYPE_422.0, "TYPE_422"), + (VideoChromaSubsamplingFlagsKHR::TYPE_444.0, "TYPE_444"), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for VideoCodecOperationFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (VideoCodecOperationFlagsKHR::NONE.0, "NONE"), + ( + VideoCodecOperationFlagsKHR::ENCODE_H264_EXT.0, + "ENCODE_H264_EXT", + ), + ( + VideoCodecOperationFlagsKHR::ENCODE_H265_EXT.0, + "ENCODE_H265_EXT", + ), + (VideoCodecOperationFlagsKHR::DECODE_H264.0, "DECODE_H264"), + (VideoCodecOperationFlagsKHR::DECODE_H265.0, "DECODE_H265"), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for VideoCodingControlFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (VideoCodingControlFlagsKHR::RESET.0, "RESET"), + ( + VideoCodingControlFlagsKHR::ENCODE_RATE_CONTROL.0, + "ENCODE_RATE_CONTROL", + ), + ( + VideoCodingControlFlagsKHR::ENCODE_RATE_CONTROL_LAYER.0, + "ENCODE_RATE_CONTROL_LAYER", + ), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for VideoComponentBitDepthFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (VideoComponentBitDepthFlagsKHR::INVALID.0, "INVALID"), + (VideoComponentBitDepthFlagsKHR::TYPE_8.0, "TYPE_8"), + (VideoComponentBitDepthFlagsKHR::TYPE_10.0, "TYPE_10"), + (VideoComponentBitDepthFlagsKHR::TYPE_12.0, "TYPE_12"), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for VideoDecodeCapabilityFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + VideoDecodeCapabilityFlagsKHR::DPB_AND_OUTPUT_COINCIDE.0, + "DPB_AND_OUTPUT_COINCIDE", + ), + ( + VideoDecodeCapabilityFlagsKHR::DPB_AND_OUTPUT_DISTINCT.0, + "DPB_AND_OUTPUT_DISTINCT", + ), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for VideoDecodeFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for VideoDecodeH264PictureLayoutFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + VideoDecodeH264PictureLayoutFlagsKHR::PROGRESSIVE.0, + "PROGRESSIVE", + ), + ( + VideoDecodeH264PictureLayoutFlagsKHR::INTERLACED_INTERLEAVED_LINES.0, + "INTERLACED_INTERLEAVED_LINES", + ), + ( + VideoDecodeH264PictureLayoutFlagsKHR::INTERLACED_SEPARATE_PLANES.0, + "INTERLACED_SEPARATE_PLANES", + ), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for VideoDecodeUsageFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (VideoDecodeUsageFlagsKHR::DEFAULT.0, "DEFAULT"), + (VideoDecodeUsageFlagsKHR::TRANSCODING.0, "TRANSCODING"), + (VideoDecodeUsageFlagsKHR::OFFLINE.0, "OFFLINE"), + (VideoDecodeUsageFlagsKHR::STREAMING.0, "STREAMING"), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for VideoEncodeCapabilityFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[( + VideoEncodeCapabilityFlagsKHR::PRECEDING_EXTERNALLY_ENCODED_BYTES.0, + "PRECEDING_EXTERNALLY_ENCODED_BYTES", + )]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for VideoEncodeContentFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (VideoEncodeContentFlagsKHR::DEFAULT.0, "DEFAULT"), + (VideoEncodeContentFlagsKHR::CAMERA.0, "CAMERA"), + (VideoEncodeContentFlagsKHR::DESKTOP.0, "DESKTOP"), + (VideoEncodeContentFlagsKHR::RENDERED.0, "RENDERED"), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for VideoEncodeFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for VideoEncodeH264CapabilityFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + VideoEncodeH264CapabilityFlagsEXT::DIRECT_8X8_INFERENCE_ENABLED.0, + "DIRECT_8X8_INFERENCE_ENABLED", + ), + ( + VideoEncodeH264CapabilityFlagsEXT::DIRECT_8X8_INFERENCE_DISABLED.0, + "DIRECT_8X8_INFERENCE_DISABLED", + ), + ( + VideoEncodeH264CapabilityFlagsEXT::SEPARATE_COLOUR_PLANE.0, + "SEPARATE_COLOUR_PLANE", + ), + ( + VideoEncodeH264CapabilityFlagsEXT::QPPRIME_Y_ZERO_TRANSFORM_BYPASS.0, + "QPPRIME_Y_ZERO_TRANSFORM_BYPASS", + ), + ( + VideoEncodeH264CapabilityFlagsEXT::SCALING_LISTS.0, + "SCALING_LISTS", + ), + ( + VideoEncodeH264CapabilityFlagsEXT::HRD_COMPLIANCE.0, + "HRD_COMPLIANCE", + ), + ( + VideoEncodeH264CapabilityFlagsEXT::CHROMA_QP_OFFSET.0, + "CHROMA_QP_OFFSET", + ), + ( + VideoEncodeH264CapabilityFlagsEXT::SECOND_CHROMA_QP_OFFSET.0, + "SECOND_CHROMA_QP_OFFSET", + ), + ( + VideoEncodeH264CapabilityFlagsEXT::PIC_INIT_QP_MINUS26.0, + "PIC_INIT_QP_MINUS26", + ), + ( + VideoEncodeH264CapabilityFlagsEXT::WEIGHTED_PRED.0, + "WEIGHTED_PRED", + ), + ( + VideoEncodeH264CapabilityFlagsEXT::WEIGHTED_BIPRED_EXPLICIT.0, + "WEIGHTED_BIPRED_EXPLICIT", + ), + ( + VideoEncodeH264CapabilityFlagsEXT::WEIGHTED_BIPRED_IMPLICIT.0, + "WEIGHTED_BIPRED_IMPLICIT", + ), + ( + VideoEncodeH264CapabilityFlagsEXT::WEIGHTED_PRED_NO_TABLE.0, + "WEIGHTED_PRED_NO_TABLE", + ), + ( + VideoEncodeH264CapabilityFlagsEXT::TRANSFORM_8X8.0, + "TRANSFORM_8X8", + ), + (VideoEncodeH264CapabilityFlagsEXT::CABAC.0, "CABAC"), + (VideoEncodeH264CapabilityFlagsEXT::CAVLC.0, "CAVLC"), + ( + VideoEncodeH264CapabilityFlagsEXT::DEBLOCKING_FILTER_DISABLED.0, + "DEBLOCKING_FILTER_DISABLED", + ), + ( + VideoEncodeH264CapabilityFlagsEXT::DEBLOCKING_FILTER_ENABLED.0, + "DEBLOCKING_FILTER_ENABLED", + ), + ( + VideoEncodeH264CapabilityFlagsEXT::DEBLOCKING_FILTER_PARTIAL.0, + "DEBLOCKING_FILTER_PARTIAL", + ), + ( + VideoEncodeH264CapabilityFlagsEXT::DISABLE_DIRECT_SPATIAL_MV_PRED.0, + "DISABLE_DIRECT_SPATIAL_MV_PRED", + ), + ( + VideoEncodeH264CapabilityFlagsEXT::MULTIPLE_SLICE_PER_FRAME.0, + "MULTIPLE_SLICE_PER_FRAME", + ), + ( + VideoEncodeH264CapabilityFlagsEXT::SLICE_MB_COUNT.0, + "SLICE_MB_COUNT", + ), + ( + VideoEncodeH264CapabilityFlagsEXT::ROW_UNALIGNED_SLICE.0, + "ROW_UNALIGNED_SLICE", + ), + ( + VideoEncodeH264CapabilityFlagsEXT::DIFFERENT_SLICE_TYPE.0, + "DIFFERENT_SLICE_TYPE", + ), + ( + VideoEncodeH264CapabilityFlagsEXT::B_FRAME_IN_L1_LIST.0, + "B_FRAME_IN_L1_LIST", + ), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for VideoEncodeH264InputModeFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (VideoEncodeH264InputModeFlagsEXT::FRAME.0, "FRAME"), + (VideoEncodeH264InputModeFlagsEXT::SLICE.0, "SLICE"), + (VideoEncodeH264InputModeFlagsEXT::NON_VCL.0, "NON_VCL"), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for VideoEncodeH264OutputModeFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (VideoEncodeH264OutputModeFlagsEXT::FRAME.0, "FRAME"), + (VideoEncodeH264OutputModeFlagsEXT::SLICE.0, "SLICE"), + (VideoEncodeH264OutputModeFlagsEXT::NON_VCL.0, "NON_VCL"), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for VideoEncodeH264RateControlStructureEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UNKNOWN => Some("UNKNOWN"), + Self::FLAT => Some("FLAT"), + Self::DYADIC => Some("DYADIC"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for VideoEncodeH265CapabilityFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + VideoEncodeH265CapabilityFlagsEXT::SEPARATE_COLOUR_PLANE.0, + "SEPARATE_COLOUR_PLANE", + ), + ( + VideoEncodeH265CapabilityFlagsEXT::SCALING_LISTS.0, + "SCALING_LISTS", + ), + ( + VideoEncodeH265CapabilityFlagsEXT::SAMPLE_ADAPTIVE_OFFSET_ENABLED.0, + "SAMPLE_ADAPTIVE_OFFSET_ENABLED", + ), + ( + VideoEncodeH265CapabilityFlagsEXT::PCM_ENABLE.0, + "PCM_ENABLE", + ), + ( + VideoEncodeH265CapabilityFlagsEXT::SPS_TEMPORAL_MVP_ENABLED.0, + "SPS_TEMPORAL_MVP_ENABLED", + ), + ( + VideoEncodeH265CapabilityFlagsEXT::HRD_COMPLIANCE.0, + "HRD_COMPLIANCE", + ), + ( + VideoEncodeH265CapabilityFlagsEXT::INIT_QP_MINUS26.0, + "INIT_QP_MINUS26", + ), + ( + VideoEncodeH265CapabilityFlagsEXT::LOG2_PARALLEL_MERGE_LEVEL_MINUS2.0, + "LOG2_PARALLEL_MERGE_LEVEL_MINUS2", + ), + ( + VideoEncodeH265CapabilityFlagsEXT::SIGN_DATA_HIDING_ENABLED.0, + "SIGN_DATA_HIDING_ENABLED", + ), + ( + VideoEncodeH265CapabilityFlagsEXT::TRANSFORM_SKIP_ENABLED.0, + "TRANSFORM_SKIP_ENABLED", + ), + ( + VideoEncodeH265CapabilityFlagsEXT::TRANSFORM_SKIP_DISABLED.0, + "TRANSFORM_SKIP_DISABLED", + ), + ( + VideoEncodeH265CapabilityFlagsEXT::PPS_SLICE_CHROMA_QP_OFFSETS_PRESENT.0, + "PPS_SLICE_CHROMA_QP_OFFSETS_PRESENT", + ), + ( + VideoEncodeH265CapabilityFlagsEXT::WEIGHTED_PRED.0, + "WEIGHTED_PRED", + ), + ( + VideoEncodeH265CapabilityFlagsEXT::WEIGHTED_BIPRED.0, + "WEIGHTED_BIPRED", + ), + ( + VideoEncodeH265CapabilityFlagsEXT::WEIGHTED_PRED_NO_TABLE.0, + "WEIGHTED_PRED_NO_TABLE", + ), + ( + VideoEncodeH265CapabilityFlagsEXT::TRANSQUANT_BYPASS_ENABLED.0, + "TRANSQUANT_BYPASS_ENABLED", + ), + ( + VideoEncodeH265CapabilityFlagsEXT::ENTROPY_CODING_SYNC_ENABLED.0, + "ENTROPY_CODING_SYNC_ENABLED", + ), + ( + VideoEncodeH265CapabilityFlagsEXT::DEBLOCKING_FILTER_OVERRIDE_ENABLED.0, + "DEBLOCKING_FILTER_OVERRIDE_ENABLED", + ), + ( + VideoEncodeH265CapabilityFlagsEXT::MULTIPLE_TILE_PER_FRAME.0, + "MULTIPLE_TILE_PER_FRAME", + ), + ( + VideoEncodeH265CapabilityFlagsEXT::MULTIPLE_SLICE_PER_TILE.0, + "MULTIPLE_SLICE_PER_TILE", + ), + ( + VideoEncodeH265CapabilityFlagsEXT::MULTIPLE_TILE_PER_SLICE.0, + "MULTIPLE_TILE_PER_SLICE", + ), + ( + VideoEncodeH265CapabilityFlagsEXT::SLICE_SEGMENT_CTB_COUNT.0, + "SLICE_SEGMENT_CTB_COUNT", + ), + ( + VideoEncodeH265CapabilityFlagsEXT::ROW_UNALIGNED_SLICE_SEGMENT.0, + "ROW_UNALIGNED_SLICE_SEGMENT", + ), + ( + VideoEncodeH265CapabilityFlagsEXT::DEPENDENT_SLICE_SEGMENT.0, + "DEPENDENT_SLICE_SEGMENT", + ), + ( + VideoEncodeH265CapabilityFlagsEXT::DIFFERENT_SLICE_TYPE.0, + "DIFFERENT_SLICE_TYPE", + ), + ( + VideoEncodeH265CapabilityFlagsEXT::B_FRAME_IN_L1_LIST.0, + "B_FRAME_IN_L1_LIST", + ), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for VideoEncodeH265CtbSizeFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (VideoEncodeH265CtbSizeFlagsEXT::TYPE_16.0, "TYPE_16"), + (VideoEncodeH265CtbSizeFlagsEXT::TYPE_32.0, "TYPE_32"), + (VideoEncodeH265CtbSizeFlagsEXT::TYPE_64.0, "TYPE_64"), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for VideoEncodeH265InputModeFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (VideoEncodeH265InputModeFlagsEXT::FRAME.0, "FRAME"), + ( + VideoEncodeH265InputModeFlagsEXT::SLICE_SEGMENT.0, + "SLICE_SEGMENT", + ), + (VideoEncodeH265InputModeFlagsEXT::NON_VCL.0, "NON_VCL"), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for VideoEncodeH265OutputModeFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (VideoEncodeH265OutputModeFlagsEXT::FRAME.0, "FRAME"), + ( + VideoEncodeH265OutputModeFlagsEXT::SLICE_SEGMENT.0, + "SLICE_SEGMENT", + ), + (VideoEncodeH265OutputModeFlagsEXT::NON_VCL.0, "NON_VCL"), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for VideoEncodeH265RateControlStructureEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UNKNOWN => Some("UNKNOWN"), + Self::FLAT => Some("FLAT"), + Self::DYADIC => Some("DYADIC"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for VideoEncodeH265TransformBlockSizeFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + VideoEncodeH265TransformBlockSizeFlagsEXT::TYPE_4.0, + "TYPE_4", + ), + ( + VideoEncodeH265TransformBlockSizeFlagsEXT::TYPE_8.0, + "TYPE_8", + ), + ( + VideoEncodeH265TransformBlockSizeFlagsEXT::TYPE_16.0, + "TYPE_16", + ), + ( + VideoEncodeH265TransformBlockSizeFlagsEXT::TYPE_32.0, + "TYPE_32", + ), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for VideoEncodeRateControlFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for VideoEncodeRateControlModeFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (VideoEncodeRateControlModeFlagsKHR::NONE.0, "NONE"), + (VideoEncodeRateControlModeFlagsKHR::CBR.0, "CBR"), + (VideoEncodeRateControlModeFlagsKHR::VBR.0, "VBR"), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for VideoEncodeTuningModeKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::DEFAULT => Some("DEFAULT"), + Self::HIGH_QUALITY => Some("HIGH_QUALITY"), + Self::LOW_LATENCY => Some("LOW_LATENCY"), + Self::ULTRA_LOW_LATENCY => Some("ULTRA_LOW_LATENCY"), + Self::LOSSLESS => Some("LOSSLESS"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for VideoEncodeUsageFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (VideoEncodeUsageFlagsKHR::DEFAULT.0, "DEFAULT"), + (VideoEncodeUsageFlagsKHR::TRANSCODING.0, "TRANSCODING"), + (VideoEncodeUsageFlagsKHR::STREAMING.0, "STREAMING"), + (VideoEncodeUsageFlagsKHR::RECORDING.0, "RECORDING"), + (VideoEncodeUsageFlagsKHR::CONFERENCING.0, "CONFERENCING"), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for VideoEndCodingFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for VideoSessionCreateFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[( + VideoSessionCreateFlagsKHR::PROTECTED_CONTENT.0, + "PROTECTED_CONTENT", + )]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for VideoSessionParametersCreateFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for ViewportCoordinateSwizzleNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::POSITIVE_X => Some("POSITIVE_X"), + Self::NEGATIVE_X => Some("NEGATIVE_X"), + Self::POSITIVE_Y => Some("POSITIVE_Y"), + Self::NEGATIVE_Y => Some("NEGATIVE_Y"), + Self::POSITIVE_Z => Some("POSITIVE_Z"), + Self::NEGATIVE_Z => Some("NEGATIVE_Z"), + Self::POSITIVE_W => Some("POSITIVE_W"), + Self::NEGATIVE_W => Some("NEGATIVE_W"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for WaylandSurfaceCreateFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for Win32SurfaceCreateFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for XcbSurfaceCreateFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for XlibSurfaceCreateFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[]; + debug_flags(f, KNOWN, self.0) + } +} diff --git a/third_party/rust/ash/src/vk/constants.rs b/third_party/rust/ash/src/vk/constants.rs new file mode 100644 index 0000000000..78da55ec71 --- /dev/null +++ b/third_party/rust/ash/src/vk/constants.rs @@ -0,0 +1,27 @@ +use crate::vk::definitions::*; +pub const MAX_PHYSICAL_DEVICE_NAME_SIZE: usize = 256; +pub const UUID_SIZE: usize = 16; +pub const LUID_SIZE: usize = 8; +pub const MAX_EXTENSION_NAME_SIZE: usize = 256; +pub const MAX_DESCRIPTION_SIZE: usize = 256; +pub const MAX_MEMORY_TYPES: usize = 32; +#[doc = "The maximum number of unique memory heaps, each of which supporting 1 or more memory types"] +pub const MAX_MEMORY_HEAPS: usize = 16; +pub const LOD_CLAMP_NONE: f32 = 1000.00; +pub const REMAINING_MIP_LEVELS: u32 = !0; +pub const REMAINING_ARRAY_LAYERS: u32 = !0; +pub const WHOLE_SIZE: u64 = !0; +pub const ATTACHMENT_UNUSED: u32 = !0; +pub const TRUE: Bool32 = 1; +pub const FALSE: Bool32 = 0; +pub const QUEUE_FAMILY_IGNORED: u32 = !0; +pub const QUEUE_FAMILY_EXTERNAL: u32 = !1; +pub const QUEUE_FAMILY_FOREIGN_EXT: u32 = !2; +pub const SUBPASS_EXTERNAL: u32 = !0; +pub const MAX_DEVICE_GROUP_SIZE: usize = 32; +pub const MAX_DRIVER_NAME_SIZE: usize = 256; +pub const MAX_DRIVER_INFO_SIZE: usize = 256; +pub const SHADER_UNUSED_KHR: u32 = !0; +pub const MAX_GLOBAL_PRIORITY_SIZE_KHR: usize = 16; +pub const MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT: usize = 32; +pub const SHADER_UNUSED_NV: u32 = SHADER_UNUSED_KHR; diff --git a/third_party/rust/ash/src/vk/definitions.rs b/third_party/rust/ash/src/vk/definitions.rs new file mode 100644 index 0000000000..c73770b05e --- /dev/null +++ b/third_party/rust/ash/src/vk/definitions.rs @@ -0,0 +1,73178 @@ +use crate::vk::aliases::*; +use crate::vk::bitflags::*; +use crate::vk::constants::*; +use crate::vk::enums::*; +use crate::vk::native::*; +use crate::vk::platform_types::*; +use crate::vk::prelude::*; +use crate::vk::{ptr_chain_iter, Handle}; +use std::fmt; +use std::os::raw::*; +#[deprecated = "This define is deprecated. VK_MAKE_API_VERSION should be used instead."] +#[doc = ""] +pub const fn make_version(major: u32, minor: u32, patch: u32) -> u32 { + ((major) << 22) | ((minor) << 12) | (patch) +} +#[deprecated = "This define is deprecated. VK_API_VERSION_MAJOR should be used instead."] +#[doc = ""] +pub const fn version_major(version: u32) -> u32 { + (version) >> 22 +} +#[deprecated = "This define is deprecated. VK_API_VERSION_MINOR should be used instead."] +#[doc = ""] +pub const fn version_minor(version: u32) -> u32 { + ((version) >> 12) & 0x3ffu32 +} +#[deprecated = "This define is deprecated. VK_API_VERSION_PATCH should be used instead."] +#[doc = ""] +pub const fn version_patch(version: u32) -> u32 { + (version) & 0xfffu32 +} +#[doc = ""] +pub const fn make_api_version(variant: u32, major: u32, minor: u32, patch: u32) -> u32 { + ((variant) << 29) | ((major) << 22) | ((minor) << 12) | (patch) +} +#[doc = ""] +pub const fn api_version_variant(version: u32) -> u32 { + (version) >> 29 +} +#[doc = ""] +pub const fn api_version_major(version: u32) -> u32 { + ((version) >> 22) & 0x7fu32 +} +#[doc = ""] +pub const fn api_version_minor(version: u32) -> u32 { + ((version) >> 12) & 0x3ffu32 +} +#[doc = ""] +pub const fn api_version_patch(version: u32) -> u32 { + (version) & 0xfffu32 +} +#[doc = ""] +pub const API_VERSION_1_0: u32 = make_api_version(0, 1, 0, 0); +#[doc = ""] +pub const API_VERSION_1_1: u32 = make_api_version(0, 1, 1, 0); +#[doc = ""] +pub const API_VERSION_1_2: u32 = make_api_version(0, 1, 2, 0); +#[doc = ""] +pub const API_VERSION_1_3: u32 = make_api_version(0, 1, 3, 0); +pub const HEADER_VERSION: u32 = 238u32; +#[doc = ""] +pub const HEADER_VERSION_COMPLETE: u32 = make_api_version(0, 1, 3, HEADER_VERSION); +#[doc = ""] +pub type SampleMask = u32; +#[doc = ""] +pub type Bool32 = u32; +#[doc = ""] +pub type Flags = u32; +#[doc = ""] +pub type Flags64 = u64; +#[doc = ""] +pub type DeviceSize = u64; +#[doc = ""] +pub type DeviceAddress = u64; +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct QueryPoolCreateFlags(pub(crate) Flags); +vk_bitflags_wrapped!(QueryPoolCreateFlags, Flags); +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct PipelineDynamicStateCreateFlags(pub(crate) Flags); +vk_bitflags_wrapped!(PipelineDynamicStateCreateFlags, Flags); +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct PipelineMultisampleStateCreateFlags(pub(crate) Flags); +vk_bitflags_wrapped!(PipelineMultisampleStateCreateFlags, Flags); +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct PipelineRasterizationStateCreateFlags(pub(crate) Flags); +vk_bitflags_wrapped!(PipelineRasterizationStateCreateFlags, Flags); +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct PipelineViewportStateCreateFlags(pub(crate) Flags); +vk_bitflags_wrapped!(PipelineViewportStateCreateFlags, Flags); +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct PipelineTessellationStateCreateFlags(pub(crate) Flags); +vk_bitflags_wrapped!(PipelineTessellationStateCreateFlags, Flags); +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct PipelineInputAssemblyStateCreateFlags(pub(crate) Flags); +vk_bitflags_wrapped!(PipelineInputAssemblyStateCreateFlags, Flags); +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct PipelineVertexInputStateCreateFlags(pub(crate) Flags); +vk_bitflags_wrapped!(PipelineVertexInputStateCreateFlags, Flags); +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct BufferViewCreateFlags(pub(crate) Flags); +vk_bitflags_wrapped!(BufferViewCreateFlags, Flags); +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct DeviceCreateFlags(pub(crate) Flags); +vk_bitflags_wrapped!(DeviceCreateFlags, Flags); +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct MemoryMapFlags(pub(crate) Flags); +vk_bitflags_wrapped!(MemoryMapFlags, Flags); +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct DescriptorPoolResetFlags(pub(crate) Flags); +vk_bitflags_wrapped!(DescriptorPoolResetFlags, Flags); +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct DescriptorUpdateTemplateCreateFlags(pub(crate) Flags); +vk_bitflags_wrapped!(DescriptorUpdateTemplateCreateFlags, Flags); +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct AccelerationStructureMotionInfoFlagsNV(pub(crate) Flags); +vk_bitflags_wrapped!(AccelerationStructureMotionInfoFlagsNV, Flags); +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct AccelerationStructureMotionInstanceFlagsNV(pub(crate) Flags); +vk_bitflags_wrapped!(AccelerationStructureMotionInstanceFlagsNV, Flags); +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct DirectDriverLoadingFlagsLUNARG(pub(crate) Flags); +vk_bitflags_wrapped!(DirectDriverLoadingFlagsLUNARG, Flags); +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct DisplayModeCreateFlagsKHR(pub(crate) Flags); +vk_bitflags_wrapped!(DisplayModeCreateFlagsKHR, Flags); +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct DisplaySurfaceCreateFlagsKHR(pub(crate) Flags); +vk_bitflags_wrapped!(DisplaySurfaceCreateFlagsKHR, Flags); +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct AndroidSurfaceCreateFlagsKHR(pub(crate) Flags); +vk_bitflags_wrapped!(AndroidSurfaceCreateFlagsKHR, Flags); +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct ViSurfaceCreateFlagsNN(pub(crate) Flags); +vk_bitflags_wrapped!(ViSurfaceCreateFlagsNN, Flags); +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct WaylandSurfaceCreateFlagsKHR(pub(crate) Flags); +vk_bitflags_wrapped!(WaylandSurfaceCreateFlagsKHR, Flags); +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct Win32SurfaceCreateFlagsKHR(pub(crate) Flags); +vk_bitflags_wrapped!(Win32SurfaceCreateFlagsKHR, Flags); +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct XlibSurfaceCreateFlagsKHR(pub(crate) Flags); +vk_bitflags_wrapped!(XlibSurfaceCreateFlagsKHR, Flags); +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct XcbSurfaceCreateFlagsKHR(pub(crate) Flags); +vk_bitflags_wrapped!(XcbSurfaceCreateFlagsKHR, Flags); +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct DirectFBSurfaceCreateFlagsEXT(pub(crate) Flags); +vk_bitflags_wrapped!(DirectFBSurfaceCreateFlagsEXT, Flags); +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct IOSSurfaceCreateFlagsMVK(pub(crate) Flags); +vk_bitflags_wrapped!(IOSSurfaceCreateFlagsMVK, Flags); +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct MacOSSurfaceCreateFlagsMVK(pub(crate) Flags); +vk_bitflags_wrapped!(MacOSSurfaceCreateFlagsMVK, Flags); +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct MetalSurfaceCreateFlagsEXT(pub(crate) Flags); +vk_bitflags_wrapped!(MetalSurfaceCreateFlagsEXT, Flags); +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct ImagePipeSurfaceCreateFlagsFUCHSIA(pub(crate) Flags); +vk_bitflags_wrapped!(ImagePipeSurfaceCreateFlagsFUCHSIA, Flags); +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct StreamDescriptorSurfaceCreateFlagsGGP(pub(crate) Flags); +vk_bitflags_wrapped!(StreamDescriptorSurfaceCreateFlagsGGP, Flags); +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct HeadlessSurfaceCreateFlagsEXT(pub(crate) Flags); +vk_bitflags_wrapped!(HeadlessSurfaceCreateFlagsEXT, Flags); +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct ScreenSurfaceCreateFlagsQNX(pub(crate) Flags); +vk_bitflags_wrapped!(ScreenSurfaceCreateFlagsQNX, Flags); +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct CommandPoolTrimFlags(pub(crate) Flags); +vk_bitflags_wrapped!(CommandPoolTrimFlags, Flags); +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct PipelineViewportSwizzleStateCreateFlagsNV(pub(crate) Flags); +vk_bitflags_wrapped!(PipelineViewportSwizzleStateCreateFlagsNV, Flags); +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct PipelineDiscardRectangleStateCreateFlagsEXT(pub(crate) Flags); +vk_bitflags_wrapped!(PipelineDiscardRectangleStateCreateFlagsEXT, Flags); +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct PipelineCoverageToColorStateCreateFlagsNV(pub(crate) Flags); +vk_bitflags_wrapped!(PipelineCoverageToColorStateCreateFlagsNV, Flags); +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct PipelineCoverageModulationStateCreateFlagsNV(pub(crate) Flags); +vk_bitflags_wrapped!(PipelineCoverageModulationStateCreateFlagsNV, Flags); +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct PipelineCoverageReductionStateCreateFlagsNV(pub(crate) Flags); +vk_bitflags_wrapped!(PipelineCoverageReductionStateCreateFlagsNV, Flags); +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct ValidationCacheCreateFlagsEXT(pub(crate) Flags); +vk_bitflags_wrapped!(ValidationCacheCreateFlagsEXT, Flags); +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct DebugUtilsMessengerCreateFlagsEXT(pub(crate) Flags); +vk_bitflags_wrapped!(DebugUtilsMessengerCreateFlagsEXT, Flags); +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct DebugUtilsMessengerCallbackDataFlagsEXT(pub(crate) Flags); +vk_bitflags_wrapped!(DebugUtilsMessengerCallbackDataFlagsEXT, Flags); +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct DeviceMemoryReportFlagsEXT(pub(crate) Flags); +vk_bitflags_wrapped!(DeviceMemoryReportFlagsEXT, Flags); +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct PipelineRasterizationConservativeStateCreateFlagsEXT(pub(crate) Flags); +vk_bitflags_wrapped!(PipelineRasterizationConservativeStateCreateFlagsEXT, Flags); +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct PipelineRasterizationStateStreamCreateFlagsEXT(pub(crate) Flags); +vk_bitflags_wrapped!(PipelineRasterizationStateStreamCreateFlagsEXT, Flags); +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct PipelineRasterizationDepthClipStateCreateFlagsEXT(pub(crate) Flags); +vk_bitflags_wrapped!(PipelineRasterizationDepthClipStateCreateFlagsEXT, Flags); +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct VideoSessionParametersCreateFlagsKHR(pub(crate) Flags); +vk_bitflags_wrapped!(VideoSessionParametersCreateFlagsKHR, Flags); +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct VideoBeginCodingFlagsKHR(pub(crate) Flags); +vk_bitflags_wrapped!(VideoBeginCodingFlagsKHR, Flags); +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct VideoEndCodingFlagsKHR(pub(crate) Flags); +vk_bitflags_wrapped!(VideoEndCodingFlagsKHR, Flags); +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct VideoDecodeFlagsKHR(pub(crate) Flags); +vk_bitflags_wrapped!(VideoDecodeFlagsKHR, Flags); +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct VideoEncodeFlagsKHR(pub(crate) Flags); +vk_bitflags_wrapped!(VideoEncodeFlagsKHR, Flags); +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct VideoEncodeRateControlFlagsKHR(pub(crate) Flags); +vk_bitflags_wrapped!(VideoEncodeRateControlFlagsKHR, Flags); +define_handle!( + Instance, + INSTANCE, + doc = "" +); +define_handle ! (PhysicalDevice , PHYSICAL_DEVICE , doc = "") ; +define_handle!( + Device, + DEVICE, + doc = "" +); +define_handle!( + Queue, + QUEUE, + doc = "" +); +define_handle ! (CommandBuffer , COMMAND_BUFFER , doc = "") ; +handle_nondispatchable ! (DeviceMemory , DEVICE_MEMORY , doc = "") ; +handle_nondispatchable ! (CommandPool , COMMAND_POOL , doc = "") ; +handle_nondispatchable!( + Buffer, + BUFFER, + doc = "" +); +handle_nondispatchable!( + BufferView, + BUFFER_VIEW, + doc = + "" +); +handle_nondispatchable!( + Image, + IMAGE, + doc = "" +); +handle_nondispatchable!( + ImageView, + IMAGE_VIEW, + doc = + "" +); +handle_nondispatchable ! (ShaderModule , SHADER_MODULE , doc = "") ; +handle_nondispatchable!( + Pipeline, + PIPELINE, + doc = "" +); +handle_nondispatchable ! (PipelineLayout , PIPELINE_LAYOUT , doc = "") ; +handle_nondispatchable!( + Sampler, + SAMPLER, + doc = "" +); +handle_nondispatchable ! (DescriptorSet , DESCRIPTOR_SET , doc = "") ; +handle_nondispatchable ! (DescriptorSetLayout , DESCRIPTOR_SET_LAYOUT , doc = "") ; +handle_nondispatchable ! (DescriptorPool , DESCRIPTOR_POOL , doc = "") ; +handle_nondispatchable!( + Fence, + FENCE, + doc = "" +); +handle_nondispatchable!( + Semaphore, + SEMAPHORE, + doc = + "" +); +handle_nondispatchable!( + Event, + EVENT, + doc = "" +); +handle_nondispatchable!( + QueryPool, + QUERY_POOL, + doc = + "" +); +handle_nondispatchable ! (Framebuffer , FRAMEBUFFER , doc = "") ; +handle_nondispatchable!( + RenderPass, + RENDER_PASS, + doc = + "" +); +handle_nondispatchable ! (PipelineCache , PIPELINE_CACHE , doc = "") ; +handle_nondispatchable ! (IndirectCommandsLayoutNV , INDIRECT_COMMANDS_LAYOUT_NV , doc = "") ; +handle_nondispatchable ! (DescriptorUpdateTemplate , DESCRIPTOR_UPDATE_TEMPLATE , doc = "") ; +handle_nondispatchable ! (SamplerYcbcrConversion , SAMPLER_YCBCR_CONVERSION , doc = "") ; +handle_nondispatchable ! (ValidationCacheEXT , VALIDATION_CACHE_EXT , doc = "") ; +handle_nondispatchable ! (AccelerationStructureKHR , ACCELERATION_STRUCTURE_KHR , doc = "") ; +handle_nondispatchable ! (AccelerationStructureNV , ACCELERATION_STRUCTURE_NV , doc = "") ; +handle_nondispatchable ! (PerformanceConfigurationINTEL , PERFORMANCE_CONFIGURATION_INTEL , doc = "") ; +handle_nondispatchable ! (BufferCollectionFUCHSIA , BUFFER_COLLECTION_FUCHSIA , doc = "") ; +handle_nondispatchable ! (DeferredOperationKHR , DEFERRED_OPERATION_KHR , doc = "") ; +handle_nondispatchable ! (PrivateDataSlot , PRIVATE_DATA_SLOT , doc = "") ; +handle_nondispatchable ! (CuModuleNVX , CU_MODULE_NVX , doc = "") ; +handle_nondispatchable ! (CuFunctionNVX , CU_FUNCTION_NVX , doc = "") ; +handle_nondispatchable ! (OpticalFlowSessionNV , OPTICAL_FLOW_SESSION_NV , doc = "") ; +handle_nondispatchable ! (MicromapEXT , MICROMAP_EXT , doc = "") ; +handle_nondispatchable!( + DisplayKHR, + DISPLAY_KHR, + doc = + "" +); +handle_nondispatchable ! (DisplayModeKHR , DISPLAY_MODE_KHR , doc = "") ; +handle_nondispatchable!( + SurfaceKHR, + SURFACE_KHR, + doc = + "" +); +handle_nondispatchable ! (SwapchainKHR , SWAPCHAIN_KHR , doc = "") ; +handle_nondispatchable ! (DebugReportCallbackEXT , DEBUG_REPORT_CALLBACK_EXT , doc = "") ; +handle_nondispatchable ! (DebugUtilsMessengerEXT , DEBUG_UTILS_MESSENGER_EXT , doc = "") ; +handle_nondispatchable ! (VideoSessionKHR , VIDEO_SESSION_KHR , doc = "") ; +handle_nondispatchable ! (VideoSessionParametersKHR , VIDEO_SESSION_PARAMETERS_KHR , doc = "") ; +#[allow(non_camel_case_types)] +#[doc = ""] +pub type PFN_vkInternalAllocationNotification = Option< + unsafe extern "system" fn( + p_user_data: *mut c_void, + size: usize, + allocation_type: InternalAllocationType, + allocation_scope: SystemAllocationScope, + ), +>; +#[allow(non_camel_case_types)] +#[doc = ""] +pub type PFN_vkInternalFreeNotification = Option< + unsafe extern "system" fn( + p_user_data: *mut c_void, + size: usize, + allocation_type: InternalAllocationType, + allocation_scope: SystemAllocationScope, + ), +>; +#[allow(non_camel_case_types)] +#[doc = ""] +pub type PFN_vkReallocationFunction = Option< + unsafe extern "system" fn( + p_user_data: *mut c_void, + p_original: *mut c_void, + size: usize, + alignment: usize, + allocation_scope: SystemAllocationScope, + ) -> *mut c_void, +>; +#[allow(non_camel_case_types)] +#[doc = ""] +pub type PFN_vkAllocationFunction = Option< + unsafe extern "system" fn( + p_user_data: *mut c_void, + size: usize, + alignment: usize, + allocation_scope: SystemAllocationScope, + ) -> *mut c_void, +>; +#[allow(non_camel_case_types)] +#[doc = ""] +pub type PFN_vkFreeFunction = + Option; +#[allow(non_camel_case_types)] +#[doc = ""] +pub type PFN_vkVoidFunction = Option; +#[allow(non_camel_case_types)] +#[doc = ""] +pub type PFN_vkDebugReportCallbackEXT = Option< + unsafe extern "system" fn( + flags: DebugReportFlagsEXT, + object_type: DebugReportObjectTypeEXT, + object: u64, + location: usize, + message_code: i32, + p_layer_prefix: *const c_char, + p_message: *const c_char, + p_user_data: *mut c_void, + ) -> Bool32, +>; +#[allow(non_camel_case_types)] +#[doc = ""] +pub type PFN_vkDebugUtilsMessengerCallbackEXT = Option< + unsafe extern "system" fn( + message_severity: DebugUtilsMessageSeverityFlagsEXT, + message_types: DebugUtilsMessageTypeFlagsEXT, + p_callback_data: *const DebugUtilsMessengerCallbackDataEXT, + p_user_data: *mut c_void, + ) -> Bool32, +>; +#[allow(non_camel_case_types)] +#[doc = ""] +pub type PFN_vkDeviceMemoryReportCallbackEXT = Option< + unsafe extern "system" fn( + p_callback_data: *const DeviceMemoryReportCallbackDataEXT, + p_user_data: *mut c_void, + ), +>; +#[allow(non_camel_case_types)] +#[doc = ""] +pub type PFN_vkGetInstanceProcAddrLUNARG = Option< + unsafe extern "system" fn(instance: Instance, p_name: *const c_char) -> PFN_vkVoidFunction, +>; +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct BaseOutStructure { + pub s_type: StructureType, + pub p_next: *mut Self, +} +impl ::std::default::Default for BaseOutStructure { + #[inline] + fn default() -> Self { + Self { + s_type: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null_mut(), + } + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct BaseInStructure { + pub s_type: StructureType, + pub p_next: *const Self, +} +impl ::std::default::Default for BaseInStructure { + #[inline] + fn default() -> Self { + Self { + s_type: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), + } + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default, PartialEq, Eq, Hash)] +#[doc = ""] +pub struct Offset2D { + pub x: i32, + pub y: i32, +} +impl Offset2D { + pub fn builder<'a>() -> Offset2DBuilder<'a> { + Offset2DBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct Offset2DBuilder<'a> { + inner: Offset2D, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for Offset2DBuilder<'a> { + type Target = Offset2D; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for Offset2DBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> Offset2DBuilder<'a> { + #[inline] + pub fn x(mut self, x: i32) -> Self { + self.inner.x = x; + self + } + #[inline] + pub fn y(mut self, y: i32) -> Self { + self.inner.y = y; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> Offset2D { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default, PartialEq, Eq, Hash)] +#[doc = ""] +pub struct Offset3D { + pub x: i32, + pub y: i32, + pub z: i32, +} +impl Offset3D { + pub fn builder<'a>() -> Offset3DBuilder<'a> { + Offset3DBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct Offset3DBuilder<'a> { + inner: Offset3D, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for Offset3DBuilder<'a> { + type Target = Offset3D; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for Offset3DBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> Offset3DBuilder<'a> { + #[inline] + pub fn x(mut self, x: i32) -> Self { + self.inner.x = x; + self + } + #[inline] + pub fn y(mut self, y: i32) -> Self { + self.inner.y = y; + self + } + #[inline] + pub fn z(mut self, z: i32) -> Self { + self.inner.z = z; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> Offset3D { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default, PartialEq, Eq, Hash)] +#[doc = ""] +pub struct Extent2D { + pub width: u32, + pub height: u32, +} +impl Extent2D { + pub fn builder<'a>() -> Extent2DBuilder<'a> { + Extent2DBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct Extent2DBuilder<'a> { + inner: Extent2D, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for Extent2DBuilder<'a> { + type Target = Extent2D; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for Extent2DBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> Extent2DBuilder<'a> { + #[inline] + pub fn width(mut self, width: u32) -> Self { + self.inner.width = width; + self + } + #[inline] + pub fn height(mut self, height: u32) -> Self { + self.inner.height = height; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> Extent2D { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default, PartialEq, Eq, Hash)] +#[doc = ""] +pub struct Extent3D { + pub width: u32, + pub height: u32, + pub depth: u32, +} +impl Extent3D { + pub fn builder<'a>() -> Extent3DBuilder<'a> { + Extent3DBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct Extent3DBuilder<'a> { + inner: Extent3D, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for Extent3DBuilder<'a> { + type Target = Extent3D; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for Extent3DBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> Extent3DBuilder<'a> { + #[inline] + pub fn width(mut self, width: u32) -> Self { + self.inner.width = width; + self + } + #[inline] + pub fn height(mut self, height: u32) -> Self { + self.inner.height = height; + self + } + #[inline] + pub fn depth(mut self, depth: u32) -> Self { + self.inner.depth = depth; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> Extent3D { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct Viewport { + pub x: f32, + pub y: f32, + pub width: f32, + pub height: f32, + pub min_depth: f32, + pub max_depth: f32, +} +impl Viewport { + pub fn builder<'a>() -> ViewportBuilder<'a> { + ViewportBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ViewportBuilder<'a> { + inner: Viewport, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ViewportBuilder<'a> { + type Target = Viewport; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ViewportBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ViewportBuilder<'a> { + #[inline] + pub fn x(mut self, x: f32) -> Self { + self.inner.x = x; + self + } + #[inline] + pub fn y(mut self, y: f32) -> Self { + self.inner.y = y; + self + } + #[inline] + pub fn width(mut self, width: f32) -> Self { + self.inner.width = width; + self + } + #[inline] + pub fn height(mut self, height: f32) -> Self { + self.inner.height = height; + self + } + #[inline] + pub fn min_depth(mut self, min_depth: f32) -> Self { + self.inner.min_depth = min_depth; + self + } + #[inline] + pub fn max_depth(mut self, max_depth: f32) -> Self { + self.inner.max_depth = max_depth; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> Viewport { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default, PartialEq, Eq, Hash)] +#[doc = ""] +pub struct Rect2D { + pub offset: Offset2D, + pub extent: Extent2D, +} +impl Rect2D { + pub fn builder<'a>() -> Rect2DBuilder<'a> { + Rect2DBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct Rect2DBuilder<'a> { + inner: Rect2D, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for Rect2DBuilder<'a> { + type Target = Rect2D; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for Rect2DBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> Rect2DBuilder<'a> { + #[inline] + pub fn offset(mut self, offset: Offset2D) -> Self { + self.inner.offset = offset; + self + } + #[inline] + pub fn extent(mut self, extent: Extent2D) -> Self { + self.inner.extent = extent; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> Rect2D { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default, PartialEq, Eq, Hash)] +#[doc = ""] +pub struct ClearRect { + pub rect: Rect2D, + pub base_array_layer: u32, + pub layer_count: u32, +} +impl ClearRect { + pub fn builder<'a>() -> ClearRectBuilder<'a> { + ClearRectBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ClearRectBuilder<'a> { + inner: ClearRect, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ClearRectBuilder<'a> { + type Target = ClearRect; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ClearRectBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ClearRectBuilder<'a> { + #[inline] + pub fn rect(mut self, rect: Rect2D) -> Self { + self.inner.rect = rect; + self + } + #[inline] + pub fn base_array_layer(mut self, base_array_layer: u32) -> Self { + self.inner.base_array_layer = base_array_layer; + self + } + #[inline] + pub fn layer_count(mut self, layer_count: u32) -> Self { + self.inner.layer_count = layer_count; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ClearRect { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct ComponentMapping { + pub r: ComponentSwizzle, + pub g: ComponentSwizzle, + pub b: ComponentSwizzle, + pub a: ComponentSwizzle, +} +impl ComponentMapping { + pub fn builder<'a>() -> ComponentMappingBuilder<'a> { + ComponentMappingBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ComponentMappingBuilder<'a> { + inner: ComponentMapping, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ComponentMappingBuilder<'a> { + type Target = ComponentMapping; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ComponentMappingBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ComponentMappingBuilder<'a> { + #[inline] + pub fn r(mut self, r: ComponentSwizzle) -> Self { + self.inner.r = r; + self + } + #[inline] + pub fn g(mut self, g: ComponentSwizzle) -> Self { + self.inner.g = g; + self + } + #[inline] + pub fn b(mut self, b: ComponentSwizzle) -> Self { + self.inner.b = b; + self + } + #[inline] + pub fn a(mut self, a: ComponentSwizzle) -> Self { + self.inner.a = a; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ComponentMapping { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceProperties { + pub api_version: u32, + pub driver_version: u32, + pub vendor_id: u32, + pub device_id: u32, + pub device_type: PhysicalDeviceType, + pub device_name: [c_char; MAX_PHYSICAL_DEVICE_NAME_SIZE], + pub pipeline_cache_uuid: [u8; UUID_SIZE], + pub limits: PhysicalDeviceLimits, + pub sparse_properties: PhysicalDeviceSparseProperties, +} +#[cfg(feature = "debug")] +impl fmt::Debug for PhysicalDeviceProperties { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fmt.debug_struct("PhysicalDeviceProperties") + .field("api_version", &self.api_version) + .field("driver_version", &self.driver_version) + .field("vendor_id", &self.vendor_id) + .field("device_id", &self.device_id) + .field("device_type", &self.device_type) + .field("device_name", &unsafe { + ::std::ffi::CStr::from_ptr(self.device_name.as_ptr()) + }) + .field("pipeline_cache_uuid", &self.pipeline_cache_uuid) + .field("limits", &self.limits) + .field("sparse_properties", &self.sparse_properties) + .finish() + } +} +impl ::std::default::Default for PhysicalDeviceProperties { + #[inline] + fn default() -> Self { + Self { + api_version: u32::default(), + driver_version: u32::default(), + vendor_id: u32::default(), + device_id: u32::default(), + device_type: PhysicalDeviceType::default(), + device_name: unsafe { ::std::mem::zeroed() }, + pipeline_cache_uuid: unsafe { ::std::mem::zeroed() }, + limits: PhysicalDeviceLimits::default(), + sparse_properties: PhysicalDeviceSparseProperties::default(), + } + } +} +impl PhysicalDeviceProperties { + pub fn builder<'a>() -> PhysicalDevicePropertiesBuilder<'a> { + PhysicalDevicePropertiesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDevicePropertiesBuilder<'a> { + inner: PhysicalDeviceProperties, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PhysicalDevicePropertiesBuilder<'a> { + type Target = PhysicalDeviceProperties; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDevicePropertiesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDevicePropertiesBuilder<'a> { + #[inline] + pub fn api_version(mut self, api_version: u32) -> Self { + self.inner.api_version = api_version; + self + } + #[inline] + pub fn driver_version(mut self, driver_version: u32) -> Self { + self.inner.driver_version = driver_version; + self + } + #[inline] + pub fn vendor_id(mut self, vendor_id: u32) -> Self { + self.inner.vendor_id = vendor_id; + self + } + #[inline] + pub fn device_id(mut self, device_id: u32) -> Self { + self.inner.device_id = device_id; + self + } + #[inline] + pub fn device_type(mut self, device_type: PhysicalDeviceType) -> Self { + self.inner.device_type = device_type; + self + } + #[inline] + pub fn device_name(mut self, device_name: [c_char; MAX_PHYSICAL_DEVICE_NAME_SIZE]) -> Self { + self.inner.device_name = device_name; + self + } + #[inline] + pub fn pipeline_cache_uuid(mut self, pipeline_cache_uuid: [u8; UUID_SIZE]) -> Self { + self.inner.pipeline_cache_uuid = pipeline_cache_uuid; + self + } + #[inline] + pub fn limits(mut self, limits: PhysicalDeviceLimits) -> Self { + self.inner.limits = limits; + self + } + #[inline] + pub fn sparse_properties(mut self, sparse_properties: PhysicalDeviceSparseProperties) -> Self { + self.inner.sparse_properties = sparse_properties; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceProperties { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ExtensionProperties { + pub extension_name: [c_char; MAX_EXTENSION_NAME_SIZE], + pub spec_version: u32, +} +#[cfg(feature = "debug")] +impl fmt::Debug for ExtensionProperties { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fmt.debug_struct("ExtensionProperties") + .field("extension_name", &unsafe { + ::std::ffi::CStr::from_ptr(self.extension_name.as_ptr()) + }) + .field("spec_version", &self.spec_version) + .finish() + } +} +impl ::std::default::Default for ExtensionProperties { + #[inline] + fn default() -> Self { + Self { + extension_name: unsafe { ::std::mem::zeroed() }, + spec_version: u32::default(), + } + } +} +impl ExtensionProperties { + pub fn builder<'a>() -> ExtensionPropertiesBuilder<'a> { + ExtensionPropertiesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ExtensionPropertiesBuilder<'a> { + inner: ExtensionProperties, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ExtensionPropertiesBuilder<'a> { + type Target = ExtensionProperties; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ExtensionPropertiesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ExtensionPropertiesBuilder<'a> { + #[inline] + pub fn extension_name(mut self, extension_name: [c_char; MAX_EXTENSION_NAME_SIZE]) -> Self { + self.inner.extension_name = extension_name; + self + } + #[inline] + pub fn spec_version(mut self, spec_version: u32) -> Self { + self.inner.spec_version = spec_version; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ExtensionProperties { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct LayerProperties { + pub layer_name: [c_char; MAX_EXTENSION_NAME_SIZE], + pub spec_version: u32, + pub implementation_version: u32, + pub description: [c_char; MAX_DESCRIPTION_SIZE], +} +#[cfg(feature = "debug")] +impl fmt::Debug for LayerProperties { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fmt.debug_struct("LayerProperties") + .field("layer_name", &unsafe { + ::std::ffi::CStr::from_ptr(self.layer_name.as_ptr()) + }) + .field("spec_version", &self.spec_version) + .field("implementation_version", &self.implementation_version) + .field("description", &unsafe { + ::std::ffi::CStr::from_ptr(self.description.as_ptr()) + }) + .finish() + } +} +impl ::std::default::Default for LayerProperties { + #[inline] + fn default() -> Self { + Self { + layer_name: unsafe { ::std::mem::zeroed() }, + spec_version: u32::default(), + implementation_version: u32::default(), + description: unsafe { ::std::mem::zeroed() }, + } + } +} +impl LayerProperties { + pub fn builder<'a>() -> LayerPropertiesBuilder<'a> { + LayerPropertiesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct LayerPropertiesBuilder<'a> { + inner: LayerProperties, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for LayerPropertiesBuilder<'a> { + type Target = LayerProperties; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for LayerPropertiesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> LayerPropertiesBuilder<'a> { + #[inline] + pub fn layer_name(mut self, layer_name: [c_char; MAX_EXTENSION_NAME_SIZE]) -> Self { + self.inner.layer_name = layer_name; + self + } + #[inline] + pub fn spec_version(mut self, spec_version: u32) -> Self { + self.inner.spec_version = spec_version; + self + } + #[inline] + pub fn implementation_version(mut self, implementation_version: u32) -> Self { + self.inner.implementation_version = implementation_version; + self + } + #[inline] + pub fn description(mut self, description: [c_char; MAX_DESCRIPTION_SIZE]) -> Self { + self.inner.description = description; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> LayerProperties { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ApplicationInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub p_application_name: *const c_char, + pub application_version: u32, + pub p_engine_name: *const c_char, + pub engine_version: u32, + pub api_version: u32, +} +impl ::std::default::Default for ApplicationInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + p_application_name: ::std::ptr::null(), + application_version: u32::default(), + p_engine_name: ::std::ptr::null(), + engine_version: u32::default(), + api_version: u32::default(), + } + } +} +unsafe impl TaggedStructure for ApplicationInfo { + const STRUCTURE_TYPE: StructureType = StructureType::APPLICATION_INFO; +} +impl ApplicationInfo { + pub fn builder<'a>() -> ApplicationInfoBuilder<'a> { + ApplicationInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ApplicationInfoBuilder<'a> { + inner: ApplicationInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ApplicationInfoBuilder<'a> { + type Target = ApplicationInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ApplicationInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ApplicationInfoBuilder<'a> { + #[inline] + pub fn application_name(mut self, application_name: &'a ::std::ffi::CStr) -> Self { + self.inner.p_application_name = application_name.as_ptr(); + self + } + #[inline] + pub fn application_version(mut self, application_version: u32) -> Self { + self.inner.application_version = application_version; + self + } + #[inline] + pub fn engine_name(mut self, engine_name: &'a ::std::ffi::CStr) -> Self { + self.inner.p_engine_name = engine_name.as_ptr(); + self + } + #[inline] + pub fn engine_version(mut self, engine_version: u32) -> Self { + self.inner.engine_version = engine_version; + self + } + #[inline] + pub fn api_version(mut self, api_version: u32) -> Self { + self.inner.api_version = api_version; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ApplicationInfo { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct AllocationCallbacks { + pub p_user_data: *mut c_void, + pub pfn_allocation: PFN_vkAllocationFunction, + pub pfn_reallocation: PFN_vkReallocationFunction, + pub pfn_free: PFN_vkFreeFunction, + pub pfn_internal_allocation: PFN_vkInternalAllocationNotification, + pub pfn_internal_free: PFN_vkInternalFreeNotification, +} +#[cfg(feature = "debug")] +impl fmt::Debug for AllocationCallbacks { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fmt.debug_struct("AllocationCallbacks") + .field("p_user_data", &self.p_user_data) + .field( + "pfn_allocation", + &(self.pfn_allocation.map(|x| x as *const ())), + ) + .field( + "pfn_reallocation", + &(self.pfn_reallocation.map(|x| x as *const ())), + ) + .field("pfn_free", &(self.pfn_free.map(|x| x as *const ()))) + .field( + "pfn_internal_allocation", + &(self.pfn_internal_allocation.map(|x| x as *const ())), + ) + .field( + "pfn_internal_free", + &(self.pfn_internal_free.map(|x| x as *const ())), + ) + .finish() + } +} +impl ::std::default::Default for AllocationCallbacks { + #[inline] + fn default() -> Self { + Self { + p_user_data: ::std::ptr::null_mut(), + pfn_allocation: PFN_vkAllocationFunction::default(), + pfn_reallocation: PFN_vkReallocationFunction::default(), + pfn_free: PFN_vkFreeFunction::default(), + pfn_internal_allocation: PFN_vkInternalAllocationNotification::default(), + pfn_internal_free: PFN_vkInternalFreeNotification::default(), + } + } +} +impl AllocationCallbacks { + pub fn builder<'a>() -> AllocationCallbacksBuilder<'a> { + AllocationCallbacksBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct AllocationCallbacksBuilder<'a> { + inner: AllocationCallbacks, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for AllocationCallbacksBuilder<'a> { + type Target = AllocationCallbacks; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for AllocationCallbacksBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> AllocationCallbacksBuilder<'a> { + #[inline] + pub fn user_data(mut self, user_data: *mut c_void) -> Self { + self.inner.p_user_data = user_data; + self + } + #[inline] + pub fn pfn_allocation(mut self, pfn_allocation: PFN_vkAllocationFunction) -> Self { + self.inner.pfn_allocation = pfn_allocation; + self + } + #[inline] + pub fn pfn_reallocation(mut self, pfn_reallocation: PFN_vkReallocationFunction) -> Self { + self.inner.pfn_reallocation = pfn_reallocation; + self + } + #[inline] + pub fn pfn_free(mut self, pfn_free: PFN_vkFreeFunction) -> Self { + self.inner.pfn_free = pfn_free; + self + } + #[inline] + pub fn pfn_internal_allocation( + mut self, + pfn_internal_allocation: PFN_vkInternalAllocationNotification, + ) -> Self { + self.inner.pfn_internal_allocation = pfn_internal_allocation; + self + } + #[inline] + pub fn pfn_internal_free(mut self, pfn_internal_free: PFN_vkInternalFreeNotification) -> Self { + self.inner.pfn_internal_free = pfn_internal_free; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> AllocationCallbacks { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DeviceQueueCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: DeviceQueueCreateFlags, + pub queue_family_index: u32, + pub queue_count: u32, + pub p_queue_priorities: *const f32, +} +impl ::std::default::Default for DeviceQueueCreateInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: DeviceQueueCreateFlags::default(), + queue_family_index: u32::default(), + queue_count: u32::default(), + p_queue_priorities: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for DeviceQueueCreateInfo { + const STRUCTURE_TYPE: StructureType = StructureType::DEVICE_QUEUE_CREATE_INFO; +} +impl DeviceQueueCreateInfo { + pub fn builder<'a>() -> DeviceQueueCreateInfoBuilder<'a> { + DeviceQueueCreateInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DeviceQueueCreateInfoBuilder<'a> { + inner: DeviceQueueCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsDeviceQueueCreateInfo {} +impl<'a> ::std::ops::Deref for DeviceQueueCreateInfoBuilder<'a> { + type Target = DeviceQueueCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DeviceQueueCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DeviceQueueCreateInfoBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: DeviceQueueCreateFlags) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn queue_family_index(mut self, queue_family_index: u32) -> Self { + self.inner.queue_family_index = queue_family_index; + self + } + #[inline] + pub fn queue_priorities(mut self, queue_priorities: &'a [f32]) -> Self { + self.inner.queue_count = queue_priorities.len() as _; + self.inner.p_queue_priorities = queue_priorities.as_ptr(); + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DeviceQueueCreateInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DeviceCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: DeviceCreateFlags, + pub queue_create_info_count: u32, + pub p_queue_create_infos: *const DeviceQueueCreateInfo, + pub enabled_layer_count: u32, + pub pp_enabled_layer_names: *const *const c_char, + pub enabled_extension_count: u32, + pub pp_enabled_extension_names: *const *const c_char, + pub p_enabled_features: *const PhysicalDeviceFeatures, +} +impl ::std::default::Default for DeviceCreateInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: DeviceCreateFlags::default(), + queue_create_info_count: u32::default(), + p_queue_create_infos: ::std::ptr::null(), + enabled_layer_count: u32::default(), + pp_enabled_layer_names: ::std::ptr::null(), + enabled_extension_count: u32::default(), + pp_enabled_extension_names: ::std::ptr::null(), + p_enabled_features: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for DeviceCreateInfo { + const STRUCTURE_TYPE: StructureType = StructureType::DEVICE_CREATE_INFO; +} +impl DeviceCreateInfo { + pub fn builder<'a>() -> DeviceCreateInfoBuilder<'a> { + DeviceCreateInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DeviceCreateInfoBuilder<'a> { + inner: DeviceCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsDeviceCreateInfo {} +impl<'a> ::std::ops::Deref for DeviceCreateInfoBuilder<'a> { + type Target = DeviceCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DeviceCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DeviceCreateInfoBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: DeviceCreateFlags) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn queue_create_infos(mut self, queue_create_infos: &'a [DeviceQueueCreateInfo]) -> Self { + self.inner.queue_create_info_count = queue_create_infos.len() as _; + self.inner.p_queue_create_infos = queue_create_infos.as_ptr(); + self + } + #[inline] + pub fn enabled_layer_names(mut self, enabled_layer_names: &'a [*const c_char]) -> Self { + self.inner.enabled_layer_count = enabled_layer_names.len() as _; + self.inner.pp_enabled_layer_names = enabled_layer_names.as_ptr(); + self + } + #[inline] + pub fn enabled_extension_names(mut self, enabled_extension_names: &'a [*const c_char]) -> Self { + self.inner.enabled_extension_count = enabled_extension_names.len() as _; + self.inner.pp_enabled_extension_names = enabled_extension_names.as_ptr(); + self + } + #[inline] + pub fn enabled_features(mut self, enabled_features: &'a PhysicalDeviceFeatures) -> Self { + self.inner.p_enabled_features = enabled_features; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DeviceCreateInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct InstanceCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: InstanceCreateFlags, + pub p_application_info: *const ApplicationInfo, + pub enabled_layer_count: u32, + pub pp_enabled_layer_names: *const *const c_char, + pub enabled_extension_count: u32, + pub pp_enabled_extension_names: *const *const c_char, +} +impl ::std::default::Default for InstanceCreateInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: InstanceCreateFlags::default(), + p_application_info: ::std::ptr::null(), + enabled_layer_count: u32::default(), + pp_enabled_layer_names: ::std::ptr::null(), + enabled_extension_count: u32::default(), + pp_enabled_extension_names: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for InstanceCreateInfo { + const STRUCTURE_TYPE: StructureType = StructureType::INSTANCE_CREATE_INFO; +} +impl InstanceCreateInfo { + pub fn builder<'a>() -> InstanceCreateInfoBuilder<'a> { + InstanceCreateInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct InstanceCreateInfoBuilder<'a> { + inner: InstanceCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsInstanceCreateInfo {} +impl<'a> ::std::ops::Deref for InstanceCreateInfoBuilder<'a> { + type Target = InstanceCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for InstanceCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> InstanceCreateInfoBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: InstanceCreateFlags) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn application_info(mut self, application_info: &'a ApplicationInfo) -> Self { + self.inner.p_application_info = application_info; + self + } + #[inline] + pub fn enabled_layer_names(mut self, enabled_layer_names: &'a [*const c_char]) -> Self { + self.inner.enabled_layer_count = enabled_layer_names.len() as _; + self.inner.pp_enabled_layer_names = enabled_layer_names.as_ptr(); + self + } + #[inline] + pub fn enabled_extension_names(mut self, enabled_extension_names: &'a [*const c_char]) -> Self { + self.inner.enabled_extension_count = enabled_extension_names.len() as _; + self.inner.pp_enabled_extension_names = enabled_extension_names.as_ptr(); + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> InstanceCreateInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct QueueFamilyProperties { + pub queue_flags: QueueFlags, + pub queue_count: u32, + pub timestamp_valid_bits: u32, + pub min_image_transfer_granularity: Extent3D, +} +impl QueueFamilyProperties { + pub fn builder<'a>() -> QueueFamilyPropertiesBuilder<'a> { + QueueFamilyPropertiesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct QueueFamilyPropertiesBuilder<'a> { + inner: QueueFamilyProperties, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for QueueFamilyPropertiesBuilder<'a> { + type Target = QueueFamilyProperties; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for QueueFamilyPropertiesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> QueueFamilyPropertiesBuilder<'a> { + #[inline] + pub fn queue_flags(mut self, queue_flags: QueueFlags) -> Self { + self.inner.queue_flags = queue_flags; + self + } + #[inline] + pub fn queue_count(mut self, queue_count: u32) -> Self { + self.inner.queue_count = queue_count; + self + } + #[inline] + pub fn timestamp_valid_bits(mut self, timestamp_valid_bits: u32) -> Self { + self.inner.timestamp_valid_bits = timestamp_valid_bits; + self + } + #[inline] + pub fn min_image_transfer_granularity( + mut self, + min_image_transfer_granularity: Extent3D, + ) -> Self { + self.inner.min_image_transfer_granularity = min_image_transfer_granularity; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> QueueFamilyProperties { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceMemoryProperties { + pub memory_type_count: u32, + pub memory_types: [MemoryType; MAX_MEMORY_TYPES], + pub memory_heap_count: u32, + pub memory_heaps: [MemoryHeap; MAX_MEMORY_HEAPS], +} +impl ::std::default::Default for PhysicalDeviceMemoryProperties { + #[inline] + fn default() -> Self { + Self { + memory_type_count: u32::default(), + memory_types: unsafe { ::std::mem::zeroed() }, + memory_heap_count: u32::default(), + memory_heaps: unsafe { ::std::mem::zeroed() }, + } + } +} +impl PhysicalDeviceMemoryProperties { + pub fn builder<'a>() -> PhysicalDeviceMemoryPropertiesBuilder<'a> { + PhysicalDeviceMemoryPropertiesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceMemoryPropertiesBuilder<'a> { + inner: PhysicalDeviceMemoryProperties, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PhysicalDeviceMemoryPropertiesBuilder<'a> { + type Target = PhysicalDeviceMemoryProperties; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceMemoryPropertiesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceMemoryPropertiesBuilder<'a> { + #[inline] + pub fn memory_type_count(mut self, memory_type_count: u32) -> Self { + self.inner.memory_type_count = memory_type_count; + self + } + #[inline] + pub fn memory_types(mut self, memory_types: [MemoryType; MAX_MEMORY_TYPES]) -> Self { + self.inner.memory_types = memory_types; + self + } + #[inline] + pub fn memory_heap_count(mut self, memory_heap_count: u32) -> Self { + self.inner.memory_heap_count = memory_heap_count; + self + } + #[inline] + pub fn memory_heaps(mut self, memory_heaps: [MemoryHeap; MAX_MEMORY_HEAPS]) -> Self { + self.inner.memory_heaps = memory_heaps; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceMemoryProperties { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct MemoryAllocateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub allocation_size: DeviceSize, + pub memory_type_index: u32, +} +impl ::std::default::Default for MemoryAllocateInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + allocation_size: DeviceSize::default(), + memory_type_index: u32::default(), + } + } +} +unsafe impl TaggedStructure for MemoryAllocateInfo { + const STRUCTURE_TYPE: StructureType = StructureType::MEMORY_ALLOCATE_INFO; +} +impl MemoryAllocateInfo { + pub fn builder<'a>() -> MemoryAllocateInfoBuilder<'a> { + MemoryAllocateInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct MemoryAllocateInfoBuilder<'a> { + inner: MemoryAllocateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsMemoryAllocateInfo {} +impl<'a> ::std::ops::Deref for MemoryAllocateInfoBuilder<'a> { + type Target = MemoryAllocateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for MemoryAllocateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> MemoryAllocateInfoBuilder<'a> { + #[inline] + pub fn allocation_size(mut self, allocation_size: DeviceSize) -> Self { + self.inner.allocation_size = allocation_size; + self + } + #[inline] + pub fn memory_type_index(mut self, memory_type_index: u32) -> Self { + self.inner.memory_type_index = memory_type_index; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> MemoryAllocateInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct MemoryRequirements { + pub size: DeviceSize, + pub alignment: DeviceSize, + pub memory_type_bits: u32, +} +impl MemoryRequirements { + pub fn builder<'a>() -> MemoryRequirementsBuilder<'a> { + MemoryRequirementsBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct MemoryRequirementsBuilder<'a> { + inner: MemoryRequirements, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for MemoryRequirementsBuilder<'a> { + type Target = MemoryRequirements; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for MemoryRequirementsBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> MemoryRequirementsBuilder<'a> { + #[inline] + pub fn size(mut self, size: DeviceSize) -> Self { + self.inner.size = size; + self + } + #[inline] + pub fn alignment(mut self, alignment: DeviceSize) -> Self { + self.inner.alignment = alignment; + self + } + #[inline] + pub fn memory_type_bits(mut self, memory_type_bits: u32) -> Self { + self.inner.memory_type_bits = memory_type_bits; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> MemoryRequirements { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct SparseImageFormatProperties { + pub aspect_mask: ImageAspectFlags, + pub image_granularity: Extent3D, + pub flags: SparseImageFormatFlags, +} +impl SparseImageFormatProperties { + pub fn builder<'a>() -> SparseImageFormatPropertiesBuilder<'a> { + SparseImageFormatPropertiesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SparseImageFormatPropertiesBuilder<'a> { + inner: SparseImageFormatProperties, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for SparseImageFormatPropertiesBuilder<'a> { + type Target = SparseImageFormatProperties; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SparseImageFormatPropertiesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SparseImageFormatPropertiesBuilder<'a> { + #[inline] + pub fn aspect_mask(mut self, aspect_mask: ImageAspectFlags) -> Self { + self.inner.aspect_mask = aspect_mask; + self + } + #[inline] + pub fn image_granularity(mut self, image_granularity: Extent3D) -> Self { + self.inner.image_granularity = image_granularity; + self + } + #[inline] + pub fn flags(mut self, flags: SparseImageFormatFlags) -> Self { + self.inner.flags = flags; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SparseImageFormatProperties { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct SparseImageMemoryRequirements { + pub format_properties: SparseImageFormatProperties, + pub image_mip_tail_first_lod: u32, + pub image_mip_tail_size: DeviceSize, + pub image_mip_tail_offset: DeviceSize, + pub image_mip_tail_stride: DeviceSize, +} +impl SparseImageMemoryRequirements { + pub fn builder<'a>() -> SparseImageMemoryRequirementsBuilder<'a> { + SparseImageMemoryRequirementsBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SparseImageMemoryRequirementsBuilder<'a> { + inner: SparseImageMemoryRequirements, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for SparseImageMemoryRequirementsBuilder<'a> { + type Target = SparseImageMemoryRequirements; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SparseImageMemoryRequirementsBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SparseImageMemoryRequirementsBuilder<'a> { + #[inline] + pub fn format_properties(mut self, format_properties: SparseImageFormatProperties) -> Self { + self.inner.format_properties = format_properties; + self + } + #[inline] + pub fn image_mip_tail_first_lod(mut self, image_mip_tail_first_lod: u32) -> Self { + self.inner.image_mip_tail_first_lod = image_mip_tail_first_lod; + self + } + #[inline] + pub fn image_mip_tail_size(mut self, image_mip_tail_size: DeviceSize) -> Self { + self.inner.image_mip_tail_size = image_mip_tail_size; + self + } + #[inline] + pub fn image_mip_tail_offset(mut self, image_mip_tail_offset: DeviceSize) -> Self { + self.inner.image_mip_tail_offset = image_mip_tail_offset; + self + } + #[inline] + pub fn image_mip_tail_stride(mut self, image_mip_tail_stride: DeviceSize) -> Self { + self.inner.image_mip_tail_stride = image_mip_tail_stride; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SparseImageMemoryRequirements { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct MemoryType { + pub property_flags: MemoryPropertyFlags, + pub heap_index: u32, +} +impl MemoryType { + pub fn builder<'a>() -> MemoryTypeBuilder<'a> { + MemoryTypeBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct MemoryTypeBuilder<'a> { + inner: MemoryType, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for MemoryTypeBuilder<'a> { + type Target = MemoryType; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for MemoryTypeBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> MemoryTypeBuilder<'a> { + #[inline] + pub fn property_flags(mut self, property_flags: MemoryPropertyFlags) -> Self { + self.inner.property_flags = property_flags; + self + } + #[inline] + pub fn heap_index(mut self, heap_index: u32) -> Self { + self.inner.heap_index = heap_index; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> MemoryType { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct MemoryHeap { + pub size: DeviceSize, + pub flags: MemoryHeapFlags, +} +impl MemoryHeap { + pub fn builder<'a>() -> MemoryHeapBuilder<'a> { + MemoryHeapBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct MemoryHeapBuilder<'a> { + inner: MemoryHeap, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for MemoryHeapBuilder<'a> { + type Target = MemoryHeap; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for MemoryHeapBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> MemoryHeapBuilder<'a> { + #[inline] + pub fn size(mut self, size: DeviceSize) -> Self { + self.inner.size = size; + self + } + #[inline] + pub fn flags(mut self, flags: MemoryHeapFlags) -> Self { + self.inner.flags = flags; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> MemoryHeap { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct MappedMemoryRange { + pub s_type: StructureType, + pub p_next: *const c_void, + pub memory: DeviceMemory, + pub offset: DeviceSize, + pub size: DeviceSize, +} +impl ::std::default::Default for MappedMemoryRange { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + memory: DeviceMemory::default(), + offset: DeviceSize::default(), + size: DeviceSize::default(), + } + } +} +unsafe impl TaggedStructure for MappedMemoryRange { + const STRUCTURE_TYPE: StructureType = StructureType::MAPPED_MEMORY_RANGE; +} +impl MappedMemoryRange { + pub fn builder<'a>() -> MappedMemoryRangeBuilder<'a> { + MappedMemoryRangeBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct MappedMemoryRangeBuilder<'a> { + inner: MappedMemoryRange, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for MappedMemoryRangeBuilder<'a> { + type Target = MappedMemoryRange; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for MappedMemoryRangeBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> MappedMemoryRangeBuilder<'a> { + #[inline] + pub fn memory(mut self, memory: DeviceMemory) -> Self { + self.inner.memory = memory; + self + } + #[inline] + pub fn offset(mut self, offset: DeviceSize) -> Self { + self.inner.offset = offset; + self + } + #[inline] + pub fn size(mut self, size: DeviceSize) -> Self { + self.inner.size = size; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> MappedMemoryRange { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct FormatProperties { + pub linear_tiling_features: FormatFeatureFlags, + pub optimal_tiling_features: FormatFeatureFlags, + pub buffer_features: FormatFeatureFlags, +} +impl FormatProperties { + pub fn builder<'a>() -> FormatPropertiesBuilder<'a> { + FormatPropertiesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct FormatPropertiesBuilder<'a> { + inner: FormatProperties, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for FormatPropertiesBuilder<'a> { + type Target = FormatProperties; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for FormatPropertiesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> FormatPropertiesBuilder<'a> { + #[inline] + pub fn linear_tiling_features(mut self, linear_tiling_features: FormatFeatureFlags) -> Self { + self.inner.linear_tiling_features = linear_tiling_features; + self + } + #[inline] + pub fn optimal_tiling_features(mut self, optimal_tiling_features: FormatFeatureFlags) -> Self { + self.inner.optimal_tiling_features = optimal_tiling_features; + self + } + #[inline] + pub fn buffer_features(mut self, buffer_features: FormatFeatureFlags) -> Self { + self.inner.buffer_features = buffer_features; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> FormatProperties { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct ImageFormatProperties { + pub max_extent: Extent3D, + pub max_mip_levels: u32, + pub max_array_layers: u32, + pub sample_counts: SampleCountFlags, + pub max_resource_size: DeviceSize, +} +impl ImageFormatProperties { + pub fn builder<'a>() -> ImageFormatPropertiesBuilder<'a> { + ImageFormatPropertiesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ImageFormatPropertiesBuilder<'a> { + inner: ImageFormatProperties, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ImageFormatPropertiesBuilder<'a> { + type Target = ImageFormatProperties; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ImageFormatPropertiesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ImageFormatPropertiesBuilder<'a> { + #[inline] + pub fn max_extent(mut self, max_extent: Extent3D) -> Self { + self.inner.max_extent = max_extent; + self + } + #[inline] + pub fn max_mip_levels(mut self, max_mip_levels: u32) -> Self { + self.inner.max_mip_levels = max_mip_levels; + self + } + #[inline] + pub fn max_array_layers(mut self, max_array_layers: u32) -> Self { + self.inner.max_array_layers = max_array_layers; + self + } + #[inline] + pub fn sample_counts(mut self, sample_counts: SampleCountFlags) -> Self { + self.inner.sample_counts = sample_counts; + self + } + #[inline] + pub fn max_resource_size(mut self, max_resource_size: DeviceSize) -> Self { + self.inner.max_resource_size = max_resource_size; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ImageFormatProperties { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct DescriptorBufferInfo { + pub buffer: Buffer, + pub offset: DeviceSize, + pub range: DeviceSize, +} +impl DescriptorBufferInfo { + pub fn builder<'a>() -> DescriptorBufferInfoBuilder<'a> { + DescriptorBufferInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DescriptorBufferInfoBuilder<'a> { + inner: DescriptorBufferInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DescriptorBufferInfoBuilder<'a> { + type Target = DescriptorBufferInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DescriptorBufferInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DescriptorBufferInfoBuilder<'a> { + #[inline] + pub fn buffer(mut self, buffer: Buffer) -> Self { + self.inner.buffer = buffer; + self + } + #[inline] + pub fn offset(mut self, offset: DeviceSize) -> Self { + self.inner.offset = offset; + self + } + #[inline] + pub fn range(mut self, range: DeviceSize) -> Self { + self.inner.range = range; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DescriptorBufferInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct DescriptorImageInfo { + pub sampler: Sampler, + pub image_view: ImageView, + pub image_layout: ImageLayout, +} +impl DescriptorImageInfo { + pub fn builder<'a>() -> DescriptorImageInfoBuilder<'a> { + DescriptorImageInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DescriptorImageInfoBuilder<'a> { + inner: DescriptorImageInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DescriptorImageInfoBuilder<'a> { + type Target = DescriptorImageInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DescriptorImageInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DescriptorImageInfoBuilder<'a> { + #[inline] + pub fn sampler(mut self, sampler: Sampler) -> Self { + self.inner.sampler = sampler; + self + } + #[inline] + pub fn image_view(mut self, image_view: ImageView) -> Self { + self.inner.image_view = image_view; + self + } + #[inline] + pub fn image_layout(mut self, image_layout: ImageLayout) -> Self { + self.inner.image_layout = image_layout; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DescriptorImageInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct WriteDescriptorSet { + pub s_type: StructureType, + pub p_next: *const c_void, + pub dst_set: DescriptorSet, + pub dst_binding: u32, + pub dst_array_element: u32, + pub descriptor_count: u32, + pub descriptor_type: DescriptorType, + pub p_image_info: *const DescriptorImageInfo, + pub p_buffer_info: *const DescriptorBufferInfo, + pub p_texel_buffer_view: *const BufferView, +} +impl ::std::default::Default for WriteDescriptorSet { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + dst_set: DescriptorSet::default(), + dst_binding: u32::default(), + dst_array_element: u32::default(), + descriptor_count: u32::default(), + descriptor_type: DescriptorType::default(), + p_image_info: ::std::ptr::null(), + p_buffer_info: ::std::ptr::null(), + p_texel_buffer_view: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for WriteDescriptorSet { + const STRUCTURE_TYPE: StructureType = StructureType::WRITE_DESCRIPTOR_SET; +} +impl WriteDescriptorSet { + pub fn builder<'a>() -> WriteDescriptorSetBuilder<'a> { + WriteDescriptorSetBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct WriteDescriptorSetBuilder<'a> { + inner: WriteDescriptorSet, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsWriteDescriptorSet {} +impl<'a> ::std::ops::Deref for WriteDescriptorSetBuilder<'a> { + type Target = WriteDescriptorSet; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for WriteDescriptorSetBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> WriteDescriptorSetBuilder<'a> { + #[inline] + pub fn dst_set(mut self, dst_set: DescriptorSet) -> Self { + self.inner.dst_set = dst_set; + self + } + #[inline] + pub fn dst_binding(mut self, dst_binding: u32) -> Self { + self.inner.dst_binding = dst_binding; + self + } + #[inline] + pub fn dst_array_element(mut self, dst_array_element: u32) -> Self { + self.inner.dst_array_element = dst_array_element; + self + } + #[inline] + pub fn descriptor_type(mut self, descriptor_type: DescriptorType) -> Self { + self.inner.descriptor_type = descriptor_type; + self + } + #[inline] + pub fn image_info(mut self, image_info: &'a [DescriptorImageInfo]) -> Self { + self.inner.descriptor_count = image_info.len() as _; + self.inner.p_image_info = image_info.as_ptr(); + self + } + #[inline] + pub fn buffer_info(mut self, buffer_info: &'a [DescriptorBufferInfo]) -> Self { + self.inner.descriptor_count = buffer_info.len() as _; + self.inner.p_buffer_info = buffer_info.as_ptr(); + self + } + #[inline] + pub fn texel_buffer_view(mut self, texel_buffer_view: &'a [BufferView]) -> Self { + self.inner.descriptor_count = texel_buffer_view.len() as _; + self.inner.p_texel_buffer_view = texel_buffer_view.as_ptr(); + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> WriteDescriptorSet { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct CopyDescriptorSet { + pub s_type: StructureType, + pub p_next: *const c_void, + pub src_set: DescriptorSet, + pub src_binding: u32, + pub src_array_element: u32, + pub dst_set: DescriptorSet, + pub dst_binding: u32, + pub dst_array_element: u32, + pub descriptor_count: u32, +} +impl ::std::default::Default for CopyDescriptorSet { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + src_set: DescriptorSet::default(), + src_binding: u32::default(), + src_array_element: u32::default(), + dst_set: DescriptorSet::default(), + dst_binding: u32::default(), + dst_array_element: u32::default(), + descriptor_count: u32::default(), + } + } +} +unsafe impl TaggedStructure for CopyDescriptorSet { + const STRUCTURE_TYPE: StructureType = StructureType::COPY_DESCRIPTOR_SET; +} +impl CopyDescriptorSet { + pub fn builder<'a>() -> CopyDescriptorSetBuilder<'a> { + CopyDescriptorSetBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct CopyDescriptorSetBuilder<'a> { + inner: CopyDescriptorSet, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for CopyDescriptorSetBuilder<'a> { + type Target = CopyDescriptorSet; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for CopyDescriptorSetBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> CopyDescriptorSetBuilder<'a> { + #[inline] + pub fn src_set(mut self, src_set: DescriptorSet) -> Self { + self.inner.src_set = src_set; + self + } + #[inline] + pub fn src_binding(mut self, src_binding: u32) -> Self { + self.inner.src_binding = src_binding; + self + } + #[inline] + pub fn src_array_element(mut self, src_array_element: u32) -> Self { + self.inner.src_array_element = src_array_element; + self + } + #[inline] + pub fn dst_set(mut self, dst_set: DescriptorSet) -> Self { + self.inner.dst_set = dst_set; + self + } + #[inline] + pub fn dst_binding(mut self, dst_binding: u32) -> Self { + self.inner.dst_binding = dst_binding; + self + } + #[inline] + pub fn dst_array_element(mut self, dst_array_element: u32) -> Self { + self.inner.dst_array_element = dst_array_element; + self + } + #[inline] + pub fn descriptor_count(mut self, descriptor_count: u32) -> Self { + self.inner.descriptor_count = descriptor_count; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> CopyDescriptorSet { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct BufferCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: BufferCreateFlags, + pub size: DeviceSize, + pub usage: BufferUsageFlags, + pub sharing_mode: SharingMode, + pub queue_family_index_count: u32, + pub p_queue_family_indices: *const u32, +} +impl ::std::default::Default for BufferCreateInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: BufferCreateFlags::default(), + size: DeviceSize::default(), + usage: BufferUsageFlags::default(), + sharing_mode: SharingMode::default(), + queue_family_index_count: u32::default(), + p_queue_family_indices: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for BufferCreateInfo { + const STRUCTURE_TYPE: StructureType = StructureType::BUFFER_CREATE_INFO; +} +impl BufferCreateInfo { + pub fn builder<'a>() -> BufferCreateInfoBuilder<'a> { + BufferCreateInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct BufferCreateInfoBuilder<'a> { + inner: BufferCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsBufferCreateInfo {} +impl<'a> ::std::ops::Deref for BufferCreateInfoBuilder<'a> { + type Target = BufferCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for BufferCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> BufferCreateInfoBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: BufferCreateFlags) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn size(mut self, size: DeviceSize) -> Self { + self.inner.size = size; + self + } + #[inline] + pub fn usage(mut self, usage: BufferUsageFlags) -> Self { + self.inner.usage = usage; + self + } + #[inline] + pub fn sharing_mode(mut self, sharing_mode: SharingMode) -> Self { + self.inner.sharing_mode = sharing_mode; + self + } + #[inline] + pub fn queue_family_indices(mut self, queue_family_indices: &'a [u32]) -> Self { + self.inner.queue_family_index_count = queue_family_indices.len() as _; + self.inner.p_queue_family_indices = queue_family_indices.as_ptr(); + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> BufferCreateInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct BufferViewCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: BufferViewCreateFlags, + pub buffer: Buffer, + pub format: Format, + pub offset: DeviceSize, + pub range: DeviceSize, +} +impl ::std::default::Default for BufferViewCreateInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: BufferViewCreateFlags::default(), + buffer: Buffer::default(), + format: Format::default(), + offset: DeviceSize::default(), + range: DeviceSize::default(), + } + } +} +unsafe impl TaggedStructure for BufferViewCreateInfo { + const STRUCTURE_TYPE: StructureType = StructureType::BUFFER_VIEW_CREATE_INFO; +} +impl BufferViewCreateInfo { + pub fn builder<'a>() -> BufferViewCreateInfoBuilder<'a> { + BufferViewCreateInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct BufferViewCreateInfoBuilder<'a> { + inner: BufferViewCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsBufferViewCreateInfo {} +impl<'a> ::std::ops::Deref for BufferViewCreateInfoBuilder<'a> { + type Target = BufferViewCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for BufferViewCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> BufferViewCreateInfoBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: BufferViewCreateFlags) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn buffer(mut self, buffer: Buffer) -> Self { + self.inner.buffer = buffer; + self + } + #[inline] + pub fn format(mut self, format: Format) -> Self { + self.inner.format = format; + self + } + #[inline] + pub fn offset(mut self, offset: DeviceSize) -> Self { + self.inner.offset = offset; + self + } + #[inline] + pub fn range(mut self, range: DeviceSize) -> Self { + self.inner.range = range; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> BufferViewCreateInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct ImageSubresource { + pub aspect_mask: ImageAspectFlags, + pub mip_level: u32, + pub array_layer: u32, +} +impl ImageSubresource { + pub fn builder<'a>() -> ImageSubresourceBuilder<'a> { + ImageSubresourceBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ImageSubresourceBuilder<'a> { + inner: ImageSubresource, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ImageSubresourceBuilder<'a> { + type Target = ImageSubresource; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ImageSubresourceBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ImageSubresourceBuilder<'a> { + #[inline] + pub fn aspect_mask(mut self, aspect_mask: ImageAspectFlags) -> Self { + self.inner.aspect_mask = aspect_mask; + self + } + #[inline] + pub fn mip_level(mut self, mip_level: u32) -> Self { + self.inner.mip_level = mip_level; + self + } + #[inline] + pub fn array_layer(mut self, array_layer: u32) -> Self { + self.inner.array_layer = array_layer; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ImageSubresource { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct ImageSubresourceLayers { + pub aspect_mask: ImageAspectFlags, + pub mip_level: u32, + pub base_array_layer: u32, + pub layer_count: u32, +} +impl ImageSubresourceLayers { + pub fn builder<'a>() -> ImageSubresourceLayersBuilder<'a> { + ImageSubresourceLayersBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ImageSubresourceLayersBuilder<'a> { + inner: ImageSubresourceLayers, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ImageSubresourceLayersBuilder<'a> { + type Target = ImageSubresourceLayers; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ImageSubresourceLayersBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ImageSubresourceLayersBuilder<'a> { + #[inline] + pub fn aspect_mask(mut self, aspect_mask: ImageAspectFlags) -> Self { + self.inner.aspect_mask = aspect_mask; + self + } + #[inline] + pub fn mip_level(mut self, mip_level: u32) -> Self { + self.inner.mip_level = mip_level; + self + } + #[inline] + pub fn base_array_layer(mut self, base_array_layer: u32) -> Self { + self.inner.base_array_layer = base_array_layer; + self + } + #[inline] + pub fn layer_count(mut self, layer_count: u32) -> Self { + self.inner.layer_count = layer_count; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ImageSubresourceLayers { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct ImageSubresourceRange { + pub aspect_mask: ImageAspectFlags, + pub base_mip_level: u32, + pub level_count: u32, + pub base_array_layer: u32, + pub layer_count: u32, +} +impl ImageSubresourceRange { + pub fn builder<'a>() -> ImageSubresourceRangeBuilder<'a> { + ImageSubresourceRangeBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ImageSubresourceRangeBuilder<'a> { + inner: ImageSubresourceRange, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ImageSubresourceRangeBuilder<'a> { + type Target = ImageSubresourceRange; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ImageSubresourceRangeBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ImageSubresourceRangeBuilder<'a> { + #[inline] + pub fn aspect_mask(mut self, aspect_mask: ImageAspectFlags) -> Self { + self.inner.aspect_mask = aspect_mask; + self + } + #[inline] + pub fn base_mip_level(mut self, base_mip_level: u32) -> Self { + self.inner.base_mip_level = base_mip_level; + self + } + #[inline] + pub fn level_count(mut self, level_count: u32) -> Self { + self.inner.level_count = level_count; + self + } + #[inline] + pub fn base_array_layer(mut self, base_array_layer: u32) -> Self { + self.inner.base_array_layer = base_array_layer; + self + } + #[inline] + pub fn layer_count(mut self, layer_count: u32) -> Self { + self.inner.layer_count = layer_count; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ImageSubresourceRange { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct MemoryBarrier { + pub s_type: StructureType, + pub p_next: *const c_void, + pub src_access_mask: AccessFlags, + pub dst_access_mask: AccessFlags, +} +impl ::std::default::Default for MemoryBarrier { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + src_access_mask: AccessFlags::default(), + dst_access_mask: AccessFlags::default(), + } + } +} +unsafe impl TaggedStructure for MemoryBarrier { + const STRUCTURE_TYPE: StructureType = StructureType::MEMORY_BARRIER; +} +impl MemoryBarrier { + pub fn builder<'a>() -> MemoryBarrierBuilder<'a> { + MemoryBarrierBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct MemoryBarrierBuilder<'a> { + inner: MemoryBarrier, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for MemoryBarrierBuilder<'a> { + type Target = MemoryBarrier; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for MemoryBarrierBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> MemoryBarrierBuilder<'a> { + #[inline] + pub fn src_access_mask(mut self, src_access_mask: AccessFlags) -> Self { + self.inner.src_access_mask = src_access_mask; + self + } + #[inline] + pub fn dst_access_mask(mut self, dst_access_mask: AccessFlags) -> Self { + self.inner.dst_access_mask = dst_access_mask; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> MemoryBarrier { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct BufferMemoryBarrier { + pub s_type: StructureType, + pub p_next: *const c_void, + pub src_access_mask: AccessFlags, + pub dst_access_mask: AccessFlags, + pub src_queue_family_index: u32, + pub dst_queue_family_index: u32, + pub buffer: Buffer, + pub offset: DeviceSize, + pub size: DeviceSize, +} +impl ::std::default::Default for BufferMemoryBarrier { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + src_access_mask: AccessFlags::default(), + dst_access_mask: AccessFlags::default(), + src_queue_family_index: u32::default(), + dst_queue_family_index: u32::default(), + buffer: Buffer::default(), + offset: DeviceSize::default(), + size: DeviceSize::default(), + } + } +} +unsafe impl TaggedStructure for BufferMemoryBarrier { + const STRUCTURE_TYPE: StructureType = StructureType::BUFFER_MEMORY_BARRIER; +} +impl BufferMemoryBarrier { + pub fn builder<'a>() -> BufferMemoryBarrierBuilder<'a> { + BufferMemoryBarrierBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct BufferMemoryBarrierBuilder<'a> { + inner: BufferMemoryBarrier, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for BufferMemoryBarrierBuilder<'a> { + type Target = BufferMemoryBarrier; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for BufferMemoryBarrierBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> BufferMemoryBarrierBuilder<'a> { + #[inline] + pub fn src_access_mask(mut self, src_access_mask: AccessFlags) -> Self { + self.inner.src_access_mask = src_access_mask; + self + } + #[inline] + pub fn dst_access_mask(mut self, dst_access_mask: AccessFlags) -> Self { + self.inner.dst_access_mask = dst_access_mask; + self + } + #[inline] + pub fn src_queue_family_index(mut self, src_queue_family_index: u32) -> Self { + self.inner.src_queue_family_index = src_queue_family_index; + self + } + #[inline] + pub fn dst_queue_family_index(mut self, dst_queue_family_index: u32) -> Self { + self.inner.dst_queue_family_index = dst_queue_family_index; + self + } + #[inline] + pub fn buffer(mut self, buffer: Buffer) -> Self { + self.inner.buffer = buffer; + self + } + #[inline] + pub fn offset(mut self, offset: DeviceSize) -> Self { + self.inner.offset = offset; + self + } + #[inline] + pub fn size(mut self, size: DeviceSize) -> Self { + self.inner.size = size; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> BufferMemoryBarrier { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ImageMemoryBarrier { + pub s_type: StructureType, + pub p_next: *const c_void, + pub src_access_mask: AccessFlags, + pub dst_access_mask: AccessFlags, + pub old_layout: ImageLayout, + pub new_layout: ImageLayout, + pub src_queue_family_index: u32, + pub dst_queue_family_index: u32, + pub image: Image, + pub subresource_range: ImageSubresourceRange, +} +impl ::std::default::Default for ImageMemoryBarrier { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + src_access_mask: AccessFlags::default(), + dst_access_mask: AccessFlags::default(), + old_layout: ImageLayout::default(), + new_layout: ImageLayout::default(), + src_queue_family_index: u32::default(), + dst_queue_family_index: u32::default(), + image: Image::default(), + subresource_range: ImageSubresourceRange::default(), + } + } +} +unsafe impl TaggedStructure for ImageMemoryBarrier { + const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_MEMORY_BARRIER; +} +impl ImageMemoryBarrier { + pub fn builder<'a>() -> ImageMemoryBarrierBuilder<'a> { + ImageMemoryBarrierBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ImageMemoryBarrierBuilder<'a> { + inner: ImageMemoryBarrier, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsImageMemoryBarrier {} +impl<'a> ::std::ops::Deref for ImageMemoryBarrierBuilder<'a> { + type Target = ImageMemoryBarrier; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ImageMemoryBarrierBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ImageMemoryBarrierBuilder<'a> { + #[inline] + pub fn src_access_mask(mut self, src_access_mask: AccessFlags) -> Self { + self.inner.src_access_mask = src_access_mask; + self + } + #[inline] + pub fn dst_access_mask(mut self, dst_access_mask: AccessFlags) -> Self { + self.inner.dst_access_mask = dst_access_mask; + self + } + #[inline] + pub fn old_layout(mut self, old_layout: ImageLayout) -> Self { + self.inner.old_layout = old_layout; + self + } + #[inline] + pub fn new_layout(mut self, new_layout: ImageLayout) -> Self { + self.inner.new_layout = new_layout; + self + } + #[inline] + pub fn src_queue_family_index(mut self, src_queue_family_index: u32) -> Self { + self.inner.src_queue_family_index = src_queue_family_index; + self + } + #[inline] + pub fn dst_queue_family_index(mut self, dst_queue_family_index: u32) -> Self { + self.inner.dst_queue_family_index = dst_queue_family_index; + self + } + #[inline] + pub fn image(mut self, image: Image) -> Self { + self.inner.image = image; + self + } + #[inline] + pub fn subresource_range(mut self, subresource_range: ImageSubresourceRange) -> Self { + self.inner.subresource_range = subresource_range; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ImageMemoryBarrier { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ImageCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: ImageCreateFlags, + pub image_type: ImageType, + pub format: Format, + pub extent: Extent3D, + pub mip_levels: u32, + pub array_layers: u32, + pub samples: SampleCountFlags, + pub tiling: ImageTiling, + pub usage: ImageUsageFlags, + pub sharing_mode: SharingMode, + pub queue_family_index_count: u32, + pub p_queue_family_indices: *const u32, + pub initial_layout: ImageLayout, +} +impl ::std::default::Default for ImageCreateInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: ImageCreateFlags::default(), + image_type: ImageType::default(), + format: Format::default(), + extent: Extent3D::default(), + mip_levels: u32::default(), + array_layers: u32::default(), + samples: SampleCountFlags::default(), + tiling: ImageTiling::default(), + usage: ImageUsageFlags::default(), + sharing_mode: SharingMode::default(), + queue_family_index_count: u32::default(), + p_queue_family_indices: ::std::ptr::null(), + initial_layout: ImageLayout::default(), + } + } +} +unsafe impl TaggedStructure for ImageCreateInfo { + const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_CREATE_INFO; +} +impl ImageCreateInfo { + pub fn builder<'a>() -> ImageCreateInfoBuilder<'a> { + ImageCreateInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ImageCreateInfoBuilder<'a> { + inner: ImageCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsImageCreateInfo {} +impl<'a> ::std::ops::Deref for ImageCreateInfoBuilder<'a> { + type Target = ImageCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ImageCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ImageCreateInfoBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: ImageCreateFlags) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn image_type(mut self, image_type: ImageType) -> Self { + self.inner.image_type = image_type; + self + } + #[inline] + pub fn format(mut self, format: Format) -> Self { + self.inner.format = format; + self + } + #[inline] + pub fn extent(mut self, extent: Extent3D) -> Self { + self.inner.extent = extent; + self + } + #[inline] + pub fn mip_levels(mut self, mip_levels: u32) -> Self { + self.inner.mip_levels = mip_levels; + self + } + #[inline] + pub fn array_layers(mut self, array_layers: u32) -> Self { + self.inner.array_layers = array_layers; + self + } + #[inline] + pub fn samples(mut self, samples: SampleCountFlags) -> Self { + self.inner.samples = samples; + self + } + #[inline] + pub fn tiling(mut self, tiling: ImageTiling) -> Self { + self.inner.tiling = tiling; + self + } + #[inline] + pub fn usage(mut self, usage: ImageUsageFlags) -> Self { + self.inner.usage = usage; + self + } + #[inline] + pub fn sharing_mode(mut self, sharing_mode: SharingMode) -> Self { + self.inner.sharing_mode = sharing_mode; + self + } + #[inline] + pub fn queue_family_indices(mut self, queue_family_indices: &'a [u32]) -> Self { + self.inner.queue_family_index_count = queue_family_indices.len() as _; + self.inner.p_queue_family_indices = queue_family_indices.as_ptr(); + self + } + #[inline] + pub fn initial_layout(mut self, initial_layout: ImageLayout) -> Self { + self.inner.initial_layout = initial_layout; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ImageCreateInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct SubresourceLayout { + pub offset: DeviceSize, + pub size: DeviceSize, + pub row_pitch: DeviceSize, + pub array_pitch: DeviceSize, + pub depth_pitch: DeviceSize, +} +impl SubresourceLayout { + pub fn builder<'a>() -> SubresourceLayoutBuilder<'a> { + SubresourceLayoutBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SubresourceLayoutBuilder<'a> { + inner: SubresourceLayout, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for SubresourceLayoutBuilder<'a> { + type Target = SubresourceLayout; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SubresourceLayoutBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SubresourceLayoutBuilder<'a> { + #[inline] + pub fn offset(mut self, offset: DeviceSize) -> Self { + self.inner.offset = offset; + self + } + #[inline] + pub fn size(mut self, size: DeviceSize) -> Self { + self.inner.size = size; + self + } + #[inline] + pub fn row_pitch(mut self, row_pitch: DeviceSize) -> Self { + self.inner.row_pitch = row_pitch; + self + } + #[inline] + pub fn array_pitch(mut self, array_pitch: DeviceSize) -> Self { + self.inner.array_pitch = array_pitch; + self + } + #[inline] + pub fn depth_pitch(mut self, depth_pitch: DeviceSize) -> Self { + self.inner.depth_pitch = depth_pitch; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SubresourceLayout { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ImageViewCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: ImageViewCreateFlags, + pub image: Image, + pub view_type: ImageViewType, + pub format: Format, + pub components: ComponentMapping, + pub subresource_range: ImageSubresourceRange, +} +impl ::std::default::Default for ImageViewCreateInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: ImageViewCreateFlags::default(), + image: Image::default(), + view_type: ImageViewType::default(), + format: Format::default(), + components: ComponentMapping::default(), + subresource_range: ImageSubresourceRange::default(), + } + } +} +unsafe impl TaggedStructure for ImageViewCreateInfo { + const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_VIEW_CREATE_INFO; +} +impl ImageViewCreateInfo { + pub fn builder<'a>() -> ImageViewCreateInfoBuilder<'a> { + ImageViewCreateInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ImageViewCreateInfoBuilder<'a> { + inner: ImageViewCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsImageViewCreateInfo {} +impl<'a> ::std::ops::Deref for ImageViewCreateInfoBuilder<'a> { + type Target = ImageViewCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ImageViewCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ImageViewCreateInfoBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: ImageViewCreateFlags) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn image(mut self, image: Image) -> Self { + self.inner.image = image; + self + } + #[inline] + pub fn view_type(mut self, view_type: ImageViewType) -> Self { + self.inner.view_type = view_type; + self + } + #[inline] + pub fn format(mut self, format: Format) -> Self { + self.inner.format = format; + self + } + #[inline] + pub fn components(mut self, components: ComponentMapping) -> Self { + self.inner.components = components; + self + } + #[inline] + pub fn subresource_range(mut self, subresource_range: ImageSubresourceRange) -> Self { + self.inner.subresource_range = subresource_range; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ImageViewCreateInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct BufferCopy { + pub src_offset: DeviceSize, + pub dst_offset: DeviceSize, + pub size: DeviceSize, +} +impl BufferCopy { + pub fn builder<'a>() -> BufferCopyBuilder<'a> { + BufferCopyBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct BufferCopyBuilder<'a> { + inner: BufferCopy, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for BufferCopyBuilder<'a> { + type Target = BufferCopy; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for BufferCopyBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> BufferCopyBuilder<'a> { + #[inline] + pub fn src_offset(mut self, src_offset: DeviceSize) -> Self { + self.inner.src_offset = src_offset; + self + } + #[inline] + pub fn dst_offset(mut self, dst_offset: DeviceSize) -> Self { + self.inner.dst_offset = dst_offset; + self + } + #[inline] + pub fn size(mut self, size: DeviceSize) -> Self { + self.inner.size = size; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> BufferCopy { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct SparseMemoryBind { + pub resource_offset: DeviceSize, + pub size: DeviceSize, + pub memory: DeviceMemory, + pub memory_offset: DeviceSize, + pub flags: SparseMemoryBindFlags, +} +impl SparseMemoryBind { + pub fn builder<'a>() -> SparseMemoryBindBuilder<'a> { + SparseMemoryBindBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SparseMemoryBindBuilder<'a> { + inner: SparseMemoryBind, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for SparseMemoryBindBuilder<'a> { + type Target = SparseMemoryBind; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SparseMemoryBindBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SparseMemoryBindBuilder<'a> { + #[inline] + pub fn resource_offset(mut self, resource_offset: DeviceSize) -> Self { + self.inner.resource_offset = resource_offset; + self + } + #[inline] + pub fn size(mut self, size: DeviceSize) -> Self { + self.inner.size = size; + self + } + #[inline] + pub fn memory(mut self, memory: DeviceMemory) -> Self { + self.inner.memory = memory; + self + } + #[inline] + pub fn memory_offset(mut self, memory_offset: DeviceSize) -> Self { + self.inner.memory_offset = memory_offset; + self + } + #[inline] + pub fn flags(mut self, flags: SparseMemoryBindFlags) -> Self { + self.inner.flags = flags; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SparseMemoryBind { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct SparseImageMemoryBind { + pub subresource: ImageSubresource, + pub offset: Offset3D, + pub extent: Extent3D, + pub memory: DeviceMemory, + pub memory_offset: DeviceSize, + pub flags: SparseMemoryBindFlags, +} +impl SparseImageMemoryBind { + pub fn builder<'a>() -> SparseImageMemoryBindBuilder<'a> { + SparseImageMemoryBindBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SparseImageMemoryBindBuilder<'a> { + inner: SparseImageMemoryBind, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for SparseImageMemoryBindBuilder<'a> { + type Target = SparseImageMemoryBind; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SparseImageMemoryBindBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SparseImageMemoryBindBuilder<'a> { + #[inline] + pub fn subresource(mut self, subresource: ImageSubresource) -> Self { + self.inner.subresource = subresource; + self + } + #[inline] + pub fn offset(mut self, offset: Offset3D) -> Self { + self.inner.offset = offset; + self + } + #[inline] + pub fn extent(mut self, extent: Extent3D) -> Self { + self.inner.extent = extent; + self + } + #[inline] + pub fn memory(mut self, memory: DeviceMemory) -> Self { + self.inner.memory = memory; + self + } + #[inline] + pub fn memory_offset(mut self, memory_offset: DeviceSize) -> Self { + self.inner.memory_offset = memory_offset; + self + } + #[inline] + pub fn flags(mut self, flags: SparseMemoryBindFlags) -> Self { + self.inner.flags = flags; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SparseImageMemoryBind { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SparseBufferMemoryBindInfo { + pub buffer: Buffer, + pub bind_count: u32, + pub p_binds: *const SparseMemoryBind, +} +impl ::std::default::Default for SparseBufferMemoryBindInfo { + #[inline] + fn default() -> Self { + Self { + buffer: Buffer::default(), + bind_count: u32::default(), + p_binds: ::std::ptr::null(), + } + } +} +impl SparseBufferMemoryBindInfo { + pub fn builder<'a>() -> SparseBufferMemoryBindInfoBuilder<'a> { + SparseBufferMemoryBindInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SparseBufferMemoryBindInfoBuilder<'a> { + inner: SparseBufferMemoryBindInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for SparseBufferMemoryBindInfoBuilder<'a> { + type Target = SparseBufferMemoryBindInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SparseBufferMemoryBindInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SparseBufferMemoryBindInfoBuilder<'a> { + #[inline] + pub fn buffer(mut self, buffer: Buffer) -> Self { + self.inner.buffer = buffer; + self + } + #[inline] + pub fn binds(mut self, binds: &'a [SparseMemoryBind]) -> Self { + self.inner.bind_count = binds.len() as _; + self.inner.p_binds = binds.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SparseBufferMemoryBindInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SparseImageOpaqueMemoryBindInfo { + pub image: Image, + pub bind_count: u32, + pub p_binds: *const SparseMemoryBind, +} +impl ::std::default::Default for SparseImageOpaqueMemoryBindInfo { + #[inline] + fn default() -> Self { + Self { + image: Image::default(), + bind_count: u32::default(), + p_binds: ::std::ptr::null(), + } + } +} +impl SparseImageOpaqueMemoryBindInfo { + pub fn builder<'a>() -> SparseImageOpaqueMemoryBindInfoBuilder<'a> { + SparseImageOpaqueMemoryBindInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SparseImageOpaqueMemoryBindInfoBuilder<'a> { + inner: SparseImageOpaqueMemoryBindInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for SparseImageOpaqueMemoryBindInfoBuilder<'a> { + type Target = SparseImageOpaqueMemoryBindInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SparseImageOpaqueMemoryBindInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SparseImageOpaqueMemoryBindInfoBuilder<'a> { + #[inline] + pub fn image(mut self, image: Image) -> Self { + self.inner.image = image; + self + } + #[inline] + pub fn binds(mut self, binds: &'a [SparseMemoryBind]) -> Self { + self.inner.bind_count = binds.len() as _; + self.inner.p_binds = binds.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SparseImageOpaqueMemoryBindInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SparseImageMemoryBindInfo { + pub image: Image, + pub bind_count: u32, + pub p_binds: *const SparseImageMemoryBind, +} +impl ::std::default::Default for SparseImageMemoryBindInfo { + #[inline] + fn default() -> Self { + Self { + image: Image::default(), + bind_count: u32::default(), + p_binds: ::std::ptr::null(), + } + } +} +impl SparseImageMemoryBindInfo { + pub fn builder<'a>() -> SparseImageMemoryBindInfoBuilder<'a> { + SparseImageMemoryBindInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SparseImageMemoryBindInfoBuilder<'a> { + inner: SparseImageMemoryBindInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for SparseImageMemoryBindInfoBuilder<'a> { + type Target = SparseImageMemoryBindInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SparseImageMemoryBindInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SparseImageMemoryBindInfoBuilder<'a> { + #[inline] + pub fn image(mut self, image: Image) -> Self { + self.inner.image = image; + self + } + #[inline] + pub fn binds(mut self, binds: &'a [SparseImageMemoryBind]) -> Self { + self.inner.bind_count = binds.len() as _; + self.inner.p_binds = binds.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SparseImageMemoryBindInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct BindSparseInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub wait_semaphore_count: u32, + pub p_wait_semaphores: *const Semaphore, + pub buffer_bind_count: u32, + pub p_buffer_binds: *const SparseBufferMemoryBindInfo, + pub image_opaque_bind_count: u32, + pub p_image_opaque_binds: *const SparseImageOpaqueMemoryBindInfo, + pub image_bind_count: u32, + pub p_image_binds: *const SparseImageMemoryBindInfo, + pub signal_semaphore_count: u32, + pub p_signal_semaphores: *const Semaphore, +} +impl ::std::default::Default for BindSparseInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + wait_semaphore_count: u32::default(), + p_wait_semaphores: ::std::ptr::null(), + buffer_bind_count: u32::default(), + p_buffer_binds: ::std::ptr::null(), + image_opaque_bind_count: u32::default(), + p_image_opaque_binds: ::std::ptr::null(), + image_bind_count: u32::default(), + p_image_binds: ::std::ptr::null(), + signal_semaphore_count: u32::default(), + p_signal_semaphores: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for BindSparseInfo { + const STRUCTURE_TYPE: StructureType = StructureType::BIND_SPARSE_INFO; +} +impl BindSparseInfo { + pub fn builder<'a>() -> BindSparseInfoBuilder<'a> { + BindSparseInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct BindSparseInfoBuilder<'a> { + inner: BindSparseInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsBindSparseInfo {} +impl<'a> ::std::ops::Deref for BindSparseInfoBuilder<'a> { + type Target = BindSparseInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for BindSparseInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> BindSparseInfoBuilder<'a> { + #[inline] + pub fn wait_semaphores(mut self, wait_semaphores: &'a [Semaphore]) -> Self { + self.inner.wait_semaphore_count = wait_semaphores.len() as _; + self.inner.p_wait_semaphores = wait_semaphores.as_ptr(); + self + } + #[inline] + pub fn buffer_binds(mut self, buffer_binds: &'a [SparseBufferMemoryBindInfo]) -> Self { + self.inner.buffer_bind_count = buffer_binds.len() as _; + self.inner.p_buffer_binds = buffer_binds.as_ptr(); + self + } + #[inline] + pub fn image_opaque_binds( + mut self, + image_opaque_binds: &'a [SparseImageOpaqueMemoryBindInfo], + ) -> Self { + self.inner.image_opaque_bind_count = image_opaque_binds.len() as _; + self.inner.p_image_opaque_binds = image_opaque_binds.as_ptr(); + self + } + #[inline] + pub fn image_binds(mut self, image_binds: &'a [SparseImageMemoryBindInfo]) -> Self { + self.inner.image_bind_count = image_binds.len() as _; + self.inner.p_image_binds = image_binds.as_ptr(); + self + } + #[inline] + pub fn signal_semaphores(mut self, signal_semaphores: &'a [Semaphore]) -> Self { + self.inner.signal_semaphore_count = signal_semaphores.len() as _; + self.inner.p_signal_semaphores = signal_semaphores.as_ptr(); + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> BindSparseInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct ImageCopy { + pub src_subresource: ImageSubresourceLayers, + pub src_offset: Offset3D, + pub dst_subresource: ImageSubresourceLayers, + pub dst_offset: Offset3D, + pub extent: Extent3D, +} +impl ImageCopy { + pub fn builder<'a>() -> ImageCopyBuilder<'a> { + ImageCopyBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ImageCopyBuilder<'a> { + inner: ImageCopy, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ImageCopyBuilder<'a> { + type Target = ImageCopy; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ImageCopyBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ImageCopyBuilder<'a> { + #[inline] + pub fn src_subresource(mut self, src_subresource: ImageSubresourceLayers) -> Self { + self.inner.src_subresource = src_subresource; + self + } + #[inline] + pub fn src_offset(mut self, src_offset: Offset3D) -> Self { + self.inner.src_offset = src_offset; + self + } + #[inline] + pub fn dst_subresource(mut self, dst_subresource: ImageSubresourceLayers) -> Self { + self.inner.dst_subresource = dst_subresource; + self + } + #[inline] + pub fn dst_offset(mut self, dst_offset: Offset3D) -> Self { + self.inner.dst_offset = dst_offset; + self + } + #[inline] + pub fn extent(mut self, extent: Extent3D) -> Self { + self.inner.extent = extent; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ImageCopy { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ImageBlit { + pub src_subresource: ImageSubresourceLayers, + pub src_offsets: [Offset3D; 2], + pub dst_subresource: ImageSubresourceLayers, + pub dst_offsets: [Offset3D; 2], +} +impl ::std::default::Default for ImageBlit { + #[inline] + fn default() -> Self { + Self { + src_subresource: ImageSubresourceLayers::default(), + src_offsets: unsafe { ::std::mem::zeroed() }, + dst_subresource: ImageSubresourceLayers::default(), + dst_offsets: unsafe { ::std::mem::zeroed() }, + } + } +} +impl ImageBlit { + pub fn builder<'a>() -> ImageBlitBuilder<'a> { + ImageBlitBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ImageBlitBuilder<'a> { + inner: ImageBlit, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ImageBlitBuilder<'a> { + type Target = ImageBlit; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ImageBlitBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ImageBlitBuilder<'a> { + #[inline] + pub fn src_subresource(mut self, src_subresource: ImageSubresourceLayers) -> Self { + self.inner.src_subresource = src_subresource; + self + } + #[inline] + pub fn src_offsets(mut self, src_offsets: [Offset3D; 2]) -> Self { + self.inner.src_offsets = src_offsets; + self + } + #[inline] + pub fn dst_subresource(mut self, dst_subresource: ImageSubresourceLayers) -> Self { + self.inner.dst_subresource = dst_subresource; + self + } + #[inline] + pub fn dst_offsets(mut self, dst_offsets: [Offset3D; 2]) -> Self { + self.inner.dst_offsets = dst_offsets; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ImageBlit { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct BufferImageCopy { + pub buffer_offset: DeviceSize, + pub buffer_row_length: u32, + pub buffer_image_height: u32, + pub image_subresource: ImageSubresourceLayers, + pub image_offset: Offset3D, + pub image_extent: Extent3D, +} +impl BufferImageCopy { + pub fn builder<'a>() -> BufferImageCopyBuilder<'a> { + BufferImageCopyBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct BufferImageCopyBuilder<'a> { + inner: BufferImageCopy, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for BufferImageCopyBuilder<'a> { + type Target = BufferImageCopy; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for BufferImageCopyBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> BufferImageCopyBuilder<'a> { + #[inline] + pub fn buffer_offset(mut self, buffer_offset: DeviceSize) -> Self { + self.inner.buffer_offset = buffer_offset; + self + } + #[inline] + pub fn buffer_row_length(mut self, buffer_row_length: u32) -> Self { + self.inner.buffer_row_length = buffer_row_length; + self + } + #[inline] + pub fn buffer_image_height(mut self, buffer_image_height: u32) -> Self { + self.inner.buffer_image_height = buffer_image_height; + self + } + #[inline] + pub fn image_subresource(mut self, image_subresource: ImageSubresourceLayers) -> Self { + self.inner.image_subresource = image_subresource; + self + } + #[inline] + pub fn image_offset(mut self, image_offset: Offset3D) -> Self { + self.inner.image_offset = image_offset; + self + } + #[inline] + pub fn image_extent(mut self, image_extent: Extent3D) -> Self { + self.inner.image_extent = image_extent; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> BufferImageCopy { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct CopyMemoryIndirectCommandNV { + pub src_address: DeviceAddress, + pub dst_address: DeviceAddress, + pub size: DeviceSize, +} +impl CopyMemoryIndirectCommandNV { + pub fn builder<'a>() -> CopyMemoryIndirectCommandNVBuilder<'a> { + CopyMemoryIndirectCommandNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct CopyMemoryIndirectCommandNVBuilder<'a> { + inner: CopyMemoryIndirectCommandNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for CopyMemoryIndirectCommandNVBuilder<'a> { + type Target = CopyMemoryIndirectCommandNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for CopyMemoryIndirectCommandNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> CopyMemoryIndirectCommandNVBuilder<'a> { + #[inline] + pub fn src_address(mut self, src_address: DeviceAddress) -> Self { + self.inner.src_address = src_address; + self + } + #[inline] + pub fn dst_address(mut self, dst_address: DeviceAddress) -> Self { + self.inner.dst_address = dst_address; + self + } + #[inline] + pub fn size(mut self, size: DeviceSize) -> Self { + self.inner.size = size; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> CopyMemoryIndirectCommandNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct CopyMemoryToImageIndirectCommandNV { + pub src_address: DeviceAddress, + pub buffer_row_length: u32, + pub buffer_image_height: u32, + pub image_subresource: ImageSubresourceLayers, + pub image_offset: Offset3D, + pub image_extent: Extent3D, +} +impl CopyMemoryToImageIndirectCommandNV { + pub fn builder<'a>() -> CopyMemoryToImageIndirectCommandNVBuilder<'a> { + CopyMemoryToImageIndirectCommandNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct CopyMemoryToImageIndirectCommandNVBuilder<'a> { + inner: CopyMemoryToImageIndirectCommandNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for CopyMemoryToImageIndirectCommandNVBuilder<'a> { + type Target = CopyMemoryToImageIndirectCommandNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for CopyMemoryToImageIndirectCommandNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> CopyMemoryToImageIndirectCommandNVBuilder<'a> { + #[inline] + pub fn src_address(mut self, src_address: DeviceAddress) -> Self { + self.inner.src_address = src_address; + self + } + #[inline] + pub fn buffer_row_length(mut self, buffer_row_length: u32) -> Self { + self.inner.buffer_row_length = buffer_row_length; + self + } + #[inline] + pub fn buffer_image_height(mut self, buffer_image_height: u32) -> Self { + self.inner.buffer_image_height = buffer_image_height; + self + } + #[inline] + pub fn image_subresource(mut self, image_subresource: ImageSubresourceLayers) -> Self { + self.inner.image_subresource = image_subresource; + self + } + #[inline] + pub fn image_offset(mut self, image_offset: Offset3D) -> Self { + self.inner.image_offset = image_offset; + self + } + #[inline] + pub fn image_extent(mut self, image_extent: Extent3D) -> Self { + self.inner.image_extent = image_extent; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> CopyMemoryToImageIndirectCommandNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct ImageResolve { + pub src_subresource: ImageSubresourceLayers, + pub src_offset: Offset3D, + pub dst_subresource: ImageSubresourceLayers, + pub dst_offset: Offset3D, + pub extent: Extent3D, +} +impl ImageResolve { + pub fn builder<'a>() -> ImageResolveBuilder<'a> { + ImageResolveBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ImageResolveBuilder<'a> { + inner: ImageResolve, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ImageResolveBuilder<'a> { + type Target = ImageResolve; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ImageResolveBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ImageResolveBuilder<'a> { + #[inline] + pub fn src_subresource(mut self, src_subresource: ImageSubresourceLayers) -> Self { + self.inner.src_subresource = src_subresource; + self + } + #[inline] + pub fn src_offset(mut self, src_offset: Offset3D) -> Self { + self.inner.src_offset = src_offset; + self + } + #[inline] + pub fn dst_subresource(mut self, dst_subresource: ImageSubresourceLayers) -> Self { + self.inner.dst_subresource = dst_subresource; + self + } + #[inline] + pub fn dst_offset(mut self, dst_offset: Offset3D) -> Self { + self.inner.dst_offset = dst_offset; + self + } + #[inline] + pub fn extent(mut self, extent: Extent3D) -> Self { + self.inner.extent = extent; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ImageResolve { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ShaderModuleCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: ShaderModuleCreateFlags, + pub code_size: usize, + pub p_code: *const u32, +} +impl ::std::default::Default for ShaderModuleCreateInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: ShaderModuleCreateFlags::default(), + code_size: usize::default(), + p_code: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for ShaderModuleCreateInfo { + const STRUCTURE_TYPE: StructureType = StructureType::SHADER_MODULE_CREATE_INFO; +} +impl ShaderModuleCreateInfo { + pub fn builder<'a>() -> ShaderModuleCreateInfoBuilder<'a> { + ShaderModuleCreateInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ShaderModuleCreateInfoBuilder<'a> { + inner: ShaderModuleCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPipelineShaderStageCreateInfo for ShaderModuleCreateInfoBuilder<'_> {} +unsafe impl ExtendsPipelineShaderStageCreateInfo for ShaderModuleCreateInfo {} +pub unsafe trait ExtendsShaderModuleCreateInfo {} +impl<'a> ::std::ops::Deref for ShaderModuleCreateInfoBuilder<'a> { + type Target = ShaderModuleCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ShaderModuleCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ShaderModuleCreateInfoBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: ShaderModuleCreateFlags) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn code(mut self, code: &'a [u32]) -> Self { + self.inner.code_size = code.len() * 4; + self.inner.p_code = code.as_ptr(); + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ShaderModuleCreateInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DescriptorSetLayoutBinding { + pub binding: u32, + pub descriptor_type: DescriptorType, + pub descriptor_count: u32, + pub stage_flags: ShaderStageFlags, + pub p_immutable_samplers: *const Sampler, +} +impl ::std::default::Default for DescriptorSetLayoutBinding { + #[inline] + fn default() -> Self { + Self { + binding: u32::default(), + descriptor_type: DescriptorType::default(), + descriptor_count: u32::default(), + stage_flags: ShaderStageFlags::default(), + p_immutable_samplers: ::std::ptr::null(), + } + } +} +impl DescriptorSetLayoutBinding { + pub fn builder<'a>() -> DescriptorSetLayoutBindingBuilder<'a> { + DescriptorSetLayoutBindingBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DescriptorSetLayoutBindingBuilder<'a> { + inner: DescriptorSetLayoutBinding, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DescriptorSetLayoutBindingBuilder<'a> { + type Target = DescriptorSetLayoutBinding; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DescriptorSetLayoutBindingBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DescriptorSetLayoutBindingBuilder<'a> { + #[inline] + pub fn binding(mut self, binding: u32) -> Self { + self.inner.binding = binding; + self + } + #[inline] + pub fn descriptor_type(mut self, descriptor_type: DescriptorType) -> Self { + self.inner.descriptor_type = descriptor_type; + self + } + #[inline] + pub fn descriptor_count(mut self, descriptor_count: u32) -> Self { + self.inner.descriptor_count = descriptor_count; + self + } + #[inline] + pub fn stage_flags(mut self, stage_flags: ShaderStageFlags) -> Self { + self.inner.stage_flags = stage_flags; + self + } + #[inline] + pub fn immutable_samplers(mut self, immutable_samplers: &'a [Sampler]) -> Self { + self.inner.descriptor_count = immutable_samplers.len() as _; + self.inner.p_immutable_samplers = immutable_samplers.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DescriptorSetLayoutBinding { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DescriptorSetLayoutCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: DescriptorSetLayoutCreateFlags, + pub binding_count: u32, + pub p_bindings: *const DescriptorSetLayoutBinding, +} +impl ::std::default::Default for DescriptorSetLayoutCreateInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: DescriptorSetLayoutCreateFlags::default(), + binding_count: u32::default(), + p_bindings: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for DescriptorSetLayoutCreateInfo { + const STRUCTURE_TYPE: StructureType = StructureType::DESCRIPTOR_SET_LAYOUT_CREATE_INFO; +} +impl DescriptorSetLayoutCreateInfo { + pub fn builder<'a>() -> DescriptorSetLayoutCreateInfoBuilder<'a> { + DescriptorSetLayoutCreateInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DescriptorSetLayoutCreateInfoBuilder<'a> { + inner: DescriptorSetLayoutCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsDescriptorSetLayoutCreateInfo {} +impl<'a> ::std::ops::Deref for DescriptorSetLayoutCreateInfoBuilder<'a> { + type Target = DescriptorSetLayoutCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DescriptorSetLayoutCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DescriptorSetLayoutCreateInfoBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: DescriptorSetLayoutCreateFlags) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn bindings(mut self, bindings: &'a [DescriptorSetLayoutBinding]) -> Self { + self.inner.binding_count = bindings.len() as _; + self.inner.p_bindings = bindings.as_ptr(); + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DescriptorSetLayoutCreateInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct DescriptorPoolSize { + pub ty: DescriptorType, + pub descriptor_count: u32, +} +impl DescriptorPoolSize { + pub fn builder<'a>() -> DescriptorPoolSizeBuilder<'a> { + DescriptorPoolSizeBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DescriptorPoolSizeBuilder<'a> { + inner: DescriptorPoolSize, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DescriptorPoolSizeBuilder<'a> { + type Target = DescriptorPoolSize; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DescriptorPoolSizeBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DescriptorPoolSizeBuilder<'a> { + #[inline] + pub fn ty(mut self, ty: DescriptorType) -> Self { + self.inner.ty = ty; + self + } + #[inline] + pub fn descriptor_count(mut self, descriptor_count: u32) -> Self { + self.inner.descriptor_count = descriptor_count; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DescriptorPoolSize { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DescriptorPoolCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: DescriptorPoolCreateFlags, + pub max_sets: u32, + pub pool_size_count: u32, + pub p_pool_sizes: *const DescriptorPoolSize, +} +impl ::std::default::Default for DescriptorPoolCreateInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: DescriptorPoolCreateFlags::default(), + max_sets: u32::default(), + pool_size_count: u32::default(), + p_pool_sizes: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for DescriptorPoolCreateInfo { + const STRUCTURE_TYPE: StructureType = StructureType::DESCRIPTOR_POOL_CREATE_INFO; +} +impl DescriptorPoolCreateInfo { + pub fn builder<'a>() -> DescriptorPoolCreateInfoBuilder<'a> { + DescriptorPoolCreateInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DescriptorPoolCreateInfoBuilder<'a> { + inner: DescriptorPoolCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsDescriptorPoolCreateInfo {} +impl<'a> ::std::ops::Deref for DescriptorPoolCreateInfoBuilder<'a> { + type Target = DescriptorPoolCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DescriptorPoolCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DescriptorPoolCreateInfoBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: DescriptorPoolCreateFlags) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn max_sets(mut self, max_sets: u32) -> Self { + self.inner.max_sets = max_sets; + self + } + #[inline] + pub fn pool_sizes(mut self, pool_sizes: &'a [DescriptorPoolSize]) -> Self { + self.inner.pool_size_count = pool_sizes.len() as _; + self.inner.p_pool_sizes = pool_sizes.as_ptr(); + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DescriptorPoolCreateInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DescriptorSetAllocateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub descriptor_pool: DescriptorPool, + pub descriptor_set_count: u32, + pub p_set_layouts: *const DescriptorSetLayout, +} +impl ::std::default::Default for DescriptorSetAllocateInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + descriptor_pool: DescriptorPool::default(), + descriptor_set_count: u32::default(), + p_set_layouts: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for DescriptorSetAllocateInfo { + const STRUCTURE_TYPE: StructureType = StructureType::DESCRIPTOR_SET_ALLOCATE_INFO; +} +impl DescriptorSetAllocateInfo { + pub fn builder<'a>() -> DescriptorSetAllocateInfoBuilder<'a> { + DescriptorSetAllocateInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DescriptorSetAllocateInfoBuilder<'a> { + inner: DescriptorSetAllocateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsDescriptorSetAllocateInfo {} +impl<'a> ::std::ops::Deref for DescriptorSetAllocateInfoBuilder<'a> { + type Target = DescriptorSetAllocateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DescriptorSetAllocateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DescriptorSetAllocateInfoBuilder<'a> { + #[inline] + pub fn descriptor_pool(mut self, descriptor_pool: DescriptorPool) -> Self { + self.inner.descriptor_pool = descriptor_pool; + self + } + #[inline] + pub fn set_layouts(mut self, set_layouts: &'a [DescriptorSetLayout]) -> Self { + self.inner.descriptor_set_count = set_layouts.len() as _; + self.inner.p_set_layouts = set_layouts.as_ptr(); + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DescriptorSetAllocateInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct SpecializationMapEntry { + pub constant_id: u32, + pub offset: u32, + pub size: usize, +} +impl SpecializationMapEntry { + pub fn builder<'a>() -> SpecializationMapEntryBuilder<'a> { + SpecializationMapEntryBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SpecializationMapEntryBuilder<'a> { + inner: SpecializationMapEntry, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for SpecializationMapEntryBuilder<'a> { + type Target = SpecializationMapEntry; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SpecializationMapEntryBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SpecializationMapEntryBuilder<'a> { + #[inline] + pub fn constant_id(mut self, constant_id: u32) -> Self { + self.inner.constant_id = constant_id; + self + } + #[inline] + pub fn offset(mut self, offset: u32) -> Self { + self.inner.offset = offset; + self + } + #[inline] + pub fn size(mut self, size: usize) -> Self { + self.inner.size = size; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SpecializationMapEntry { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SpecializationInfo { + pub map_entry_count: u32, + pub p_map_entries: *const SpecializationMapEntry, + pub data_size: usize, + pub p_data: *const c_void, +} +impl ::std::default::Default for SpecializationInfo { + #[inline] + fn default() -> Self { + Self { + map_entry_count: u32::default(), + p_map_entries: ::std::ptr::null(), + data_size: usize::default(), + p_data: ::std::ptr::null(), + } + } +} +impl SpecializationInfo { + pub fn builder<'a>() -> SpecializationInfoBuilder<'a> { + SpecializationInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SpecializationInfoBuilder<'a> { + inner: SpecializationInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for SpecializationInfoBuilder<'a> { + type Target = SpecializationInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SpecializationInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SpecializationInfoBuilder<'a> { + #[inline] + pub fn map_entries(mut self, map_entries: &'a [SpecializationMapEntry]) -> Self { + self.inner.map_entry_count = map_entries.len() as _; + self.inner.p_map_entries = map_entries.as_ptr(); + self + } + #[inline] + pub fn data(mut self, data: &'a [u8]) -> Self { + self.inner.data_size = data.len(); + self.inner.p_data = data.as_ptr().cast(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SpecializationInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PipelineShaderStageCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: PipelineShaderStageCreateFlags, + pub stage: ShaderStageFlags, + pub module: ShaderModule, + pub p_name: *const c_char, + pub p_specialization_info: *const SpecializationInfo, +} +impl ::std::default::Default for PipelineShaderStageCreateInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: PipelineShaderStageCreateFlags::default(), + stage: ShaderStageFlags::default(), + module: ShaderModule::default(), + p_name: ::std::ptr::null(), + p_specialization_info: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for PipelineShaderStageCreateInfo { + const STRUCTURE_TYPE: StructureType = StructureType::PIPELINE_SHADER_STAGE_CREATE_INFO; +} +impl PipelineShaderStageCreateInfo { + pub fn builder<'a>() -> PipelineShaderStageCreateInfoBuilder<'a> { + PipelineShaderStageCreateInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PipelineShaderStageCreateInfoBuilder<'a> { + inner: PipelineShaderStageCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsPipelineShaderStageCreateInfo {} +impl<'a> ::std::ops::Deref for PipelineShaderStageCreateInfoBuilder<'a> { + type Target = PipelineShaderStageCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PipelineShaderStageCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PipelineShaderStageCreateInfoBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: PipelineShaderStageCreateFlags) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn stage(mut self, stage: ShaderStageFlags) -> Self { + self.inner.stage = stage; + self + } + #[inline] + pub fn module(mut self, module: ShaderModule) -> Self { + self.inner.module = module; + self + } + #[inline] + pub fn name(mut self, name: &'a ::std::ffi::CStr) -> Self { + self.inner.p_name = name.as_ptr(); + self + } + #[inline] + pub fn specialization_info(mut self, specialization_info: &'a SpecializationInfo) -> Self { + self.inner.p_specialization_info = specialization_info; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PipelineShaderStageCreateInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ComputePipelineCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: PipelineCreateFlags, + pub stage: PipelineShaderStageCreateInfo, + pub layout: PipelineLayout, + pub base_pipeline_handle: Pipeline, + pub base_pipeline_index: i32, +} +impl ::std::default::Default for ComputePipelineCreateInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: PipelineCreateFlags::default(), + stage: PipelineShaderStageCreateInfo::default(), + layout: PipelineLayout::default(), + base_pipeline_handle: Pipeline::default(), + base_pipeline_index: i32::default(), + } + } +} +unsafe impl TaggedStructure for ComputePipelineCreateInfo { + const STRUCTURE_TYPE: StructureType = StructureType::COMPUTE_PIPELINE_CREATE_INFO; +} +impl ComputePipelineCreateInfo { + pub fn builder<'a>() -> ComputePipelineCreateInfoBuilder<'a> { + ComputePipelineCreateInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ComputePipelineCreateInfoBuilder<'a> { + inner: ComputePipelineCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsComputePipelineCreateInfo {} +impl<'a> ::std::ops::Deref for ComputePipelineCreateInfoBuilder<'a> { + type Target = ComputePipelineCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ComputePipelineCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ComputePipelineCreateInfoBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: PipelineCreateFlags) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn stage(mut self, stage: PipelineShaderStageCreateInfo) -> Self { + self.inner.stage = stage; + self + } + #[inline] + pub fn layout(mut self, layout: PipelineLayout) -> Self { + self.inner.layout = layout; + self + } + #[inline] + pub fn base_pipeline_handle(mut self, base_pipeline_handle: Pipeline) -> Self { + self.inner.base_pipeline_handle = base_pipeline_handle; + self + } + #[inline] + pub fn base_pipeline_index(mut self, base_pipeline_index: i32) -> Self { + self.inner.base_pipeline_index = base_pipeline_index; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ComputePipelineCreateInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct VertexInputBindingDescription { + pub binding: u32, + pub stride: u32, + pub input_rate: VertexInputRate, +} +impl VertexInputBindingDescription { + pub fn builder<'a>() -> VertexInputBindingDescriptionBuilder<'a> { + VertexInputBindingDescriptionBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VertexInputBindingDescriptionBuilder<'a> { + inner: VertexInputBindingDescription, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for VertexInputBindingDescriptionBuilder<'a> { + type Target = VertexInputBindingDescription; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VertexInputBindingDescriptionBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VertexInputBindingDescriptionBuilder<'a> { + #[inline] + pub fn binding(mut self, binding: u32) -> Self { + self.inner.binding = binding; + self + } + #[inline] + pub fn stride(mut self, stride: u32) -> Self { + self.inner.stride = stride; + self + } + #[inline] + pub fn input_rate(mut self, input_rate: VertexInputRate) -> Self { + self.inner.input_rate = input_rate; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VertexInputBindingDescription { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct VertexInputAttributeDescription { + pub location: u32, + pub binding: u32, + pub format: Format, + pub offset: u32, +} +impl VertexInputAttributeDescription { + pub fn builder<'a>() -> VertexInputAttributeDescriptionBuilder<'a> { + VertexInputAttributeDescriptionBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VertexInputAttributeDescriptionBuilder<'a> { + inner: VertexInputAttributeDescription, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for VertexInputAttributeDescriptionBuilder<'a> { + type Target = VertexInputAttributeDescription; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VertexInputAttributeDescriptionBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VertexInputAttributeDescriptionBuilder<'a> { + #[inline] + pub fn location(mut self, location: u32) -> Self { + self.inner.location = location; + self + } + #[inline] + pub fn binding(mut self, binding: u32) -> Self { + self.inner.binding = binding; + self + } + #[inline] + pub fn format(mut self, format: Format) -> Self { + self.inner.format = format; + self + } + #[inline] + pub fn offset(mut self, offset: u32) -> Self { + self.inner.offset = offset; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VertexInputAttributeDescription { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PipelineVertexInputStateCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: PipelineVertexInputStateCreateFlags, + pub vertex_binding_description_count: u32, + pub p_vertex_binding_descriptions: *const VertexInputBindingDescription, + pub vertex_attribute_description_count: u32, + pub p_vertex_attribute_descriptions: *const VertexInputAttributeDescription, +} +impl ::std::default::Default for PipelineVertexInputStateCreateInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: PipelineVertexInputStateCreateFlags::default(), + vertex_binding_description_count: u32::default(), + p_vertex_binding_descriptions: ::std::ptr::null(), + vertex_attribute_description_count: u32::default(), + p_vertex_attribute_descriptions: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for PipelineVertexInputStateCreateInfo { + const STRUCTURE_TYPE: StructureType = StructureType::PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO; +} +impl PipelineVertexInputStateCreateInfo { + pub fn builder<'a>() -> PipelineVertexInputStateCreateInfoBuilder<'a> { + PipelineVertexInputStateCreateInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PipelineVertexInputStateCreateInfoBuilder<'a> { + inner: PipelineVertexInputStateCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsPipelineVertexInputStateCreateInfo {} +impl<'a> ::std::ops::Deref for PipelineVertexInputStateCreateInfoBuilder<'a> { + type Target = PipelineVertexInputStateCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PipelineVertexInputStateCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PipelineVertexInputStateCreateInfoBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: PipelineVertexInputStateCreateFlags) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn vertex_binding_descriptions( + mut self, + vertex_binding_descriptions: &'a [VertexInputBindingDescription], + ) -> Self { + self.inner.vertex_binding_description_count = vertex_binding_descriptions.len() as _; + self.inner.p_vertex_binding_descriptions = vertex_binding_descriptions.as_ptr(); + self + } + #[inline] + pub fn vertex_attribute_descriptions( + mut self, + vertex_attribute_descriptions: &'a [VertexInputAttributeDescription], + ) -> Self { + self.inner.vertex_attribute_description_count = vertex_attribute_descriptions.len() as _; + self.inner.p_vertex_attribute_descriptions = vertex_attribute_descriptions.as_ptr(); + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next( + mut self, + next: &'a mut T, + ) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PipelineVertexInputStateCreateInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PipelineInputAssemblyStateCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: PipelineInputAssemblyStateCreateFlags, + pub topology: PrimitiveTopology, + pub primitive_restart_enable: Bool32, +} +impl ::std::default::Default for PipelineInputAssemblyStateCreateInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: PipelineInputAssemblyStateCreateFlags::default(), + topology: PrimitiveTopology::default(), + primitive_restart_enable: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PipelineInputAssemblyStateCreateInfo { + const STRUCTURE_TYPE: StructureType = StructureType::PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO; +} +impl PipelineInputAssemblyStateCreateInfo { + pub fn builder<'a>() -> PipelineInputAssemblyStateCreateInfoBuilder<'a> { + PipelineInputAssemblyStateCreateInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PipelineInputAssemblyStateCreateInfoBuilder<'a> { + inner: PipelineInputAssemblyStateCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PipelineInputAssemblyStateCreateInfoBuilder<'a> { + type Target = PipelineInputAssemblyStateCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PipelineInputAssemblyStateCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PipelineInputAssemblyStateCreateInfoBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: PipelineInputAssemblyStateCreateFlags) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn topology(mut self, topology: PrimitiveTopology) -> Self { + self.inner.topology = topology; + self + } + #[inline] + pub fn primitive_restart_enable(mut self, primitive_restart_enable: bool) -> Self { + self.inner.primitive_restart_enable = primitive_restart_enable.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PipelineInputAssemblyStateCreateInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PipelineTessellationStateCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: PipelineTessellationStateCreateFlags, + pub patch_control_points: u32, +} +impl ::std::default::Default for PipelineTessellationStateCreateInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: PipelineTessellationStateCreateFlags::default(), + patch_control_points: u32::default(), + } + } +} +unsafe impl TaggedStructure for PipelineTessellationStateCreateInfo { + const STRUCTURE_TYPE: StructureType = StructureType::PIPELINE_TESSELLATION_STATE_CREATE_INFO; +} +impl PipelineTessellationStateCreateInfo { + pub fn builder<'a>() -> PipelineTessellationStateCreateInfoBuilder<'a> { + PipelineTessellationStateCreateInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PipelineTessellationStateCreateInfoBuilder<'a> { + inner: PipelineTessellationStateCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsPipelineTessellationStateCreateInfo {} +impl<'a> ::std::ops::Deref for PipelineTessellationStateCreateInfoBuilder<'a> { + type Target = PipelineTessellationStateCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PipelineTessellationStateCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PipelineTessellationStateCreateInfoBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: PipelineTessellationStateCreateFlags) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn patch_control_points(mut self, patch_control_points: u32) -> Self { + self.inner.patch_control_points = patch_control_points; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next( + mut self, + next: &'a mut T, + ) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PipelineTessellationStateCreateInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PipelineViewportStateCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: PipelineViewportStateCreateFlags, + pub viewport_count: u32, + pub p_viewports: *const Viewport, + pub scissor_count: u32, + pub p_scissors: *const Rect2D, +} +impl ::std::default::Default for PipelineViewportStateCreateInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: PipelineViewportStateCreateFlags::default(), + viewport_count: u32::default(), + p_viewports: ::std::ptr::null(), + scissor_count: u32::default(), + p_scissors: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for PipelineViewportStateCreateInfo { + const STRUCTURE_TYPE: StructureType = StructureType::PIPELINE_VIEWPORT_STATE_CREATE_INFO; +} +impl PipelineViewportStateCreateInfo { + pub fn builder<'a>() -> PipelineViewportStateCreateInfoBuilder<'a> { + PipelineViewportStateCreateInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PipelineViewportStateCreateInfoBuilder<'a> { + inner: PipelineViewportStateCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsPipelineViewportStateCreateInfo {} +impl<'a> ::std::ops::Deref for PipelineViewportStateCreateInfoBuilder<'a> { + type Target = PipelineViewportStateCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PipelineViewportStateCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PipelineViewportStateCreateInfoBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: PipelineViewportStateCreateFlags) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn viewport_count(mut self, viewport_count: u32) -> Self { + self.inner.viewport_count = viewport_count; + self + } + #[inline] + pub fn viewports(mut self, viewports: &'a [Viewport]) -> Self { + self.inner.viewport_count = viewports.len() as _; + self.inner.p_viewports = viewports.as_ptr(); + self + } + #[inline] + pub fn scissor_count(mut self, scissor_count: u32) -> Self { + self.inner.scissor_count = scissor_count; + self + } + #[inline] + pub fn scissors(mut self, scissors: &'a [Rect2D]) -> Self { + self.inner.scissor_count = scissors.len() as _; + self.inner.p_scissors = scissors.as_ptr(); + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PipelineViewportStateCreateInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PipelineRasterizationStateCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: PipelineRasterizationStateCreateFlags, + pub depth_clamp_enable: Bool32, + pub rasterizer_discard_enable: Bool32, + pub polygon_mode: PolygonMode, + pub cull_mode: CullModeFlags, + pub front_face: FrontFace, + pub depth_bias_enable: Bool32, + pub depth_bias_constant_factor: f32, + pub depth_bias_clamp: f32, + pub depth_bias_slope_factor: f32, + pub line_width: f32, +} +impl ::std::default::Default for PipelineRasterizationStateCreateInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: PipelineRasterizationStateCreateFlags::default(), + depth_clamp_enable: Bool32::default(), + rasterizer_discard_enable: Bool32::default(), + polygon_mode: PolygonMode::default(), + cull_mode: CullModeFlags::default(), + front_face: FrontFace::default(), + depth_bias_enable: Bool32::default(), + depth_bias_constant_factor: f32::default(), + depth_bias_clamp: f32::default(), + depth_bias_slope_factor: f32::default(), + line_width: f32::default(), + } + } +} +unsafe impl TaggedStructure for PipelineRasterizationStateCreateInfo { + const STRUCTURE_TYPE: StructureType = StructureType::PIPELINE_RASTERIZATION_STATE_CREATE_INFO; +} +impl PipelineRasterizationStateCreateInfo { + pub fn builder<'a>() -> PipelineRasterizationStateCreateInfoBuilder<'a> { + PipelineRasterizationStateCreateInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PipelineRasterizationStateCreateInfoBuilder<'a> { + inner: PipelineRasterizationStateCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsPipelineRasterizationStateCreateInfo {} +impl<'a> ::std::ops::Deref for PipelineRasterizationStateCreateInfoBuilder<'a> { + type Target = PipelineRasterizationStateCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PipelineRasterizationStateCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PipelineRasterizationStateCreateInfoBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: PipelineRasterizationStateCreateFlags) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn depth_clamp_enable(mut self, depth_clamp_enable: bool) -> Self { + self.inner.depth_clamp_enable = depth_clamp_enable.into(); + self + } + #[inline] + pub fn rasterizer_discard_enable(mut self, rasterizer_discard_enable: bool) -> Self { + self.inner.rasterizer_discard_enable = rasterizer_discard_enable.into(); + self + } + #[inline] + pub fn polygon_mode(mut self, polygon_mode: PolygonMode) -> Self { + self.inner.polygon_mode = polygon_mode; + self + } + #[inline] + pub fn cull_mode(mut self, cull_mode: CullModeFlags) -> Self { + self.inner.cull_mode = cull_mode; + self + } + #[inline] + pub fn front_face(mut self, front_face: FrontFace) -> Self { + self.inner.front_face = front_face; + self + } + #[inline] + pub fn depth_bias_enable(mut self, depth_bias_enable: bool) -> Self { + self.inner.depth_bias_enable = depth_bias_enable.into(); + self + } + #[inline] + pub fn depth_bias_constant_factor(mut self, depth_bias_constant_factor: f32) -> Self { + self.inner.depth_bias_constant_factor = depth_bias_constant_factor; + self + } + #[inline] + pub fn depth_bias_clamp(mut self, depth_bias_clamp: f32) -> Self { + self.inner.depth_bias_clamp = depth_bias_clamp; + self + } + #[inline] + pub fn depth_bias_slope_factor(mut self, depth_bias_slope_factor: f32) -> Self { + self.inner.depth_bias_slope_factor = depth_bias_slope_factor; + self + } + #[inline] + pub fn line_width(mut self, line_width: f32) -> Self { + self.inner.line_width = line_width; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next( + mut self, + next: &'a mut T, + ) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PipelineRasterizationStateCreateInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PipelineMultisampleStateCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: PipelineMultisampleStateCreateFlags, + pub rasterization_samples: SampleCountFlags, + pub sample_shading_enable: Bool32, + pub min_sample_shading: f32, + pub p_sample_mask: *const SampleMask, + pub alpha_to_coverage_enable: Bool32, + pub alpha_to_one_enable: Bool32, +} +impl ::std::default::Default for PipelineMultisampleStateCreateInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: PipelineMultisampleStateCreateFlags::default(), + rasterization_samples: SampleCountFlags::default(), + sample_shading_enable: Bool32::default(), + min_sample_shading: f32::default(), + p_sample_mask: ::std::ptr::null(), + alpha_to_coverage_enable: Bool32::default(), + alpha_to_one_enable: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PipelineMultisampleStateCreateInfo { + const STRUCTURE_TYPE: StructureType = StructureType::PIPELINE_MULTISAMPLE_STATE_CREATE_INFO; +} +impl PipelineMultisampleStateCreateInfo { + pub fn builder<'a>() -> PipelineMultisampleStateCreateInfoBuilder<'a> { + PipelineMultisampleStateCreateInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PipelineMultisampleStateCreateInfoBuilder<'a> { + inner: PipelineMultisampleStateCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsPipelineMultisampleStateCreateInfo {} +impl<'a> ::std::ops::Deref for PipelineMultisampleStateCreateInfoBuilder<'a> { + type Target = PipelineMultisampleStateCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PipelineMultisampleStateCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PipelineMultisampleStateCreateInfoBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: PipelineMultisampleStateCreateFlags) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn rasterization_samples(mut self, rasterization_samples: SampleCountFlags) -> Self { + self.inner.rasterization_samples = rasterization_samples; + self + } + #[inline] + pub fn sample_shading_enable(mut self, sample_shading_enable: bool) -> Self { + self.inner.sample_shading_enable = sample_shading_enable.into(); + self + } + #[inline] + pub fn min_sample_shading(mut self, min_sample_shading: f32) -> Self { + self.inner.min_sample_shading = min_sample_shading; + self + } + #[doc = r" Sets `p_sample_mask` to `null` if the slice is empty. The mask will"] + #[doc = r" be treated as if it has all bits set to `1`."] + #[doc = r""] + #[doc = r" See "] + #[doc = r" for more details."] + #[inline] + pub fn sample_mask(mut self, sample_mask: &'a [SampleMask]) -> Self { + self.inner.p_sample_mask = if sample_mask.is_empty() { + std::ptr::null() + } else { + sample_mask.as_ptr() + }; + self + } + #[inline] + pub fn alpha_to_coverage_enable(mut self, alpha_to_coverage_enable: bool) -> Self { + self.inner.alpha_to_coverage_enable = alpha_to_coverage_enable.into(); + self + } + #[inline] + pub fn alpha_to_one_enable(mut self, alpha_to_one_enable: bool) -> Self { + self.inner.alpha_to_one_enable = alpha_to_one_enable.into(); + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next( + mut self, + next: &'a mut T, + ) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PipelineMultisampleStateCreateInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct PipelineColorBlendAttachmentState { + pub blend_enable: Bool32, + pub src_color_blend_factor: BlendFactor, + pub dst_color_blend_factor: BlendFactor, + pub color_blend_op: BlendOp, + pub src_alpha_blend_factor: BlendFactor, + pub dst_alpha_blend_factor: BlendFactor, + pub alpha_blend_op: BlendOp, + pub color_write_mask: ColorComponentFlags, +} +impl PipelineColorBlendAttachmentState { + pub fn builder<'a>() -> PipelineColorBlendAttachmentStateBuilder<'a> { + PipelineColorBlendAttachmentStateBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PipelineColorBlendAttachmentStateBuilder<'a> { + inner: PipelineColorBlendAttachmentState, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PipelineColorBlendAttachmentStateBuilder<'a> { + type Target = PipelineColorBlendAttachmentState; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PipelineColorBlendAttachmentStateBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PipelineColorBlendAttachmentStateBuilder<'a> { + #[inline] + pub fn blend_enable(mut self, blend_enable: bool) -> Self { + self.inner.blend_enable = blend_enable.into(); + self + } + #[inline] + pub fn src_color_blend_factor(mut self, src_color_blend_factor: BlendFactor) -> Self { + self.inner.src_color_blend_factor = src_color_blend_factor; + self + } + #[inline] + pub fn dst_color_blend_factor(mut self, dst_color_blend_factor: BlendFactor) -> Self { + self.inner.dst_color_blend_factor = dst_color_blend_factor; + self + } + #[inline] + pub fn color_blend_op(mut self, color_blend_op: BlendOp) -> Self { + self.inner.color_blend_op = color_blend_op; + self + } + #[inline] + pub fn src_alpha_blend_factor(mut self, src_alpha_blend_factor: BlendFactor) -> Self { + self.inner.src_alpha_blend_factor = src_alpha_blend_factor; + self + } + #[inline] + pub fn dst_alpha_blend_factor(mut self, dst_alpha_blend_factor: BlendFactor) -> Self { + self.inner.dst_alpha_blend_factor = dst_alpha_blend_factor; + self + } + #[inline] + pub fn alpha_blend_op(mut self, alpha_blend_op: BlendOp) -> Self { + self.inner.alpha_blend_op = alpha_blend_op; + self + } + #[inline] + pub fn color_write_mask(mut self, color_write_mask: ColorComponentFlags) -> Self { + self.inner.color_write_mask = color_write_mask; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PipelineColorBlendAttachmentState { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PipelineColorBlendStateCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: PipelineColorBlendStateCreateFlags, + pub logic_op_enable: Bool32, + pub logic_op: LogicOp, + pub attachment_count: u32, + pub p_attachments: *const PipelineColorBlendAttachmentState, + pub blend_constants: [f32; 4], +} +impl ::std::default::Default for PipelineColorBlendStateCreateInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: PipelineColorBlendStateCreateFlags::default(), + logic_op_enable: Bool32::default(), + logic_op: LogicOp::default(), + attachment_count: u32::default(), + p_attachments: ::std::ptr::null(), + blend_constants: unsafe { ::std::mem::zeroed() }, + } + } +} +unsafe impl TaggedStructure for PipelineColorBlendStateCreateInfo { + const STRUCTURE_TYPE: StructureType = StructureType::PIPELINE_COLOR_BLEND_STATE_CREATE_INFO; +} +impl PipelineColorBlendStateCreateInfo { + pub fn builder<'a>() -> PipelineColorBlendStateCreateInfoBuilder<'a> { + PipelineColorBlendStateCreateInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PipelineColorBlendStateCreateInfoBuilder<'a> { + inner: PipelineColorBlendStateCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsPipelineColorBlendStateCreateInfo {} +impl<'a> ::std::ops::Deref for PipelineColorBlendStateCreateInfoBuilder<'a> { + type Target = PipelineColorBlendStateCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PipelineColorBlendStateCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PipelineColorBlendStateCreateInfoBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: PipelineColorBlendStateCreateFlags) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn logic_op_enable(mut self, logic_op_enable: bool) -> Self { + self.inner.logic_op_enable = logic_op_enable.into(); + self + } + #[inline] + pub fn logic_op(mut self, logic_op: LogicOp) -> Self { + self.inner.logic_op = logic_op; + self + } + #[inline] + pub fn attachments(mut self, attachments: &'a [PipelineColorBlendAttachmentState]) -> Self { + self.inner.attachment_count = attachments.len() as _; + self.inner.p_attachments = attachments.as_ptr(); + self + } + #[inline] + pub fn blend_constants(mut self, blend_constants: [f32; 4]) -> Self { + self.inner.blend_constants = blend_constants; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next( + mut self, + next: &'a mut T, + ) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PipelineColorBlendStateCreateInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PipelineDynamicStateCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: PipelineDynamicStateCreateFlags, + pub dynamic_state_count: u32, + pub p_dynamic_states: *const DynamicState, +} +impl ::std::default::Default for PipelineDynamicStateCreateInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: PipelineDynamicStateCreateFlags::default(), + dynamic_state_count: u32::default(), + p_dynamic_states: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for PipelineDynamicStateCreateInfo { + const STRUCTURE_TYPE: StructureType = StructureType::PIPELINE_DYNAMIC_STATE_CREATE_INFO; +} +impl PipelineDynamicStateCreateInfo { + pub fn builder<'a>() -> PipelineDynamicStateCreateInfoBuilder<'a> { + PipelineDynamicStateCreateInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PipelineDynamicStateCreateInfoBuilder<'a> { + inner: PipelineDynamicStateCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PipelineDynamicStateCreateInfoBuilder<'a> { + type Target = PipelineDynamicStateCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PipelineDynamicStateCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PipelineDynamicStateCreateInfoBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: PipelineDynamicStateCreateFlags) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn dynamic_states(mut self, dynamic_states: &'a [DynamicState]) -> Self { + self.inner.dynamic_state_count = dynamic_states.len() as _; + self.inner.p_dynamic_states = dynamic_states.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PipelineDynamicStateCreateInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct StencilOpState { + pub fail_op: StencilOp, + pub pass_op: StencilOp, + pub depth_fail_op: StencilOp, + pub compare_op: CompareOp, + pub compare_mask: u32, + pub write_mask: u32, + pub reference: u32, +} +impl StencilOpState { + pub fn builder<'a>() -> StencilOpStateBuilder<'a> { + StencilOpStateBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct StencilOpStateBuilder<'a> { + inner: StencilOpState, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for StencilOpStateBuilder<'a> { + type Target = StencilOpState; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for StencilOpStateBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> StencilOpStateBuilder<'a> { + #[inline] + pub fn fail_op(mut self, fail_op: StencilOp) -> Self { + self.inner.fail_op = fail_op; + self + } + #[inline] + pub fn pass_op(mut self, pass_op: StencilOp) -> Self { + self.inner.pass_op = pass_op; + self + } + #[inline] + pub fn depth_fail_op(mut self, depth_fail_op: StencilOp) -> Self { + self.inner.depth_fail_op = depth_fail_op; + self + } + #[inline] + pub fn compare_op(mut self, compare_op: CompareOp) -> Self { + self.inner.compare_op = compare_op; + self + } + #[inline] + pub fn compare_mask(mut self, compare_mask: u32) -> Self { + self.inner.compare_mask = compare_mask; + self + } + #[inline] + pub fn write_mask(mut self, write_mask: u32) -> Self { + self.inner.write_mask = write_mask; + self + } + #[inline] + pub fn reference(mut self, reference: u32) -> Self { + self.inner.reference = reference; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> StencilOpState { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PipelineDepthStencilStateCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: PipelineDepthStencilStateCreateFlags, + pub depth_test_enable: Bool32, + pub depth_write_enable: Bool32, + pub depth_compare_op: CompareOp, + pub depth_bounds_test_enable: Bool32, + pub stencil_test_enable: Bool32, + pub front: StencilOpState, + pub back: StencilOpState, + pub min_depth_bounds: f32, + pub max_depth_bounds: f32, +} +impl ::std::default::Default for PipelineDepthStencilStateCreateInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: PipelineDepthStencilStateCreateFlags::default(), + depth_test_enable: Bool32::default(), + depth_write_enable: Bool32::default(), + depth_compare_op: CompareOp::default(), + depth_bounds_test_enable: Bool32::default(), + stencil_test_enable: Bool32::default(), + front: StencilOpState::default(), + back: StencilOpState::default(), + min_depth_bounds: f32::default(), + max_depth_bounds: f32::default(), + } + } +} +unsafe impl TaggedStructure for PipelineDepthStencilStateCreateInfo { + const STRUCTURE_TYPE: StructureType = StructureType::PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO; +} +impl PipelineDepthStencilStateCreateInfo { + pub fn builder<'a>() -> PipelineDepthStencilStateCreateInfoBuilder<'a> { + PipelineDepthStencilStateCreateInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PipelineDepthStencilStateCreateInfoBuilder<'a> { + inner: PipelineDepthStencilStateCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PipelineDepthStencilStateCreateInfoBuilder<'a> { + type Target = PipelineDepthStencilStateCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PipelineDepthStencilStateCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PipelineDepthStencilStateCreateInfoBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: PipelineDepthStencilStateCreateFlags) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn depth_test_enable(mut self, depth_test_enable: bool) -> Self { + self.inner.depth_test_enable = depth_test_enable.into(); + self + } + #[inline] + pub fn depth_write_enable(mut self, depth_write_enable: bool) -> Self { + self.inner.depth_write_enable = depth_write_enable.into(); + self + } + #[inline] + pub fn depth_compare_op(mut self, depth_compare_op: CompareOp) -> Self { + self.inner.depth_compare_op = depth_compare_op; + self + } + #[inline] + pub fn depth_bounds_test_enable(mut self, depth_bounds_test_enable: bool) -> Self { + self.inner.depth_bounds_test_enable = depth_bounds_test_enable.into(); + self + } + #[inline] + pub fn stencil_test_enable(mut self, stencil_test_enable: bool) -> Self { + self.inner.stencil_test_enable = stencil_test_enable.into(); + self + } + #[inline] + pub fn front(mut self, front: StencilOpState) -> Self { + self.inner.front = front; + self + } + #[inline] + pub fn back(mut self, back: StencilOpState) -> Self { + self.inner.back = back; + self + } + #[inline] + pub fn min_depth_bounds(mut self, min_depth_bounds: f32) -> Self { + self.inner.min_depth_bounds = min_depth_bounds; + self + } + #[inline] + pub fn max_depth_bounds(mut self, max_depth_bounds: f32) -> Self { + self.inner.max_depth_bounds = max_depth_bounds; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PipelineDepthStencilStateCreateInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct GraphicsPipelineCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: PipelineCreateFlags, + pub stage_count: u32, + pub p_stages: *const PipelineShaderStageCreateInfo, + pub p_vertex_input_state: *const PipelineVertexInputStateCreateInfo, + pub p_input_assembly_state: *const PipelineInputAssemblyStateCreateInfo, + pub p_tessellation_state: *const PipelineTessellationStateCreateInfo, + pub p_viewport_state: *const PipelineViewportStateCreateInfo, + pub p_rasterization_state: *const PipelineRasterizationStateCreateInfo, + pub p_multisample_state: *const PipelineMultisampleStateCreateInfo, + pub p_depth_stencil_state: *const PipelineDepthStencilStateCreateInfo, + pub p_color_blend_state: *const PipelineColorBlendStateCreateInfo, + pub p_dynamic_state: *const PipelineDynamicStateCreateInfo, + pub layout: PipelineLayout, + pub render_pass: RenderPass, + pub subpass: u32, + pub base_pipeline_handle: Pipeline, + pub base_pipeline_index: i32, +} +impl ::std::default::Default for GraphicsPipelineCreateInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: PipelineCreateFlags::default(), + stage_count: u32::default(), + p_stages: ::std::ptr::null(), + p_vertex_input_state: ::std::ptr::null(), + p_input_assembly_state: ::std::ptr::null(), + p_tessellation_state: ::std::ptr::null(), + p_viewport_state: ::std::ptr::null(), + p_rasterization_state: ::std::ptr::null(), + p_multisample_state: ::std::ptr::null(), + p_depth_stencil_state: ::std::ptr::null(), + p_color_blend_state: ::std::ptr::null(), + p_dynamic_state: ::std::ptr::null(), + layout: PipelineLayout::default(), + render_pass: RenderPass::default(), + subpass: u32::default(), + base_pipeline_handle: Pipeline::default(), + base_pipeline_index: i32::default(), + } + } +} +unsafe impl TaggedStructure for GraphicsPipelineCreateInfo { + const STRUCTURE_TYPE: StructureType = StructureType::GRAPHICS_PIPELINE_CREATE_INFO; +} +impl GraphicsPipelineCreateInfo { + pub fn builder<'a>() -> GraphicsPipelineCreateInfoBuilder<'a> { + GraphicsPipelineCreateInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct GraphicsPipelineCreateInfoBuilder<'a> { + inner: GraphicsPipelineCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsGraphicsPipelineCreateInfo {} +impl<'a> ::std::ops::Deref for GraphicsPipelineCreateInfoBuilder<'a> { + type Target = GraphicsPipelineCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for GraphicsPipelineCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> GraphicsPipelineCreateInfoBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: PipelineCreateFlags) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn stages(mut self, stages: &'a [PipelineShaderStageCreateInfo]) -> Self { + self.inner.stage_count = stages.len() as _; + self.inner.p_stages = stages.as_ptr(); + self + } + #[inline] + pub fn vertex_input_state( + mut self, + vertex_input_state: &'a PipelineVertexInputStateCreateInfo, + ) -> Self { + self.inner.p_vertex_input_state = vertex_input_state; + self + } + #[inline] + pub fn input_assembly_state( + mut self, + input_assembly_state: &'a PipelineInputAssemblyStateCreateInfo, + ) -> Self { + self.inner.p_input_assembly_state = input_assembly_state; + self + } + #[inline] + pub fn tessellation_state( + mut self, + tessellation_state: &'a PipelineTessellationStateCreateInfo, + ) -> Self { + self.inner.p_tessellation_state = tessellation_state; + self + } + #[inline] + pub fn viewport_state(mut self, viewport_state: &'a PipelineViewportStateCreateInfo) -> Self { + self.inner.p_viewport_state = viewport_state; + self + } + #[inline] + pub fn rasterization_state( + mut self, + rasterization_state: &'a PipelineRasterizationStateCreateInfo, + ) -> Self { + self.inner.p_rasterization_state = rasterization_state; + self + } + #[inline] + pub fn multisample_state( + mut self, + multisample_state: &'a PipelineMultisampleStateCreateInfo, + ) -> Self { + self.inner.p_multisample_state = multisample_state; + self + } + #[inline] + pub fn depth_stencil_state( + mut self, + depth_stencil_state: &'a PipelineDepthStencilStateCreateInfo, + ) -> Self { + self.inner.p_depth_stencil_state = depth_stencil_state; + self + } + #[inline] + pub fn color_blend_state( + mut self, + color_blend_state: &'a PipelineColorBlendStateCreateInfo, + ) -> Self { + self.inner.p_color_blend_state = color_blend_state; + self + } + #[inline] + pub fn dynamic_state(mut self, dynamic_state: &'a PipelineDynamicStateCreateInfo) -> Self { + self.inner.p_dynamic_state = dynamic_state; + self + } + #[inline] + pub fn layout(mut self, layout: PipelineLayout) -> Self { + self.inner.layout = layout; + self + } + #[inline] + pub fn render_pass(mut self, render_pass: RenderPass) -> Self { + self.inner.render_pass = render_pass; + self + } + #[inline] + pub fn subpass(mut self, subpass: u32) -> Self { + self.inner.subpass = subpass; + self + } + #[inline] + pub fn base_pipeline_handle(mut self, base_pipeline_handle: Pipeline) -> Self { + self.inner.base_pipeline_handle = base_pipeline_handle; + self + } + #[inline] + pub fn base_pipeline_index(mut self, base_pipeline_index: i32) -> Self { + self.inner.base_pipeline_index = base_pipeline_index; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> GraphicsPipelineCreateInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PipelineCacheCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: PipelineCacheCreateFlags, + pub initial_data_size: usize, + pub p_initial_data: *const c_void, +} +impl ::std::default::Default for PipelineCacheCreateInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: PipelineCacheCreateFlags::default(), + initial_data_size: usize::default(), + p_initial_data: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for PipelineCacheCreateInfo { + const STRUCTURE_TYPE: StructureType = StructureType::PIPELINE_CACHE_CREATE_INFO; +} +impl PipelineCacheCreateInfo { + pub fn builder<'a>() -> PipelineCacheCreateInfoBuilder<'a> { + PipelineCacheCreateInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PipelineCacheCreateInfoBuilder<'a> { + inner: PipelineCacheCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PipelineCacheCreateInfoBuilder<'a> { + type Target = PipelineCacheCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PipelineCacheCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PipelineCacheCreateInfoBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: PipelineCacheCreateFlags) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn initial_data(mut self, initial_data: &'a [u8]) -> Self { + self.inner.initial_data_size = initial_data.len(); + self.inner.p_initial_data = initial_data.as_ptr().cast(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PipelineCacheCreateInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PipelineCacheHeaderVersionOne { + pub header_size: u32, + pub header_version: PipelineCacheHeaderVersion, + pub vendor_id: u32, + pub device_id: u32, + pub pipeline_cache_uuid: [u8; UUID_SIZE], +} +impl ::std::default::Default for PipelineCacheHeaderVersionOne { + #[inline] + fn default() -> Self { + Self { + header_size: u32::default(), + header_version: PipelineCacheHeaderVersion::default(), + vendor_id: u32::default(), + device_id: u32::default(), + pipeline_cache_uuid: unsafe { ::std::mem::zeroed() }, + } + } +} +impl PipelineCacheHeaderVersionOne { + pub fn builder<'a>() -> PipelineCacheHeaderVersionOneBuilder<'a> { + PipelineCacheHeaderVersionOneBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PipelineCacheHeaderVersionOneBuilder<'a> { + inner: PipelineCacheHeaderVersionOne, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PipelineCacheHeaderVersionOneBuilder<'a> { + type Target = PipelineCacheHeaderVersionOne; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PipelineCacheHeaderVersionOneBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PipelineCacheHeaderVersionOneBuilder<'a> { + #[inline] + pub fn header_size(mut self, header_size: u32) -> Self { + self.inner.header_size = header_size; + self + } + #[inline] + pub fn header_version(mut self, header_version: PipelineCacheHeaderVersion) -> Self { + self.inner.header_version = header_version; + self + } + #[inline] + pub fn vendor_id(mut self, vendor_id: u32) -> Self { + self.inner.vendor_id = vendor_id; + self + } + #[inline] + pub fn device_id(mut self, device_id: u32) -> Self { + self.inner.device_id = device_id; + self + } + #[inline] + pub fn pipeline_cache_uuid(mut self, pipeline_cache_uuid: [u8; UUID_SIZE]) -> Self { + self.inner.pipeline_cache_uuid = pipeline_cache_uuid; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PipelineCacheHeaderVersionOne { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct PushConstantRange { + pub stage_flags: ShaderStageFlags, + pub offset: u32, + pub size: u32, +} +impl PushConstantRange { + pub fn builder<'a>() -> PushConstantRangeBuilder<'a> { + PushConstantRangeBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PushConstantRangeBuilder<'a> { + inner: PushConstantRange, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PushConstantRangeBuilder<'a> { + type Target = PushConstantRange; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PushConstantRangeBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PushConstantRangeBuilder<'a> { + #[inline] + pub fn stage_flags(mut self, stage_flags: ShaderStageFlags) -> Self { + self.inner.stage_flags = stage_flags; + self + } + #[inline] + pub fn offset(mut self, offset: u32) -> Self { + self.inner.offset = offset; + self + } + #[inline] + pub fn size(mut self, size: u32) -> Self { + self.inner.size = size; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PushConstantRange { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PipelineLayoutCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: PipelineLayoutCreateFlags, + pub set_layout_count: u32, + pub p_set_layouts: *const DescriptorSetLayout, + pub push_constant_range_count: u32, + pub p_push_constant_ranges: *const PushConstantRange, +} +impl ::std::default::Default for PipelineLayoutCreateInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: PipelineLayoutCreateFlags::default(), + set_layout_count: u32::default(), + p_set_layouts: ::std::ptr::null(), + push_constant_range_count: u32::default(), + p_push_constant_ranges: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for PipelineLayoutCreateInfo { + const STRUCTURE_TYPE: StructureType = StructureType::PIPELINE_LAYOUT_CREATE_INFO; +} +impl PipelineLayoutCreateInfo { + pub fn builder<'a>() -> PipelineLayoutCreateInfoBuilder<'a> { + PipelineLayoutCreateInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PipelineLayoutCreateInfoBuilder<'a> { + inner: PipelineLayoutCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PipelineLayoutCreateInfoBuilder<'a> { + type Target = PipelineLayoutCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PipelineLayoutCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PipelineLayoutCreateInfoBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: PipelineLayoutCreateFlags) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn set_layouts(mut self, set_layouts: &'a [DescriptorSetLayout]) -> Self { + self.inner.set_layout_count = set_layouts.len() as _; + self.inner.p_set_layouts = set_layouts.as_ptr(); + self + } + #[inline] + pub fn push_constant_ranges(mut self, push_constant_ranges: &'a [PushConstantRange]) -> Self { + self.inner.push_constant_range_count = push_constant_ranges.len() as _; + self.inner.p_push_constant_ranges = push_constant_ranges.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PipelineLayoutCreateInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SamplerCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: SamplerCreateFlags, + pub mag_filter: Filter, + pub min_filter: Filter, + pub mipmap_mode: SamplerMipmapMode, + pub address_mode_u: SamplerAddressMode, + pub address_mode_v: SamplerAddressMode, + pub address_mode_w: SamplerAddressMode, + pub mip_lod_bias: f32, + pub anisotropy_enable: Bool32, + pub max_anisotropy: f32, + pub compare_enable: Bool32, + pub compare_op: CompareOp, + pub min_lod: f32, + pub max_lod: f32, + pub border_color: BorderColor, + pub unnormalized_coordinates: Bool32, +} +impl ::std::default::Default for SamplerCreateInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: SamplerCreateFlags::default(), + mag_filter: Filter::default(), + min_filter: Filter::default(), + mipmap_mode: SamplerMipmapMode::default(), + address_mode_u: SamplerAddressMode::default(), + address_mode_v: SamplerAddressMode::default(), + address_mode_w: SamplerAddressMode::default(), + mip_lod_bias: f32::default(), + anisotropy_enable: Bool32::default(), + max_anisotropy: f32::default(), + compare_enable: Bool32::default(), + compare_op: CompareOp::default(), + min_lod: f32::default(), + max_lod: f32::default(), + border_color: BorderColor::default(), + unnormalized_coordinates: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for SamplerCreateInfo { + const STRUCTURE_TYPE: StructureType = StructureType::SAMPLER_CREATE_INFO; +} +impl SamplerCreateInfo { + pub fn builder<'a>() -> SamplerCreateInfoBuilder<'a> { + SamplerCreateInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SamplerCreateInfoBuilder<'a> { + inner: SamplerCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsSamplerCreateInfo {} +impl<'a> ::std::ops::Deref for SamplerCreateInfoBuilder<'a> { + type Target = SamplerCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SamplerCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SamplerCreateInfoBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: SamplerCreateFlags) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn mag_filter(mut self, mag_filter: Filter) -> Self { + self.inner.mag_filter = mag_filter; + self + } + #[inline] + pub fn min_filter(mut self, min_filter: Filter) -> Self { + self.inner.min_filter = min_filter; + self + } + #[inline] + pub fn mipmap_mode(mut self, mipmap_mode: SamplerMipmapMode) -> Self { + self.inner.mipmap_mode = mipmap_mode; + self + } + #[inline] + pub fn address_mode_u(mut self, address_mode_u: SamplerAddressMode) -> Self { + self.inner.address_mode_u = address_mode_u; + self + } + #[inline] + pub fn address_mode_v(mut self, address_mode_v: SamplerAddressMode) -> Self { + self.inner.address_mode_v = address_mode_v; + self + } + #[inline] + pub fn address_mode_w(mut self, address_mode_w: SamplerAddressMode) -> Self { + self.inner.address_mode_w = address_mode_w; + self + } + #[inline] + pub fn mip_lod_bias(mut self, mip_lod_bias: f32) -> Self { + self.inner.mip_lod_bias = mip_lod_bias; + self + } + #[inline] + pub fn anisotropy_enable(mut self, anisotropy_enable: bool) -> Self { + self.inner.anisotropy_enable = anisotropy_enable.into(); + self + } + #[inline] + pub fn max_anisotropy(mut self, max_anisotropy: f32) -> Self { + self.inner.max_anisotropy = max_anisotropy; + self + } + #[inline] + pub fn compare_enable(mut self, compare_enable: bool) -> Self { + self.inner.compare_enable = compare_enable.into(); + self + } + #[inline] + pub fn compare_op(mut self, compare_op: CompareOp) -> Self { + self.inner.compare_op = compare_op; + self + } + #[inline] + pub fn min_lod(mut self, min_lod: f32) -> Self { + self.inner.min_lod = min_lod; + self + } + #[inline] + pub fn max_lod(mut self, max_lod: f32) -> Self { + self.inner.max_lod = max_lod; + self + } + #[inline] + pub fn border_color(mut self, border_color: BorderColor) -> Self { + self.inner.border_color = border_color; + self + } + #[inline] + pub fn unnormalized_coordinates(mut self, unnormalized_coordinates: bool) -> Self { + self.inner.unnormalized_coordinates = unnormalized_coordinates.into(); + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SamplerCreateInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct CommandPoolCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: CommandPoolCreateFlags, + pub queue_family_index: u32, +} +impl ::std::default::Default for CommandPoolCreateInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: CommandPoolCreateFlags::default(), + queue_family_index: u32::default(), + } + } +} +unsafe impl TaggedStructure for CommandPoolCreateInfo { + const STRUCTURE_TYPE: StructureType = StructureType::COMMAND_POOL_CREATE_INFO; +} +impl CommandPoolCreateInfo { + pub fn builder<'a>() -> CommandPoolCreateInfoBuilder<'a> { + CommandPoolCreateInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct CommandPoolCreateInfoBuilder<'a> { + inner: CommandPoolCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for CommandPoolCreateInfoBuilder<'a> { + type Target = CommandPoolCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for CommandPoolCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> CommandPoolCreateInfoBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: CommandPoolCreateFlags) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn queue_family_index(mut self, queue_family_index: u32) -> Self { + self.inner.queue_family_index = queue_family_index; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> CommandPoolCreateInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct CommandBufferAllocateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub command_pool: CommandPool, + pub level: CommandBufferLevel, + pub command_buffer_count: u32, +} +impl ::std::default::Default for CommandBufferAllocateInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + command_pool: CommandPool::default(), + level: CommandBufferLevel::default(), + command_buffer_count: u32::default(), + } + } +} +unsafe impl TaggedStructure for CommandBufferAllocateInfo { + const STRUCTURE_TYPE: StructureType = StructureType::COMMAND_BUFFER_ALLOCATE_INFO; +} +impl CommandBufferAllocateInfo { + pub fn builder<'a>() -> CommandBufferAllocateInfoBuilder<'a> { + CommandBufferAllocateInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct CommandBufferAllocateInfoBuilder<'a> { + inner: CommandBufferAllocateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for CommandBufferAllocateInfoBuilder<'a> { + type Target = CommandBufferAllocateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for CommandBufferAllocateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> CommandBufferAllocateInfoBuilder<'a> { + #[inline] + pub fn command_pool(mut self, command_pool: CommandPool) -> Self { + self.inner.command_pool = command_pool; + self + } + #[inline] + pub fn level(mut self, level: CommandBufferLevel) -> Self { + self.inner.level = level; + self + } + #[inline] + pub fn command_buffer_count(mut self, command_buffer_count: u32) -> Self { + self.inner.command_buffer_count = command_buffer_count; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> CommandBufferAllocateInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct CommandBufferInheritanceInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub render_pass: RenderPass, + pub subpass: u32, + pub framebuffer: Framebuffer, + pub occlusion_query_enable: Bool32, + pub query_flags: QueryControlFlags, + pub pipeline_statistics: QueryPipelineStatisticFlags, +} +impl ::std::default::Default for CommandBufferInheritanceInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + render_pass: RenderPass::default(), + subpass: u32::default(), + framebuffer: Framebuffer::default(), + occlusion_query_enable: Bool32::default(), + query_flags: QueryControlFlags::default(), + pipeline_statistics: QueryPipelineStatisticFlags::default(), + } + } +} +unsafe impl TaggedStructure for CommandBufferInheritanceInfo { + const STRUCTURE_TYPE: StructureType = StructureType::COMMAND_BUFFER_INHERITANCE_INFO; +} +impl CommandBufferInheritanceInfo { + pub fn builder<'a>() -> CommandBufferInheritanceInfoBuilder<'a> { + CommandBufferInheritanceInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct CommandBufferInheritanceInfoBuilder<'a> { + inner: CommandBufferInheritanceInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsCommandBufferInheritanceInfo {} +impl<'a> ::std::ops::Deref for CommandBufferInheritanceInfoBuilder<'a> { + type Target = CommandBufferInheritanceInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for CommandBufferInheritanceInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> CommandBufferInheritanceInfoBuilder<'a> { + #[inline] + pub fn render_pass(mut self, render_pass: RenderPass) -> Self { + self.inner.render_pass = render_pass; + self + } + #[inline] + pub fn subpass(mut self, subpass: u32) -> Self { + self.inner.subpass = subpass; + self + } + #[inline] + pub fn framebuffer(mut self, framebuffer: Framebuffer) -> Self { + self.inner.framebuffer = framebuffer; + self + } + #[inline] + pub fn occlusion_query_enable(mut self, occlusion_query_enable: bool) -> Self { + self.inner.occlusion_query_enable = occlusion_query_enable.into(); + self + } + #[inline] + pub fn query_flags(mut self, query_flags: QueryControlFlags) -> Self { + self.inner.query_flags = query_flags; + self + } + #[inline] + pub fn pipeline_statistics(mut self, pipeline_statistics: QueryPipelineStatisticFlags) -> Self { + self.inner.pipeline_statistics = pipeline_statistics; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> CommandBufferInheritanceInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct CommandBufferBeginInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: CommandBufferUsageFlags, + pub p_inheritance_info: *const CommandBufferInheritanceInfo, +} +impl ::std::default::Default for CommandBufferBeginInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: CommandBufferUsageFlags::default(), + p_inheritance_info: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for CommandBufferBeginInfo { + const STRUCTURE_TYPE: StructureType = StructureType::COMMAND_BUFFER_BEGIN_INFO; +} +impl CommandBufferBeginInfo { + pub fn builder<'a>() -> CommandBufferBeginInfoBuilder<'a> { + CommandBufferBeginInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct CommandBufferBeginInfoBuilder<'a> { + inner: CommandBufferBeginInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsCommandBufferBeginInfo {} +impl<'a> ::std::ops::Deref for CommandBufferBeginInfoBuilder<'a> { + type Target = CommandBufferBeginInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for CommandBufferBeginInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> CommandBufferBeginInfoBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: CommandBufferUsageFlags) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn inheritance_info(mut self, inheritance_info: &'a CommandBufferInheritanceInfo) -> Self { + self.inner.p_inheritance_info = inheritance_info; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> CommandBufferBeginInfo { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct RenderPassBeginInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub render_pass: RenderPass, + pub framebuffer: Framebuffer, + pub render_area: Rect2D, + pub clear_value_count: u32, + pub p_clear_values: *const ClearValue, +} +#[cfg(feature = "debug")] +impl fmt::Debug for RenderPassBeginInfo { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fmt.debug_struct("RenderPassBeginInfo") + .field("s_type", &self.s_type) + .field("p_next", &self.p_next) + .field("render_pass", &self.render_pass) + .field("framebuffer", &self.framebuffer) + .field("render_area", &self.render_area) + .field("clear_value_count", &self.clear_value_count) + .field("p_clear_values", &"union") + .finish() + } +} +impl ::std::default::Default for RenderPassBeginInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + render_pass: RenderPass::default(), + framebuffer: Framebuffer::default(), + render_area: Rect2D::default(), + clear_value_count: u32::default(), + p_clear_values: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for RenderPassBeginInfo { + const STRUCTURE_TYPE: StructureType = StructureType::RENDER_PASS_BEGIN_INFO; +} +impl RenderPassBeginInfo { + pub fn builder<'a>() -> RenderPassBeginInfoBuilder<'a> { + RenderPassBeginInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct RenderPassBeginInfoBuilder<'a> { + inner: RenderPassBeginInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsRenderPassBeginInfo {} +impl<'a> ::std::ops::Deref for RenderPassBeginInfoBuilder<'a> { + type Target = RenderPassBeginInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for RenderPassBeginInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> RenderPassBeginInfoBuilder<'a> { + #[inline] + pub fn render_pass(mut self, render_pass: RenderPass) -> Self { + self.inner.render_pass = render_pass; + self + } + #[inline] + pub fn framebuffer(mut self, framebuffer: Framebuffer) -> Self { + self.inner.framebuffer = framebuffer; + self + } + #[inline] + pub fn render_area(mut self, render_area: Rect2D) -> Self { + self.inner.render_area = render_area; + self + } + #[inline] + pub fn clear_values(mut self, clear_values: &'a [ClearValue]) -> Self { + self.inner.clear_value_count = clear_values.len() as _; + self.inner.p_clear_values = clear_values.as_ptr(); + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> RenderPassBeginInfo { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[doc = ""] +pub union ClearColorValue { + pub float32: [f32; 4], + pub int32: [i32; 4], + pub uint32: [u32; 4], +} +impl ::std::default::Default for ClearColorValue { + #[inline] + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct ClearDepthStencilValue { + pub depth: f32, + pub stencil: u32, +} +impl ClearDepthStencilValue { + pub fn builder<'a>() -> ClearDepthStencilValueBuilder<'a> { + ClearDepthStencilValueBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ClearDepthStencilValueBuilder<'a> { + inner: ClearDepthStencilValue, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ClearDepthStencilValueBuilder<'a> { + type Target = ClearDepthStencilValue; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ClearDepthStencilValueBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ClearDepthStencilValueBuilder<'a> { + #[inline] + pub fn depth(mut self, depth: f32) -> Self { + self.inner.depth = depth; + self + } + #[inline] + pub fn stencil(mut self, stencil: u32) -> Self { + self.inner.stencil = stencil; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ClearDepthStencilValue { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[doc = ""] +pub union ClearValue { + pub color: ClearColorValue, + pub depth_stencil: ClearDepthStencilValue, +} +impl ::std::default::Default for ClearValue { + #[inline] + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } +} +#[repr(C)] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct ClearAttachment { + pub aspect_mask: ImageAspectFlags, + pub color_attachment: u32, + pub clear_value: ClearValue, +} +#[cfg(feature = "debug")] +impl fmt::Debug for ClearAttachment { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fmt.debug_struct("ClearAttachment") + .field("aspect_mask", &self.aspect_mask) + .field("color_attachment", &self.color_attachment) + .field("clear_value", &"union") + .finish() + } +} +impl ClearAttachment { + pub fn builder<'a>() -> ClearAttachmentBuilder<'a> { + ClearAttachmentBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ClearAttachmentBuilder<'a> { + inner: ClearAttachment, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ClearAttachmentBuilder<'a> { + type Target = ClearAttachment; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ClearAttachmentBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ClearAttachmentBuilder<'a> { + #[inline] + pub fn aspect_mask(mut self, aspect_mask: ImageAspectFlags) -> Self { + self.inner.aspect_mask = aspect_mask; + self + } + #[inline] + pub fn color_attachment(mut self, color_attachment: u32) -> Self { + self.inner.color_attachment = color_attachment; + self + } + #[inline] + pub fn clear_value(mut self, clear_value: ClearValue) -> Self { + self.inner.clear_value = clear_value; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ClearAttachment { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct AttachmentDescription { + pub flags: AttachmentDescriptionFlags, + pub format: Format, + pub samples: SampleCountFlags, + pub load_op: AttachmentLoadOp, + pub store_op: AttachmentStoreOp, + pub stencil_load_op: AttachmentLoadOp, + pub stencil_store_op: AttachmentStoreOp, + pub initial_layout: ImageLayout, + pub final_layout: ImageLayout, +} +impl AttachmentDescription { + pub fn builder<'a>() -> AttachmentDescriptionBuilder<'a> { + AttachmentDescriptionBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct AttachmentDescriptionBuilder<'a> { + inner: AttachmentDescription, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for AttachmentDescriptionBuilder<'a> { + type Target = AttachmentDescription; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for AttachmentDescriptionBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> AttachmentDescriptionBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: AttachmentDescriptionFlags) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn format(mut self, format: Format) -> Self { + self.inner.format = format; + self + } + #[inline] + pub fn samples(mut self, samples: SampleCountFlags) -> Self { + self.inner.samples = samples; + self + } + #[inline] + pub fn load_op(mut self, load_op: AttachmentLoadOp) -> Self { + self.inner.load_op = load_op; + self + } + #[inline] + pub fn store_op(mut self, store_op: AttachmentStoreOp) -> Self { + self.inner.store_op = store_op; + self + } + #[inline] + pub fn stencil_load_op(mut self, stencil_load_op: AttachmentLoadOp) -> Self { + self.inner.stencil_load_op = stencil_load_op; + self + } + #[inline] + pub fn stencil_store_op(mut self, stencil_store_op: AttachmentStoreOp) -> Self { + self.inner.stencil_store_op = stencil_store_op; + self + } + #[inline] + pub fn initial_layout(mut self, initial_layout: ImageLayout) -> Self { + self.inner.initial_layout = initial_layout; + self + } + #[inline] + pub fn final_layout(mut self, final_layout: ImageLayout) -> Self { + self.inner.final_layout = final_layout; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> AttachmentDescription { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct AttachmentReference { + pub attachment: u32, + pub layout: ImageLayout, +} +impl AttachmentReference { + pub fn builder<'a>() -> AttachmentReferenceBuilder<'a> { + AttachmentReferenceBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct AttachmentReferenceBuilder<'a> { + inner: AttachmentReference, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for AttachmentReferenceBuilder<'a> { + type Target = AttachmentReference; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for AttachmentReferenceBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> AttachmentReferenceBuilder<'a> { + #[inline] + pub fn attachment(mut self, attachment: u32) -> Self { + self.inner.attachment = attachment; + self + } + #[inline] + pub fn layout(mut self, layout: ImageLayout) -> Self { + self.inner.layout = layout; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> AttachmentReference { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SubpassDescription { + pub flags: SubpassDescriptionFlags, + pub pipeline_bind_point: PipelineBindPoint, + pub input_attachment_count: u32, + pub p_input_attachments: *const AttachmentReference, + pub color_attachment_count: u32, + pub p_color_attachments: *const AttachmentReference, + pub p_resolve_attachments: *const AttachmentReference, + pub p_depth_stencil_attachment: *const AttachmentReference, + pub preserve_attachment_count: u32, + pub p_preserve_attachments: *const u32, +} +impl ::std::default::Default for SubpassDescription { + #[inline] + fn default() -> Self { + Self { + flags: SubpassDescriptionFlags::default(), + pipeline_bind_point: PipelineBindPoint::default(), + input_attachment_count: u32::default(), + p_input_attachments: ::std::ptr::null(), + color_attachment_count: u32::default(), + p_color_attachments: ::std::ptr::null(), + p_resolve_attachments: ::std::ptr::null(), + p_depth_stencil_attachment: ::std::ptr::null(), + preserve_attachment_count: u32::default(), + p_preserve_attachments: ::std::ptr::null(), + } + } +} +impl SubpassDescription { + pub fn builder<'a>() -> SubpassDescriptionBuilder<'a> { + SubpassDescriptionBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SubpassDescriptionBuilder<'a> { + inner: SubpassDescription, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for SubpassDescriptionBuilder<'a> { + type Target = SubpassDescription; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SubpassDescriptionBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SubpassDescriptionBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: SubpassDescriptionFlags) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn pipeline_bind_point(mut self, pipeline_bind_point: PipelineBindPoint) -> Self { + self.inner.pipeline_bind_point = pipeline_bind_point; + self + } + #[inline] + pub fn input_attachments(mut self, input_attachments: &'a [AttachmentReference]) -> Self { + self.inner.input_attachment_count = input_attachments.len() as _; + self.inner.p_input_attachments = input_attachments.as_ptr(); + self + } + #[inline] + pub fn color_attachments(mut self, color_attachments: &'a [AttachmentReference]) -> Self { + self.inner.color_attachment_count = color_attachments.len() as _; + self.inner.p_color_attachments = color_attachments.as_ptr(); + self + } + #[inline] + pub fn resolve_attachments(mut self, resolve_attachments: &'a [AttachmentReference]) -> Self { + self.inner.color_attachment_count = resolve_attachments.len() as _; + self.inner.p_resolve_attachments = resolve_attachments.as_ptr(); + self + } + #[inline] + pub fn depth_stencil_attachment( + mut self, + depth_stencil_attachment: &'a AttachmentReference, + ) -> Self { + self.inner.p_depth_stencil_attachment = depth_stencil_attachment; + self + } + #[inline] + pub fn preserve_attachments(mut self, preserve_attachments: &'a [u32]) -> Self { + self.inner.preserve_attachment_count = preserve_attachments.len() as _; + self.inner.p_preserve_attachments = preserve_attachments.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SubpassDescription { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct SubpassDependency { + pub src_subpass: u32, + pub dst_subpass: u32, + pub src_stage_mask: PipelineStageFlags, + pub dst_stage_mask: PipelineStageFlags, + pub src_access_mask: AccessFlags, + pub dst_access_mask: AccessFlags, + pub dependency_flags: DependencyFlags, +} +impl SubpassDependency { + pub fn builder<'a>() -> SubpassDependencyBuilder<'a> { + SubpassDependencyBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SubpassDependencyBuilder<'a> { + inner: SubpassDependency, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for SubpassDependencyBuilder<'a> { + type Target = SubpassDependency; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SubpassDependencyBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SubpassDependencyBuilder<'a> { + #[inline] + pub fn src_subpass(mut self, src_subpass: u32) -> Self { + self.inner.src_subpass = src_subpass; + self + } + #[inline] + pub fn dst_subpass(mut self, dst_subpass: u32) -> Self { + self.inner.dst_subpass = dst_subpass; + self + } + #[inline] + pub fn src_stage_mask(mut self, src_stage_mask: PipelineStageFlags) -> Self { + self.inner.src_stage_mask = src_stage_mask; + self + } + #[inline] + pub fn dst_stage_mask(mut self, dst_stage_mask: PipelineStageFlags) -> Self { + self.inner.dst_stage_mask = dst_stage_mask; + self + } + #[inline] + pub fn src_access_mask(mut self, src_access_mask: AccessFlags) -> Self { + self.inner.src_access_mask = src_access_mask; + self + } + #[inline] + pub fn dst_access_mask(mut self, dst_access_mask: AccessFlags) -> Self { + self.inner.dst_access_mask = dst_access_mask; + self + } + #[inline] + pub fn dependency_flags(mut self, dependency_flags: DependencyFlags) -> Self { + self.inner.dependency_flags = dependency_flags; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SubpassDependency { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct RenderPassCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: RenderPassCreateFlags, + pub attachment_count: u32, + pub p_attachments: *const AttachmentDescription, + pub subpass_count: u32, + pub p_subpasses: *const SubpassDescription, + pub dependency_count: u32, + pub p_dependencies: *const SubpassDependency, +} +impl ::std::default::Default for RenderPassCreateInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: RenderPassCreateFlags::default(), + attachment_count: u32::default(), + p_attachments: ::std::ptr::null(), + subpass_count: u32::default(), + p_subpasses: ::std::ptr::null(), + dependency_count: u32::default(), + p_dependencies: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for RenderPassCreateInfo { + const STRUCTURE_TYPE: StructureType = StructureType::RENDER_PASS_CREATE_INFO; +} +impl RenderPassCreateInfo { + pub fn builder<'a>() -> RenderPassCreateInfoBuilder<'a> { + RenderPassCreateInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct RenderPassCreateInfoBuilder<'a> { + inner: RenderPassCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsRenderPassCreateInfo {} +impl<'a> ::std::ops::Deref for RenderPassCreateInfoBuilder<'a> { + type Target = RenderPassCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for RenderPassCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> RenderPassCreateInfoBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: RenderPassCreateFlags) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn attachments(mut self, attachments: &'a [AttachmentDescription]) -> Self { + self.inner.attachment_count = attachments.len() as _; + self.inner.p_attachments = attachments.as_ptr(); + self + } + #[inline] + pub fn subpasses(mut self, subpasses: &'a [SubpassDescription]) -> Self { + self.inner.subpass_count = subpasses.len() as _; + self.inner.p_subpasses = subpasses.as_ptr(); + self + } + #[inline] + pub fn dependencies(mut self, dependencies: &'a [SubpassDependency]) -> Self { + self.inner.dependency_count = dependencies.len() as _; + self.inner.p_dependencies = dependencies.as_ptr(); + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> RenderPassCreateInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct EventCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: EventCreateFlags, +} +impl ::std::default::Default for EventCreateInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: EventCreateFlags::default(), + } + } +} +unsafe impl TaggedStructure for EventCreateInfo { + const STRUCTURE_TYPE: StructureType = StructureType::EVENT_CREATE_INFO; +} +impl EventCreateInfo { + pub fn builder<'a>() -> EventCreateInfoBuilder<'a> { + EventCreateInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct EventCreateInfoBuilder<'a> { + inner: EventCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsEventCreateInfo {} +impl<'a> ::std::ops::Deref for EventCreateInfoBuilder<'a> { + type Target = EventCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for EventCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> EventCreateInfoBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: EventCreateFlags) -> Self { + self.inner.flags = flags; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> EventCreateInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct FenceCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: FenceCreateFlags, +} +impl ::std::default::Default for FenceCreateInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: FenceCreateFlags::default(), + } + } +} +unsafe impl TaggedStructure for FenceCreateInfo { + const STRUCTURE_TYPE: StructureType = StructureType::FENCE_CREATE_INFO; +} +impl FenceCreateInfo { + pub fn builder<'a>() -> FenceCreateInfoBuilder<'a> { + FenceCreateInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct FenceCreateInfoBuilder<'a> { + inner: FenceCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsFenceCreateInfo {} +impl<'a> ::std::ops::Deref for FenceCreateInfoBuilder<'a> { + type Target = FenceCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for FenceCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> FenceCreateInfoBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: FenceCreateFlags) -> Self { + self.inner.flags = flags; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> FenceCreateInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct PhysicalDeviceFeatures { + pub robust_buffer_access: Bool32, + pub full_draw_index_uint32: Bool32, + pub image_cube_array: Bool32, + pub independent_blend: Bool32, + pub geometry_shader: Bool32, + pub tessellation_shader: Bool32, + pub sample_rate_shading: Bool32, + pub dual_src_blend: Bool32, + pub logic_op: Bool32, + pub multi_draw_indirect: Bool32, + pub draw_indirect_first_instance: Bool32, + pub depth_clamp: Bool32, + pub depth_bias_clamp: Bool32, + pub fill_mode_non_solid: Bool32, + pub depth_bounds: Bool32, + pub wide_lines: Bool32, + pub large_points: Bool32, + pub alpha_to_one: Bool32, + pub multi_viewport: Bool32, + pub sampler_anisotropy: Bool32, + pub texture_compression_etc2: Bool32, + pub texture_compression_astc_ldr: Bool32, + pub texture_compression_bc: Bool32, + pub occlusion_query_precise: Bool32, + pub pipeline_statistics_query: Bool32, + pub vertex_pipeline_stores_and_atomics: Bool32, + pub fragment_stores_and_atomics: Bool32, + pub shader_tessellation_and_geometry_point_size: Bool32, + pub shader_image_gather_extended: Bool32, + pub shader_storage_image_extended_formats: Bool32, + pub shader_storage_image_multisample: Bool32, + pub shader_storage_image_read_without_format: Bool32, + pub shader_storage_image_write_without_format: Bool32, + pub shader_uniform_buffer_array_dynamic_indexing: Bool32, + pub shader_sampled_image_array_dynamic_indexing: Bool32, + pub shader_storage_buffer_array_dynamic_indexing: Bool32, + pub shader_storage_image_array_dynamic_indexing: Bool32, + pub shader_clip_distance: Bool32, + pub shader_cull_distance: Bool32, + pub shader_float64: Bool32, + pub shader_int64: Bool32, + pub shader_int16: Bool32, + pub shader_resource_residency: Bool32, + pub shader_resource_min_lod: Bool32, + pub sparse_binding: Bool32, + pub sparse_residency_buffer: Bool32, + pub sparse_residency_image2_d: Bool32, + pub sparse_residency_image3_d: Bool32, + pub sparse_residency2_samples: Bool32, + pub sparse_residency4_samples: Bool32, + pub sparse_residency8_samples: Bool32, + pub sparse_residency16_samples: Bool32, + pub sparse_residency_aliased: Bool32, + pub variable_multisample_rate: Bool32, + pub inherited_queries: Bool32, +} +impl PhysicalDeviceFeatures { + pub fn builder<'a>() -> PhysicalDeviceFeaturesBuilder<'a> { + PhysicalDeviceFeaturesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceFeaturesBuilder<'a> { + inner: PhysicalDeviceFeatures, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PhysicalDeviceFeaturesBuilder<'a> { + type Target = PhysicalDeviceFeatures; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceFeaturesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceFeaturesBuilder<'a> { + #[inline] + pub fn robust_buffer_access(mut self, robust_buffer_access: bool) -> Self { + self.inner.robust_buffer_access = robust_buffer_access.into(); + self + } + #[inline] + pub fn full_draw_index_uint32(mut self, full_draw_index_uint32: bool) -> Self { + self.inner.full_draw_index_uint32 = full_draw_index_uint32.into(); + self + } + #[inline] + pub fn image_cube_array(mut self, image_cube_array: bool) -> Self { + self.inner.image_cube_array = image_cube_array.into(); + self + } + #[inline] + pub fn independent_blend(mut self, independent_blend: bool) -> Self { + self.inner.independent_blend = independent_blend.into(); + self + } + #[inline] + pub fn geometry_shader(mut self, geometry_shader: bool) -> Self { + self.inner.geometry_shader = geometry_shader.into(); + self + } + #[inline] + pub fn tessellation_shader(mut self, tessellation_shader: bool) -> Self { + self.inner.tessellation_shader = tessellation_shader.into(); + self + } + #[inline] + pub fn sample_rate_shading(mut self, sample_rate_shading: bool) -> Self { + self.inner.sample_rate_shading = sample_rate_shading.into(); + self + } + #[inline] + pub fn dual_src_blend(mut self, dual_src_blend: bool) -> Self { + self.inner.dual_src_blend = dual_src_blend.into(); + self + } + #[inline] + pub fn logic_op(mut self, logic_op: bool) -> Self { + self.inner.logic_op = logic_op.into(); + self + } + #[inline] + pub fn multi_draw_indirect(mut self, multi_draw_indirect: bool) -> Self { + self.inner.multi_draw_indirect = multi_draw_indirect.into(); + self + } + #[inline] + pub fn draw_indirect_first_instance(mut self, draw_indirect_first_instance: bool) -> Self { + self.inner.draw_indirect_first_instance = draw_indirect_first_instance.into(); + self + } + #[inline] + pub fn depth_clamp(mut self, depth_clamp: bool) -> Self { + self.inner.depth_clamp = depth_clamp.into(); + self + } + #[inline] + pub fn depth_bias_clamp(mut self, depth_bias_clamp: bool) -> Self { + self.inner.depth_bias_clamp = depth_bias_clamp.into(); + self + } + #[inline] + pub fn fill_mode_non_solid(mut self, fill_mode_non_solid: bool) -> Self { + self.inner.fill_mode_non_solid = fill_mode_non_solid.into(); + self + } + #[inline] + pub fn depth_bounds(mut self, depth_bounds: bool) -> Self { + self.inner.depth_bounds = depth_bounds.into(); + self + } + #[inline] + pub fn wide_lines(mut self, wide_lines: bool) -> Self { + self.inner.wide_lines = wide_lines.into(); + self + } + #[inline] + pub fn large_points(mut self, large_points: bool) -> Self { + self.inner.large_points = large_points.into(); + self + } + #[inline] + pub fn alpha_to_one(mut self, alpha_to_one: bool) -> Self { + self.inner.alpha_to_one = alpha_to_one.into(); + self + } + #[inline] + pub fn multi_viewport(mut self, multi_viewport: bool) -> Self { + self.inner.multi_viewport = multi_viewport.into(); + self + } + #[inline] + pub fn sampler_anisotropy(mut self, sampler_anisotropy: bool) -> Self { + self.inner.sampler_anisotropy = sampler_anisotropy.into(); + self + } + #[inline] + pub fn texture_compression_etc2(mut self, texture_compression_etc2: bool) -> Self { + self.inner.texture_compression_etc2 = texture_compression_etc2.into(); + self + } + #[inline] + pub fn texture_compression_astc_ldr(mut self, texture_compression_astc_ldr: bool) -> Self { + self.inner.texture_compression_astc_ldr = texture_compression_astc_ldr.into(); + self + } + #[inline] + pub fn texture_compression_bc(mut self, texture_compression_bc: bool) -> Self { + self.inner.texture_compression_bc = texture_compression_bc.into(); + self + } + #[inline] + pub fn occlusion_query_precise(mut self, occlusion_query_precise: bool) -> Self { + self.inner.occlusion_query_precise = occlusion_query_precise.into(); + self + } + #[inline] + pub fn pipeline_statistics_query(mut self, pipeline_statistics_query: bool) -> Self { + self.inner.pipeline_statistics_query = pipeline_statistics_query.into(); + self + } + #[inline] + pub fn vertex_pipeline_stores_and_atomics( + mut self, + vertex_pipeline_stores_and_atomics: bool, + ) -> Self { + self.inner.vertex_pipeline_stores_and_atomics = vertex_pipeline_stores_and_atomics.into(); + self + } + #[inline] + pub fn fragment_stores_and_atomics(mut self, fragment_stores_and_atomics: bool) -> Self { + self.inner.fragment_stores_and_atomics = fragment_stores_and_atomics.into(); + self + } + #[inline] + pub fn shader_tessellation_and_geometry_point_size( + mut self, + shader_tessellation_and_geometry_point_size: bool, + ) -> Self { + self.inner.shader_tessellation_and_geometry_point_size = + shader_tessellation_and_geometry_point_size.into(); + self + } + #[inline] + pub fn shader_image_gather_extended(mut self, shader_image_gather_extended: bool) -> Self { + self.inner.shader_image_gather_extended = shader_image_gather_extended.into(); + self + } + #[inline] + pub fn shader_storage_image_extended_formats( + mut self, + shader_storage_image_extended_formats: bool, + ) -> Self { + self.inner.shader_storage_image_extended_formats = + shader_storage_image_extended_formats.into(); + self + } + #[inline] + pub fn shader_storage_image_multisample( + mut self, + shader_storage_image_multisample: bool, + ) -> Self { + self.inner.shader_storage_image_multisample = shader_storage_image_multisample.into(); + self + } + #[inline] + pub fn shader_storage_image_read_without_format( + mut self, + shader_storage_image_read_without_format: bool, + ) -> Self { + self.inner.shader_storage_image_read_without_format = + shader_storage_image_read_without_format.into(); + self + } + #[inline] + pub fn shader_storage_image_write_without_format( + mut self, + shader_storage_image_write_without_format: bool, + ) -> Self { + self.inner.shader_storage_image_write_without_format = + shader_storage_image_write_without_format.into(); + self + } + #[inline] + pub fn shader_uniform_buffer_array_dynamic_indexing( + mut self, + shader_uniform_buffer_array_dynamic_indexing: bool, + ) -> Self { + self.inner.shader_uniform_buffer_array_dynamic_indexing = + shader_uniform_buffer_array_dynamic_indexing.into(); + self + } + #[inline] + pub fn shader_sampled_image_array_dynamic_indexing( + mut self, + shader_sampled_image_array_dynamic_indexing: bool, + ) -> Self { + self.inner.shader_sampled_image_array_dynamic_indexing = + shader_sampled_image_array_dynamic_indexing.into(); + self + } + #[inline] + pub fn shader_storage_buffer_array_dynamic_indexing( + mut self, + shader_storage_buffer_array_dynamic_indexing: bool, + ) -> Self { + self.inner.shader_storage_buffer_array_dynamic_indexing = + shader_storage_buffer_array_dynamic_indexing.into(); + self + } + #[inline] + pub fn shader_storage_image_array_dynamic_indexing( + mut self, + shader_storage_image_array_dynamic_indexing: bool, + ) -> Self { + self.inner.shader_storage_image_array_dynamic_indexing = + shader_storage_image_array_dynamic_indexing.into(); + self + } + #[inline] + pub fn shader_clip_distance(mut self, shader_clip_distance: bool) -> Self { + self.inner.shader_clip_distance = shader_clip_distance.into(); + self + } + #[inline] + pub fn shader_cull_distance(mut self, shader_cull_distance: bool) -> Self { + self.inner.shader_cull_distance = shader_cull_distance.into(); + self + } + #[inline] + pub fn shader_float64(mut self, shader_float64: bool) -> Self { + self.inner.shader_float64 = shader_float64.into(); + self + } + #[inline] + pub fn shader_int64(mut self, shader_int64: bool) -> Self { + self.inner.shader_int64 = shader_int64.into(); + self + } + #[inline] + pub fn shader_int16(mut self, shader_int16: bool) -> Self { + self.inner.shader_int16 = shader_int16.into(); + self + } + #[inline] + pub fn shader_resource_residency(mut self, shader_resource_residency: bool) -> Self { + self.inner.shader_resource_residency = shader_resource_residency.into(); + self + } + #[inline] + pub fn shader_resource_min_lod(mut self, shader_resource_min_lod: bool) -> Self { + self.inner.shader_resource_min_lod = shader_resource_min_lod.into(); + self + } + #[inline] + pub fn sparse_binding(mut self, sparse_binding: bool) -> Self { + self.inner.sparse_binding = sparse_binding.into(); + self + } + #[inline] + pub fn sparse_residency_buffer(mut self, sparse_residency_buffer: bool) -> Self { + self.inner.sparse_residency_buffer = sparse_residency_buffer.into(); + self + } + #[inline] + pub fn sparse_residency_image2_d(mut self, sparse_residency_image2_d: bool) -> Self { + self.inner.sparse_residency_image2_d = sparse_residency_image2_d.into(); + self + } + #[inline] + pub fn sparse_residency_image3_d(mut self, sparse_residency_image3_d: bool) -> Self { + self.inner.sparse_residency_image3_d = sparse_residency_image3_d.into(); + self + } + #[inline] + pub fn sparse_residency2_samples(mut self, sparse_residency2_samples: bool) -> Self { + self.inner.sparse_residency2_samples = sparse_residency2_samples.into(); + self + } + #[inline] + pub fn sparse_residency4_samples(mut self, sparse_residency4_samples: bool) -> Self { + self.inner.sparse_residency4_samples = sparse_residency4_samples.into(); + self + } + #[inline] + pub fn sparse_residency8_samples(mut self, sparse_residency8_samples: bool) -> Self { + self.inner.sparse_residency8_samples = sparse_residency8_samples.into(); + self + } + #[inline] + pub fn sparse_residency16_samples(mut self, sparse_residency16_samples: bool) -> Self { + self.inner.sparse_residency16_samples = sparse_residency16_samples.into(); + self + } + #[inline] + pub fn sparse_residency_aliased(mut self, sparse_residency_aliased: bool) -> Self { + self.inner.sparse_residency_aliased = sparse_residency_aliased.into(); + self + } + #[inline] + pub fn variable_multisample_rate(mut self, variable_multisample_rate: bool) -> Self { + self.inner.variable_multisample_rate = variable_multisample_rate.into(); + self + } + #[inline] + pub fn inherited_queries(mut self, inherited_queries: bool) -> Self { + self.inner.inherited_queries = inherited_queries.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceFeatures { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct PhysicalDeviceSparseProperties { + pub residency_standard2_d_block_shape: Bool32, + pub residency_standard2_d_multisample_block_shape: Bool32, + pub residency_standard3_d_block_shape: Bool32, + pub residency_aligned_mip_size: Bool32, + pub residency_non_resident_strict: Bool32, +} +impl PhysicalDeviceSparseProperties { + pub fn builder<'a>() -> PhysicalDeviceSparsePropertiesBuilder<'a> { + PhysicalDeviceSparsePropertiesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceSparsePropertiesBuilder<'a> { + inner: PhysicalDeviceSparseProperties, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PhysicalDeviceSparsePropertiesBuilder<'a> { + type Target = PhysicalDeviceSparseProperties; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceSparsePropertiesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceSparsePropertiesBuilder<'a> { + #[inline] + pub fn residency_standard2_d_block_shape( + mut self, + residency_standard2_d_block_shape: bool, + ) -> Self { + self.inner.residency_standard2_d_block_shape = residency_standard2_d_block_shape.into(); + self + } + #[inline] + pub fn residency_standard2_d_multisample_block_shape( + mut self, + residency_standard2_d_multisample_block_shape: bool, + ) -> Self { + self.inner.residency_standard2_d_multisample_block_shape = + residency_standard2_d_multisample_block_shape.into(); + self + } + #[inline] + pub fn residency_standard3_d_block_shape( + mut self, + residency_standard3_d_block_shape: bool, + ) -> Self { + self.inner.residency_standard3_d_block_shape = residency_standard3_d_block_shape.into(); + self + } + #[inline] + pub fn residency_aligned_mip_size(mut self, residency_aligned_mip_size: bool) -> Self { + self.inner.residency_aligned_mip_size = residency_aligned_mip_size.into(); + self + } + #[inline] + pub fn residency_non_resident_strict(mut self, residency_non_resident_strict: bool) -> Self { + self.inner.residency_non_resident_strict = residency_non_resident_strict.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceSparseProperties { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceLimits { + pub max_image_dimension1_d: u32, + pub max_image_dimension2_d: u32, + pub max_image_dimension3_d: u32, + pub max_image_dimension_cube: u32, + pub max_image_array_layers: u32, + pub max_texel_buffer_elements: u32, + pub max_uniform_buffer_range: u32, + pub max_storage_buffer_range: u32, + pub max_push_constants_size: u32, + pub max_memory_allocation_count: u32, + pub max_sampler_allocation_count: u32, + pub buffer_image_granularity: DeviceSize, + pub sparse_address_space_size: DeviceSize, + pub max_bound_descriptor_sets: u32, + pub max_per_stage_descriptor_samplers: u32, + pub max_per_stage_descriptor_uniform_buffers: u32, + pub max_per_stage_descriptor_storage_buffers: u32, + pub max_per_stage_descriptor_sampled_images: u32, + pub max_per_stage_descriptor_storage_images: u32, + pub max_per_stage_descriptor_input_attachments: u32, + pub max_per_stage_resources: u32, + pub max_descriptor_set_samplers: u32, + pub max_descriptor_set_uniform_buffers: u32, + pub max_descriptor_set_uniform_buffers_dynamic: u32, + pub max_descriptor_set_storage_buffers: u32, + pub max_descriptor_set_storage_buffers_dynamic: u32, + pub max_descriptor_set_sampled_images: u32, + pub max_descriptor_set_storage_images: u32, + pub max_descriptor_set_input_attachments: u32, + pub max_vertex_input_attributes: u32, + pub max_vertex_input_bindings: u32, + pub max_vertex_input_attribute_offset: u32, + pub max_vertex_input_binding_stride: u32, + pub max_vertex_output_components: u32, + pub max_tessellation_generation_level: u32, + pub max_tessellation_patch_size: u32, + pub max_tessellation_control_per_vertex_input_components: u32, + pub max_tessellation_control_per_vertex_output_components: u32, + pub max_tessellation_control_per_patch_output_components: u32, + pub max_tessellation_control_total_output_components: u32, + pub max_tessellation_evaluation_input_components: u32, + pub max_tessellation_evaluation_output_components: u32, + pub max_geometry_shader_invocations: u32, + pub max_geometry_input_components: u32, + pub max_geometry_output_components: u32, + pub max_geometry_output_vertices: u32, + pub max_geometry_total_output_components: u32, + pub max_fragment_input_components: u32, + pub max_fragment_output_attachments: u32, + pub max_fragment_dual_src_attachments: u32, + pub max_fragment_combined_output_resources: u32, + pub max_compute_shared_memory_size: u32, + pub max_compute_work_group_count: [u32; 3], + pub max_compute_work_group_invocations: u32, + pub max_compute_work_group_size: [u32; 3], + pub sub_pixel_precision_bits: u32, + pub sub_texel_precision_bits: u32, + pub mipmap_precision_bits: u32, + pub max_draw_indexed_index_value: u32, + pub max_draw_indirect_count: u32, + pub max_sampler_lod_bias: f32, + pub max_sampler_anisotropy: f32, + pub max_viewports: u32, + pub max_viewport_dimensions: [u32; 2], + pub viewport_bounds_range: [f32; 2], + pub viewport_sub_pixel_bits: u32, + pub min_memory_map_alignment: usize, + pub min_texel_buffer_offset_alignment: DeviceSize, + pub min_uniform_buffer_offset_alignment: DeviceSize, + pub min_storage_buffer_offset_alignment: DeviceSize, + pub min_texel_offset: i32, + pub max_texel_offset: u32, + pub min_texel_gather_offset: i32, + pub max_texel_gather_offset: u32, + pub min_interpolation_offset: f32, + pub max_interpolation_offset: f32, + pub sub_pixel_interpolation_offset_bits: u32, + pub max_framebuffer_width: u32, + pub max_framebuffer_height: u32, + pub max_framebuffer_layers: u32, + pub framebuffer_color_sample_counts: SampleCountFlags, + pub framebuffer_depth_sample_counts: SampleCountFlags, + pub framebuffer_stencil_sample_counts: SampleCountFlags, + pub framebuffer_no_attachments_sample_counts: SampleCountFlags, + pub max_color_attachments: u32, + pub sampled_image_color_sample_counts: SampleCountFlags, + pub sampled_image_integer_sample_counts: SampleCountFlags, + pub sampled_image_depth_sample_counts: SampleCountFlags, + pub sampled_image_stencil_sample_counts: SampleCountFlags, + pub storage_image_sample_counts: SampleCountFlags, + pub max_sample_mask_words: u32, + pub timestamp_compute_and_graphics: Bool32, + pub timestamp_period: f32, + pub max_clip_distances: u32, + pub max_cull_distances: u32, + pub max_combined_clip_and_cull_distances: u32, + pub discrete_queue_priorities: u32, + pub point_size_range: [f32; 2], + pub line_width_range: [f32; 2], + pub point_size_granularity: f32, + pub line_width_granularity: f32, + pub strict_lines: Bool32, + pub standard_sample_locations: Bool32, + pub optimal_buffer_copy_offset_alignment: DeviceSize, + pub optimal_buffer_copy_row_pitch_alignment: DeviceSize, + pub non_coherent_atom_size: DeviceSize, +} +impl ::std::default::Default for PhysicalDeviceLimits { + #[inline] + fn default() -> Self { + Self { + max_image_dimension1_d: u32::default(), + max_image_dimension2_d: u32::default(), + max_image_dimension3_d: u32::default(), + max_image_dimension_cube: u32::default(), + max_image_array_layers: u32::default(), + max_texel_buffer_elements: u32::default(), + max_uniform_buffer_range: u32::default(), + max_storage_buffer_range: u32::default(), + max_push_constants_size: u32::default(), + max_memory_allocation_count: u32::default(), + max_sampler_allocation_count: u32::default(), + buffer_image_granularity: DeviceSize::default(), + sparse_address_space_size: DeviceSize::default(), + max_bound_descriptor_sets: u32::default(), + max_per_stage_descriptor_samplers: u32::default(), + max_per_stage_descriptor_uniform_buffers: u32::default(), + max_per_stage_descriptor_storage_buffers: u32::default(), + max_per_stage_descriptor_sampled_images: u32::default(), + max_per_stage_descriptor_storage_images: u32::default(), + max_per_stage_descriptor_input_attachments: u32::default(), + max_per_stage_resources: u32::default(), + max_descriptor_set_samplers: u32::default(), + max_descriptor_set_uniform_buffers: u32::default(), + max_descriptor_set_uniform_buffers_dynamic: u32::default(), + max_descriptor_set_storage_buffers: u32::default(), + max_descriptor_set_storage_buffers_dynamic: u32::default(), + max_descriptor_set_sampled_images: u32::default(), + max_descriptor_set_storage_images: u32::default(), + max_descriptor_set_input_attachments: u32::default(), + max_vertex_input_attributes: u32::default(), + max_vertex_input_bindings: u32::default(), + max_vertex_input_attribute_offset: u32::default(), + max_vertex_input_binding_stride: u32::default(), + max_vertex_output_components: u32::default(), + max_tessellation_generation_level: u32::default(), + max_tessellation_patch_size: u32::default(), + max_tessellation_control_per_vertex_input_components: u32::default(), + max_tessellation_control_per_vertex_output_components: u32::default(), + max_tessellation_control_per_patch_output_components: u32::default(), + max_tessellation_control_total_output_components: u32::default(), + max_tessellation_evaluation_input_components: u32::default(), + max_tessellation_evaluation_output_components: u32::default(), + max_geometry_shader_invocations: u32::default(), + max_geometry_input_components: u32::default(), + max_geometry_output_components: u32::default(), + max_geometry_output_vertices: u32::default(), + max_geometry_total_output_components: u32::default(), + max_fragment_input_components: u32::default(), + max_fragment_output_attachments: u32::default(), + max_fragment_dual_src_attachments: u32::default(), + max_fragment_combined_output_resources: u32::default(), + max_compute_shared_memory_size: u32::default(), + max_compute_work_group_count: unsafe { ::std::mem::zeroed() }, + max_compute_work_group_invocations: u32::default(), + max_compute_work_group_size: unsafe { ::std::mem::zeroed() }, + sub_pixel_precision_bits: u32::default(), + sub_texel_precision_bits: u32::default(), + mipmap_precision_bits: u32::default(), + max_draw_indexed_index_value: u32::default(), + max_draw_indirect_count: u32::default(), + max_sampler_lod_bias: f32::default(), + max_sampler_anisotropy: f32::default(), + max_viewports: u32::default(), + max_viewport_dimensions: unsafe { ::std::mem::zeroed() }, + viewport_bounds_range: unsafe { ::std::mem::zeroed() }, + viewport_sub_pixel_bits: u32::default(), + min_memory_map_alignment: usize::default(), + min_texel_buffer_offset_alignment: DeviceSize::default(), + min_uniform_buffer_offset_alignment: DeviceSize::default(), + min_storage_buffer_offset_alignment: DeviceSize::default(), + min_texel_offset: i32::default(), + max_texel_offset: u32::default(), + min_texel_gather_offset: i32::default(), + max_texel_gather_offset: u32::default(), + min_interpolation_offset: f32::default(), + max_interpolation_offset: f32::default(), + sub_pixel_interpolation_offset_bits: u32::default(), + max_framebuffer_width: u32::default(), + max_framebuffer_height: u32::default(), + max_framebuffer_layers: u32::default(), + framebuffer_color_sample_counts: SampleCountFlags::default(), + framebuffer_depth_sample_counts: SampleCountFlags::default(), + framebuffer_stencil_sample_counts: SampleCountFlags::default(), + framebuffer_no_attachments_sample_counts: SampleCountFlags::default(), + max_color_attachments: u32::default(), + sampled_image_color_sample_counts: SampleCountFlags::default(), + sampled_image_integer_sample_counts: SampleCountFlags::default(), + sampled_image_depth_sample_counts: SampleCountFlags::default(), + sampled_image_stencil_sample_counts: SampleCountFlags::default(), + storage_image_sample_counts: SampleCountFlags::default(), + max_sample_mask_words: u32::default(), + timestamp_compute_and_graphics: Bool32::default(), + timestamp_period: f32::default(), + max_clip_distances: u32::default(), + max_cull_distances: u32::default(), + max_combined_clip_and_cull_distances: u32::default(), + discrete_queue_priorities: u32::default(), + point_size_range: unsafe { ::std::mem::zeroed() }, + line_width_range: unsafe { ::std::mem::zeroed() }, + point_size_granularity: f32::default(), + line_width_granularity: f32::default(), + strict_lines: Bool32::default(), + standard_sample_locations: Bool32::default(), + optimal_buffer_copy_offset_alignment: DeviceSize::default(), + optimal_buffer_copy_row_pitch_alignment: DeviceSize::default(), + non_coherent_atom_size: DeviceSize::default(), + } + } +} +impl PhysicalDeviceLimits { + pub fn builder<'a>() -> PhysicalDeviceLimitsBuilder<'a> { + PhysicalDeviceLimitsBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceLimitsBuilder<'a> { + inner: PhysicalDeviceLimits, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PhysicalDeviceLimitsBuilder<'a> { + type Target = PhysicalDeviceLimits; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceLimitsBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceLimitsBuilder<'a> { + #[inline] + pub fn max_image_dimension1_d(mut self, max_image_dimension1_d: u32) -> Self { + self.inner.max_image_dimension1_d = max_image_dimension1_d; + self + } + #[inline] + pub fn max_image_dimension2_d(mut self, max_image_dimension2_d: u32) -> Self { + self.inner.max_image_dimension2_d = max_image_dimension2_d; + self + } + #[inline] + pub fn max_image_dimension3_d(mut self, max_image_dimension3_d: u32) -> Self { + self.inner.max_image_dimension3_d = max_image_dimension3_d; + self + } + #[inline] + pub fn max_image_dimension_cube(mut self, max_image_dimension_cube: u32) -> Self { + self.inner.max_image_dimension_cube = max_image_dimension_cube; + self + } + #[inline] + pub fn max_image_array_layers(mut self, max_image_array_layers: u32) -> Self { + self.inner.max_image_array_layers = max_image_array_layers; + self + } + #[inline] + pub fn max_texel_buffer_elements(mut self, max_texel_buffer_elements: u32) -> Self { + self.inner.max_texel_buffer_elements = max_texel_buffer_elements; + self + } + #[inline] + pub fn max_uniform_buffer_range(mut self, max_uniform_buffer_range: u32) -> Self { + self.inner.max_uniform_buffer_range = max_uniform_buffer_range; + self + } + #[inline] + pub fn max_storage_buffer_range(mut self, max_storage_buffer_range: u32) -> Self { + self.inner.max_storage_buffer_range = max_storage_buffer_range; + self + } + #[inline] + pub fn max_push_constants_size(mut self, max_push_constants_size: u32) -> Self { + self.inner.max_push_constants_size = max_push_constants_size; + self + } + #[inline] + pub fn max_memory_allocation_count(mut self, max_memory_allocation_count: u32) -> Self { + self.inner.max_memory_allocation_count = max_memory_allocation_count; + self + } + #[inline] + pub fn max_sampler_allocation_count(mut self, max_sampler_allocation_count: u32) -> Self { + self.inner.max_sampler_allocation_count = max_sampler_allocation_count; + self + } + #[inline] + pub fn buffer_image_granularity(mut self, buffer_image_granularity: DeviceSize) -> Self { + self.inner.buffer_image_granularity = buffer_image_granularity; + self + } + #[inline] + pub fn sparse_address_space_size(mut self, sparse_address_space_size: DeviceSize) -> Self { + self.inner.sparse_address_space_size = sparse_address_space_size; + self + } + #[inline] + pub fn max_bound_descriptor_sets(mut self, max_bound_descriptor_sets: u32) -> Self { + self.inner.max_bound_descriptor_sets = max_bound_descriptor_sets; + self + } + #[inline] + pub fn max_per_stage_descriptor_samplers( + mut self, + max_per_stage_descriptor_samplers: u32, + ) -> Self { + self.inner.max_per_stage_descriptor_samplers = max_per_stage_descriptor_samplers; + self + } + #[inline] + pub fn max_per_stage_descriptor_uniform_buffers( + mut self, + max_per_stage_descriptor_uniform_buffers: u32, + ) -> Self { + self.inner.max_per_stage_descriptor_uniform_buffers = + max_per_stage_descriptor_uniform_buffers; + self + } + #[inline] + pub fn max_per_stage_descriptor_storage_buffers( + mut self, + max_per_stage_descriptor_storage_buffers: u32, + ) -> Self { + self.inner.max_per_stage_descriptor_storage_buffers = + max_per_stage_descriptor_storage_buffers; + self + } + #[inline] + pub fn max_per_stage_descriptor_sampled_images( + mut self, + max_per_stage_descriptor_sampled_images: u32, + ) -> Self { + self.inner.max_per_stage_descriptor_sampled_images = + max_per_stage_descriptor_sampled_images; + self + } + #[inline] + pub fn max_per_stage_descriptor_storage_images( + mut self, + max_per_stage_descriptor_storage_images: u32, + ) -> Self { + self.inner.max_per_stage_descriptor_storage_images = + max_per_stage_descriptor_storage_images; + self + } + #[inline] + pub fn max_per_stage_descriptor_input_attachments( + mut self, + max_per_stage_descriptor_input_attachments: u32, + ) -> Self { + self.inner.max_per_stage_descriptor_input_attachments = + max_per_stage_descriptor_input_attachments; + self + } + #[inline] + pub fn max_per_stage_resources(mut self, max_per_stage_resources: u32) -> Self { + self.inner.max_per_stage_resources = max_per_stage_resources; + self + } + #[inline] + pub fn max_descriptor_set_samplers(mut self, max_descriptor_set_samplers: u32) -> Self { + self.inner.max_descriptor_set_samplers = max_descriptor_set_samplers; + self + } + #[inline] + pub fn max_descriptor_set_uniform_buffers( + mut self, + max_descriptor_set_uniform_buffers: u32, + ) -> Self { + self.inner.max_descriptor_set_uniform_buffers = max_descriptor_set_uniform_buffers; + self + } + #[inline] + pub fn max_descriptor_set_uniform_buffers_dynamic( + mut self, + max_descriptor_set_uniform_buffers_dynamic: u32, + ) -> Self { + self.inner.max_descriptor_set_uniform_buffers_dynamic = + max_descriptor_set_uniform_buffers_dynamic; + self + } + #[inline] + pub fn max_descriptor_set_storage_buffers( + mut self, + max_descriptor_set_storage_buffers: u32, + ) -> Self { + self.inner.max_descriptor_set_storage_buffers = max_descriptor_set_storage_buffers; + self + } + #[inline] + pub fn max_descriptor_set_storage_buffers_dynamic( + mut self, + max_descriptor_set_storage_buffers_dynamic: u32, + ) -> Self { + self.inner.max_descriptor_set_storage_buffers_dynamic = + max_descriptor_set_storage_buffers_dynamic; + self + } + #[inline] + pub fn max_descriptor_set_sampled_images( + mut self, + max_descriptor_set_sampled_images: u32, + ) -> Self { + self.inner.max_descriptor_set_sampled_images = max_descriptor_set_sampled_images; + self + } + #[inline] + pub fn max_descriptor_set_storage_images( + mut self, + max_descriptor_set_storage_images: u32, + ) -> Self { + self.inner.max_descriptor_set_storage_images = max_descriptor_set_storage_images; + self + } + #[inline] + pub fn max_descriptor_set_input_attachments( + mut self, + max_descriptor_set_input_attachments: u32, + ) -> Self { + self.inner.max_descriptor_set_input_attachments = max_descriptor_set_input_attachments; + self + } + #[inline] + pub fn max_vertex_input_attributes(mut self, max_vertex_input_attributes: u32) -> Self { + self.inner.max_vertex_input_attributes = max_vertex_input_attributes; + self + } + #[inline] + pub fn max_vertex_input_bindings(mut self, max_vertex_input_bindings: u32) -> Self { + self.inner.max_vertex_input_bindings = max_vertex_input_bindings; + self + } + #[inline] + pub fn max_vertex_input_attribute_offset( + mut self, + max_vertex_input_attribute_offset: u32, + ) -> Self { + self.inner.max_vertex_input_attribute_offset = max_vertex_input_attribute_offset; + self + } + #[inline] + pub fn max_vertex_input_binding_stride(mut self, max_vertex_input_binding_stride: u32) -> Self { + self.inner.max_vertex_input_binding_stride = max_vertex_input_binding_stride; + self + } + #[inline] + pub fn max_vertex_output_components(mut self, max_vertex_output_components: u32) -> Self { + self.inner.max_vertex_output_components = max_vertex_output_components; + self + } + #[inline] + pub fn max_tessellation_generation_level( + mut self, + max_tessellation_generation_level: u32, + ) -> Self { + self.inner.max_tessellation_generation_level = max_tessellation_generation_level; + self + } + #[inline] + pub fn max_tessellation_patch_size(mut self, max_tessellation_patch_size: u32) -> Self { + self.inner.max_tessellation_patch_size = max_tessellation_patch_size; + self + } + #[inline] + pub fn max_tessellation_control_per_vertex_input_components( + mut self, + max_tessellation_control_per_vertex_input_components: u32, + ) -> Self { + self.inner + .max_tessellation_control_per_vertex_input_components = + max_tessellation_control_per_vertex_input_components; + self + } + #[inline] + pub fn max_tessellation_control_per_vertex_output_components( + mut self, + max_tessellation_control_per_vertex_output_components: u32, + ) -> Self { + self.inner + .max_tessellation_control_per_vertex_output_components = + max_tessellation_control_per_vertex_output_components; + self + } + #[inline] + pub fn max_tessellation_control_per_patch_output_components( + mut self, + max_tessellation_control_per_patch_output_components: u32, + ) -> Self { + self.inner + .max_tessellation_control_per_patch_output_components = + max_tessellation_control_per_patch_output_components; + self + } + #[inline] + pub fn max_tessellation_control_total_output_components( + mut self, + max_tessellation_control_total_output_components: u32, + ) -> Self { + self.inner.max_tessellation_control_total_output_components = + max_tessellation_control_total_output_components; + self + } + #[inline] + pub fn max_tessellation_evaluation_input_components( + mut self, + max_tessellation_evaluation_input_components: u32, + ) -> Self { + self.inner.max_tessellation_evaluation_input_components = + max_tessellation_evaluation_input_components; + self + } + #[inline] + pub fn max_tessellation_evaluation_output_components( + mut self, + max_tessellation_evaluation_output_components: u32, + ) -> Self { + self.inner.max_tessellation_evaluation_output_components = + max_tessellation_evaluation_output_components; + self + } + #[inline] + pub fn max_geometry_shader_invocations(mut self, max_geometry_shader_invocations: u32) -> Self { + self.inner.max_geometry_shader_invocations = max_geometry_shader_invocations; + self + } + #[inline] + pub fn max_geometry_input_components(mut self, max_geometry_input_components: u32) -> Self { + self.inner.max_geometry_input_components = max_geometry_input_components; + self + } + #[inline] + pub fn max_geometry_output_components(mut self, max_geometry_output_components: u32) -> Self { + self.inner.max_geometry_output_components = max_geometry_output_components; + self + } + #[inline] + pub fn max_geometry_output_vertices(mut self, max_geometry_output_vertices: u32) -> Self { + self.inner.max_geometry_output_vertices = max_geometry_output_vertices; + self + } + #[inline] + pub fn max_geometry_total_output_components( + mut self, + max_geometry_total_output_components: u32, + ) -> Self { + self.inner.max_geometry_total_output_components = max_geometry_total_output_components; + self + } + #[inline] + pub fn max_fragment_input_components(mut self, max_fragment_input_components: u32) -> Self { + self.inner.max_fragment_input_components = max_fragment_input_components; + self + } + #[inline] + pub fn max_fragment_output_attachments(mut self, max_fragment_output_attachments: u32) -> Self { + self.inner.max_fragment_output_attachments = max_fragment_output_attachments; + self + } + #[inline] + pub fn max_fragment_dual_src_attachments( + mut self, + max_fragment_dual_src_attachments: u32, + ) -> Self { + self.inner.max_fragment_dual_src_attachments = max_fragment_dual_src_attachments; + self + } + #[inline] + pub fn max_fragment_combined_output_resources( + mut self, + max_fragment_combined_output_resources: u32, + ) -> Self { + self.inner.max_fragment_combined_output_resources = max_fragment_combined_output_resources; + self + } + #[inline] + pub fn max_compute_shared_memory_size(mut self, max_compute_shared_memory_size: u32) -> Self { + self.inner.max_compute_shared_memory_size = max_compute_shared_memory_size; + self + } + #[inline] + pub fn max_compute_work_group_count(mut self, max_compute_work_group_count: [u32; 3]) -> Self { + self.inner.max_compute_work_group_count = max_compute_work_group_count; + self + } + #[inline] + pub fn max_compute_work_group_invocations( + mut self, + max_compute_work_group_invocations: u32, + ) -> Self { + self.inner.max_compute_work_group_invocations = max_compute_work_group_invocations; + self + } + #[inline] + pub fn max_compute_work_group_size(mut self, max_compute_work_group_size: [u32; 3]) -> Self { + self.inner.max_compute_work_group_size = max_compute_work_group_size; + self + } + #[inline] + pub fn sub_pixel_precision_bits(mut self, sub_pixel_precision_bits: u32) -> Self { + self.inner.sub_pixel_precision_bits = sub_pixel_precision_bits; + self + } + #[inline] + pub fn sub_texel_precision_bits(mut self, sub_texel_precision_bits: u32) -> Self { + self.inner.sub_texel_precision_bits = sub_texel_precision_bits; + self + } + #[inline] + pub fn mipmap_precision_bits(mut self, mipmap_precision_bits: u32) -> Self { + self.inner.mipmap_precision_bits = mipmap_precision_bits; + self + } + #[inline] + pub fn max_draw_indexed_index_value(mut self, max_draw_indexed_index_value: u32) -> Self { + self.inner.max_draw_indexed_index_value = max_draw_indexed_index_value; + self + } + #[inline] + pub fn max_draw_indirect_count(mut self, max_draw_indirect_count: u32) -> Self { + self.inner.max_draw_indirect_count = max_draw_indirect_count; + self + } + #[inline] + pub fn max_sampler_lod_bias(mut self, max_sampler_lod_bias: f32) -> Self { + self.inner.max_sampler_lod_bias = max_sampler_lod_bias; + self + } + #[inline] + pub fn max_sampler_anisotropy(mut self, max_sampler_anisotropy: f32) -> Self { + self.inner.max_sampler_anisotropy = max_sampler_anisotropy; + self + } + #[inline] + pub fn max_viewports(mut self, max_viewports: u32) -> Self { + self.inner.max_viewports = max_viewports; + self + } + #[inline] + pub fn max_viewport_dimensions(mut self, max_viewport_dimensions: [u32; 2]) -> Self { + self.inner.max_viewport_dimensions = max_viewport_dimensions; + self + } + #[inline] + pub fn viewport_bounds_range(mut self, viewport_bounds_range: [f32; 2]) -> Self { + self.inner.viewport_bounds_range = viewport_bounds_range; + self + } + #[inline] + pub fn viewport_sub_pixel_bits(mut self, viewport_sub_pixel_bits: u32) -> Self { + self.inner.viewport_sub_pixel_bits = viewport_sub_pixel_bits; + self + } + #[inline] + pub fn min_memory_map_alignment(mut self, min_memory_map_alignment: usize) -> Self { + self.inner.min_memory_map_alignment = min_memory_map_alignment; + self + } + #[inline] + pub fn min_texel_buffer_offset_alignment( + mut self, + min_texel_buffer_offset_alignment: DeviceSize, + ) -> Self { + self.inner.min_texel_buffer_offset_alignment = min_texel_buffer_offset_alignment; + self + } + #[inline] + pub fn min_uniform_buffer_offset_alignment( + mut self, + min_uniform_buffer_offset_alignment: DeviceSize, + ) -> Self { + self.inner.min_uniform_buffer_offset_alignment = min_uniform_buffer_offset_alignment; + self + } + #[inline] + pub fn min_storage_buffer_offset_alignment( + mut self, + min_storage_buffer_offset_alignment: DeviceSize, + ) -> Self { + self.inner.min_storage_buffer_offset_alignment = min_storage_buffer_offset_alignment; + self + } + #[inline] + pub fn min_texel_offset(mut self, min_texel_offset: i32) -> Self { + self.inner.min_texel_offset = min_texel_offset; + self + } + #[inline] + pub fn max_texel_offset(mut self, max_texel_offset: u32) -> Self { + self.inner.max_texel_offset = max_texel_offset; + self + } + #[inline] + pub fn min_texel_gather_offset(mut self, min_texel_gather_offset: i32) -> Self { + self.inner.min_texel_gather_offset = min_texel_gather_offset; + self + } + #[inline] + pub fn max_texel_gather_offset(mut self, max_texel_gather_offset: u32) -> Self { + self.inner.max_texel_gather_offset = max_texel_gather_offset; + self + } + #[inline] + pub fn min_interpolation_offset(mut self, min_interpolation_offset: f32) -> Self { + self.inner.min_interpolation_offset = min_interpolation_offset; + self + } + #[inline] + pub fn max_interpolation_offset(mut self, max_interpolation_offset: f32) -> Self { + self.inner.max_interpolation_offset = max_interpolation_offset; + self + } + #[inline] + pub fn sub_pixel_interpolation_offset_bits( + mut self, + sub_pixel_interpolation_offset_bits: u32, + ) -> Self { + self.inner.sub_pixel_interpolation_offset_bits = sub_pixel_interpolation_offset_bits; + self + } + #[inline] + pub fn max_framebuffer_width(mut self, max_framebuffer_width: u32) -> Self { + self.inner.max_framebuffer_width = max_framebuffer_width; + self + } + #[inline] + pub fn max_framebuffer_height(mut self, max_framebuffer_height: u32) -> Self { + self.inner.max_framebuffer_height = max_framebuffer_height; + self + } + #[inline] + pub fn max_framebuffer_layers(mut self, max_framebuffer_layers: u32) -> Self { + self.inner.max_framebuffer_layers = max_framebuffer_layers; + self + } + #[inline] + pub fn framebuffer_color_sample_counts( + mut self, + framebuffer_color_sample_counts: SampleCountFlags, + ) -> Self { + self.inner.framebuffer_color_sample_counts = framebuffer_color_sample_counts; + self + } + #[inline] + pub fn framebuffer_depth_sample_counts( + mut self, + framebuffer_depth_sample_counts: SampleCountFlags, + ) -> Self { + self.inner.framebuffer_depth_sample_counts = framebuffer_depth_sample_counts; + self + } + #[inline] + pub fn framebuffer_stencil_sample_counts( + mut self, + framebuffer_stencil_sample_counts: SampleCountFlags, + ) -> Self { + self.inner.framebuffer_stencil_sample_counts = framebuffer_stencil_sample_counts; + self + } + #[inline] + pub fn framebuffer_no_attachments_sample_counts( + mut self, + framebuffer_no_attachments_sample_counts: SampleCountFlags, + ) -> Self { + self.inner.framebuffer_no_attachments_sample_counts = + framebuffer_no_attachments_sample_counts; + self + } + #[inline] + pub fn max_color_attachments(mut self, max_color_attachments: u32) -> Self { + self.inner.max_color_attachments = max_color_attachments; + self + } + #[inline] + pub fn sampled_image_color_sample_counts( + mut self, + sampled_image_color_sample_counts: SampleCountFlags, + ) -> Self { + self.inner.sampled_image_color_sample_counts = sampled_image_color_sample_counts; + self + } + #[inline] + pub fn sampled_image_integer_sample_counts( + mut self, + sampled_image_integer_sample_counts: SampleCountFlags, + ) -> Self { + self.inner.sampled_image_integer_sample_counts = sampled_image_integer_sample_counts; + self + } + #[inline] + pub fn sampled_image_depth_sample_counts( + mut self, + sampled_image_depth_sample_counts: SampleCountFlags, + ) -> Self { + self.inner.sampled_image_depth_sample_counts = sampled_image_depth_sample_counts; + self + } + #[inline] + pub fn sampled_image_stencil_sample_counts( + mut self, + sampled_image_stencil_sample_counts: SampleCountFlags, + ) -> Self { + self.inner.sampled_image_stencil_sample_counts = sampled_image_stencil_sample_counts; + self + } + #[inline] + pub fn storage_image_sample_counts( + mut self, + storage_image_sample_counts: SampleCountFlags, + ) -> Self { + self.inner.storage_image_sample_counts = storage_image_sample_counts; + self + } + #[inline] + pub fn max_sample_mask_words(mut self, max_sample_mask_words: u32) -> Self { + self.inner.max_sample_mask_words = max_sample_mask_words; + self + } + #[inline] + pub fn timestamp_compute_and_graphics(mut self, timestamp_compute_and_graphics: bool) -> Self { + self.inner.timestamp_compute_and_graphics = timestamp_compute_and_graphics.into(); + self + } + #[inline] + pub fn timestamp_period(mut self, timestamp_period: f32) -> Self { + self.inner.timestamp_period = timestamp_period; + self + } + #[inline] + pub fn max_clip_distances(mut self, max_clip_distances: u32) -> Self { + self.inner.max_clip_distances = max_clip_distances; + self + } + #[inline] + pub fn max_cull_distances(mut self, max_cull_distances: u32) -> Self { + self.inner.max_cull_distances = max_cull_distances; + self + } + #[inline] + pub fn max_combined_clip_and_cull_distances( + mut self, + max_combined_clip_and_cull_distances: u32, + ) -> Self { + self.inner.max_combined_clip_and_cull_distances = max_combined_clip_and_cull_distances; + self + } + #[inline] + pub fn discrete_queue_priorities(mut self, discrete_queue_priorities: u32) -> Self { + self.inner.discrete_queue_priorities = discrete_queue_priorities; + self + } + #[inline] + pub fn point_size_range(mut self, point_size_range: [f32; 2]) -> Self { + self.inner.point_size_range = point_size_range; + self + } + #[inline] + pub fn line_width_range(mut self, line_width_range: [f32; 2]) -> Self { + self.inner.line_width_range = line_width_range; + self + } + #[inline] + pub fn point_size_granularity(mut self, point_size_granularity: f32) -> Self { + self.inner.point_size_granularity = point_size_granularity; + self + } + #[inline] + pub fn line_width_granularity(mut self, line_width_granularity: f32) -> Self { + self.inner.line_width_granularity = line_width_granularity; + self + } + #[inline] + pub fn strict_lines(mut self, strict_lines: bool) -> Self { + self.inner.strict_lines = strict_lines.into(); + self + } + #[inline] + pub fn standard_sample_locations(mut self, standard_sample_locations: bool) -> Self { + self.inner.standard_sample_locations = standard_sample_locations.into(); + self + } + #[inline] + pub fn optimal_buffer_copy_offset_alignment( + mut self, + optimal_buffer_copy_offset_alignment: DeviceSize, + ) -> Self { + self.inner.optimal_buffer_copy_offset_alignment = optimal_buffer_copy_offset_alignment; + self + } + #[inline] + pub fn optimal_buffer_copy_row_pitch_alignment( + mut self, + optimal_buffer_copy_row_pitch_alignment: DeviceSize, + ) -> Self { + self.inner.optimal_buffer_copy_row_pitch_alignment = + optimal_buffer_copy_row_pitch_alignment; + self + } + #[inline] + pub fn non_coherent_atom_size(mut self, non_coherent_atom_size: DeviceSize) -> Self { + self.inner.non_coherent_atom_size = non_coherent_atom_size; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceLimits { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SemaphoreCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: SemaphoreCreateFlags, +} +impl ::std::default::Default for SemaphoreCreateInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: SemaphoreCreateFlags::default(), + } + } +} +unsafe impl TaggedStructure for SemaphoreCreateInfo { + const STRUCTURE_TYPE: StructureType = StructureType::SEMAPHORE_CREATE_INFO; +} +impl SemaphoreCreateInfo { + pub fn builder<'a>() -> SemaphoreCreateInfoBuilder<'a> { + SemaphoreCreateInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SemaphoreCreateInfoBuilder<'a> { + inner: SemaphoreCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsSemaphoreCreateInfo {} +impl<'a> ::std::ops::Deref for SemaphoreCreateInfoBuilder<'a> { + type Target = SemaphoreCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SemaphoreCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SemaphoreCreateInfoBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: SemaphoreCreateFlags) -> Self { + self.inner.flags = flags; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SemaphoreCreateInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct QueryPoolCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: QueryPoolCreateFlags, + pub query_type: QueryType, + pub query_count: u32, + pub pipeline_statistics: QueryPipelineStatisticFlags, +} +impl ::std::default::Default for QueryPoolCreateInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: QueryPoolCreateFlags::default(), + query_type: QueryType::default(), + query_count: u32::default(), + pipeline_statistics: QueryPipelineStatisticFlags::default(), + } + } +} +unsafe impl TaggedStructure for QueryPoolCreateInfo { + const STRUCTURE_TYPE: StructureType = StructureType::QUERY_POOL_CREATE_INFO; +} +impl QueryPoolCreateInfo { + pub fn builder<'a>() -> QueryPoolCreateInfoBuilder<'a> { + QueryPoolCreateInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct QueryPoolCreateInfoBuilder<'a> { + inner: QueryPoolCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsQueryPoolCreateInfo {} +impl<'a> ::std::ops::Deref for QueryPoolCreateInfoBuilder<'a> { + type Target = QueryPoolCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for QueryPoolCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> QueryPoolCreateInfoBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: QueryPoolCreateFlags) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn query_type(mut self, query_type: QueryType) -> Self { + self.inner.query_type = query_type; + self + } + #[inline] + pub fn query_count(mut self, query_count: u32) -> Self { + self.inner.query_count = query_count; + self + } + #[inline] + pub fn pipeline_statistics(mut self, pipeline_statistics: QueryPipelineStatisticFlags) -> Self { + self.inner.pipeline_statistics = pipeline_statistics; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> QueryPoolCreateInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct FramebufferCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: FramebufferCreateFlags, + pub render_pass: RenderPass, + pub attachment_count: u32, + pub p_attachments: *const ImageView, + pub width: u32, + pub height: u32, + pub layers: u32, +} +impl ::std::default::Default for FramebufferCreateInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: FramebufferCreateFlags::default(), + render_pass: RenderPass::default(), + attachment_count: u32::default(), + p_attachments: ::std::ptr::null(), + width: u32::default(), + height: u32::default(), + layers: u32::default(), + } + } +} +unsafe impl TaggedStructure for FramebufferCreateInfo { + const STRUCTURE_TYPE: StructureType = StructureType::FRAMEBUFFER_CREATE_INFO; +} +impl FramebufferCreateInfo { + pub fn builder<'a>() -> FramebufferCreateInfoBuilder<'a> { + FramebufferCreateInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct FramebufferCreateInfoBuilder<'a> { + inner: FramebufferCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsFramebufferCreateInfo {} +impl<'a> ::std::ops::Deref for FramebufferCreateInfoBuilder<'a> { + type Target = FramebufferCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for FramebufferCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> FramebufferCreateInfoBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: FramebufferCreateFlags) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn render_pass(mut self, render_pass: RenderPass) -> Self { + self.inner.render_pass = render_pass; + self + } + #[inline] + pub fn attachments(mut self, attachments: &'a [ImageView]) -> Self { + self.inner.attachment_count = attachments.len() as _; + self.inner.p_attachments = attachments.as_ptr(); + self + } + #[inline] + pub fn width(mut self, width: u32) -> Self { + self.inner.width = width; + self + } + #[inline] + pub fn height(mut self, height: u32) -> Self { + self.inner.height = height; + self + } + #[inline] + pub fn layers(mut self, layers: u32) -> Self { + self.inner.layers = layers; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> FramebufferCreateInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct DrawIndirectCommand { + pub vertex_count: u32, + pub instance_count: u32, + pub first_vertex: u32, + pub first_instance: u32, +} +impl DrawIndirectCommand { + pub fn builder<'a>() -> DrawIndirectCommandBuilder<'a> { + DrawIndirectCommandBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DrawIndirectCommandBuilder<'a> { + inner: DrawIndirectCommand, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DrawIndirectCommandBuilder<'a> { + type Target = DrawIndirectCommand; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DrawIndirectCommandBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DrawIndirectCommandBuilder<'a> { + #[inline] + pub fn vertex_count(mut self, vertex_count: u32) -> Self { + self.inner.vertex_count = vertex_count; + self + } + #[inline] + pub fn instance_count(mut self, instance_count: u32) -> Self { + self.inner.instance_count = instance_count; + self + } + #[inline] + pub fn first_vertex(mut self, first_vertex: u32) -> Self { + self.inner.first_vertex = first_vertex; + self + } + #[inline] + pub fn first_instance(mut self, first_instance: u32) -> Self { + self.inner.first_instance = first_instance; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DrawIndirectCommand { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct DrawIndexedIndirectCommand { + pub index_count: u32, + pub instance_count: u32, + pub first_index: u32, + pub vertex_offset: i32, + pub first_instance: u32, +} +impl DrawIndexedIndirectCommand { + pub fn builder<'a>() -> DrawIndexedIndirectCommandBuilder<'a> { + DrawIndexedIndirectCommandBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DrawIndexedIndirectCommandBuilder<'a> { + inner: DrawIndexedIndirectCommand, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DrawIndexedIndirectCommandBuilder<'a> { + type Target = DrawIndexedIndirectCommand; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DrawIndexedIndirectCommandBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DrawIndexedIndirectCommandBuilder<'a> { + #[inline] + pub fn index_count(mut self, index_count: u32) -> Self { + self.inner.index_count = index_count; + self + } + #[inline] + pub fn instance_count(mut self, instance_count: u32) -> Self { + self.inner.instance_count = instance_count; + self + } + #[inline] + pub fn first_index(mut self, first_index: u32) -> Self { + self.inner.first_index = first_index; + self + } + #[inline] + pub fn vertex_offset(mut self, vertex_offset: i32) -> Self { + self.inner.vertex_offset = vertex_offset; + self + } + #[inline] + pub fn first_instance(mut self, first_instance: u32) -> Self { + self.inner.first_instance = first_instance; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DrawIndexedIndirectCommand { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct DispatchIndirectCommand { + pub x: u32, + pub y: u32, + pub z: u32, +} +impl DispatchIndirectCommand { + pub fn builder<'a>() -> DispatchIndirectCommandBuilder<'a> { + DispatchIndirectCommandBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DispatchIndirectCommandBuilder<'a> { + inner: DispatchIndirectCommand, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DispatchIndirectCommandBuilder<'a> { + type Target = DispatchIndirectCommand; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DispatchIndirectCommandBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DispatchIndirectCommandBuilder<'a> { + #[inline] + pub fn x(mut self, x: u32) -> Self { + self.inner.x = x; + self + } + #[inline] + pub fn y(mut self, y: u32) -> Self { + self.inner.y = y; + self + } + #[inline] + pub fn z(mut self, z: u32) -> Self { + self.inner.z = z; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DispatchIndirectCommand { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct MultiDrawInfoEXT { + pub first_vertex: u32, + pub vertex_count: u32, +} +impl MultiDrawInfoEXT { + pub fn builder<'a>() -> MultiDrawInfoEXTBuilder<'a> { + MultiDrawInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct MultiDrawInfoEXTBuilder<'a> { + inner: MultiDrawInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for MultiDrawInfoEXTBuilder<'a> { + type Target = MultiDrawInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for MultiDrawInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> MultiDrawInfoEXTBuilder<'a> { + #[inline] + pub fn first_vertex(mut self, first_vertex: u32) -> Self { + self.inner.first_vertex = first_vertex; + self + } + #[inline] + pub fn vertex_count(mut self, vertex_count: u32) -> Self { + self.inner.vertex_count = vertex_count; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> MultiDrawInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct MultiDrawIndexedInfoEXT { + pub first_index: u32, + pub index_count: u32, + pub vertex_offset: i32, +} +impl MultiDrawIndexedInfoEXT { + pub fn builder<'a>() -> MultiDrawIndexedInfoEXTBuilder<'a> { + MultiDrawIndexedInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct MultiDrawIndexedInfoEXTBuilder<'a> { + inner: MultiDrawIndexedInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for MultiDrawIndexedInfoEXTBuilder<'a> { + type Target = MultiDrawIndexedInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for MultiDrawIndexedInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> MultiDrawIndexedInfoEXTBuilder<'a> { + #[inline] + pub fn first_index(mut self, first_index: u32) -> Self { + self.inner.first_index = first_index; + self + } + #[inline] + pub fn index_count(mut self, index_count: u32) -> Self { + self.inner.index_count = index_count; + self + } + #[inline] + pub fn vertex_offset(mut self, vertex_offset: i32) -> Self { + self.inner.vertex_offset = vertex_offset; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> MultiDrawIndexedInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SubmitInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub wait_semaphore_count: u32, + pub p_wait_semaphores: *const Semaphore, + pub p_wait_dst_stage_mask: *const PipelineStageFlags, + pub command_buffer_count: u32, + pub p_command_buffers: *const CommandBuffer, + pub signal_semaphore_count: u32, + pub p_signal_semaphores: *const Semaphore, +} +impl ::std::default::Default for SubmitInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + wait_semaphore_count: u32::default(), + p_wait_semaphores: ::std::ptr::null(), + p_wait_dst_stage_mask: ::std::ptr::null(), + command_buffer_count: u32::default(), + p_command_buffers: ::std::ptr::null(), + signal_semaphore_count: u32::default(), + p_signal_semaphores: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for SubmitInfo { + const STRUCTURE_TYPE: StructureType = StructureType::SUBMIT_INFO; +} +impl SubmitInfo { + pub fn builder<'a>() -> SubmitInfoBuilder<'a> { + SubmitInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SubmitInfoBuilder<'a> { + inner: SubmitInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsSubmitInfo {} +impl<'a> ::std::ops::Deref for SubmitInfoBuilder<'a> { + type Target = SubmitInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SubmitInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SubmitInfoBuilder<'a> { + #[inline] + pub fn wait_semaphores(mut self, wait_semaphores: &'a [Semaphore]) -> Self { + self.inner.wait_semaphore_count = wait_semaphores.len() as _; + self.inner.p_wait_semaphores = wait_semaphores.as_ptr(); + self + } + #[inline] + pub fn wait_dst_stage_mask(mut self, wait_dst_stage_mask: &'a [PipelineStageFlags]) -> Self { + self.inner.wait_semaphore_count = wait_dst_stage_mask.len() as _; + self.inner.p_wait_dst_stage_mask = wait_dst_stage_mask.as_ptr(); + self + } + #[inline] + pub fn command_buffers(mut self, command_buffers: &'a [CommandBuffer]) -> Self { + self.inner.command_buffer_count = command_buffers.len() as _; + self.inner.p_command_buffers = command_buffers.as_ptr(); + self + } + #[inline] + pub fn signal_semaphores(mut self, signal_semaphores: &'a [Semaphore]) -> Self { + self.inner.signal_semaphore_count = signal_semaphores.len() as _; + self.inner.p_signal_semaphores = signal_semaphores.as_ptr(); + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SubmitInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DisplayPropertiesKHR { + pub display: DisplayKHR, + pub display_name: *const c_char, + pub physical_dimensions: Extent2D, + pub physical_resolution: Extent2D, + pub supported_transforms: SurfaceTransformFlagsKHR, + pub plane_reorder_possible: Bool32, + pub persistent_content: Bool32, +} +impl ::std::default::Default for DisplayPropertiesKHR { + #[inline] + fn default() -> Self { + Self { + display: DisplayKHR::default(), + display_name: ::std::ptr::null(), + physical_dimensions: Extent2D::default(), + physical_resolution: Extent2D::default(), + supported_transforms: SurfaceTransformFlagsKHR::default(), + plane_reorder_possible: Bool32::default(), + persistent_content: Bool32::default(), + } + } +} +impl DisplayPropertiesKHR { + pub fn builder<'a>() -> DisplayPropertiesKHRBuilder<'a> { + DisplayPropertiesKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DisplayPropertiesKHRBuilder<'a> { + inner: DisplayPropertiesKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DisplayPropertiesKHRBuilder<'a> { + type Target = DisplayPropertiesKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DisplayPropertiesKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DisplayPropertiesKHRBuilder<'a> { + #[inline] + pub fn display(mut self, display: DisplayKHR) -> Self { + self.inner.display = display; + self + } + #[inline] + pub fn display_name(mut self, display_name: &'a ::std::ffi::CStr) -> Self { + self.inner.display_name = display_name.as_ptr(); + self + } + #[inline] + pub fn physical_dimensions(mut self, physical_dimensions: Extent2D) -> Self { + self.inner.physical_dimensions = physical_dimensions; + self + } + #[inline] + pub fn physical_resolution(mut self, physical_resolution: Extent2D) -> Self { + self.inner.physical_resolution = physical_resolution; + self + } + #[inline] + pub fn supported_transforms(mut self, supported_transforms: SurfaceTransformFlagsKHR) -> Self { + self.inner.supported_transforms = supported_transforms; + self + } + #[inline] + pub fn plane_reorder_possible(mut self, plane_reorder_possible: bool) -> Self { + self.inner.plane_reorder_possible = plane_reorder_possible.into(); + self + } + #[inline] + pub fn persistent_content(mut self, persistent_content: bool) -> Self { + self.inner.persistent_content = persistent_content.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DisplayPropertiesKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct DisplayPlanePropertiesKHR { + pub current_display: DisplayKHR, + pub current_stack_index: u32, +} +impl DisplayPlanePropertiesKHR { + pub fn builder<'a>() -> DisplayPlanePropertiesKHRBuilder<'a> { + DisplayPlanePropertiesKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DisplayPlanePropertiesKHRBuilder<'a> { + inner: DisplayPlanePropertiesKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DisplayPlanePropertiesKHRBuilder<'a> { + type Target = DisplayPlanePropertiesKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DisplayPlanePropertiesKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DisplayPlanePropertiesKHRBuilder<'a> { + #[inline] + pub fn current_display(mut self, current_display: DisplayKHR) -> Self { + self.inner.current_display = current_display; + self + } + #[inline] + pub fn current_stack_index(mut self, current_stack_index: u32) -> Self { + self.inner.current_stack_index = current_stack_index; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DisplayPlanePropertiesKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct DisplayModeParametersKHR { + pub visible_region: Extent2D, + pub refresh_rate: u32, +} +impl DisplayModeParametersKHR { + pub fn builder<'a>() -> DisplayModeParametersKHRBuilder<'a> { + DisplayModeParametersKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DisplayModeParametersKHRBuilder<'a> { + inner: DisplayModeParametersKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DisplayModeParametersKHRBuilder<'a> { + type Target = DisplayModeParametersKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DisplayModeParametersKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DisplayModeParametersKHRBuilder<'a> { + #[inline] + pub fn visible_region(mut self, visible_region: Extent2D) -> Self { + self.inner.visible_region = visible_region; + self + } + #[inline] + pub fn refresh_rate(mut self, refresh_rate: u32) -> Self { + self.inner.refresh_rate = refresh_rate; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DisplayModeParametersKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct DisplayModePropertiesKHR { + pub display_mode: DisplayModeKHR, + pub parameters: DisplayModeParametersKHR, +} +impl DisplayModePropertiesKHR { + pub fn builder<'a>() -> DisplayModePropertiesKHRBuilder<'a> { + DisplayModePropertiesKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DisplayModePropertiesKHRBuilder<'a> { + inner: DisplayModePropertiesKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DisplayModePropertiesKHRBuilder<'a> { + type Target = DisplayModePropertiesKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DisplayModePropertiesKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DisplayModePropertiesKHRBuilder<'a> { + #[inline] + pub fn display_mode(mut self, display_mode: DisplayModeKHR) -> Self { + self.inner.display_mode = display_mode; + self + } + #[inline] + pub fn parameters(mut self, parameters: DisplayModeParametersKHR) -> Self { + self.inner.parameters = parameters; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DisplayModePropertiesKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DisplayModeCreateInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: DisplayModeCreateFlagsKHR, + pub parameters: DisplayModeParametersKHR, +} +impl ::std::default::Default for DisplayModeCreateInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: DisplayModeCreateFlagsKHR::default(), + parameters: DisplayModeParametersKHR::default(), + } + } +} +unsafe impl TaggedStructure for DisplayModeCreateInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::DISPLAY_MODE_CREATE_INFO_KHR; +} +impl DisplayModeCreateInfoKHR { + pub fn builder<'a>() -> DisplayModeCreateInfoKHRBuilder<'a> { + DisplayModeCreateInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DisplayModeCreateInfoKHRBuilder<'a> { + inner: DisplayModeCreateInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DisplayModeCreateInfoKHRBuilder<'a> { + type Target = DisplayModeCreateInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DisplayModeCreateInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DisplayModeCreateInfoKHRBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: DisplayModeCreateFlagsKHR) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn parameters(mut self, parameters: DisplayModeParametersKHR) -> Self { + self.inner.parameters = parameters; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DisplayModeCreateInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct DisplayPlaneCapabilitiesKHR { + pub supported_alpha: DisplayPlaneAlphaFlagsKHR, + pub min_src_position: Offset2D, + pub max_src_position: Offset2D, + pub min_src_extent: Extent2D, + pub max_src_extent: Extent2D, + pub min_dst_position: Offset2D, + pub max_dst_position: Offset2D, + pub min_dst_extent: Extent2D, + pub max_dst_extent: Extent2D, +} +impl DisplayPlaneCapabilitiesKHR { + pub fn builder<'a>() -> DisplayPlaneCapabilitiesKHRBuilder<'a> { + DisplayPlaneCapabilitiesKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DisplayPlaneCapabilitiesKHRBuilder<'a> { + inner: DisplayPlaneCapabilitiesKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DisplayPlaneCapabilitiesKHRBuilder<'a> { + type Target = DisplayPlaneCapabilitiesKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DisplayPlaneCapabilitiesKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DisplayPlaneCapabilitiesKHRBuilder<'a> { + #[inline] + pub fn supported_alpha(mut self, supported_alpha: DisplayPlaneAlphaFlagsKHR) -> Self { + self.inner.supported_alpha = supported_alpha; + self + } + #[inline] + pub fn min_src_position(mut self, min_src_position: Offset2D) -> Self { + self.inner.min_src_position = min_src_position; + self + } + #[inline] + pub fn max_src_position(mut self, max_src_position: Offset2D) -> Self { + self.inner.max_src_position = max_src_position; + self + } + #[inline] + pub fn min_src_extent(mut self, min_src_extent: Extent2D) -> Self { + self.inner.min_src_extent = min_src_extent; + self + } + #[inline] + pub fn max_src_extent(mut self, max_src_extent: Extent2D) -> Self { + self.inner.max_src_extent = max_src_extent; + self + } + #[inline] + pub fn min_dst_position(mut self, min_dst_position: Offset2D) -> Self { + self.inner.min_dst_position = min_dst_position; + self + } + #[inline] + pub fn max_dst_position(mut self, max_dst_position: Offset2D) -> Self { + self.inner.max_dst_position = max_dst_position; + self + } + #[inline] + pub fn min_dst_extent(mut self, min_dst_extent: Extent2D) -> Self { + self.inner.min_dst_extent = min_dst_extent; + self + } + #[inline] + pub fn max_dst_extent(mut self, max_dst_extent: Extent2D) -> Self { + self.inner.max_dst_extent = max_dst_extent; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DisplayPlaneCapabilitiesKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DisplaySurfaceCreateInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: DisplaySurfaceCreateFlagsKHR, + pub display_mode: DisplayModeKHR, + pub plane_index: u32, + pub plane_stack_index: u32, + pub transform: SurfaceTransformFlagsKHR, + pub global_alpha: f32, + pub alpha_mode: DisplayPlaneAlphaFlagsKHR, + pub image_extent: Extent2D, +} +impl ::std::default::Default for DisplaySurfaceCreateInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: DisplaySurfaceCreateFlagsKHR::default(), + display_mode: DisplayModeKHR::default(), + plane_index: u32::default(), + plane_stack_index: u32::default(), + transform: SurfaceTransformFlagsKHR::default(), + global_alpha: f32::default(), + alpha_mode: DisplayPlaneAlphaFlagsKHR::default(), + image_extent: Extent2D::default(), + } + } +} +unsafe impl TaggedStructure for DisplaySurfaceCreateInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::DISPLAY_SURFACE_CREATE_INFO_KHR; +} +impl DisplaySurfaceCreateInfoKHR { + pub fn builder<'a>() -> DisplaySurfaceCreateInfoKHRBuilder<'a> { + DisplaySurfaceCreateInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DisplaySurfaceCreateInfoKHRBuilder<'a> { + inner: DisplaySurfaceCreateInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DisplaySurfaceCreateInfoKHRBuilder<'a> { + type Target = DisplaySurfaceCreateInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DisplaySurfaceCreateInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DisplaySurfaceCreateInfoKHRBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: DisplaySurfaceCreateFlagsKHR) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn display_mode(mut self, display_mode: DisplayModeKHR) -> Self { + self.inner.display_mode = display_mode; + self + } + #[inline] + pub fn plane_index(mut self, plane_index: u32) -> Self { + self.inner.plane_index = plane_index; + self + } + #[inline] + pub fn plane_stack_index(mut self, plane_stack_index: u32) -> Self { + self.inner.plane_stack_index = plane_stack_index; + self + } + #[inline] + pub fn transform(mut self, transform: SurfaceTransformFlagsKHR) -> Self { + self.inner.transform = transform; + self + } + #[inline] + pub fn global_alpha(mut self, global_alpha: f32) -> Self { + self.inner.global_alpha = global_alpha; + self + } + #[inline] + pub fn alpha_mode(mut self, alpha_mode: DisplayPlaneAlphaFlagsKHR) -> Self { + self.inner.alpha_mode = alpha_mode; + self + } + #[inline] + pub fn image_extent(mut self, image_extent: Extent2D) -> Self { + self.inner.image_extent = image_extent; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DisplaySurfaceCreateInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DisplayPresentInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub src_rect: Rect2D, + pub dst_rect: Rect2D, + pub persistent: Bool32, +} +impl ::std::default::Default for DisplayPresentInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + src_rect: Rect2D::default(), + dst_rect: Rect2D::default(), + persistent: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for DisplayPresentInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::DISPLAY_PRESENT_INFO_KHR; +} +impl DisplayPresentInfoKHR { + pub fn builder<'a>() -> DisplayPresentInfoKHRBuilder<'a> { + DisplayPresentInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DisplayPresentInfoKHRBuilder<'a> { + inner: DisplayPresentInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPresentInfoKHR for DisplayPresentInfoKHRBuilder<'_> {} +unsafe impl ExtendsPresentInfoKHR for DisplayPresentInfoKHR {} +impl<'a> ::std::ops::Deref for DisplayPresentInfoKHRBuilder<'a> { + type Target = DisplayPresentInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DisplayPresentInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DisplayPresentInfoKHRBuilder<'a> { + #[inline] + pub fn src_rect(mut self, src_rect: Rect2D) -> Self { + self.inner.src_rect = src_rect; + self + } + #[inline] + pub fn dst_rect(mut self, dst_rect: Rect2D) -> Self { + self.inner.dst_rect = dst_rect; + self + } + #[inline] + pub fn persistent(mut self, persistent: bool) -> Self { + self.inner.persistent = persistent.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DisplayPresentInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct SurfaceCapabilitiesKHR { + pub min_image_count: u32, + pub max_image_count: u32, + pub current_extent: Extent2D, + pub min_image_extent: Extent2D, + pub max_image_extent: Extent2D, + pub max_image_array_layers: u32, + pub supported_transforms: SurfaceTransformFlagsKHR, + pub current_transform: SurfaceTransformFlagsKHR, + pub supported_composite_alpha: CompositeAlphaFlagsKHR, + pub supported_usage_flags: ImageUsageFlags, +} +impl SurfaceCapabilitiesKHR { + pub fn builder<'a>() -> SurfaceCapabilitiesKHRBuilder<'a> { + SurfaceCapabilitiesKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SurfaceCapabilitiesKHRBuilder<'a> { + inner: SurfaceCapabilitiesKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for SurfaceCapabilitiesKHRBuilder<'a> { + type Target = SurfaceCapabilitiesKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SurfaceCapabilitiesKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SurfaceCapabilitiesKHRBuilder<'a> { + #[inline] + pub fn min_image_count(mut self, min_image_count: u32) -> Self { + self.inner.min_image_count = min_image_count; + self + } + #[inline] + pub fn max_image_count(mut self, max_image_count: u32) -> Self { + self.inner.max_image_count = max_image_count; + self + } + #[inline] + pub fn current_extent(mut self, current_extent: Extent2D) -> Self { + self.inner.current_extent = current_extent; + self + } + #[inline] + pub fn min_image_extent(mut self, min_image_extent: Extent2D) -> Self { + self.inner.min_image_extent = min_image_extent; + self + } + #[inline] + pub fn max_image_extent(mut self, max_image_extent: Extent2D) -> Self { + self.inner.max_image_extent = max_image_extent; + self + } + #[inline] + pub fn max_image_array_layers(mut self, max_image_array_layers: u32) -> Self { + self.inner.max_image_array_layers = max_image_array_layers; + self + } + #[inline] + pub fn supported_transforms(mut self, supported_transforms: SurfaceTransformFlagsKHR) -> Self { + self.inner.supported_transforms = supported_transforms; + self + } + #[inline] + pub fn current_transform(mut self, current_transform: SurfaceTransformFlagsKHR) -> Self { + self.inner.current_transform = current_transform; + self + } + #[inline] + pub fn supported_composite_alpha( + mut self, + supported_composite_alpha: CompositeAlphaFlagsKHR, + ) -> Self { + self.inner.supported_composite_alpha = supported_composite_alpha; + self + } + #[inline] + pub fn supported_usage_flags(mut self, supported_usage_flags: ImageUsageFlags) -> Self { + self.inner.supported_usage_flags = supported_usage_flags; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SurfaceCapabilitiesKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct AndroidSurfaceCreateInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: AndroidSurfaceCreateFlagsKHR, + pub window: *mut ANativeWindow, +} +impl ::std::default::Default for AndroidSurfaceCreateInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: AndroidSurfaceCreateFlagsKHR::default(), + window: ::std::ptr::null_mut(), + } + } +} +unsafe impl TaggedStructure for AndroidSurfaceCreateInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::ANDROID_SURFACE_CREATE_INFO_KHR; +} +impl AndroidSurfaceCreateInfoKHR { + pub fn builder<'a>() -> AndroidSurfaceCreateInfoKHRBuilder<'a> { + AndroidSurfaceCreateInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct AndroidSurfaceCreateInfoKHRBuilder<'a> { + inner: AndroidSurfaceCreateInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for AndroidSurfaceCreateInfoKHRBuilder<'a> { + type Target = AndroidSurfaceCreateInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for AndroidSurfaceCreateInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> AndroidSurfaceCreateInfoKHRBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: AndroidSurfaceCreateFlagsKHR) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn window(mut self, window: *mut ANativeWindow) -> Self { + self.inner.window = window; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> AndroidSurfaceCreateInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ViSurfaceCreateInfoNN { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: ViSurfaceCreateFlagsNN, + pub window: *mut c_void, +} +impl ::std::default::Default for ViSurfaceCreateInfoNN { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: ViSurfaceCreateFlagsNN::default(), + window: ::std::ptr::null_mut(), + } + } +} +unsafe impl TaggedStructure for ViSurfaceCreateInfoNN { + const STRUCTURE_TYPE: StructureType = StructureType::VI_SURFACE_CREATE_INFO_NN; +} +impl ViSurfaceCreateInfoNN { + pub fn builder<'a>() -> ViSurfaceCreateInfoNNBuilder<'a> { + ViSurfaceCreateInfoNNBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ViSurfaceCreateInfoNNBuilder<'a> { + inner: ViSurfaceCreateInfoNN, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ViSurfaceCreateInfoNNBuilder<'a> { + type Target = ViSurfaceCreateInfoNN; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ViSurfaceCreateInfoNNBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ViSurfaceCreateInfoNNBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: ViSurfaceCreateFlagsNN) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn window(mut self, window: *mut c_void) -> Self { + self.inner.window = window; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ViSurfaceCreateInfoNN { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct WaylandSurfaceCreateInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: WaylandSurfaceCreateFlagsKHR, + pub display: *mut wl_display, + pub surface: *mut wl_surface, +} +impl ::std::default::Default for WaylandSurfaceCreateInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: WaylandSurfaceCreateFlagsKHR::default(), + display: ::std::ptr::null_mut(), + surface: ::std::ptr::null_mut(), + } + } +} +unsafe impl TaggedStructure for WaylandSurfaceCreateInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::WAYLAND_SURFACE_CREATE_INFO_KHR; +} +impl WaylandSurfaceCreateInfoKHR { + pub fn builder<'a>() -> WaylandSurfaceCreateInfoKHRBuilder<'a> { + WaylandSurfaceCreateInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct WaylandSurfaceCreateInfoKHRBuilder<'a> { + inner: WaylandSurfaceCreateInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for WaylandSurfaceCreateInfoKHRBuilder<'a> { + type Target = WaylandSurfaceCreateInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for WaylandSurfaceCreateInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> WaylandSurfaceCreateInfoKHRBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: WaylandSurfaceCreateFlagsKHR) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn display(mut self, display: *mut wl_display) -> Self { + self.inner.display = display; + self + } + #[inline] + pub fn surface(mut self, surface: *mut wl_surface) -> Self { + self.inner.surface = surface; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> WaylandSurfaceCreateInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct Win32SurfaceCreateInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: Win32SurfaceCreateFlagsKHR, + pub hinstance: HINSTANCE, + pub hwnd: HWND, +} +impl ::std::default::Default for Win32SurfaceCreateInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: Win32SurfaceCreateFlagsKHR::default(), + hinstance: unsafe { ::std::mem::zeroed() }, + hwnd: unsafe { ::std::mem::zeroed() }, + } + } +} +unsafe impl TaggedStructure for Win32SurfaceCreateInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::WIN32_SURFACE_CREATE_INFO_KHR; +} +impl Win32SurfaceCreateInfoKHR { + pub fn builder<'a>() -> Win32SurfaceCreateInfoKHRBuilder<'a> { + Win32SurfaceCreateInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct Win32SurfaceCreateInfoKHRBuilder<'a> { + inner: Win32SurfaceCreateInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for Win32SurfaceCreateInfoKHRBuilder<'a> { + type Target = Win32SurfaceCreateInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for Win32SurfaceCreateInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> Win32SurfaceCreateInfoKHRBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: Win32SurfaceCreateFlagsKHR) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn hinstance(mut self, hinstance: HINSTANCE) -> Self { + self.inner.hinstance = hinstance; + self + } + #[inline] + pub fn hwnd(mut self, hwnd: HWND) -> Self { + self.inner.hwnd = hwnd; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> Win32SurfaceCreateInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct XlibSurfaceCreateInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: XlibSurfaceCreateFlagsKHR, + pub dpy: *mut Display, + pub window: Window, +} +impl ::std::default::Default for XlibSurfaceCreateInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: XlibSurfaceCreateFlagsKHR::default(), + dpy: ::std::ptr::null_mut(), + window: Window::default(), + } + } +} +unsafe impl TaggedStructure for XlibSurfaceCreateInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::XLIB_SURFACE_CREATE_INFO_KHR; +} +impl XlibSurfaceCreateInfoKHR { + pub fn builder<'a>() -> XlibSurfaceCreateInfoKHRBuilder<'a> { + XlibSurfaceCreateInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct XlibSurfaceCreateInfoKHRBuilder<'a> { + inner: XlibSurfaceCreateInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for XlibSurfaceCreateInfoKHRBuilder<'a> { + type Target = XlibSurfaceCreateInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for XlibSurfaceCreateInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> XlibSurfaceCreateInfoKHRBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: XlibSurfaceCreateFlagsKHR) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn dpy(mut self, dpy: *mut Display) -> Self { + self.inner.dpy = dpy; + self + } + #[inline] + pub fn window(mut self, window: Window) -> Self { + self.inner.window = window; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> XlibSurfaceCreateInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct XcbSurfaceCreateInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: XcbSurfaceCreateFlagsKHR, + pub connection: *mut xcb_connection_t, + pub window: xcb_window_t, +} +impl ::std::default::Default for XcbSurfaceCreateInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: XcbSurfaceCreateFlagsKHR::default(), + connection: ::std::ptr::null_mut(), + window: xcb_window_t::default(), + } + } +} +unsafe impl TaggedStructure for XcbSurfaceCreateInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::XCB_SURFACE_CREATE_INFO_KHR; +} +impl XcbSurfaceCreateInfoKHR { + pub fn builder<'a>() -> XcbSurfaceCreateInfoKHRBuilder<'a> { + XcbSurfaceCreateInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct XcbSurfaceCreateInfoKHRBuilder<'a> { + inner: XcbSurfaceCreateInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for XcbSurfaceCreateInfoKHRBuilder<'a> { + type Target = XcbSurfaceCreateInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for XcbSurfaceCreateInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> XcbSurfaceCreateInfoKHRBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: XcbSurfaceCreateFlagsKHR) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn connection(mut self, connection: *mut xcb_connection_t) -> Self { + self.inner.connection = connection; + self + } + #[inline] + pub fn window(mut self, window: xcb_window_t) -> Self { + self.inner.window = window; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> XcbSurfaceCreateInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DirectFBSurfaceCreateInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: DirectFBSurfaceCreateFlagsEXT, + pub dfb: *mut IDirectFB, + pub surface: *mut IDirectFBSurface, +} +impl ::std::default::Default for DirectFBSurfaceCreateInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: DirectFBSurfaceCreateFlagsEXT::default(), + dfb: ::std::ptr::null_mut(), + surface: ::std::ptr::null_mut(), + } + } +} +unsafe impl TaggedStructure for DirectFBSurfaceCreateInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::DIRECTFB_SURFACE_CREATE_INFO_EXT; +} +impl DirectFBSurfaceCreateInfoEXT { + pub fn builder<'a>() -> DirectFBSurfaceCreateInfoEXTBuilder<'a> { + DirectFBSurfaceCreateInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DirectFBSurfaceCreateInfoEXTBuilder<'a> { + inner: DirectFBSurfaceCreateInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DirectFBSurfaceCreateInfoEXTBuilder<'a> { + type Target = DirectFBSurfaceCreateInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DirectFBSurfaceCreateInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DirectFBSurfaceCreateInfoEXTBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: DirectFBSurfaceCreateFlagsEXT) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn dfb(mut self, dfb: *mut IDirectFB) -> Self { + self.inner.dfb = dfb; + self + } + #[inline] + pub fn surface(mut self, surface: *mut IDirectFBSurface) -> Self { + self.inner.surface = surface; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DirectFBSurfaceCreateInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ImagePipeSurfaceCreateInfoFUCHSIA { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: ImagePipeSurfaceCreateFlagsFUCHSIA, + pub image_pipe_handle: zx_handle_t, +} +impl ::std::default::Default for ImagePipeSurfaceCreateInfoFUCHSIA { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: ImagePipeSurfaceCreateFlagsFUCHSIA::default(), + image_pipe_handle: zx_handle_t::default(), + } + } +} +unsafe impl TaggedStructure for ImagePipeSurfaceCreateInfoFUCHSIA { + const STRUCTURE_TYPE: StructureType = StructureType::IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA; +} +impl ImagePipeSurfaceCreateInfoFUCHSIA { + pub fn builder<'a>() -> ImagePipeSurfaceCreateInfoFUCHSIABuilder<'a> { + ImagePipeSurfaceCreateInfoFUCHSIABuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ImagePipeSurfaceCreateInfoFUCHSIABuilder<'a> { + inner: ImagePipeSurfaceCreateInfoFUCHSIA, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ImagePipeSurfaceCreateInfoFUCHSIABuilder<'a> { + type Target = ImagePipeSurfaceCreateInfoFUCHSIA; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ImagePipeSurfaceCreateInfoFUCHSIABuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ImagePipeSurfaceCreateInfoFUCHSIABuilder<'a> { + #[inline] + pub fn flags(mut self, flags: ImagePipeSurfaceCreateFlagsFUCHSIA) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn image_pipe_handle(mut self, image_pipe_handle: zx_handle_t) -> Self { + self.inner.image_pipe_handle = image_pipe_handle; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ImagePipeSurfaceCreateInfoFUCHSIA { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct StreamDescriptorSurfaceCreateInfoGGP { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: StreamDescriptorSurfaceCreateFlagsGGP, + pub stream_descriptor: GgpStreamDescriptor, +} +impl ::std::default::Default for StreamDescriptorSurfaceCreateInfoGGP { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: StreamDescriptorSurfaceCreateFlagsGGP::default(), + stream_descriptor: GgpStreamDescriptor::default(), + } + } +} +unsafe impl TaggedStructure for StreamDescriptorSurfaceCreateInfoGGP { + const STRUCTURE_TYPE: StructureType = StructureType::STREAM_DESCRIPTOR_SURFACE_CREATE_INFO_GGP; +} +impl StreamDescriptorSurfaceCreateInfoGGP { + pub fn builder<'a>() -> StreamDescriptorSurfaceCreateInfoGGPBuilder<'a> { + StreamDescriptorSurfaceCreateInfoGGPBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct StreamDescriptorSurfaceCreateInfoGGPBuilder<'a> { + inner: StreamDescriptorSurfaceCreateInfoGGP, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for StreamDescriptorSurfaceCreateInfoGGPBuilder<'a> { + type Target = StreamDescriptorSurfaceCreateInfoGGP; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for StreamDescriptorSurfaceCreateInfoGGPBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> StreamDescriptorSurfaceCreateInfoGGPBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: StreamDescriptorSurfaceCreateFlagsGGP) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn stream_descriptor(mut self, stream_descriptor: GgpStreamDescriptor) -> Self { + self.inner.stream_descriptor = stream_descriptor; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> StreamDescriptorSurfaceCreateInfoGGP { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ScreenSurfaceCreateInfoQNX { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: ScreenSurfaceCreateFlagsQNX, + pub context: *mut _screen_context, + pub window: *mut _screen_window, +} +impl ::std::default::Default for ScreenSurfaceCreateInfoQNX { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: ScreenSurfaceCreateFlagsQNX::default(), + context: ::std::ptr::null_mut(), + window: ::std::ptr::null_mut(), + } + } +} +unsafe impl TaggedStructure for ScreenSurfaceCreateInfoQNX { + const STRUCTURE_TYPE: StructureType = StructureType::SCREEN_SURFACE_CREATE_INFO_QNX; +} +impl ScreenSurfaceCreateInfoQNX { + pub fn builder<'a>() -> ScreenSurfaceCreateInfoQNXBuilder<'a> { + ScreenSurfaceCreateInfoQNXBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ScreenSurfaceCreateInfoQNXBuilder<'a> { + inner: ScreenSurfaceCreateInfoQNX, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ScreenSurfaceCreateInfoQNXBuilder<'a> { + type Target = ScreenSurfaceCreateInfoQNX; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ScreenSurfaceCreateInfoQNXBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ScreenSurfaceCreateInfoQNXBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: ScreenSurfaceCreateFlagsQNX) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn context(mut self, context: &'a mut _screen_context) -> Self { + self.inner.context = context; + self + } + #[inline] + pub fn window(mut self, window: &'a mut _screen_window) -> Self { + self.inner.window = window; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ScreenSurfaceCreateInfoQNX { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default, PartialEq, Eq, Hash)] +#[doc = ""] +pub struct SurfaceFormatKHR { + pub format: Format, + pub color_space: ColorSpaceKHR, +} +impl SurfaceFormatKHR { + pub fn builder<'a>() -> SurfaceFormatKHRBuilder<'a> { + SurfaceFormatKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SurfaceFormatKHRBuilder<'a> { + inner: SurfaceFormatKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for SurfaceFormatKHRBuilder<'a> { + type Target = SurfaceFormatKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SurfaceFormatKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SurfaceFormatKHRBuilder<'a> { + #[inline] + pub fn format(mut self, format: Format) -> Self { + self.inner.format = format; + self + } + #[inline] + pub fn color_space(mut self, color_space: ColorSpaceKHR) -> Self { + self.inner.color_space = color_space; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SurfaceFormatKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SwapchainCreateInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: SwapchainCreateFlagsKHR, + pub surface: SurfaceKHR, + pub min_image_count: u32, + pub image_format: Format, + pub image_color_space: ColorSpaceKHR, + pub image_extent: Extent2D, + pub image_array_layers: u32, + pub image_usage: ImageUsageFlags, + pub image_sharing_mode: SharingMode, + pub queue_family_index_count: u32, + pub p_queue_family_indices: *const u32, + pub pre_transform: SurfaceTransformFlagsKHR, + pub composite_alpha: CompositeAlphaFlagsKHR, + pub present_mode: PresentModeKHR, + pub clipped: Bool32, + pub old_swapchain: SwapchainKHR, +} +impl ::std::default::Default for SwapchainCreateInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: SwapchainCreateFlagsKHR::default(), + surface: SurfaceKHR::default(), + min_image_count: u32::default(), + image_format: Format::default(), + image_color_space: ColorSpaceKHR::default(), + image_extent: Extent2D::default(), + image_array_layers: u32::default(), + image_usage: ImageUsageFlags::default(), + image_sharing_mode: SharingMode::default(), + queue_family_index_count: u32::default(), + p_queue_family_indices: ::std::ptr::null(), + pre_transform: SurfaceTransformFlagsKHR::default(), + composite_alpha: CompositeAlphaFlagsKHR::default(), + present_mode: PresentModeKHR::default(), + clipped: Bool32::default(), + old_swapchain: SwapchainKHR::default(), + } + } +} +unsafe impl TaggedStructure for SwapchainCreateInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::SWAPCHAIN_CREATE_INFO_KHR; +} +impl SwapchainCreateInfoKHR { + pub fn builder<'a>() -> SwapchainCreateInfoKHRBuilder<'a> { + SwapchainCreateInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SwapchainCreateInfoKHRBuilder<'a> { + inner: SwapchainCreateInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsSwapchainCreateInfoKHR {} +impl<'a> ::std::ops::Deref for SwapchainCreateInfoKHRBuilder<'a> { + type Target = SwapchainCreateInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SwapchainCreateInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SwapchainCreateInfoKHRBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: SwapchainCreateFlagsKHR) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn surface(mut self, surface: SurfaceKHR) -> Self { + self.inner.surface = surface; + self + } + #[inline] + pub fn min_image_count(mut self, min_image_count: u32) -> Self { + self.inner.min_image_count = min_image_count; + self + } + #[inline] + pub fn image_format(mut self, image_format: Format) -> Self { + self.inner.image_format = image_format; + self + } + #[inline] + pub fn image_color_space(mut self, image_color_space: ColorSpaceKHR) -> Self { + self.inner.image_color_space = image_color_space; + self + } + #[inline] + pub fn image_extent(mut self, image_extent: Extent2D) -> Self { + self.inner.image_extent = image_extent; + self + } + #[inline] + pub fn image_array_layers(mut self, image_array_layers: u32) -> Self { + self.inner.image_array_layers = image_array_layers; + self + } + #[inline] + pub fn image_usage(mut self, image_usage: ImageUsageFlags) -> Self { + self.inner.image_usage = image_usage; + self + } + #[inline] + pub fn image_sharing_mode(mut self, image_sharing_mode: SharingMode) -> Self { + self.inner.image_sharing_mode = image_sharing_mode; + self + } + #[inline] + pub fn queue_family_indices(mut self, queue_family_indices: &'a [u32]) -> Self { + self.inner.queue_family_index_count = queue_family_indices.len() as _; + self.inner.p_queue_family_indices = queue_family_indices.as_ptr(); + self + } + #[inline] + pub fn pre_transform(mut self, pre_transform: SurfaceTransformFlagsKHR) -> Self { + self.inner.pre_transform = pre_transform; + self + } + #[inline] + pub fn composite_alpha(mut self, composite_alpha: CompositeAlphaFlagsKHR) -> Self { + self.inner.composite_alpha = composite_alpha; + self + } + #[inline] + pub fn present_mode(mut self, present_mode: PresentModeKHR) -> Self { + self.inner.present_mode = present_mode; + self + } + #[inline] + pub fn clipped(mut self, clipped: bool) -> Self { + self.inner.clipped = clipped.into(); + self + } + #[inline] + pub fn old_swapchain(mut self, old_swapchain: SwapchainKHR) -> Self { + self.inner.old_swapchain = old_swapchain; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SwapchainCreateInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PresentInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub wait_semaphore_count: u32, + pub p_wait_semaphores: *const Semaphore, + pub swapchain_count: u32, + pub p_swapchains: *const SwapchainKHR, + pub p_image_indices: *const u32, + pub p_results: *mut Result, +} +impl ::std::default::Default for PresentInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + wait_semaphore_count: u32::default(), + p_wait_semaphores: ::std::ptr::null(), + swapchain_count: u32::default(), + p_swapchains: ::std::ptr::null(), + p_image_indices: ::std::ptr::null(), + p_results: ::std::ptr::null_mut(), + } + } +} +unsafe impl TaggedStructure for PresentInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::PRESENT_INFO_KHR; +} +impl PresentInfoKHR { + pub fn builder<'a>() -> PresentInfoKHRBuilder<'a> { + PresentInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PresentInfoKHRBuilder<'a> { + inner: PresentInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsPresentInfoKHR {} +impl<'a> ::std::ops::Deref for PresentInfoKHRBuilder<'a> { + type Target = PresentInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PresentInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PresentInfoKHRBuilder<'a> { + #[inline] + pub fn wait_semaphores(mut self, wait_semaphores: &'a [Semaphore]) -> Self { + self.inner.wait_semaphore_count = wait_semaphores.len() as _; + self.inner.p_wait_semaphores = wait_semaphores.as_ptr(); + self + } + #[inline] + pub fn swapchains(mut self, swapchains: &'a [SwapchainKHR]) -> Self { + self.inner.swapchain_count = swapchains.len() as _; + self.inner.p_swapchains = swapchains.as_ptr(); + self + } + #[inline] + pub fn image_indices(mut self, image_indices: &'a [u32]) -> Self { + self.inner.swapchain_count = image_indices.len() as _; + self.inner.p_image_indices = image_indices.as_ptr(); + self + } + #[inline] + pub fn results(mut self, results: &'a mut [Result]) -> Self { + self.inner.swapchain_count = results.len() as _; + self.inner.p_results = results.as_mut_ptr(); + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PresentInfoKHR { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DebugReportCallbackCreateInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: DebugReportFlagsEXT, + pub pfn_callback: PFN_vkDebugReportCallbackEXT, + pub p_user_data: *mut c_void, +} +#[cfg(feature = "debug")] +impl fmt::Debug for DebugReportCallbackCreateInfoEXT { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fmt.debug_struct("DebugReportCallbackCreateInfoEXT") + .field("s_type", &self.s_type) + .field("p_next", &self.p_next) + .field("flags", &self.flags) + .field("pfn_callback", &(self.pfn_callback.map(|x| x as *const ()))) + .field("p_user_data", &self.p_user_data) + .finish() + } +} +impl ::std::default::Default for DebugReportCallbackCreateInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: DebugReportFlagsEXT::default(), + pfn_callback: PFN_vkDebugReportCallbackEXT::default(), + p_user_data: ::std::ptr::null_mut(), + } + } +} +unsafe impl TaggedStructure for DebugReportCallbackCreateInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT; +} +impl DebugReportCallbackCreateInfoEXT { + pub fn builder<'a>() -> DebugReportCallbackCreateInfoEXTBuilder<'a> { + DebugReportCallbackCreateInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DebugReportCallbackCreateInfoEXTBuilder<'a> { + inner: DebugReportCallbackCreateInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsInstanceCreateInfo for DebugReportCallbackCreateInfoEXTBuilder<'_> {} +unsafe impl ExtendsInstanceCreateInfo for DebugReportCallbackCreateInfoEXT {} +impl<'a> ::std::ops::Deref for DebugReportCallbackCreateInfoEXTBuilder<'a> { + type Target = DebugReportCallbackCreateInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DebugReportCallbackCreateInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DebugReportCallbackCreateInfoEXTBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: DebugReportFlagsEXT) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn pfn_callback(mut self, pfn_callback: PFN_vkDebugReportCallbackEXT) -> Self { + self.inner.pfn_callback = pfn_callback; + self + } + #[inline] + pub fn user_data(mut self, user_data: *mut c_void) -> Self { + self.inner.p_user_data = user_data; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DebugReportCallbackCreateInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ValidationFlagsEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub disabled_validation_check_count: u32, + pub p_disabled_validation_checks: *const ValidationCheckEXT, +} +impl ::std::default::Default for ValidationFlagsEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + disabled_validation_check_count: u32::default(), + p_disabled_validation_checks: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for ValidationFlagsEXT { + const STRUCTURE_TYPE: StructureType = StructureType::VALIDATION_FLAGS_EXT; +} +impl ValidationFlagsEXT { + pub fn builder<'a>() -> ValidationFlagsEXTBuilder<'a> { + ValidationFlagsEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ValidationFlagsEXTBuilder<'a> { + inner: ValidationFlagsEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsInstanceCreateInfo for ValidationFlagsEXTBuilder<'_> {} +unsafe impl ExtendsInstanceCreateInfo for ValidationFlagsEXT {} +impl<'a> ::std::ops::Deref for ValidationFlagsEXTBuilder<'a> { + type Target = ValidationFlagsEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ValidationFlagsEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ValidationFlagsEXTBuilder<'a> { + #[inline] + pub fn disabled_validation_checks( + mut self, + disabled_validation_checks: &'a [ValidationCheckEXT], + ) -> Self { + self.inner.disabled_validation_check_count = disabled_validation_checks.len() as _; + self.inner.p_disabled_validation_checks = disabled_validation_checks.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ValidationFlagsEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ValidationFeaturesEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub enabled_validation_feature_count: u32, + pub p_enabled_validation_features: *const ValidationFeatureEnableEXT, + pub disabled_validation_feature_count: u32, + pub p_disabled_validation_features: *const ValidationFeatureDisableEXT, +} +impl ::std::default::Default for ValidationFeaturesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + enabled_validation_feature_count: u32::default(), + p_enabled_validation_features: ::std::ptr::null(), + disabled_validation_feature_count: u32::default(), + p_disabled_validation_features: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for ValidationFeaturesEXT { + const STRUCTURE_TYPE: StructureType = StructureType::VALIDATION_FEATURES_EXT; +} +impl ValidationFeaturesEXT { + pub fn builder<'a>() -> ValidationFeaturesEXTBuilder<'a> { + ValidationFeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ValidationFeaturesEXTBuilder<'a> { + inner: ValidationFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsInstanceCreateInfo for ValidationFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsInstanceCreateInfo for ValidationFeaturesEXT {} +impl<'a> ::std::ops::Deref for ValidationFeaturesEXTBuilder<'a> { + type Target = ValidationFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ValidationFeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ValidationFeaturesEXTBuilder<'a> { + #[inline] + pub fn enabled_validation_features( + mut self, + enabled_validation_features: &'a [ValidationFeatureEnableEXT], + ) -> Self { + self.inner.enabled_validation_feature_count = enabled_validation_features.len() as _; + self.inner.p_enabled_validation_features = enabled_validation_features.as_ptr(); + self + } + #[inline] + pub fn disabled_validation_features( + mut self, + disabled_validation_features: &'a [ValidationFeatureDisableEXT], + ) -> Self { + self.inner.disabled_validation_feature_count = disabled_validation_features.len() as _; + self.inner.p_disabled_validation_features = disabled_validation_features.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ValidationFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PipelineRasterizationStateRasterizationOrderAMD { + pub s_type: StructureType, + pub p_next: *const c_void, + pub rasterization_order: RasterizationOrderAMD, +} +impl ::std::default::Default for PipelineRasterizationStateRasterizationOrderAMD { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + rasterization_order: RasterizationOrderAMD::default(), + } + } +} +unsafe impl TaggedStructure for PipelineRasterizationStateRasterizationOrderAMD { + const STRUCTURE_TYPE: StructureType = + StructureType::PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD; +} +impl PipelineRasterizationStateRasterizationOrderAMD { + pub fn builder<'a>() -> PipelineRasterizationStateRasterizationOrderAMDBuilder<'a> { + PipelineRasterizationStateRasterizationOrderAMDBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PipelineRasterizationStateRasterizationOrderAMDBuilder<'a> { + inner: PipelineRasterizationStateRasterizationOrderAMD, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPipelineRasterizationStateCreateInfo + for PipelineRasterizationStateRasterizationOrderAMDBuilder<'_> +{ +} +unsafe impl ExtendsPipelineRasterizationStateCreateInfo + for PipelineRasterizationStateRasterizationOrderAMD +{ +} +impl<'a> ::std::ops::Deref for PipelineRasterizationStateRasterizationOrderAMDBuilder<'a> { + type Target = PipelineRasterizationStateRasterizationOrderAMD; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PipelineRasterizationStateRasterizationOrderAMDBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PipelineRasterizationStateRasterizationOrderAMDBuilder<'a> { + #[inline] + pub fn rasterization_order(mut self, rasterization_order: RasterizationOrderAMD) -> Self { + self.inner.rasterization_order = rasterization_order; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PipelineRasterizationStateRasterizationOrderAMD { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DebugMarkerObjectNameInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub object_type: DebugReportObjectTypeEXT, + pub object: u64, + pub p_object_name: *const c_char, +} +impl ::std::default::Default for DebugMarkerObjectNameInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + object_type: DebugReportObjectTypeEXT::default(), + object: u64::default(), + p_object_name: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for DebugMarkerObjectNameInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::DEBUG_MARKER_OBJECT_NAME_INFO_EXT; +} +impl DebugMarkerObjectNameInfoEXT { + pub fn builder<'a>() -> DebugMarkerObjectNameInfoEXTBuilder<'a> { + DebugMarkerObjectNameInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DebugMarkerObjectNameInfoEXTBuilder<'a> { + inner: DebugMarkerObjectNameInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DebugMarkerObjectNameInfoEXTBuilder<'a> { + type Target = DebugMarkerObjectNameInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DebugMarkerObjectNameInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DebugMarkerObjectNameInfoEXTBuilder<'a> { + #[inline] + pub fn object_type(mut self, object_type: DebugReportObjectTypeEXT) -> Self { + self.inner.object_type = object_type; + self + } + #[inline] + pub fn object(mut self, object: u64) -> Self { + self.inner.object = object; + self + } + #[inline] + pub fn object_name(mut self, object_name: &'a ::std::ffi::CStr) -> Self { + self.inner.p_object_name = object_name.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DebugMarkerObjectNameInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DebugMarkerObjectTagInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub object_type: DebugReportObjectTypeEXT, + pub object: u64, + pub tag_name: u64, + pub tag_size: usize, + pub p_tag: *const c_void, +} +impl ::std::default::Default for DebugMarkerObjectTagInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + object_type: DebugReportObjectTypeEXT::default(), + object: u64::default(), + tag_name: u64::default(), + tag_size: usize::default(), + p_tag: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for DebugMarkerObjectTagInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::DEBUG_MARKER_OBJECT_TAG_INFO_EXT; +} +impl DebugMarkerObjectTagInfoEXT { + pub fn builder<'a>() -> DebugMarkerObjectTagInfoEXTBuilder<'a> { + DebugMarkerObjectTagInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DebugMarkerObjectTagInfoEXTBuilder<'a> { + inner: DebugMarkerObjectTagInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DebugMarkerObjectTagInfoEXTBuilder<'a> { + type Target = DebugMarkerObjectTagInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DebugMarkerObjectTagInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DebugMarkerObjectTagInfoEXTBuilder<'a> { + #[inline] + pub fn object_type(mut self, object_type: DebugReportObjectTypeEXT) -> Self { + self.inner.object_type = object_type; + self + } + #[inline] + pub fn object(mut self, object: u64) -> Self { + self.inner.object = object; + self + } + #[inline] + pub fn tag_name(mut self, tag_name: u64) -> Self { + self.inner.tag_name = tag_name; + self + } + #[inline] + pub fn tag(mut self, tag: &'a [u8]) -> Self { + self.inner.tag_size = tag.len(); + self.inner.p_tag = tag.as_ptr().cast(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DebugMarkerObjectTagInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DebugMarkerMarkerInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub p_marker_name: *const c_char, + pub color: [f32; 4], +} +impl ::std::default::Default for DebugMarkerMarkerInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + p_marker_name: ::std::ptr::null(), + color: unsafe { ::std::mem::zeroed() }, + } + } +} +unsafe impl TaggedStructure for DebugMarkerMarkerInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::DEBUG_MARKER_MARKER_INFO_EXT; +} +impl DebugMarkerMarkerInfoEXT { + pub fn builder<'a>() -> DebugMarkerMarkerInfoEXTBuilder<'a> { + DebugMarkerMarkerInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DebugMarkerMarkerInfoEXTBuilder<'a> { + inner: DebugMarkerMarkerInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DebugMarkerMarkerInfoEXTBuilder<'a> { + type Target = DebugMarkerMarkerInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DebugMarkerMarkerInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DebugMarkerMarkerInfoEXTBuilder<'a> { + #[inline] + pub fn marker_name(mut self, marker_name: &'a ::std::ffi::CStr) -> Self { + self.inner.p_marker_name = marker_name.as_ptr(); + self + } + #[inline] + pub fn color(mut self, color: [f32; 4]) -> Self { + self.inner.color = color; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DebugMarkerMarkerInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DedicatedAllocationImageCreateInfoNV { + pub s_type: StructureType, + pub p_next: *const c_void, + pub dedicated_allocation: Bool32, +} +impl ::std::default::Default for DedicatedAllocationImageCreateInfoNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + dedicated_allocation: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for DedicatedAllocationImageCreateInfoNV { + const STRUCTURE_TYPE: StructureType = StructureType::DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV; +} +impl DedicatedAllocationImageCreateInfoNV { + pub fn builder<'a>() -> DedicatedAllocationImageCreateInfoNVBuilder<'a> { + DedicatedAllocationImageCreateInfoNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DedicatedAllocationImageCreateInfoNVBuilder<'a> { + inner: DedicatedAllocationImageCreateInfoNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsImageCreateInfo for DedicatedAllocationImageCreateInfoNVBuilder<'_> {} +unsafe impl ExtendsImageCreateInfo for DedicatedAllocationImageCreateInfoNV {} +impl<'a> ::std::ops::Deref for DedicatedAllocationImageCreateInfoNVBuilder<'a> { + type Target = DedicatedAllocationImageCreateInfoNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DedicatedAllocationImageCreateInfoNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DedicatedAllocationImageCreateInfoNVBuilder<'a> { + #[inline] + pub fn dedicated_allocation(mut self, dedicated_allocation: bool) -> Self { + self.inner.dedicated_allocation = dedicated_allocation.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DedicatedAllocationImageCreateInfoNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DedicatedAllocationBufferCreateInfoNV { + pub s_type: StructureType, + pub p_next: *const c_void, + pub dedicated_allocation: Bool32, +} +impl ::std::default::Default for DedicatedAllocationBufferCreateInfoNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + dedicated_allocation: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for DedicatedAllocationBufferCreateInfoNV { + const STRUCTURE_TYPE: StructureType = StructureType::DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV; +} +impl DedicatedAllocationBufferCreateInfoNV { + pub fn builder<'a>() -> DedicatedAllocationBufferCreateInfoNVBuilder<'a> { + DedicatedAllocationBufferCreateInfoNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DedicatedAllocationBufferCreateInfoNVBuilder<'a> { + inner: DedicatedAllocationBufferCreateInfoNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsBufferCreateInfo for DedicatedAllocationBufferCreateInfoNVBuilder<'_> {} +unsafe impl ExtendsBufferCreateInfo for DedicatedAllocationBufferCreateInfoNV {} +impl<'a> ::std::ops::Deref for DedicatedAllocationBufferCreateInfoNVBuilder<'a> { + type Target = DedicatedAllocationBufferCreateInfoNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DedicatedAllocationBufferCreateInfoNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DedicatedAllocationBufferCreateInfoNVBuilder<'a> { + #[inline] + pub fn dedicated_allocation(mut self, dedicated_allocation: bool) -> Self { + self.inner.dedicated_allocation = dedicated_allocation.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DedicatedAllocationBufferCreateInfoNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DedicatedAllocationMemoryAllocateInfoNV { + pub s_type: StructureType, + pub p_next: *const c_void, + pub image: Image, + pub buffer: Buffer, +} +impl ::std::default::Default for DedicatedAllocationMemoryAllocateInfoNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + image: Image::default(), + buffer: Buffer::default(), + } + } +} +unsafe impl TaggedStructure for DedicatedAllocationMemoryAllocateInfoNV { + const STRUCTURE_TYPE: StructureType = + StructureType::DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV; +} +impl DedicatedAllocationMemoryAllocateInfoNV { + pub fn builder<'a>() -> DedicatedAllocationMemoryAllocateInfoNVBuilder<'a> { + DedicatedAllocationMemoryAllocateInfoNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DedicatedAllocationMemoryAllocateInfoNVBuilder<'a> { + inner: DedicatedAllocationMemoryAllocateInfoNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsMemoryAllocateInfo for DedicatedAllocationMemoryAllocateInfoNVBuilder<'_> {} +unsafe impl ExtendsMemoryAllocateInfo for DedicatedAllocationMemoryAllocateInfoNV {} +impl<'a> ::std::ops::Deref for DedicatedAllocationMemoryAllocateInfoNVBuilder<'a> { + type Target = DedicatedAllocationMemoryAllocateInfoNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DedicatedAllocationMemoryAllocateInfoNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DedicatedAllocationMemoryAllocateInfoNVBuilder<'a> { + #[inline] + pub fn image(mut self, image: Image) -> Self { + self.inner.image = image; + self + } + #[inline] + pub fn buffer(mut self, buffer: Buffer) -> Self { + self.inner.buffer = buffer; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DedicatedAllocationMemoryAllocateInfoNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct ExternalImageFormatPropertiesNV { + pub image_format_properties: ImageFormatProperties, + pub external_memory_features: ExternalMemoryFeatureFlagsNV, + pub export_from_imported_handle_types: ExternalMemoryHandleTypeFlagsNV, + pub compatible_handle_types: ExternalMemoryHandleTypeFlagsNV, +} +impl ExternalImageFormatPropertiesNV { + pub fn builder<'a>() -> ExternalImageFormatPropertiesNVBuilder<'a> { + ExternalImageFormatPropertiesNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ExternalImageFormatPropertiesNVBuilder<'a> { + inner: ExternalImageFormatPropertiesNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ExternalImageFormatPropertiesNVBuilder<'a> { + type Target = ExternalImageFormatPropertiesNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ExternalImageFormatPropertiesNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ExternalImageFormatPropertiesNVBuilder<'a> { + #[inline] + pub fn image_format_properties( + mut self, + image_format_properties: ImageFormatProperties, + ) -> Self { + self.inner.image_format_properties = image_format_properties; + self + } + #[inline] + pub fn external_memory_features( + mut self, + external_memory_features: ExternalMemoryFeatureFlagsNV, + ) -> Self { + self.inner.external_memory_features = external_memory_features; + self + } + #[inline] + pub fn export_from_imported_handle_types( + mut self, + export_from_imported_handle_types: ExternalMemoryHandleTypeFlagsNV, + ) -> Self { + self.inner.export_from_imported_handle_types = export_from_imported_handle_types; + self + } + #[inline] + pub fn compatible_handle_types( + mut self, + compatible_handle_types: ExternalMemoryHandleTypeFlagsNV, + ) -> Self { + self.inner.compatible_handle_types = compatible_handle_types; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ExternalImageFormatPropertiesNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ExternalMemoryImageCreateInfoNV { + pub s_type: StructureType, + pub p_next: *const c_void, + pub handle_types: ExternalMemoryHandleTypeFlagsNV, +} +impl ::std::default::Default for ExternalMemoryImageCreateInfoNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + handle_types: ExternalMemoryHandleTypeFlagsNV::default(), + } + } +} +unsafe impl TaggedStructure for ExternalMemoryImageCreateInfoNV { + const STRUCTURE_TYPE: StructureType = StructureType::EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV; +} +impl ExternalMemoryImageCreateInfoNV { + pub fn builder<'a>() -> ExternalMemoryImageCreateInfoNVBuilder<'a> { + ExternalMemoryImageCreateInfoNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ExternalMemoryImageCreateInfoNVBuilder<'a> { + inner: ExternalMemoryImageCreateInfoNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsImageCreateInfo for ExternalMemoryImageCreateInfoNVBuilder<'_> {} +unsafe impl ExtendsImageCreateInfo for ExternalMemoryImageCreateInfoNV {} +impl<'a> ::std::ops::Deref for ExternalMemoryImageCreateInfoNVBuilder<'a> { + type Target = ExternalMemoryImageCreateInfoNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ExternalMemoryImageCreateInfoNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ExternalMemoryImageCreateInfoNVBuilder<'a> { + #[inline] + pub fn handle_types(mut self, handle_types: ExternalMemoryHandleTypeFlagsNV) -> Self { + self.inner.handle_types = handle_types; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ExternalMemoryImageCreateInfoNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ExportMemoryAllocateInfoNV { + pub s_type: StructureType, + pub p_next: *const c_void, + pub handle_types: ExternalMemoryHandleTypeFlagsNV, +} +impl ::std::default::Default for ExportMemoryAllocateInfoNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + handle_types: ExternalMemoryHandleTypeFlagsNV::default(), + } + } +} +unsafe impl TaggedStructure for ExportMemoryAllocateInfoNV { + const STRUCTURE_TYPE: StructureType = StructureType::EXPORT_MEMORY_ALLOCATE_INFO_NV; +} +impl ExportMemoryAllocateInfoNV { + pub fn builder<'a>() -> ExportMemoryAllocateInfoNVBuilder<'a> { + ExportMemoryAllocateInfoNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ExportMemoryAllocateInfoNVBuilder<'a> { + inner: ExportMemoryAllocateInfoNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsMemoryAllocateInfo for ExportMemoryAllocateInfoNVBuilder<'_> {} +unsafe impl ExtendsMemoryAllocateInfo for ExportMemoryAllocateInfoNV {} +impl<'a> ::std::ops::Deref for ExportMemoryAllocateInfoNVBuilder<'a> { + type Target = ExportMemoryAllocateInfoNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ExportMemoryAllocateInfoNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ExportMemoryAllocateInfoNVBuilder<'a> { + #[inline] + pub fn handle_types(mut self, handle_types: ExternalMemoryHandleTypeFlagsNV) -> Self { + self.inner.handle_types = handle_types; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ExportMemoryAllocateInfoNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ImportMemoryWin32HandleInfoNV { + pub s_type: StructureType, + pub p_next: *const c_void, + pub handle_type: ExternalMemoryHandleTypeFlagsNV, + pub handle: HANDLE, +} +impl ::std::default::Default for ImportMemoryWin32HandleInfoNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + handle_type: ExternalMemoryHandleTypeFlagsNV::default(), + handle: unsafe { ::std::mem::zeroed() }, + } + } +} +unsafe impl TaggedStructure for ImportMemoryWin32HandleInfoNV { + const STRUCTURE_TYPE: StructureType = StructureType::IMPORT_MEMORY_WIN32_HANDLE_INFO_NV; +} +impl ImportMemoryWin32HandleInfoNV { + pub fn builder<'a>() -> ImportMemoryWin32HandleInfoNVBuilder<'a> { + ImportMemoryWin32HandleInfoNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ImportMemoryWin32HandleInfoNVBuilder<'a> { + inner: ImportMemoryWin32HandleInfoNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsMemoryAllocateInfo for ImportMemoryWin32HandleInfoNVBuilder<'_> {} +unsafe impl ExtendsMemoryAllocateInfo for ImportMemoryWin32HandleInfoNV {} +impl<'a> ::std::ops::Deref for ImportMemoryWin32HandleInfoNVBuilder<'a> { + type Target = ImportMemoryWin32HandleInfoNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ImportMemoryWin32HandleInfoNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ImportMemoryWin32HandleInfoNVBuilder<'a> { + #[inline] + pub fn handle_type(mut self, handle_type: ExternalMemoryHandleTypeFlagsNV) -> Self { + self.inner.handle_type = handle_type; + self + } + #[inline] + pub fn handle(mut self, handle: HANDLE) -> Self { + self.inner.handle = handle; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ImportMemoryWin32HandleInfoNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ExportMemoryWin32HandleInfoNV { + pub s_type: StructureType, + pub p_next: *const c_void, + pub p_attributes: *const SECURITY_ATTRIBUTES, + pub dw_access: DWORD, +} +impl ::std::default::Default for ExportMemoryWin32HandleInfoNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + p_attributes: ::std::ptr::null(), + dw_access: DWORD::default(), + } + } +} +unsafe impl TaggedStructure for ExportMemoryWin32HandleInfoNV { + const STRUCTURE_TYPE: StructureType = StructureType::EXPORT_MEMORY_WIN32_HANDLE_INFO_NV; +} +impl ExportMemoryWin32HandleInfoNV { + pub fn builder<'a>() -> ExportMemoryWin32HandleInfoNVBuilder<'a> { + ExportMemoryWin32HandleInfoNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ExportMemoryWin32HandleInfoNVBuilder<'a> { + inner: ExportMemoryWin32HandleInfoNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsMemoryAllocateInfo for ExportMemoryWin32HandleInfoNVBuilder<'_> {} +unsafe impl ExtendsMemoryAllocateInfo for ExportMemoryWin32HandleInfoNV {} +impl<'a> ::std::ops::Deref for ExportMemoryWin32HandleInfoNVBuilder<'a> { + type Target = ExportMemoryWin32HandleInfoNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ExportMemoryWin32HandleInfoNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ExportMemoryWin32HandleInfoNVBuilder<'a> { + #[inline] + pub fn attributes(mut self, attributes: &'a SECURITY_ATTRIBUTES) -> Self { + self.inner.p_attributes = attributes; + self + } + #[inline] + pub fn dw_access(mut self, dw_access: DWORD) -> Self { + self.inner.dw_access = dw_access; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ExportMemoryWin32HandleInfoNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct Win32KeyedMutexAcquireReleaseInfoNV { + pub s_type: StructureType, + pub p_next: *const c_void, + pub acquire_count: u32, + pub p_acquire_syncs: *const DeviceMemory, + pub p_acquire_keys: *const u64, + pub p_acquire_timeout_milliseconds: *const u32, + pub release_count: u32, + pub p_release_syncs: *const DeviceMemory, + pub p_release_keys: *const u64, +} +impl ::std::default::Default for Win32KeyedMutexAcquireReleaseInfoNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + acquire_count: u32::default(), + p_acquire_syncs: ::std::ptr::null(), + p_acquire_keys: ::std::ptr::null(), + p_acquire_timeout_milliseconds: ::std::ptr::null(), + release_count: u32::default(), + p_release_syncs: ::std::ptr::null(), + p_release_keys: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for Win32KeyedMutexAcquireReleaseInfoNV { + const STRUCTURE_TYPE: StructureType = StructureType::WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV; +} +impl Win32KeyedMutexAcquireReleaseInfoNV { + pub fn builder<'a>() -> Win32KeyedMutexAcquireReleaseInfoNVBuilder<'a> { + Win32KeyedMutexAcquireReleaseInfoNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct Win32KeyedMutexAcquireReleaseInfoNVBuilder<'a> { + inner: Win32KeyedMutexAcquireReleaseInfoNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsSubmitInfo for Win32KeyedMutexAcquireReleaseInfoNVBuilder<'_> {} +unsafe impl ExtendsSubmitInfo for Win32KeyedMutexAcquireReleaseInfoNV {} +unsafe impl ExtendsSubmitInfo2 for Win32KeyedMutexAcquireReleaseInfoNVBuilder<'_> {} +unsafe impl ExtendsSubmitInfo2 for Win32KeyedMutexAcquireReleaseInfoNV {} +impl<'a> ::std::ops::Deref for Win32KeyedMutexAcquireReleaseInfoNVBuilder<'a> { + type Target = Win32KeyedMutexAcquireReleaseInfoNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for Win32KeyedMutexAcquireReleaseInfoNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> Win32KeyedMutexAcquireReleaseInfoNVBuilder<'a> { + #[inline] + pub fn acquire_syncs(mut self, acquire_syncs: &'a [DeviceMemory]) -> Self { + self.inner.acquire_count = acquire_syncs.len() as _; + self.inner.p_acquire_syncs = acquire_syncs.as_ptr(); + self + } + #[inline] + pub fn acquire_keys(mut self, acquire_keys: &'a [u64]) -> Self { + self.inner.acquire_count = acquire_keys.len() as _; + self.inner.p_acquire_keys = acquire_keys.as_ptr(); + self + } + #[inline] + pub fn acquire_timeout_milliseconds(mut self, acquire_timeout_milliseconds: &'a [u32]) -> Self { + self.inner.acquire_count = acquire_timeout_milliseconds.len() as _; + self.inner.p_acquire_timeout_milliseconds = acquire_timeout_milliseconds.as_ptr(); + self + } + #[inline] + pub fn release_syncs(mut self, release_syncs: &'a [DeviceMemory]) -> Self { + self.inner.release_count = release_syncs.len() as _; + self.inner.p_release_syncs = release_syncs.as_ptr(); + self + } + #[inline] + pub fn release_keys(mut self, release_keys: &'a [u64]) -> Self { + self.inner.release_count = release_keys.len() as _; + self.inner.p_release_keys = release_keys.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> Win32KeyedMutexAcquireReleaseInfoNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceDeviceGeneratedCommandsFeaturesNV { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub device_generated_commands: Bool32, +} +impl ::std::default::Default for PhysicalDeviceDeviceGeneratedCommandsFeaturesNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + device_generated_commands: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceDeviceGeneratedCommandsFeaturesNV { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV; +} +impl PhysicalDeviceDeviceGeneratedCommandsFeaturesNV { + pub fn builder<'a>() -> PhysicalDeviceDeviceGeneratedCommandsFeaturesNVBuilder<'a> { + PhysicalDeviceDeviceGeneratedCommandsFeaturesNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceDeviceGeneratedCommandsFeaturesNVBuilder<'a> { + inner: PhysicalDeviceDeviceGeneratedCommandsFeaturesNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceDeviceGeneratedCommandsFeaturesNVBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceDeviceGeneratedCommandsFeaturesNV {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDeviceGeneratedCommandsFeaturesNVBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDeviceGeneratedCommandsFeaturesNV {} +impl<'a> ::std::ops::Deref for PhysicalDeviceDeviceGeneratedCommandsFeaturesNVBuilder<'a> { + type Target = PhysicalDeviceDeviceGeneratedCommandsFeaturesNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceDeviceGeneratedCommandsFeaturesNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceDeviceGeneratedCommandsFeaturesNVBuilder<'a> { + #[inline] + pub fn device_generated_commands(mut self, device_generated_commands: bool) -> Self { + self.inner.device_generated_commands = device_generated_commands.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceDeviceGeneratedCommandsFeaturesNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DevicePrivateDataCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub private_data_slot_request_count: u32, +} +impl ::std::default::Default for DevicePrivateDataCreateInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + private_data_slot_request_count: u32::default(), + } + } +} +unsafe impl TaggedStructure for DevicePrivateDataCreateInfo { + const STRUCTURE_TYPE: StructureType = StructureType::DEVICE_PRIVATE_DATA_CREATE_INFO; +} +impl DevicePrivateDataCreateInfo { + pub fn builder<'a>() -> DevicePrivateDataCreateInfoBuilder<'a> { + DevicePrivateDataCreateInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DevicePrivateDataCreateInfoBuilder<'a> { + inner: DevicePrivateDataCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsDeviceCreateInfo for DevicePrivateDataCreateInfoBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for DevicePrivateDataCreateInfo {} +impl<'a> ::std::ops::Deref for DevicePrivateDataCreateInfoBuilder<'a> { + type Target = DevicePrivateDataCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DevicePrivateDataCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DevicePrivateDataCreateInfoBuilder<'a> { + #[inline] + pub fn private_data_slot_request_count(mut self, private_data_slot_request_count: u32) -> Self { + self.inner.private_data_slot_request_count = private_data_slot_request_count; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DevicePrivateDataCreateInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PrivateDataSlotCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: PrivateDataSlotCreateFlags, +} +impl ::std::default::Default for PrivateDataSlotCreateInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: PrivateDataSlotCreateFlags::default(), + } + } +} +unsafe impl TaggedStructure for PrivateDataSlotCreateInfo { + const STRUCTURE_TYPE: StructureType = StructureType::PRIVATE_DATA_SLOT_CREATE_INFO; +} +impl PrivateDataSlotCreateInfo { + pub fn builder<'a>() -> PrivateDataSlotCreateInfoBuilder<'a> { + PrivateDataSlotCreateInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PrivateDataSlotCreateInfoBuilder<'a> { + inner: PrivateDataSlotCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PrivateDataSlotCreateInfoBuilder<'a> { + type Target = PrivateDataSlotCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PrivateDataSlotCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PrivateDataSlotCreateInfoBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: PrivateDataSlotCreateFlags) -> Self { + self.inner.flags = flags; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PrivateDataSlotCreateInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDevicePrivateDataFeatures { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub private_data: Bool32, +} +impl ::std::default::Default for PhysicalDevicePrivateDataFeatures { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + private_data: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDevicePrivateDataFeatures { + const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES; +} +impl PhysicalDevicePrivateDataFeatures { + pub fn builder<'a>() -> PhysicalDevicePrivateDataFeaturesBuilder<'a> { + PhysicalDevicePrivateDataFeaturesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDevicePrivateDataFeaturesBuilder<'a> { + inner: PhysicalDevicePrivateDataFeatures, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePrivateDataFeaturesBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePrivateDataFeatures {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePrivateDataFeaturesBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePrivateDataFeatures {} +impl<'a> ::std::ops::Deref for PhysicalDevicePrivateDataFeaturesBuilder<'a> { + type Target = PhysicalDevicePrivateDataFeatures; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDevicePrivateDataFeaturesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDevicePrivateDataFeaturesBuilder<'a> { + #[inline] + pub fn private_data(mut self, private_data: bool) -> Self { + self.inner.private_data = private_data.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDevicePrivateDataFeatures { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceDeviceGeneratedCommandsPropertiesNV { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub max_graphics_shader_group_count: u32, + pub max_indirect_sequence_count: u32, + pub max_indirect_commands_token_count: u32, + pub max_indirect_commands_stream_count: u32, + pub max_indirect_commands_token_offset: u32, + pub max_indirect_commands_stream_stride: u32, + pub min_sequences_count_buffer_offset_alignment: u32, + pub min_sequences_index_buffer_offset_alignment: u32, + pub min_indirect_commands_buffer_offset_alignment: u32, +} +impl ::std::default::Default for PhysicalDeviceDeviceGeneratedCommandsPropertiesNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + max_graphics_shader_group_count: u32::default(), + max_indirect_sequence_count: u32::default(), + max_indirect_commands_token_count: u32::default(), + max_indirect_commands_stream_count: u32::default(), + max_indirect_commands_token_offset: u32::default(), + max_indirect_commands_stream_stride: u32::default(), + min_sequences_count_buffer_offset_alignment: u32::default(), + min_sequences_index_buffer_offset_alignment: u32::default(), + min_indirect_commands_buffer_offset_alignment: u32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceDeviceGeneratedCommandsPropertiesNV { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV; +} +impl PhysicalDeviceDeviceGeneratedCommandsPropertiesNV { + pub fn builder<'a>() -> PhysicalDeviceDeviceGeneratedCommandsPropertiesNVBuilder<'a> { + PhysicalDeviceDeviceGeneratedCommandsPropertiesNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceDeviceGeneratedCommandsPropertiesNVBuilder<'a> { + inner: PhysicalDeviceDeviceGeneratedCommandsPropertiesNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceDeviceGeneratedCommandsPropertiesNVBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceDeviceGeneratedCommandsPropertiesNV {} +impl<'a> ::std::ops::Deref for PhysicalDeviceDeviceGeneratedCommandsPropertiesNVBuilder<'a> { + type Target = PhysicalDeviceDeviceGeneratedCommandsPropertiesNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceDeviceGeneratedCommandsPropertiesNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceDeviceGeneratedCommandsPropertiesNVBuilder<'a> { + #[inline] + pub fn max_graphics_shader_group_count(mut self, max_graphics_shader_group_count: u32) -> Self { + self.inner.max_graphics_shader_group_count = max_graphics_shader_group_count; + self + } + #[inline] + pub fn max_indirect_sequence_count(mut self, max_indirect_sequence_count: u32) -> Self { + self.inner.max_indirect_sequence_count = max_indirect_sequence_count; + self + } + #[inline] + pub fn max_indirect_commands_token_count( + mut self, + max_indirect_commands_token_count: u32, + ) -> Self { + self.inner.max_indirect_commands_token_count = max_indirect_commands_token_count; + self + } + #[inline] + pub fn max_indirect_commands_stream_count( + mut self, + max_indirect_commands_stream_count: u32, + ) -> Self { + self.inner.max_indirect_commands_stream_count = max_indirect_commands_stream_count; + self + } + #[inline] + pub fn max_indirect_commands_token_offset( + mut self, + max_indirect_commands_token_offset: u32, + ) -> Self { + self.inner.max_indirect_commands_token_offset = max_indirect_commands_token_offset; + self + } + #[inline] + pub fn max_indirect_commands_stream_stride( + mut self, + max_indirect_commands_stream_stride: u32, + ) -> Self { + self.inner.max_indirect_commands_stream_stride = max_indirect_commands_stream_stride; + self + } + #[inline] + pub fn min_sequences_count_buffer_offset_alignment( + mut self, + min_sequences_count_buffer_offset_alignment: u32, + ) -> Self { + self.inner.min_sequences_count_buffer_offset_alignment = + min_sequences_count_buffer_offset_alignment; + self + } + #[inline] + pub fn min_sequences_index_buffer_offset_alignment( + mut self, + min_sequences_index_buffer_offset_alignment: u32, + ) -> Self { + self.inner.min_sequences_index_buffer_offset_alignment = + min_sequences_index_buffer_offset_alignment; + self + } + #[inline] + pub fn min_indirect_commands_buffer_offset_alignment( + mut self, + min_indirect_commands_buffer_offset_alignment: u32, + ) -> Self { + self.inner.min_indirect_commands_buffer_offset_alignment = + min_indirect_commands_buffer_offset_alignment; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceDeviceGeneratedCommandsPropertiesNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceMultiDrawPropertiesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub max_multi_draw_count: u32, +} +impl ::std::default::Default for PhysicalDeviceMultiDrawPropertiesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + max_multi_draw_count: u32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceMultiDrawPropertiesEXT { + const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT; +} +impl PhysicalDeviceMultiDrawPropertiesEXT { + pub fn builder<'a>() -> PhysicalDeviceMultiDrawPropertiesEXTBuilder<'a> { + PhysicalDeviceMultiDrawPropertiesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceMultiDrawPropertiesEXTBuilder<'a> { + inner: PhysicalDeviceMultiDrawPropertiesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceMultiDrawPropertiesEXTBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceMultiDrawPropertiesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceMultiDrawPropertiesEXTBuilder<'a> { + type Target = PhysicalDeviceMultiDrawPropertiesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceMultiDrawPropertiesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceMultiDrawPropertiesEXTBuilder<'a> { + #[inline] + pub fn max_multi_draw_count(mut self, max_multi_draw_count: u32) -> Self { + self.inner.max_multi_draw_count = max_multi_draw_count; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceMultiDrawPropertiesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct GraphicsShaderGroupCreateInfoNV { + pub s_type: StructureType, + pub p_next: *const c_void, + pub stage_count: u32, + pub p_stages: *const PipelineShaderStageCreateInfo, + pub p_vertex_input_state: *const PipelineVertexInputStateCreateInfo, + pub p_tessellation_state: *const PipelineTessellationStateCreateInfo, +} +impl ::std::default::Default for GraphicsShaderGroupCreateInfoNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + stage_count: u32::default(), + p_stages: ::std::ptr::null(), + p_vertex_input_state: ::std::ptr::null(), + p_tessellation_state: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for GraphicsShaderGroupCreateInfoNV { + const STRUCTURE_TYPE: StructureType = StructureType::GRAPHICS_SHADER_GROUP_CREATE_INFO_NV; +} +impl GraphicsShaderGroupCreateInfoNV { + pub fn builder<'a>() -> GraphicsShaderGroupCreateInfoNVBuilder<'a> { + GraphicsShaderGroupCreateInfoNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct GraphicsShaderGroupCreateInfoNVBuilder<'a> { + inner: GraphicsShaderGroupCreateInfoNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for GraphicsShaderGroupCreateInfoNVBuilder<'a> { + type Target = GraphicsShaderGroupCreateInfoNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for GraphicsShaderGroupCreateInfoNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> GraphicsShaderGroupCreateInfoNVBuilder<'a> { + #[inline] + pub fn stages(mut self, stages: &'a [PipelineShaderStageCreateInfo]) -> Self { + self.inner.stage_count = stages.len() as _; + self.inner.p_stages = stages.as_ptr(); + self + } + #[inline] + pub fn vertex_input_state( + mut self, + vertex_input_state: &'a PipelineVertexInputStateCreateInfo, + ) -> Self { + self.inner.p_vertex_input_state = vertex_input_state; + self + } + #[inline] + pub fn tessellation_state( + mut self, + tessellation_state: &'a PipelineTessellationStateCreateInfo, + ) -> Self { + self.inner.p_tessellation_state = tessellation_state; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> GraphicsShaderGroupCreateInfoNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct GraphicsPipelineShaderGroupsCreateInfoNV { + pub s_type: StructureType, + pub p_next: *const c_void, + pub group_count: u32, + pub p_groups: *const GraphicsShaderGroupCreateInfoNV, + pub pipeline_count: u32, + pub p_pipelines: *const Pipeline, +} +impl ::std::default::Default for GraphicsPipelineShaderGroupsCreateInfoNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + group_count: u32::default(), + p_groups: ::std::ptr::null(), + pipeline_count: u32::default(), + p_pipelines: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for GraphicsPipelineShaderGroupsCreateInfoNV { + const STRUCTURE_TYPE: StructureType = + StructureType::GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV; +} +impl GraphicsPipelineShaderGroupsCreateInfoNV { + pub fn builder<'a>() -> GraphicsPipelineShaderGroupsCreateInfoNVBuilder<'a> { + GraphicsPipelineShaderGroupsCreateInfoNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct GraphicsPipelineShaderGroupsCreateInfoNVBuilder<'a> { + inner: GraphicsPipelineShaderGroupsCreateInfoNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsGraphicsPipelineCreateInfo + for GraphicsPipelineShaderGroupsCreateInfoNVBuilder<'_> +{ +} +unsafe impl ExtendsGraphicsPipelineCreateInfo for GraphicsPipelineShaderGroupsCreateInfoNV {} +impl<'a> ::std::ops::Deref for GraphicsPipelineShaderGroupsCreateInfoNVBuilder<'a> { + type Target = GraphicsPipelineShaderGroupsCreateInfoNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for GraphicsPipelineShaderGroupsCreateInfoNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> GraphicsPipelineShaderGroupsCreateInfoNVBuilder<'a> { + #[inline] + pub fn groups(mut self, groups: &'a [GraphicsShaderGroupCreateInfoNV]) -> Self { + self.inner.group_count = groups.len() as _; + self.inner.p_groups = groups.as_ptr(); + self + } + #[inline] + pub fn pipelines(mut self, pipelines: &'a [Pipeline]) -> Self { + self.inner.pipeline_count = pipelines.len() as _; + self.inner.p_pipelines = pipelines.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> GraphicsPipelineShaderGroupsCreateInfoNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct BindShaderGroupIndirectCommandNV { + pub group_index: u32, +} +impl BindShaderGroupIndirectCommandNV { + pub fn builder<'a>() -> BindShaderGroupIndirectCommandNVBuilder<'a> { + BindShaderGroupIndirectCommandNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct BindShaderGroupIndirectCommandNVBuilder<'a> { + inner: BindShaderGroupIndirectCommandNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for BindShaderGroupIndirectCommandNVBuilder<'a> { + type Target = BindShaderGroupIndirectCommandNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for BindShaderGroupIndirectCommandNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> BindShaderGroupIndirectCommandNVBuilder<'a> { + #[inline] + pub fn group_index(mut self, group_index: u32) -> Self { + self.inner.group_index = group_index; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> BindShaderGroupIndirectCommandNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct BindIndexBufferIndirectCommandNV { + pub buffer_address: DeviceAddress, + pub size: u32, + pub index_type: IndexType, +} +impl BindIndexBufferIndirectCommandNV { + pub fn builder<'a>() -> BindIndexBufferIndirectCommandNVBuilder<'a> { + BindIndexBufferIndirectCommandNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct BindIndexBufferIndirectCommandNVBuilder<'a> { + inner: BindIndexBufferIndirectCommandNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for BindIndexBufferIndirectCommandNVBuilder<'a> { + type Target = BindIndexBufferIndirectCommandNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for BindIndexBufferIndirectCommandNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> BindIndexBufferIndirectCommandNVBuilder<'a> { + #[inline] + pub fn buffer_address(mut self, buffer_address: DeviceAddress) -> Self { + self.inner.buffer_address = buffer_address; + self + } + #[inline] + pub fn size(mut self, size: u32) -> Self { + self.inner.size = size; + self + } + #[inline] + pub fn index_type(mut self, index_type: IndexType) -> Self { + self.inner.index_type = index_type; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> BindIndexBufferIndirectCommandNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct BindVertexBufferIndirectCommandNV { + pub buffer_address: DeviceAddress, + pub size: u32, + pub stride: u32, +} +impl BindVertexBufferIndirectCommandNV { + pub fn builder<'a>() -> BindVertexBufferIndirectCommandNVBuilder<'a> { + BindVertexBufferIndirectCommandNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct BindVertexBufferIndirectCommandNVBuilder<'a> { + inner: BindVertexBufferIndirectCommandNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for BindVertexBufferIndirectCommandNVBuilder<'a> { + type Target = BindVertexBufferIndirectCommandNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for BindVertexBufferIndirectCommandNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> BindVertexBufferIndirectCommandNVBuilder<'a> { + #[inline] + pub fn buffer_address(mut self, buffer_address: DeviceAddress) -> Self { + self.inner.buffer_address = buffer_address; + self + } + #[inline] + pub fn size(mut self, size: u32) -> Self { + self.inner.size = size; + self + } + #[inline] + pub fn stride(mut self, stride: u32) -> Self { + self.inner.stride = stride; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> BindVertexBufferIndirectCommandNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct SetStateFlagsIndirectCommandNV { + pub data: u32, +} +impl SetStateFlagsIndirectCommandNV { + pub fn builder<'a>() -> SetStateFlagsIndirectCommandNVBuilder<'a> { + SetStateFlagsIndirectCommandNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SetStateFlagsIndirectCommandNVBuilder<'a> { + inner: SetStateFlagsIndirectCommandNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for SetStateFlagsIndirectCommandNVBuilder<'a> { + type Target = SetStateFlagsIndirectCommandNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SetStateFlagsIndirectCommandNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SetStateFlagsIndirectCommandNVBuilder<'a> { + #[inline] + pub fn data(mut self, data: u32) -> Self { + self.inner.data = data; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SetStateFlagsIndirectCommandNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct IndirectCommandsStreamNV { + pub buffer: Buffer, + pub offset: DeviceSize, +} +impl IndirectCommandsStreamNV { + pub fn builder<'a>() -> IndirectCommandsStreamNVBuilder<'a> { + IndirectCommandsStreamNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct IndirectCommandsStreamNVBuilder<'a> { + inner: IndirectCommandsStreamNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for IndirectCommandsStreamNVBuilder<'a> { + type Target = IndirectCommandsStreamNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for IndirectCommandsStreamNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> IndirectCommandsStreamNVBuilder<'a> { + #[inline] + pub fn buffer(mut self, buffer: Buffer) -> Self { + self.inner.buffer = buffer; + self + } + #[inline] + pub fn offset(mut self, offset: DeviceSize) -> Self { + self.inner.offset = offset; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> IndirectCommandsStreamNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct IndirectCommandsLayoutTokenNV { + pub s_type: StructureType, + pub p_next: *const c_void, + pub token_type: IndirectCommandsTokenTypeNV, + pub stream: u32, + pub offset: u32, + pub vertex_binding_unit: u32, + pub vertex_dynamic_stride: Bool32, + pub pushconstant_pipeline_layout: PipelineLayout, + pub pushconstant_shader_stage_flags: ShaderStageFlags, + pub pushconstant_offset: u32, + pub pushconstant_size: u32, + pub indirect_state_flags: IndirectStateFlagsNV, + pub index_type_count: u32, + pub p_index_types: *const IndexType, + pub p_index_type_values: *const u32, +} +impl ::std::default::Default for IndirectCommandsLayoutTokenNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + token_type: IndirectCommandsTokenTypeNV::default(), + stream: u32::default(), + offset: u32::default(), + vertex_binding_unit: u32::default(), + vertex_dynamic_stride: Bool32::default(), + pushconstant_pipeline_layout: PipelineLayout::default(), + pushconstant_shader_stage_flags: ShaderStageFlags::default(), + pushconstant_offset: u32::default(), + pushconstant_size: u32::default(), + indirect_state_flags: IndirectStateFlagsNV::default(), + index_type_count: u32::default(), + p_index_types: ::std::ptr::null(), + p_index_type_values: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for IndirectCommandsLayoutTokenNV { + const STRUCTURE_TYPE: StructureType = StructureType::INDIRECT_COMMANDS_LAYOUT_TOKEN_NV; +} +impl IndirectCommandsLayoutTokenNV { + pub fn builder<'a>() -> IndirectCommandsLayoutTokenNVBuilder<'a> { + IndirectCommandsLayoutTokenNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct IndirectCommandsLayoutTokenNVBuilder<'a> { + inner: IndirectCommandsLayoutTokenNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for IndirectCommandsLayoutTokenNVBuilder<'a> { + type Target = IndirectCommandsLayoutTokenNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for IndirectCommandsLayoutTokenNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> IndirectCommandsLayoutTokenNVBuilder<'a> { + #[inline] + pub fn token_type(mut self, token_type: IndirectCommandsTokenTypeNV) -> Self { + self.inner.token_type = token_type; + self + } + #[inline] + pub fn stream(mut self, stream: u32) -> Self { + self.inner.stream = stream; + self + } + #[inline] + pub fn offset(mut self, offset: u32) -> Self { + self.inner.offset = offset; + self + } + #[inline] + pub fn vertex_binding_unit(mut self, vertex_binding_unit: u32) -> Self { + self.inner.vertex_binding_unit = vertex_binding_unit; + self + } + #[inline] + pub fn vertex_dynamic_stride(mut self, vertex_dynamic_stride: bool) -> Self { + self.inner.vertex_dynamic_stride = vertex_dynamic_stride.into(); + self + } + #[inline] + pub fn pushconstant_pipeline_layout( + mut self, + pushconstant_pipeline_layout: PipelineLayout, + ) -> Self { + self.inner.pushconstant_pipeline_layout = pushconstant_pipeline_layout; + self + } + #[inline] + pub fn pushconstant_shader_stage_flags( + mut self, + pushconstant_shader_stage_flags: ShaderStageFlags, + ) -> Self { + self.inner.pushconstant_shader_stage_flags = pushconstant_shader_stage_flags; + self + } + #[inline] + pub fn pushconstant_offset(mut self, pushconstant_offset: u32) -> Self { + self.inner.pushconstant_offset = pushconstant_offset; + self + } + #[inline] + pub fn pushconstant_size(mut self, pushconstant_size: u32) -> Self { + self.inner.pushconstant_size = pushconstant_size; + self + } + #[inline] + pub fn indirect_state_flags(mut self, indirect_state_flags: IndirectStateFlagsNV) -> Self { + self.inner.indirect_state_flags = indirect_state_flags; + self + } + #[inline] + pub fn index_types(mut self, index_types: &'a [IndexType]) -> Self { + self.inner.index_type_count = index_types.len() as _; + self.inner.p_index_types = index_types.as_ptr(); + self + } + #[inline] + pub fn index_type_values(mut self, index_type_values: &'a [u32]) -> Self { + self.inner.index_type_count = index_type_values.len() as _; + self.inner.p_index_type_values = index_type_values.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> IndirectCommandsLayoutTokenNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct IndirectCommandsLayoutCreateInfoNV { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: IndirectCommandsLayoutUsageFlagsNV, + pub pipeline_bind_point: PipelineBindPoint, + pub token_count: u32, + pub p_tokens: *const IndirectCommandsLayoutTokenNV, + pub stream_count: u32, + pub p_stream_strides: *const u32, +} +impl ::std::default::Default for IndirectCommandsLayoutCreateInfoNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: IndirectCommandsLayoutUsageFlagsNV::default(), + pipeline_bind_point: PipelineBindPoint::default(), + token_count: u32::default(), + p_tokens: ::std::ptr::null(), + stream_count: u32::default(), + p_stream_strides: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for IndirectCommandsLayoutCreateInfoNV { + const STRUCTURE_TYPE: StructureType = StructureType::INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NV; +} +impl IndirectCommandsLayoutCreateInfoNV { + pub fn builder<'a>() -> IndirectCommandsLayoutCreateInfoNVBuilder<'a> { + IndirectCommandsLayoutCreateInfoNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct IndirectCommandsLayoutCreateInfoNVBuilder<'a> { + inner: IndirectCommandsLayoutCreateInfoNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for IndirectCommandsLayoutCreateInfoNVBuilder<'a> { + type Target = IndirectCommandsLayoutCreateInfoNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for IndirectCommandsLayoutCreateInfoNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> IndirectCommandsLayoutCreateInfoNVBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: IndirectCommandsLayoutUsageFlagsNV) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn pipeline_bind_point(mut self, pipeline_bind_point: PipelineBindPoint) -> Self { + self.inner.pipeline_bind_point = pipeline_bind_point; + self + } + #[inline] + pub fn tokens(mut self, tokens: &'a [IndirectCommandsLayoutTokenNV]) -> Self { + self.inner.token_count = tokens.len() as _; + self.inner.p_tokens = tokens.as_ptr(); + self + } + #[inline] + pub fn stream_strides(mut self, stream_strides: &'a [u32]) -> Self { + self.inner.stream_count = stream_strides.len() as _; + self.inner.p_stream_strides = stream_strides.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> IndirectCommandsLayoutCreateInfoNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct GeneratedCommandsInfoNV { + pub s_type: StructureType, + pub p_next: *const c_void, + pub pipeline_bind_point: PipelineBindPoint, + pub pipeline: Pipeline, + pub indirect_commands_layout: IndirectCommandsLayoutNV, + pub stream_count: u32, + pub p_streams: *const IndirectCommandsStreamNV, + pub sequences_count: u32, + pub preprocess_buffer: Buffer, + pub preprocess_offset: DeviceSize, + pub preprocess_size: DeviceSize, + pub sequences_count_buffer: Buffer, + pub sequences_count_offset: DeviceSize, + pub sequences_index_buffer: Buffer, + pub sequences_index_offset: DeviceSize, +} +impl ::std::default::Default for GeneratedCommandsInfoNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + pipeline_bind_point: PipelineBindPoint::default(), + pipeline: Pipeline::default(), + indirect_commands_layout: IndirectCommandsLayoutNV::default(), + stream_count: u32::default(), + p_streams: ::std::ptr::null(), + sequences_count: u32::default(), + preprocess_buffer: Buffer::default(), + preprocess_offset: DeviceSize::default(), + preprocess_size: DeviceSize::default(), + sequences_count_buffer: Buffer::default(), + sequences_count_offset: DeviceSize::default(), + sequences_index_buffer: Buffer::default(), + sequences_index_offset: DeviceSize::default(), + } + } +} +unsafe impl TaggedStructure for GeneratedCommandsInfoNV { + const STRUCTURE_TYPE: StructureType = StructureType::GENERATED_COMMANDS_INFO_NV; +} +impl GeneratedCommandsInfoNV { + pub fn builder<'a>() -> GeneratedCommandsInfoNVBuilder<'a> { + GeneratedCommandsInfoNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct GeneratedCommandsInfoNVBuilder<'a> { + inner: GeneratedCommandsInfoNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for GeneratedCommandsInfoNVBuilder<'a> { + type Target = GeneratedCommandsInfoNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for GeneratedCommandsInfoNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> GeneratedCommandsInfoNVBuilder<'a> { + #[inline] + pub fn pipeline_bind_point(mut self, pipeline_bind_point: PipelineBindPoint) -> Self { + self.inner.pipeline_bind_point = pipeline_bind_point; + self + } + #[inline] + pub fn pipeline(mut self, pipeline: Pipeline) -> Self { + self.inner.pipeline = pipeline; + self + } + #[inline] + pub fn indirect_commands_layout( + mut self, + indirect_commands_layout: IndirectCommandsLayoutNV, + ) -> Self { + self.inner.indirect_commands_layout = indirect_commands_layout; + self + } + #[inline] + pub fn streams(mut self, streams: &'a [IndirectCommandsStreamNV]) -> Self { + self.inner.stream_count = streams.len() as _; + self.inner.p_streams = streams.as_ptr(); + self + } + #[inline] + pub fn sequences_count(mut self, sequences_count: u32) -> Self { + self.inner.sequences_count = sequences_count; + self + } + #[inline] + pub fn preprocess_buffer(mut self, preprocess_buffer: Buffer) -> Self { + self.inner.preprocess_buffer = preprocess_buffer; + self + } + #[inline] + pub fn preprocess_offset(mut self, preprocess_offset: DeviceSize) -> Self { + self.inner.preprocess_offset = preprocess_offset; + self + } + #[inline] + pub fn preprocess_size(mut self, preprocess_size: DeviceSize) -> Self { + self.inner.preprocess_size = preprocess_size; + self + } + #[inline] + pub fn sequences_count_buffer(mut self, sequences_count_buffer: Buffer) -> Self { + self.inner.sequences_count_buffer = sequences_count_buffer; + self + } + #[inline] + pub fn sequences_count_offset(mut self, sequences_count_offset: DeviceSize) -> Self { + self.inner.sequences_count_offset = sequences_count_offset; + self + } + #[inline] + pub fn sequences_index_buffer(mut self, sequences_index_buffer: Buffer) -> Self { + self.inner.sequences_index_buffer = sequences_index_buffer; + self + } + #[inline] + pub fn sequences_index_offset(mut self, sequences_index_offset: DeviceSize) -> Self { + self.inner.sequences_index_offset = sequences_index_offset; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> GeneratedCommandsInfoNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct GeneratedCommandsMemoryRequirementsInfoNV { + pub s_type: StructureType, + pub p_next: *const c_void, + pub pipeline_bind_point: PipelineBindPoint, + pub pipeline: Pipeline, + pub indirect_commands_layout: IndirectCommandsLayoutNV, + pub max_sequences_count: u32, +} +impl ::std::default::Default for GeneratedCommandsMemoryRequirementsInfoNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + pipeline_bind_point: PipelineBindPoint::default(), + pipeline: Pipeline::default(), + indirect_commands_layout: IndirectCommandsLayoutNV::default(), + max_sequences_count: u32::default(), + } + } +} +unsafe impl TaggedStructure for GeneratedCommandsMemoryRequirementsInfoNV { + const STRUCTURE_TYPE: StructureType = + StructureType::GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_NV; +} +impl GeneratedCommandsMemoryRequirementsInfoNV { + pub fn builder<'a>() -> GeneratedCommandsMemoryRequirementsInfoNVBuilder<'a> { + GeneratedCommandsMemoryRequirementsInfoNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct GeneratedCommandsMemoryRequirementsInfoNVBuilder<'a> { + inner: GeneratedCommandsMemoryRequirementsInfoNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for GeneratedCommandsMemoryRequirementsInfoNVBuilder<'a> { + type Target = GeneratedCommandsMemoryRequirementsInfoNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for GeneratedCommandsMemoryRequirementsInfoNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> GeneratedCommandsMemoryRequirementsInfoNVBuilder<'a> { + #[inline] + pub fn pipeline_bind_point(mut self, pipeline_bind_point: PipelineBindPoint) -> Self { + self.inner.pipeline_bind_point = pipeline_bind_point; + self + } + #[inline] + pub fn pipeline(mut self, pipeline: Pipeline) -> Self { + self.inner.pipeline = pipeline; + self + } + #[inline] + pub fn indirect_commands_layout( + mut self, + indirect_commands_layout: IndirectCommandsLayoutNV, + ) -> Self { + self.inner.indirect_commands_layout = indirect_commands_layout; + self + } + #[inline] + pub fn max_sequences_count(mut self, max_sequences_count: u32) -> Self { + self.inner.max_sequences_count = max_sequences_count; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> GeneratedCommandsMemoryRequirementsInfoNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceFeatures2 { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub features: PhysicalDeviceFeatures, +} +impl ::std::default::Default for PhysicalDeviceFeatures2 { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + features: PhysicalDeviceFeatures::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceFeatures2 { + const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_FEATURES_2; +} +impl PhysicalDeviceFeatures2 { + pub fn builder<'a>() -> PhysicalDeviceFeatures2Builder<'a> { + PhysicalDeviceFeatures2Builder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceFeatures2Builder<'a> { + inner: PhysicalDeviceFeatures2, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFeatures2Builder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFeatures2 {} +pub unsafe trait ExtendsPhysicalDeviceFeatures2 {} +impl<'a> ::std::ops::Deref for PhysicalDeviceFeatures2Builder<'a> { + type Target = PhysicalDeviceFeatures2; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceFeatures2Builder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceFeatures2Builder<'a> { + #[inline] + pub fn features(mut self, features: PhysicalDeviceFeatures) -> Self { + self.inner.features = features; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*mut T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceFeatures2 { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceProperties2 { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub properties: PhysicalDeviceProperties, +} +impl ::std::default::Default for PhysicalDeviceProperties2 { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + properties: PhysicalDeviceProperties::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceProperties2 { + const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_PROPERTIES_2; +} +impl PhysicalDeviceProperties2 { + pub fn builder<'a>() -> PhysicalDeviceProperties2Builder<'a> { + PhysicalDeviceProperties2Builder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceProperties2Builder<'a> { + inner: PhysicalDeviceProperties2, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsPhysicalDeviceProperties2 {} +impl<'a> ::std::ops::Deref for PhysicalDeviceProperties2Builder<'a> { + type Target = PhysicalDeviceProperties2; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceProperties2Builder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceProperties2Builder<'a> { + #[inline] + pub fn properties(mut self, properties: PhysicalDeviceProperties) -> Self { + self.inner.properties = properties; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*mut T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceProperties2 { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct FormatProperties2 { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub format_properties: FormatProperties, +} +impl ::std::default::Default for FormatProperties2 { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + format_properties: FormatProperties::default(), + } + } +} +unsafe impl TaggedStructure for FormatProperties2 { + const STRUCTURE_TYPE: StructureType = StructureType::FORMAT_PROPERTIES_2; +} +impl FormatProperties2 { + pub fn builder<'a>() -> FormatProperties2Builder<'a> { + FormatProperties2Builder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct FormatProperties2Builder<'a> { + inner: FormatProperties2, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsFormatProperties2 {} +impl<'a> ::std::ops::Deref for FormatProperties2Builder<'a> { + type Target = FormatProperties2; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for FormatProperties2Builder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> FormatProperties2Builder<'a> { + #[inline] + pub fn format_properties(mut self, format_properties: FormatProperties) -> Self { + self.inner.format_properties = format_properties; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*mut T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> FormatProperties2 { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ImageFormatProperties2 { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub image_format_properties: ImageFormatProperties, +} +impl ::std::default::Default for ImageFormatProperties2 { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + image_format_properties: ImageFormatProperties::default(), + } + } +} +unsafe impl TaggedStructure for ImageFormatProperties2 { + const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_FORMAT_PROPERTIES_2; +} +impl ImageFormatProperties2 { + pub fn builder<'a>() -> ImageFormatProperties2Builder<'a> { + ImageFormatProperties2Builder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ImageFormatProperties2Builder<'a> { + inner: ImageFormatProperties2, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsImageFormatProperties2 {} +impl<'a> ::std::ops::Deref for ImageFormatProperties2Builder<'a> { + type Target = ImageFormatProperties2; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ImageFormatProperties2Builder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ImageFormatProperties2Builder<'a> { + #[inline] + pub fn image_format_properties( + mut self, + image_format_properties: ImageFormatProperties, + ) -> Self { + self.inner.image_format_properties = image_format_properties; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*mut T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ImageFormatProperties2 { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceImageFormatInfo2 { + pub s_type: StructureType, + pub p_next: *const c_void, + pub format: Format, + pub ty: ImageType, + pub tiling: ImageTiling, + pub usage: ImageUsageFlags, + pub flags: ImageCreateFlags, +} +impl ::std::default::Default for PhysicalDeviceImageFormatInfo2 { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + format: Format::default(), + ty: ImageType::default(), + tiling: ImageTiling::default(), + usage: ImageUsageFlags::default(), + flags: ImageCreateFlags::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceImageFormatInfo2 { + const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2; +} +impl PhysicalDeviceImageFormatInfo2 { + pub fn builder<'a>() -> PhysicalDeviceImageFormatInfo2Builder<'a> { + PhysicalDeviceImageFormatInfo2Builder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceImageFormatInfo2Builder<'a> { + inner: PhysicalDeviceImageFormatInfo2, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsPhysicalDeviceImageFormatInfo2 {} +impl<'a> ::std::ops::Deref for PhysicalDeviceImageFormatInfo2Builder<'a> { + type Target = PhysicalDeviceImageFormatInfo2; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceImageFormatInfo2Builder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceImageFormatInfo2Builder<'a> { + #[inline] + pub fn format(mut self, format: Format) -> Self { + self.inner.format = format; + self + } + #[inline] + pub fn ty(mut self, ty: ImageType) -> Self { + self.inner.ty = ty; + self + } + #[inline] + pub fn tiling(mut self, tiling: ImageTiling) -> Self { + self.inner.tiling = tiling; + self + } + #[inline] + pub fn usage(mut self, usage: ImageUsageFlags) -> Self { + self.inner.usage = usage; + self + } + #[inline] + pub fn flags(mut self, flags: ImageCreateFlags) -> Self { + self.inner.flags = flags; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceImageFormatInfo2 { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct QueueFamilyProperties2 { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub queue_family_properties: QueueFamilyProperties, +} +impl ::std::default::Default for QueueFamilyProperties2 { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + queue_family_properties: QueueFamilyProperties::default(), + } + } +} +unsafe impl TaggedStructure for QueueFamilyProperties2 { + const STRUCTURE_TYPE: StructureType = StructureType::QUEUE_FAMILY_PROPERTIES_2; +} +impl QueueFamilyProperties2 { + pub fn builder<'a>() -> QueueFamilyProperties2Builder<'a> { + QueueFamilyProperties2Builder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct QueueFamilyProperties2Builder<'a> { + inner: QueueFamilyProperties2, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsQueueFamilyProperties2 {} +impl<'a> ::std::ops::Deref for QueueFamilyProperties2Builder<'a> { + type Target = QueueFamilyProperties2; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for QueueFamilyProperties2Builder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> QueueFamilyProperties2Builder<'a> { + #[inline] + pub fn queue_family_properties( + mut self, + queue_family_properties: QueueFamilyProperties, + ) -> Self { + self.inner.queue_family_properties = queue_family_properties; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*mut T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> QueueFamilyProperties2 { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceMemoryProperties2 { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub memory_properties: PhysicalDeviceMemoryProperties, +} +impl ::std::default::Default for PhysicalDeviceMemoryProperties2 { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + memory_properties: PhysicalDeviceMemoryProperties::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceMemoryProperties2 { + const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_MEMORY_PROPERTIES_2; +} +impl PhysicalDeviceMemoryProperties2 { + pub fn builder<'a>() -> PhysicalDeviceMemoryProperties2Builder<'a> { + PhysicalDeviceMemoryProperties2Builder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceMemoryProperties2Builder<'a> { + inner: PhysicalDeviceMemoryProperties2, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsPhysicalDeviceMemoryProperties2 {} +impl<'a> ::std::ops::Deref for PhysicalDeviceMemoryProperties2Builder<'a> { + type Target = PhysicalDeviceMemoryProperties2; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceMemoryProperties2Builder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceMemoryProperties2Builder<'a> { + #[inline] + pub fn memory_properties(mut self, memory_properties: PhysicalDeviceMemoryProperties) -> Self { + self.inner.memory_properties = memory_properties; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*mut T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceMemoryProperties2 { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SparseImageFormatProperties2 { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub properties: SparseImageFormatProperties, +} +impl ::std::default::Default for SparseImageFormatProperties2 { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + properties: SparseImageFormatProperties::default(), + } + } +} +unsafe impl TaggedStructure for SparseImageFormatProperties2 { + const STRUCTURE_TYPE: StructureType = StructureType::SPARSE_IMAGE_FORMAT_PROPERTIES_2; +} +impl SparseImageFormatProperties2 { + pub fn builder<'a>() -> SparseImageFormatProperties2Builder<'a> { + SparseImageFormatProperties2Builder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SparseImageFormatProperties2Builder<'a> { + inner: SparseImageFormatProperties2, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for SparseImageFormatProperties2Builder<'a> { + type Target = SparseImageFormatProperties2; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SparseImageFormatProperties2Builder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SparseImageFormatProperties2Builder<'a> { + #[inline] + pub fn properties(mut self, properties: SparseImageFormatProperties) -> Self { + self.inner.properties = properties; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SparseImageFormatProperties2 { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceSparseImageFormatInfo2 { + pub s_type: StructureType, + pub p_next: *const c_void, + pub format: Format, + pub ty: ImageType, + pub samples: SampleCountFlags, + pub usage: ImageUsageFlags, + pub tiling: ImageTiling, +} +impl ::std::default::Default for PhysicalDeviceSparseImageFormatInfo2 { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + format: Format::default(), + ty: ImageType::default(), + samples: SampleCountFlags::default(), + usage: ImageUsageFlags::default(), + tiling: ImageTiling::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceSparseImageFormatInfo2 { + const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2; +} +impl PhysicalDeviceSparseImageFormatInfo2 { + pub fn builder<'a>() -> PhysicalDeviceSparseImageFormatInfo2Builder<'a> { + PhysicalDeviceSparseImageFormatInfo2Builder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceSparseImageFormatInfo2Builder<'a> { + inner: PhysicalDeviceSparseImageFormatInfo2, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PhysicalDeviceSparseImageFormatInfo2Builder<'a> { + type Target = PhysicalDeviceSparseImageFormatInfo2; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceSparseImageFormatInfo2Builder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceSparseImageFormatInfo2Builder<'a> { + #[inline] + pub fn format(mut self, format: Format) -> Self { + self.inner.format = format; + self + } + #[inline] + pub fn ty(mut self, ty: ImageType) -> Self { + self.inner.ty = ty; + self + } + #[inline] + pub fn samples(mut self, samples: SampleCountFlags) -> Self { + self.inner.samples = samples; + self + } + #[inline] + pub fn usage(mut self, usage: ImageUsageFlags) -> Self { + self.inner.usage = usage; + self + } + #[inline] + pub fn tiling(mut self, tiling: ImageTiling) -> Self { + self.inner.tiling = tiling; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceSparseImageFormatInfo2 { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDevicePushDescriptorPropertiesKHR { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub max_push_descriptors: u32, +} +impl ::std::default::Default for PhysicalDevicePushDescriptorPropertiesKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + max_push_descriptors: u32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDevicePushDescriptorPropertiesKHR { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR; +} +impl PhysicalDevicePushDescriptorPropertiesKHR { + pub fn builder<'a>() -> PhysicalDevicePushDescriptorPropertiesKHRBuilder<'a> { + PhysicalDevicePushDescriptorPropertiesKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDevicePushDescriptorPropertiesKHRBuilder<'a> { + inner: PhysicalDevicePushDescriptorPropertiesKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDevicePushDescriptorPropertiesKHRBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDevicePushDescriptorPropertiesKHR {} +impl<'a> ::std::ops::Deref for PhysicalDevicePushDescriptorPropertiesKHRBuilder<'a> { + type Target = PhysicalDevicePushDescriptorPropertiesKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDevicePushDescriptorPropertiesKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDevicePushDescriptorPropertiesKHRBuilder<'a> { + #[inline] + pub fn max_push_descriptors(mut self, max_push_descriptors: u32) -> Self { + self.inner.max_push_descriptors = max_push_descriptors; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDevicePushDescriptorPropertiesKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct ConformanceVersion { + pub major: u8, + pub minor: u8, + pub subminor: u8, + pub patch: u8, +} +impl ConformanceVersion { + pub fn builder<'a>() -> ConformanceVersionBuilder<'a> { + ConformanceVersionBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ConformanceVersionBuilder<'a> { + inner: ConformanceVersion, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ConformanceVersionBuilder<'a> { + type Target = ConformanceVersion; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ConformanceVersionBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ConformanceVersionBuilder<'a> { + #[inline] + pub fn major(mut self, major: u8) -> Self { + self.inner.major = major; + self + } + #[inline] + pub fn minor(mut self, minor: u8) -> Self { + self.inner.minor = minor; + self + } + #[inline] + pub fn subminor(mut self, subminor: u8) -> Self { + self.inner.subminor = subminor; + self + } + #[inline] + pub fn patch(mut self, patch: u8) -> Self { + self.inner.patch = patch; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ConformanceVersion { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceDriverProperties { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub driver_id: DriverId, + pub driver_name: [c_char; MAX_DRIVER_NAME_SIZE], + pub driver_info: [c_char; MAX_DRIVER_INFO_SIZE], + pub conformance_version: ConformanceVersion, +} +#[cfg(feature = "debug")] +impl fmt::Debug for PhysicalDeviceDriverProperties { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fmt.debug_struct("PhysicalDeviceDriverProperties") + .field("s_type", &self.s_type) + .field("p_next", &self.p_next) + .field("driver_id", &self.driver_id) + .field("driver_name", &unsafe { + ::std::ffi::CStr::from_ptr(self.driver_name.as_ptr()) + }) + .field("driver_info", &unsafe { + ::std::ffi::CStr::from_ptr(self.driver_info.as_ptr()) + }) + .field("conformance_version", &self.conformance_version) + .finish() + } +} +impl ::std::default::Default for PhysicalDeviceDriverProperties { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + driver_id: DriverId::default(), + driver_name: unsafe { ::std::mem::zeroed() }, + driver_info: unsafe { ::std::mem::zeroed() }, + conformance_version: ConformanceVersion::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceDriverProperties { + const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_DRIVER_PROPERTIES; +} +impl PhysicalDeviceDriverProperties { + pub fn builder<'a>() -> PhysicalDeviceDriverPropertiesBuilder<'a> { + PhysicalDeviceDriverPropertiesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceDriverPropertiesBuilder<'a> { + inner: PhysicalDeviceDriverProperties, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceDriverPropertiesBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceDriverProperties {} +impl<'a> ::std::ops::Deref for PhysicalDeviceDriverPropertiesBuilder<'a> { + type Target = PhysicalDeviceDriverProperties; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceDriverPropertiesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceDriverPropertiesBuilder<'a> { + #[inline] + pub fn driver_id(mut self, driver_id: DriverId) -> Self { + self.inner.driver_id = driver_id; + self + } + #[inline] + pub fn driver_name(mut self, driver_name: [c_char; MAX_DRIVER_NAME_SIZE]) -> Self { + self.inner.driver_name = driver_name; + self + } + #[inline] + pub fn driver_info(mut self, driver_info: [c_char; MAX_DRIVER_INFO_SIZE]) -> Self { + self.inner.driver_info = driver_info; + self + } + #[inline] + pub fn conformance_version(mut self, conformance_version: ConformanceVersion) -> Self { + self.inner.conformance_version = conformance_version; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceDriverProperties { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PresentRegionsKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub swapchain_count: u32, + pub p_regions: *const PresentRegionKHR, +} +impl ::std::default::Default for PresentRegionsKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + swapchain_count: u32::default(), + p_regions: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for PresentRegionsKHR { + const STRUCTURE_TYPE: StructureType = StructureType::PRESENT_REGIONS_KHR; +} +impl PresentRegionsKHR { + pub fn builder<'a>() -> PresentRegionsKHRBuilder<'a> { + PresentRegionsKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PresentRegionsKHRBuilder<'a> { + inner: PresentRegionsKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPresentInfoKHR for PresentRegionsKHRBuilder<'_> {} +unsafe impl ExtendsPresentInfoKHR for PresentRegionsKHR {} +impl<'a> ::std::ops::Deref for PresentRegionsKHRBuilder<'a> { + type Target = PresentRegionsKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PresentRegionsKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PresentRegionsKHRBuilder<'a> { + #[inline] + pub fn regions(mut self, regions: &'a [PresentRegionKHR]) -> Self { + self.inner.swapchain_count = regions.len() as _; + self.inner.p_regions = regions.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PresentRegionsKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PresentRegionKHR { + pub rectangle_count: u32, + pub p_rectangles: *const RectLayerKHR, +} +impl ::std::default::Default for PresentRegionKHR { + #[inline] + fn default() -> Self { + Self { + rectangle_count: u32::default(), + p_rectangles: ::std::ptr::null(), + } + } +} +impl PresentRegionKHR { + pub fn builder<'a>() -> PresentRegionKHRBuilder<'a> { + PresentRegionKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PresentRegionKHRBuilder<'a> { + inner: PresentRegionKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PresentRegionKHRBuilder<'a> { + type Target = PresentRegionKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PresentRegionKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PresentRegionKHRBuilder<'a> { + #[inline] + pub fn rectangles(mut self, rectangles: &'a [RectLayerKHR]) -> Self { + self.inner.rectangle_count = rectangles.len() as _; + self.inner.p_rectangles = rectangles.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PresentRegionKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct RectLayerKHR { + pub offset: Offset2D, + pub extent: Extent2D, + pub layer: u32, +} +impl RectLayerKHR { + pub fn builder<'a>() -> RectLayerKHRBuilder<'a> { + RectLayerKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct RectLayerKHRBuilder<'a> { + inner: RectLayerKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for RectLayerKHRBuilder<'a> { + type Target = RectLayerKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for RectLayerKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> RectLayerKHRBuilder<'a> { + #[inline] + pub fn offset(mut self, offset: Offset2D) -> Self { + self.inner.offset = offset; + self + } + #[inline] + pub fn extent(mut self, extent: Extent2D) -> Self { + self.inner.extent = extent; + self + } + #[inline] + pub fn layer(mut self, layer: u32) -> Self { + self.inner.layer = layer; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> RectLayerKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceVariablePointersFeatures { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub variable_pointers_storage_buffer: Bool32, + pub variable_pointers: Bool32, +} +impl ::std::default::Default for PhysicalDeviceVariablePointersFeatures { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + variable_pointers_storage_buffer: Bool32::default(), + variable_pointers: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceVariablePointersFeatures { + const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES; +} +impl PhysicalDeviceVariablePointersFeatures { + pub fn builder<'a>() -> PhysicalDeviceVariablePointersFeaturesBuilder<'a> { + PhysicalDeviceVariablePointersFeaturesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceVariablePointersFeaturesBuilder<'a> { + inner: PhysicalDeviceVariablePointersFeatures, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceVariablePointersFeaturesBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceVariablePointersFeatures {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVariablePointersFeaturesBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVariablePointersFeatures {} +impl<'a> ::std::ops::Deref for PhysicalDeviceVariablePointersFeaturesBuilder<'a> { + type Target = PhysicalDeviceVariablePointersFeatures; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceVariablePointersFeaturesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceVariablePointersFeaturesBuilder<'a> { + #[inline] + pub fn variable_pointers_storage_buffer( + mut self, + variable_pointers_storage_buffer: bool, + ) -> Self { + self.inner.variable_pointers_storage_buffer = variable_pointers_storage_buffer.into(); + self + } + #[inline] + pub fn variable_pointers(mut self, variable_pointers: bool) -> Self { + self.inner.variable_pointers = variable_pointers.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceVariablePointersFeatures { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct ExternalMemoryProperties { + pub external_memory_features: ExternalMemoryFeatureFlags, + pub export_from_imported_handle_types: ExternalMemoryHandleTypeFlags, + pub compatible_handle_types: ExternalMemoryHandleTypeFlags, +} +impl ExternalMemoryProperties { + pub fn builder<'a>() -> ExternalMemoryPropertiesBuilder<'a> { + ExternalMemoryPropertiesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ExternalMemoryPropertiesBuilder<'a> { + inner: ExternalMemoryProperties, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ExternalMemoryPropertiesBuilder<'a> { + type Target = ExternalMemoryProperties; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ExternalMemoryPropertiesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ExternalMemoryPropertiesBuilder<'a> { + #[inline] + pub fn external_memory_features( + mut self, + external_memory_features: ExternalMemoryFeatureFlags, + ) -> Self { + self.inner.external_memory_features = external_memory_features; + self + } + #[inline] + pub fn export_from_imported_handle_types( + mut self, + export_from_imported_handle_types: ExternalMemoryHandleTypeFlags, + ) -> Self { + self.inner.export_from_imported_handle_types = export_from_imported_handle_types; + self + } + #[inline] + pub fn compatible_handle_types( + mut self, + compatible_handle_types: ExternalMemoryHandleTypeFlags, + ) -> Self { + self.inner.compatible_handle_types = compatible_handle_types; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ExternalMemoryProperties { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceExternalImageFormatInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub handle_type: ExternalMemoryHandleTypeFlags, +} +impl ::std::default::Default for PhysicalDeviceExternalImageFormatInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + handle_type: ExternalMemoryHandleTypeFlags::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceExternalImageFormatInfo { + const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO; +} +impl PhysicalDeviceExternalImageFormatInfo { + pub fn builder<'a>() -> PhysicalDeviceExternalImageFormatInfoBuilder<'a> { + PhysicalDeviceExternalImageFormatInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceExternalImageFormatInfoBuilder<'a> { + inner: PhysicalDeviceExternalImageFormatInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceImageFormatInfo2 + for PhysicalDeviceExternalImageFormatInfoBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceImageFormatInfo2 for PhysicalDeviceExternalImageFormatInfo {} +impl<'a> ::std::ops::Deref for PhysicalDeviceExternalImageFormatInfoBuilder<'a> { + type Target = PhysicalDeviceExternalImageFormatInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceExternalImageFormatInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceExternalImageFormatInfoBuilder<'a> { + #[inline] + pub fn handle_type(mut self, handle_type: ExternalMemoryHandleTypeFlags) -> Self { + self.inner.handle_type = handle_type; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceExternalImageFormatInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ExternalImageFormatProperties { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub external_memory_properties: ExternalMemoryProperties, +} +impl ::std::default::Default for ExternalImageFormatProperties { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + external_memory_properties: ExternalMemoryProperties::default(), + } + } +} +unsafe impl TaggedStructure for ExternalImageFormatProperties { + const STRUCTURE_TYPE: StructureType = StructureType::EXTERNAL_IMAGE_FORMAT_PROPERTIES; +} +impl ExternalImageFormatProperties { + pub fn builder<'a>() -> ExternalImageFormatPropertiesBuilder<'a> { + ExternalImageFormatPropertiesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ExternalImageFormatPropertiesBuilder<'a> { + inner: ExternalImageFormatProperties, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsImageFormatProperties2 for ExternalImageFormatPropertiesBuilder<'_> {} +unsafe impl ExtendsImageFormatProperties2 for ExternalImageFormatProperties {} +impl<'a> ::std::ops::Deref for ExternalImageFormatPropertiesBuilder<'a> { + type Target = ExternalImageFormatProperties; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ExternalImageFormatPropertiesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ExternalImageFormatPropertiesBuilder<'a> { + #[inline] + pub fn external_memory_properties( + mut self, + external_memory_properties: ExternalMemoryProperties, + ) -> Self { + self.inner.external_memory_properties = external_memory_properties; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ExternalImageFormatProperties { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceExternalBufferInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: BufferCreateFlags, + pub usage: BufferUsageFlags, + pub handle_type: ExternalMemoryHandleTypeFlags, +} +impl ::std::default::Default for PhysicalDeviceExternalBufferInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: BufferCreateFlags::default(), + usage: BufferUsageFlags::default(), + handle_type: ExternalMemoryHandleTypeFlags::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceExternalBufferInfo { + const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO; +} +impl PhysicalDeviceExternalBufferInfo { + pub fn builder<'a>() -> PhysicalDeviceExternalBufferInfoBuilder<'a> { + PhysicalDeviceExternalBufferInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceExternalBufferInfoBuilder<'a> { + inner: PhysicalDeviceExternalBufferInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PhysicalDeviceExternalBufferInfoBuilder<'a> { + type Target = PhysicalDeviceExternalBufferInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceExternalBufferInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceExternalBufferInfoBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: BufferCreateFlags) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn usage(mut self, usage: BufferUsageFlags) -> Self { + self.inner.usage = usage; + self + } + #[inline] + pub fn handle_type(mut self, handle_type: ExternalMemoryHandleTypeFlags) -> Self { + self.inner.handle_type = handle_type; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceExternalBufferInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ExternalBufferProperties { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub external_memory_properties: ExternalMemoryProperties, +} +impl ::std::default::Default for ExternalBufferProperties { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + external_memory_properties: ExternalMemoryProperties::default(), + } + } +} +unsafe impl TaggedStructure for ExternalBufferProperties { + const STRUCTURE_TYPE: StructureType = StructureType::EXTERNAL_BUFFER_PROPERTIES; +} +impl ExternalBufferProperties { + pub fn builder<'a>() -> ExternalBufferPropertiesBuilder<'a> { + ExternalBufferPropertiesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ExternalBufferPropertiesBuilder<'a> { + inner: ExternalBufferProperties, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ExternalBufferPropertiesBuilder<'a> { + type Target = ExternalBufferProperties; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ExternalBufferPropertiesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ExternalBufferPropertiesBuilder<'a> { + #[inline] + pub fn external_memory_properties( + mut self, + external_memory_properties: ExternalMemoryProperties, + ) -> Self { + self.inner.external_memory_properties = external_memory_properties; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ExternalBufferProperties { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceIDProperties { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub device_uuid: [u8; UUID_SIZE], + pub driver_uuid: [u8; UUID_SIZE], + pub device_luid: [u8; LUID_SIZE], + pub device_node_mask: u32, + pub device_luid_valid: Bool32, +} +impl ::std::default::Default for PhysicalDeviceIDProperties { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + device_uuid: unsafe { ::std::mem::zeroed() }, + driver_uuid: unsafe { ::std::mem::zeroed() }, + device_luid: unsafe { ::std::mem::zeroed() }, + device_node_mask: u32::default(), + device_luid_valid: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceIDProperties { + const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_ID_PROPERTIES; +} +impl PhysicalDeviceIDProperties { + pub fn builder<'a>() -> PhysicalDeviceIDPropertiesBuilder<'a> { + PhysicalDeviceIDPropertiesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceIDPropertiesBuilder<'a> { + inner: PhysicalDeviceIDProperties, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceIDPropertiesBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceIDProperties {} +impl<'a> ::std::ops::Deref for PhysicalDeviceIDPropertiesBuilder<'a> { + type Target = PhysicalDeviceIDProperties; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceIDPropertiesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceIDPropertiesBuilder<'a> { + #[inline] + pub fn device_uuid(mut self, device_uuid: [u8; UUID_SIZE]) -> Self { + self.inner.device_uuid = device_uuid; + self + } + #[inline] + pub fn driver_uuid(mut self, driver_uuid: [u8; UUID_SIZE]) -> Self { + self.inner.driver_uuid = driver_uuid; + self + } + #[inline] + pub fn device_luid(mut self, device_luid: [u8; LUID_SIZE]) -> Self { + self.inner.device_luid = device_luid; + self + } + #[inline] + pub fn device_node_mask(mut self, device_node_mask: u32) -> Self { + self.inner.device_node_mask = device_node_mask; + self + } + #[inline] + pub fn device_luid_valid(mut self, device_luid_valid: bool) -> Self { + self.inner.device_luid_valid = device_luid_valid.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceIDProperties { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ExternalMemoryImageCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub handle_types: ExternalMemoryHandleTypeFlags, +} +impl ::std::default::Default for ExternalMemoryImageCreateInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + handle_types: ExternalMemoryHandleTypeFlags::default(), + } + } +} +unsafe impl TaggedStructure for ExternalMemoryImageCreateInfo { + const STRUCTURE_TYPE: StructureType = StructureType::EXTERNAL_MEMORY_IMAGE_CREATE_INFO; +} +impl ExternalMemoryImageCreateInfo { + pub fn builder<'a>() -> ExternalMemoryImageCreateInfoBuilder<'a> { + ExternalMemoryImageCreateInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ExternalMemoryImageCreateInfoBuilder<'a> { + inner: ExternalMemoryImageCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsImageCreateInfo for ExternalMemoryImageCreateInfoBuilder<'_> {} +unsafe impl ExtendsImageCreateInfo for ExternalMemoryImageCreateInfo {} +impl<'a> ::std::ops::Deref for ExternalMemoryImageCreateInfoBuilder<'a> { + type Target = ExternalMemoryImageCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ExternalMemoryImageCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ExternalMemoryImageCreateInfoBuilder<'a> { + #[inline] + pub fn handle_types(mut self, handle_types: ExternalMemoryHandleTypeFlags) -> Self { + self.inner.handle_types = handle_types; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ExternalMemoryImageCreateInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ExternalMemoryBufferCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub handle_types: ExternalMemoryHandleTypeFlags, +} +impl ::std::default::Default for ExternalMemoryBufferCreateInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + handle_types: ExternalMemoryHandleTypeFlags::default(), + } + } +} +unsafe impl TaggedStructure for ExternalMemoryBufferCreateInfo { + const STRUCTURE_TYPE: StructureType = StructureType::EXTERNAL_MEMORY_BUFFER_CREATE_INFO; +} +impl ExternalMemoryBufferCreateInfo { + pub fn builder<'a>() -> ExternalMemoryBufferCreateInfoBuilder<'a> { + ExternalMemoryBufferCreateInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ExternalMemoryBufferCreateInfoBuilder<'a> { + inner: ExternalMemoryBufferCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsBufferCreateInfo for ExternalMemoryBufferCreateInfoBuilder<'_> {} +unsafe impl ExtendsBufferCreateInfo for ExternalMemoryBufferCreateInfo {} +impl<'a> ::std::ops::Deref for ExternalMemoryBufferCreateInfoBuilder<'a> { + type Target = ExternalMemoryBufferCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ExternalMemoryBufferCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ExternalMemoryBufferCreateInfoBuilder<'a> { + #[inline] + pub fn handle_types(mut self, handle_types: ExternalMemoryHandleTypeFlags) -> Self { + self.inner.handle_types = handle_types; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ExternalMemoryBufferCreateInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ExportMemoryAllocateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub handle_types: ExternalMemoryHandleTypeFlags, +} +impl ::std::default::Default for ExportMemoryAllocateInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + handle_types: ExternalMemoryHandleTypeFlags::default(), + } + } +} +unsafe impl TaggedStructure for ExportMemoryAllocateInfo { + const STRUCTURE_TYPE: StructureType = StructureType::EXPORT_MEMORY_ALLOCATE_INFO; +} +impl ExportMemoryAllocateInfo { + pub fn builder<'a>() -> ExportMemoryAllocateInfoBuilder<'a> { + ExportMemoryAllocateInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ExportMemoryAllocateInfoBuilder<'a> { + inner: ExportMemoryAllocateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsMemoryAllocateInfo for ExportMemoryAllocateInfoBuilder<'_> {} +unsafe impl ExtendsMemoryAllocateInfo for ExportMemoryAllocateInfo {} +impl<'a> ::std::ops::Deref for ExportMemoryAllocateInfoBuilder<'a> { + type Target = ExportMemoryAllocateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ExportMemoryAllocateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ExportMemoryAllocateInfoBuilder<'a> { + #[inline] + pub fn handle_types(mut self, handle_types: ExternalMemoryHandleTypeFlags) -> Self { + self.inner.handle_types = handle_types; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ExportMemoryAllocateInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ImportMemoryWin32HandleInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub handle_type: ExternalMemoryHandleTypeFlags, + pub handle: HANDLE, + pub name: LPCWSTR, +} +impl ::std::default::Default for ImportMemoryWin32HandleInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + handle_type: ExternalMemoryHandleTypeFlags::default(), + handle: unsafe { ::std::mem::zeroed() }, + name: unsafe { ::std::mem::zeroed() }, + } + } +} +unsafe impl TaggedStructure for ImportMemoryWin32HandleInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR; +} +impl ImportMemoryWin32HandleInfoKHR { + pub fn builder<'a>() -> ImportMemoryWin32HandleInfoKHRBuilder<'a> { + ImportMemoryWin32HandleInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ImportMemoryWin32HandleInfoKHRBuilder<'a> { + inner: ImportMemoryWin32HandleInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsMemoryAllocateInfo for ImportMemoryWin32HandleInfoKHRBuilder<'_> {} +unsafe impl ExtendsMemoryAllocateInfo for ImportMemoryWin32HandleInfoKHR {} +impl<'a> ::std::ops::Deref for ImportMemoryWin32HandleInfoKHRBuilder<'a> { + type Target = ImportMemoryWin32HandleInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ImportMemoryWin32HandleInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ImportMemoryWin32HandleInfoKHRBuilder<'a> { + #[inline] + pub fn handle_type(mut self, handle_type: ExternalMemoryHandleTypeFlags) -> Self { + self.inner.handle_type = handle_type; + self + } + #[inline] + pub fn handle(mut self, handle: HANDLE) -> Self { + self.inner.handle = handle; + self + } + #[inline] + pub fn name(mut self, name: LPCWSTR) -> Self { + self.inner.name = name; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ImportMemoryWin32HandleInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ExportMemoryWin32HandleInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub p_attributes: *const SECURITY_ATTRIBUTES, + pub dw_access: DWORD, + pub name: LPCWSTR, +} +impl ::std::default::Default for ExportMemoryWin32HandleInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + p_attributes: ::std::ptr::null(), + dw_access: DWORD::default(), + name: unsafe { ::std::mem::zeroed() }, + } + } +} +unsafe impl TaggedStructure for ExportMemoryWin32HandleInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR; +} +impl ExportMemoryWin32HandleInfoKHR { + pub fn builder<'a>() -> ExportMemoryWin32HandleInfoKHRBuilder<'a> { + ExportMemoryWin32HandleInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ExportMemoryWin32HandleInfoKHRBuilder<'a> { + inner: ExportMemoryWin32HandleInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsMemoryAllocateInfo for ExportMemoryWin32HandleInfoKHRBuilder<'_> {} +unsafe impl ExtendsMemoryAllocateInfo for ExportMemoryWin32HandleInfoKHR {} +impl<'a> ::std::ops::Deref for ExportMemoryWin32HandleInfoKHRBuilder<'a> { + type Target = ExportMemoryWin32HandleInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ExportMemoryWin32HandleInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ExportMemoryWin32HandleInfoKHRBuilder<'a> { + #[inline] + pub fn attributes(mut self, attributes: &'a SECURITY_ATTRIBUTES) -> Self { + self.inner.p_attributes = attributes; + self + } + #[inline] + pub fn dw_access(mut self, dw_access: DWORD) -> Self { + self.inner.dw_access = dw_access; + self + } + #[inline] + pub fn name(mut self, name: LPCWSTR) -> Self { + self.inner.name = name; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ExportMemoryWin32HandleInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ImportMemoryZirconHandleInfoFUCHSIA { + pub s_type: StructureType, + pub p_next: *const c_void, + pub handle_type: ExternalMemoryHandleTypeFlags, + pub handle: zx_handle_t, +} +impl ::std::default::Default for ImportMemoryZirconHandleInfoFUCHSIA { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + handle_type: ExternalMemoryHandleTypeFlags::default(), + handle: zx_handle_t::default(), + } + } +} +unsafe impl TaggedStructure for ImportMemoryZirconHandleInfoFUCHSIA { + const STRUCTURE_TYPE: StructureType = StructureType::IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA; +} +impl ImportMemoryZirconHandleInfoFUCHSIA { + pub fn builder<'a>() -> ImportMemoryZirconHandleInfoFUCHSIABuilder<'a> { + ImportMemoryZirconHandleInfoFUCHSIABuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ImportMemoryZirconHandleInfoFUCHSIABuilder<'a> { + inner: ImportMemoryZirconHandleInfoFUCHSIA, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsMemoryAllocateInfo for ImportMemoryZirconHandleInfoFUCHSIABuilder<'_> {} +unsafe impl ExtendsMemoryAllocateInfo for ImportMemoryZirconHandleInfoFUCHSIA {} +impl<'a> ::std::ops::Deref for ImportMemoryZirconHandleInfoFUCHSIABuilder<'a> { + type Target = ImportMemoryZirconHandleInfoFUCHSIA; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ImportMemoryZirconHandleInfoFUCHSIABuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ImportMemoryZirconHandleInfoFUCHSIABuilder<'a> { + #[inline] + pub fn handle_type(mut self, handle_type: ExternalMemoryHandleTypeFlags) -> Self { + self.inner.handle_type = handle_type; + self + } + #[inline] + pub fn handle(mut self, handle: zx_handle_t) -> Self { + self.inner.handle = handle; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ImportMemoryZirconHandleInfoFUCHSIA { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct MemoryZirconHandlePropertiesFUCHSIA { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub memory_type_bits: u32, +} +impl ::std::default::Default for MemoryZirconHandlePropertiesFUCHSIA { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + memory_type_bits: u32::default(), + } + } +} +unsafe impl TaggedStructure for MemoryZirconHandlePropertiesFUCHSIA { + const STRUCTURE_TYPE: StructureType = StructureType::MEMORY_ZIRCON_HANDLE_PROPERTIES_FUCHSIA; +} +impl MemoryZirconHandlePropertiesFUCHSIA { + pub fn builder<'a>() -> MemoryZirconHandlePropertiesFUCHSIABuilder<'a> { + MemoryZirconHandlePropertiesFUCHSIABuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct MemoryZirconHandlePropertiesFUCHSIABuilder<'a> { + inner: MemoryZirconHandlePropertiesFUCHSIA, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for MemoryZirconHandlePropertiesFUCHSIABuilder<'a> { + type Target = MemoryZirconHandlePropertiesFUCHSIA; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for MemoryZirconHandlePropertiesFUCHSIABuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> MemoryZirconHandlePropertiesFUCHSIABuilder<'a> { + #[inline] + pub fn memory_type_bits(mut self, memory_type_bits: u32) -> Self { + self.inner.memory_type_bits = memory_type_bits; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> MemoryZirconHandlePropertiesFUCHSIA { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct MemoryGetZirconHandleInfoFUCHSIA { + pub s_type: StructureType, + pub p_next: *const c_void, + pub memory: DeviceMemory, + pub handle_type: ExternalMemoryHandleTypeFlags, +} +impl ::std::default::Default for MemoryGetZirconHandleInfoFUCHSIA { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + memory: DeviceMemory::default(), + handle_type: ExternalMemoryHandleTypeFlags::default(), + } + } +} +unsafe impl TaggedStructure for MemoryGetZirconHandleInfoFUCHSIA { + const STRUCTURE_TYPE: StructureType = StructureType::MEMORY_GET_ZIRCON_HANDLE_INFO_FUCHSIA; +} +impl MemoryGetZirconHandleInfoFUCHSIA { + pub fn builder<'a>() -> MemoryGetZirconHandleInfoFUCHSIABuilder<'a> { + MemoryGetZirconHandleInfoFUCHSIABuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct MemoryGetZirconHandleInfoFUCHSIABuilder<'a> { + inner: MemoryGetZirconHandleInfoFUCHSIA, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for MemoryGetZirconHandleInfoFUCHSIABuilder<'a> { + type Target = MemoryGetZirconHandleInfoFUCHSIA; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for MemoryGetZirconHandleInfoFUCHSIABuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> MemoryGetZirconHandleInfoFUCHSIABuilder<'a> { + #[inline] + pub fn memory(mut self, memory: DeviceMemory) -> Self { + self.inner.memory = memory; + self + } + #[inline] + pub fn handle_type(mut self, handle_type: ExternalMemoryHandleTypeFlags) -> Self { + self.inner.handle_type = handle_type; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> MemoryGetZirconHandleInfoFUCHSIA { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct MemoryWin32HandlePropertiesKHR { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub memory_type_bits: u32, +} +impl ::std::default::Default for MemoryWin32HandlePropertiesKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + memory_type_bits: u32::default(), + } + } +} +unsafe impl TaggedStructure for MemoryWin32HandlePropertiesKHR { + const STRUCTURE_TYPE: StructureType = StructureType::MEMORY_WIN32_HANDLE_PROPERTIES_KHR; +} +impl MemoryWin32HandlePropertiesKHR { + pub fn builder<'a>() -> MemoryWin32HandlePropertiesKHRBuilder<'a> { + MemoryWin32HandlePropertiesKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct MemoryWin32HandlePropertiesKHRBuilder<'a> { + inner: MemoryWin32HandlePropertiesKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for MemoryWin32HandlePropertiesKHRBuilder<'a> { + type Target = MemoryWin32HandlePropertiesKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for MemoryWin32HandlePropertiesKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> MemoryWin32HandlePropertiesKHRBuilder<'a> { + #[inline] + pub fn memory_type_bits(mut self, memory_type_bits: u32) -> Self { + self.inner.memory_type_bits = memory_type_bits; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> MemoryWin32HandlePropertiesKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct MemoryGetWin32HandleInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub memory: DeviceMemory, + pub handle_type: ExternalMemoryHandleTypeFlags, +} +impl ::std::default::Default for MemoryGetWin32HandleInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + memory: DeviceMemory::default(), + handle_type: ExternalMemoryHandleTypeFlags::default(), + } + } +} +unsafe impl TaggedStructure for MemoryGetWin32HandleInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::MEMORY_GET_WIN32_HANDLE_INFO_KHR; +} +impl MemoryGetWin32HandleInfoKHR { + pub fn builder<'a>() -> MemoryGetWin32HandleInfoKHRBuilder<'a> { + MemoryGetWin32HandleInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct MemoryGetWin32HandleInfoKHRBuilder<'a> { + inner: MemoryGetWin32HandleInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for MemoryGetWin32HandleInfoKHRBuilder<'a> { + type Target = MemoryGetWin32HandleInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for MemoryGetWin32HandleInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> MemoryGetWin32HandleInfoKHRBuilder<'a> { + #[inline] + pub fn memory(mut self, memory: DeviceMemory) -> Self { + self.inner.memory = memory; + self + } + #[inline] + pub fn handle_type(mut self, handle_type: ExternalMemoryHandleTypeFlags) -> Self { + self.inner.handle_type = handle_type; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> MemoryGetWin32HandleInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ImportMemoryFdInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub handle_type: ExternalMemoryHandleTypeFlags, + pub fd: c_int, +} +impl ::std::default::Default for ImportMemoryFdInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + handle_type: ExternalMemoryHandleTypeFlags::default(), + fd: c_int::default(), + } + } +} +unsafe impl TaggedStructure for ImportMemoryFdInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::IMPORT_MEMORY_FD_INFO_KHR; +} +impl ImportMemoryFdInfoKHR { + pub fn builder<'a>() -> ImportMemoryFdInfoKHRBuilder<'a> { + ImportMemoryFdInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ImportMemoryFdInfoKHRBuilder<'a> { + inner: ImportMemoryFdInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsMemoryAllocateInfo for ImportMemoryFdInfoKHRBuilder<'_> {} +unsafe impl ExtendsMemoryAllocateInfo for ImportMemoryFdInfoKHR {} +impl<'a> ::std::ops::Deref for ImportMemoryFdInfoKHRBuilder<'a> { + type Target = ImportMemoryFdInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ImportMemoryFdInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ImportMemoryFdInfoKHRBuilder<'a> { + #[inline] + pub fn handle_type(mut self, handle_type: ExternalMemoryHandleTypeFlags) -> Self { + self.inner.handle_type = handle_type; + self + } + #[inline] + pub fn fd(mut self, fd: c_int) -> Self { + self.inner.fd = fd; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ImportMemoryFdInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct MemoryFdPropertiesKHR { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub memory_type_bits: u32, +} +impl ::std::default::Default for MemoryFdPropertiesKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + memory_type_bits: u32::default(), + } + } +} +unsafe impl TaggedStructure for MemoryFdPropertiesKHR { + const STRUCTURE_TYPE: StructureType = StructureType::MEMORY_FD_PROPERTIES_KHR; +} +impl MemoryFdPropertiesKHR { + pub fn builder<'a>() -> MemoryFdPropertiesKHRBuilder<'a> { + MemoryFdPropertiesKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct MemoryFdPropertiesKHRBuilder<'a> { + inner: MemoryFdPropertiesKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for MemoryFdPropertiesKHRBuilder<'a> { + type Target = MemoryFdPropertiesKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for MemoryFdPropertiesKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> MemoryFdPropertiesKHRBuilder<'a> { + #[inline] + pub fn memory_type_bits(mut self, memory_type_bits: u32) -> Self { + self.inner.memory_type_bits = memory_type_bits; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> MemoryFdPropertiesKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct MemoryGetFdInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub memory: DeviceMemory, + pub handle_type: ExternalMemoryHandleTypeFlags, +} +impl ::std::default::Default for MemoryGetFdInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + memory: DeviceMemory::default(), + handle_type: ExternalMemoryHandleTypeFlags::default(), + } + } +} +unsafe impl TaggedStructure for MemoryGetFdInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::MEMORY_GET_FD_INFO_KHR; +} +impl MemoryGetFdInfoKHR { + pub fn builder<'a>() -> MemoryGetFdInfoKHRBuilder<'a> { + MemoryGetFdInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct MemoryGetFdInfoKHRBuilder<'a> { + inner: MemoryGetFdInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for MemoryGetFdInfoKHRBuilder<'a> { + type Target = MemoryGetFdInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for MemoryGetFdInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> MemoryGetFdInfoKHRBuilder<'a> { + #[inline] + pub fn memory(mut self, memory: DeviceMemory) -> Self { + self.inner.memory = memory; + self + } + #[inline] + pub fn handle_type(mut self, handle_type: ExternalMemoryHandleTypeFlags) -> Self { + self.inner.handle_type = handle_type; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> MemoryGetFdInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct Win32KeyedMutexAcquireReleaseInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub acquire_count: u32, + pub p_acquire_syncs: *const DeviceMemory, + pub p_acquire_keys: *const u64, + pub p_acquire_timeouts: *const u32, + pub release_count: u32, + pub p_release_syncs: *const DeviceMemory, + pub p_release_keys: *const u64, +} +impl ::std::default::Default for Win32KeyedMutexAcquireReleaseInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + acquire_count: u32::default(), + p_acquire_syncs: ::std::ptr::null(), + p_acquire_keys: ::std::ptr::null(), + p_acquire_timeouts: ::std::ptr::null(), + release_count: u32::default(), + p_release_syncs: ::std::ptr::null(), + p_release_keys: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for Win32KeyedMutexAcquireReleaseInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR; +} +impl Win32KeyedMutexAcquireReleaseInfoKHR { + pub fn builder<'a>() -> Win32KeyedMutexAcquireReleaseInfoKHRBuilder<'a> { + Win32KeyedMutexAcquireReleaseInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct Win32KeyedMutexAcquireReleaseInfoKHRBuilder<'a> { + inner: Win32KeyedMutexAcquireReleaseInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsSubmitInfo for Win32KeyedMutexAcquireReleaseInfoKHRBuilder<'_> {} +unsafe impl ExtendsSubmitInfo for Win32KeyedMutexAcquireReleaseInfoKHR {} +unsafe impl ExtendsSubmitInfo2 for Win32KeyedMutexAcquireReleaseInfoKHRBuilder<'_> {} +unsafe impl ExtendsSubmitInfo2 for Win32KeyedMutexAcquireReleaseInfoKHR {} +impl<'a> ::std::ops::Deref for Win32KeyedMutexAcquireReleaseInfoKHRBuilder<'a> { + type Target = Win32KeyedMutexAcquireReleaseInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for Win32KeyedMutexAcquireReleaseInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> Win32KeyedMutexAcquireReleaseInfoKHRBuilder<'a> { + #[inline] + pub fn acquire_syncs(mut self, acquire_syncs: &'a [DeviceMemory]) -> Self { + self.inner.acquire_count = acquire_syncs.len() as _; + self.inner.p_acquire_syncs = acquire_syncs.as_ptr(); + self + } + #[inline] + pub fn acquire_keys(mut self, acquire_keys: &'a [u64]) -> Self { + self.inner.acquire_count = acquire_keys.len() as _; + self.inner.p_acquire_keys = acquire_keys.as_ptr(); + self + } + #[inline] + pub fn acquire_timeouts(mut self, acquire_timeouts: &'a [u32]) -> Self { + self.inner.acquire_count = acquire_timeouts.len() as _; + self.inner.p_acquire_timeouts = acquire_timeouts.as_ptr(); + self + } + #[inline] + pub fn release_syncs(mut self, release_syncs: &'a [DeviceMemory]) -> Self { + self.inner.release_count = release_syncs.len() as _; + self.inner.p_release_syncs = release_syncs.as_ptr(); + self + } + #[inline] + pub fn release_keys(mut self, release_keys: &'a [u64]) -> Self { + self.inner.release_count = release_keys.len() as _; + self.inner.p_release_keys = release_keys.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> Win32KeyedMutexAcquireReleaseInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceExternalSemaphoreInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub handle_type: ExternalSemaphoreHandleTypeFlags, +} +impl ::std::default::Default for PhysicalDeviceExternalSemaphoreInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + handle_type: ExternalSemaphoreHandleTypeFlags::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceExternalSemaphoreInfo { + const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO; +} +impl PhysicalDeviceExternalSemaphoreInfo { + pub fn builder<'a>() -> PhysicalDeviceExternalSemaphoreInfoBuilder<'a> { + PhysicalDeviceExternalSemaphoreInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceExternalSemaphoreInfoBuilder<'a> { + inner: PhysicalDeviceExternalSemaphoreInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsPhysicalDeviceExternalSemaphoreInfo {} +impl<'a> ::std::ops::Deref for PhysicalDeviceExternalSemaphoreInfoBuilder<'a> { + type Target = PhysicalDeviceExternalSemaphoreInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceExternalSemaphoreInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceExternalSemaphoreInfoBuilder<'a> { + #[inline] + pub fn handle_type(mut self, handle_type: ExternalSemaphoreHandleTypeFlags) -> Self { + self.inner.handle_type = handle_type; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next( + mut self, + next: &'a mut T, + ) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceExternalSemaphoreInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ExternalSemaphoreProperties { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub export_from_imported_handle_types: ExternalSemaphoreHandleTypeFlags, + pub compatible_handle_types: ExternalSemaphoreHandleTypeFlags, + pub external_semaphore_features: ExternalSemaphoreFeatureFlags, +} +impl ::std::default::Default for ExternalSemaphoreProperties { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + export_from_imported_handle_types: ExternalSemaphoreHandleTypeFlags::default(), + compatible_handle_types: ExternalSemaphoreHandleTypeFlags::default(), + external_semaphore_features: ExternalSemaphoreFeatureFlags::default(), + } + } +} +unsafe impl TaggedStructure for ExternalSemaphoreProperties { + const STRUCTURE_TYPE: StructureType = StructureType::EXTERNAL_SEMAPHORE_PROPERTIES; +} +impl ExternalSemaphoreProperties { + pub fn builder<'a>() -> ExternalSemaphorePropertiesBuilder<'a> { + ExternalSemaphorePropertiesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ExternalSemaphorePropertiesBuilder<'a> { + inner: ExternalSemaphoreProperties, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ExternalSemaphorePropertiesBuilder<'a> { + type Target = ExternalSemaphoreProperties; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ExternalSemaphorePropertiesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ExternalSemaphorePropertiesBuilder<'a> { + #[inline] + pub fn export_from_imported_handle_types( + mut self, + export_from_imported_handle_types: ExternalSemaphoreHandleTypeFlags, + ) -> Self { + self.inner.export_from_imported_handle_types = export_from_imported_handle_types; + self + } + #[inline] + pub fn compatible_handle_types( + mut self, + compatible_handle_types: ExternalSemaphoreHandleTypeFlags, + ) -> Self { + self.inner.compatible_handle_types = compatible_handle_types; + self + } + #[inline] + pub fn external_semaphore_features( + mut self, + external_semaphore_features: ExternalSemaphoreFeatureFlags, + ) -> Self { + self.inner.external_semaphore_features = external_semaphore_features; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ExternalSemaphoreProperties { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ExportSemaphoreCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub handle_types: ExternalSemaphoreHandleTypeFlags, +} +impl ::std::default::Default for ExportSemaphoreCreateInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + handle_types: ExternalSemaphoreHandleTypeFlags::default(), + } + } +} +unsafe impl TaggedStructure for ExportSemaphoreCreateInfo { + const STRUCTURE_TYPE: StructureType = StructureType::EXPORT_SEMAPHORE_CREATE_INFO; +} +impl ExportSemaphoreCreateInfo { + pub fn builder<'a>() -> ExportSemaphoreCreateInfoBuilder<'a> { + ExportSemaphoreCreateInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ExportSemaphoreCreateInfoBuilder<'a> { + inner: ExportSemaphoreCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsSemaphoreCreateInfo for ExportSemaphoreCreateInfoBuilder<'_> {} +unsafe impl ExtendsSemaphoreCreateInfo for ExportSemaphoreCreateInfo {} +impl<'a> ::std::ops::Deref for ExportSemaphoreCreateInfoBuilder<'a> { + type Target = ExportSemaphoreCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ExportSemaphoreCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ExportSemaphoreCreateInfoBuilder<'a> { + #[inline] + pub fn handle_types(mut self, handle_types: ExternalSemaphoreHandleTypeFlags) -> Self { + self.inner.handle_types = handle_types; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ExportSemaphoreCreateInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ImportSemaphoreWin32HandleInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub semaphore: Semaphore, + pub flags: SemaphoreImportFlags, + pub handle_type: ExternalSemaphoreHandleTypeFlags, + pub handle: HANDLE, + pub name: LPCWSTR, +} +impl ::std::default::Default for ImportSemaphoreWin32HandleInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + semaphore: Semaphore::default(), + flags: SemaphoreImportFlags::default(), + handle_type: ExternalSemaphoreHandleTypeFlags::default(), + handle: unsafe { ::std::mem::zeroed() }, + name: unsafe { ::std::mem::zeroed() }, + } + } +} +unsafe impl TaggedStructure for ImportSemaphoreWin32HandleInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR; +} +impl ImportSemaphoreWin32HandleInfoKHR { + pub fn builder<'a>() -> ImportSemaphoreWin32HandleInfoKHRBuilder<'a> { + ImportSemaphoreWin32HandleInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ImportSemaphoreWin32HandleInfoKHRBuilder<'a> { + inner: ImportSemaphoreWin32HandleInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ImportSemaphoreWin32HandleInfoKHRBuilder<'a> { + type Target = ImportSemaphoreWin32HandleInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ImportSemaphoreWin32HandleInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ImportSemaphoreWin32HandleInfoKHRBuilder<'a> { + #[inline] + pub fn semaphore(mut self, semaphore: Semaphore) -> Self { + self.inner.semaphore = semaphore; + self + } + #[inline] + pub fn flags(mut self, flags: SemaphoreImportFlags) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn handle_type(mut self, handle_type: ExternalSemaphoreHandleTypeFlags) -> Self { + self.inner.handle_type = handle_type; + self + } + #[inline] + pub fn handle(mut self, handle: HANDLE) -> Self { + self.inner.handle = handle; + self + } + #[inline] + pub fn name(mut self, name: LPCWSTR) -> Self { + self.inner.name = name; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ImportSemaphoreWin32HandleInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ExportSemaphoreWin32HandleInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub p_attributes: *const SECURITY_ATTRIBUTES, + pub dw_access: DWORD, + pub name: LPCWSTR, +} +impl ::std::default::Default for ExportSemaphoreWin32HandleInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + p_attributes: ::std::ptr::null(), + dw_access: DWORD::default(), + name: unsafe { ::std::mem::zeroed() }, + } + } +} +unsafe impl TaggedStructure for ExportSemaphoreWin32HandleInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR; +} +impl ExportSemaphoreWin32HandleInfoKHR { + pub fn builder<'a>() -> ExportSemaphoreWin32HandleInfoKHRBuilder<'a> { + ExportSemaphoreWin32HandleInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ExportSemaphoreWin32HandleInfoKHRBuilder<'a> { + inner: ExportSemaphoreWin32HandleInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsSemaphoreCreateInfo for ExportSemaphoreWin32HandleInfoKHRBuilder<'_> {} +unsafe impl ExtendsSemaphoreCreateInfo for ExportSemaphoreWin32HandleInfoKHR {} +impl<'a> ::std::ops::Deref for ExportSemaphoreWin32HandleInfoKHRBuilder<'a> { + type Target = ExportSemaphoreWin32HandleInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ExportSemaphoreWin32HandleInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ExportSemaphoreWin32HandleInfoKHRBuilder<'a> { + #[inline] + pub fn attributes(mut self, attributes: &'a SECURITY_ATTRIBUTES) -> Self { + self.inner.p_attributes = attributes; + self + } + #[inline] + pub fn dw_access(mut self, dw_access: DWORD) -> Self { + self.inner.dw_access = dw_access; + self + } + #[inline] + pub fn name(mut self, name: LPCWSTR) -> Self { + self.inner.name = name; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ExportSemaphoreWin32HandleInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct D3D12FenceSubmitInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub wait_semaphore_values_count: u32, + pub p_wait_semaphore_values: *const u64, + pub signal_semaphore_values_count: u32, + pub p_signal_semaphore_values: *const u64, +} +impl ::std::default::Default for D3D12FenceSubmitInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + wait_semaphore_values_count: u32::default(), + p_wait_semaphore_values: ::std::ptr::null(), + signal_semaphore_values_count: u32::default(), + p_signal_semaphore_values: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for D3D12FenceSubmitInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::D3D12_FENCE_SUBMIT_INFO_KHR; +} +impl D3D12FenceSubmitInfoKHR { + pub fn builder<'a>() -> D3D12FenceSubmitInfoKHRBuilder<'a> { + D3D12FenceSubmitInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct D3D12FenceSubmitInfoKHRBuilder<'a> { + inner: D3D12FenceSubmitInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsSubmitInfo for D3D12FenceSubmitInfoKHRBuilder<'_> {} +unsafe impl ExtendsSubmitInfo for D3D12FenceSubmitInfoKHR {} +impl<'a> ::std::ops::Deref for D3D12FenceSubmitInfoKHRBuilder<'a> { + type Target = D3D12FenceSubmitInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for D3D12FenceSubmitInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> D3D12FenceSubmitInfoKHRBuilder<'a> { + #[inline] + pub fn wait_semaphore_values(mut self, wait_semaphore_values: &'a [u64]) -> Self { + self.inner.wait_semaphore_values_count = wait_semaphore_values.len() as _; + self.inner.p_wait_semaphore_values = wait_semaphore_values.as_ptr(); + self + } + #[inline] + pub fn signal_semaphore_values(mut self, signal_semaphore_values: &'a [u64]) -> Self { + self.inner.signal_semaphore_values_count = signal_semaphore_values.len() as _; + self.inner.p_signal_semaphore_values = signal_semaphore_values.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> D3D12FenceSubmitInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SemaphoreGetWin32HandleInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub semaphore: Semaphore, + pub handle_type: ExternalSemaphoreHandleTypeFlags, +} +impl ::std::default::Default for SemaphoreGetWin32HandleInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + semaphore: Semaphore::default(), + handle_type: ExternalSemaphoreHandleTypeFlags::default(), + } + } +} +unsafe impl TaggedStructure for SemaphoreGetWin32HandleInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR; +} +impl SemaphoreGetWin32HandleInfoKHR { + pub fn builder<'a>() -> SemaphoreGetWin32HandleInfoKHRBuilder<'a> { + SemaphoreGetWin32HandleInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SemaphoreGetWin32HandleInfoKHRBuilder<'a> { + inner: SemaphoreGetWin32HandleInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for SemaphoreGetWin32HandleInfoKHRBuilder<'a> { + type Target = SemaphoreGetWin32HandleInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SemaphoreGetWin32HandleInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SemaphoreGetWin32HandleInfoKHRBuilder<'a> { + #[inline] + pub fn semaphore(mut self, semaphore: Semaphore) -> Self { + self.inner.semaphore = semaphore; + self + } + #[inline] + pub fn handle_type(mut self, handle_type: ExternalSemaphoreHandleTypeFlags) -> Self { + self.inner.handle_type = handle_type; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SemaphoreGetWin32HandleInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ImportSemaphoreFdInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub semaphore: Semaphore, + pub flags: SemaphoreImportFlags, + pub handle_type: ExternalSemaphoreHandleTypeFlags, + pub fd: c_int, +} +impl ::std::default::Default for ImportSemaphoreFdInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + semaphore: Semaphore::default(), + flags: SemaphoreImportFlags::default(), + handle_type: ExternalSemaphoreHandleTypeFlags::default(), + fd: c_int::default(), + } + } +} +unsafe impl TaggedStructure for ImportSemaphoreFdInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::IMPORT_SEMAPHORE_FD_INFO_KHR; +} +impl ImportSemaphoreFdInfoKHR { + pub fn builder<'a>() -> ImportSemaphoreFdInfoKHRBuilder<'a> { + ImportSemaphoreFdInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ImportSemaphoreFdInfoKHRBuilder<'a> { + inner: ImportSemaphoreFdInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ImportSemaphoreFdInfoKHRBuilder<'a> { + type Target = ImportSemaphoreFdInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ImportSemaphoreFdInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ImportSemaphoreFdInfoKHRBuilder<'a> { + #[inline] + pub fn semaphore(mut self, semaphore: Semaphore) -> Self { + self.inner.semaphore = semaphore; + self + } + #[inline] + pub fn flags(mut self, flags: SemaphoreImportFlags) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn handle_type(mut self, handle_type: ExternalSemaphoreHandleTypeFlags) -> Self { + self.inner.handle_type = handle_type; + self + } + #[inline] + pub fn fd(mut self, fd: c_int) -> Self { + self.inner.fd = fd; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ImportSemaphoreFdInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SemaphoreGetFdInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub semaphore: Semaphore, + pub handle_type: ExternalSemaphoreHandleTypeFlags, +} +impl ::std::default::Default for SemaphoreGetFdInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + semaphore: Semaphore::default(), + handle_type: ExternalSemaphoreHandleTypeFlags::default(), + } + } +} +unsafe impl TaggedStructure for SemaphoreGetFdInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::SEMAPHORE_GET_FD_INFO_KHR; +} +impl SemaphoreGetFdInfoKHR { + pub fn builder<'a>() -> SemaphoreGetFdInfoKHRBuilder<'a> { + SemaphoreGetFdInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SemaphoreGetFdInfoKHRBuilder<'a> { + inner: SemaphoreGetFdInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for SemaphoreGetFdInfoKHRBuilder<'a> { + type Target = SemaphoreGetFdInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SemaphoreGetFdInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SemaphoreGetFdInfoKHRBuilder<'a> { + #[inline] + pub fn semaphore(mut self, semaphore: Semaphore) -> Self { + self.inner.semaphore = semaphore; + self + } + #[inline] + pub fn handle_type(mut self, handle_type: ExternalSemaphoreHandleTypeFlags) -> Self { + self.inner.handle_type = handle_type; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SemaphoreGetFdInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ImportSemaphoreZirconHandleInfoFUCHSIA { + pub s_type: StructureType, + pub p_next: *const c_void, + pub semaphore: Semaphore, + pub flags: SemaphoreImportFlags, + pub handle_type: ExternalSemaphoreHandleTypeFlags, + pub zircon_handle: zx_handle_t, +} +impl ::std::default::Default for ImportSemaphoreZirconHandleInfoFUCHSIA { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + semaphore: Semaphore::default(), + flags: SemaphoreImportFlags::default(), + handle_type: ExternalSemaphoreHandleTypeFlags::default(), + zircon_handle: zx_handle_t::default(), + } + } +} +unsafe impl TaggedStructure for ImportSemaphoreZirconHandleInfoFUCHSIA { + const STRUCTURE_TYPE: StructureType = + StructureType::IMPORT_SEMAPHORE_ZIRCON_HANDLE_INFO_FUCHSIA; +} +impl ImportSemaphoreZirconHandleInfoFUCHSIA { + pub fn builder<'a>() -> ImportSemaphoreZirconHandleInfoFUCHSIABuilder<'a> { + ImportSemaphoreZirconHandleInfoFUCHSIABuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ImportSemaphoreZirconHandleInfoFUCHSIABuilder<'a> { + inner: ImportSemaphoreZirconHandleInfoFUCHSIA, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ImportSemaphoreZirconHandleInfoFUCHSIABuilder<'a> { + type Target = ImportSemaphoreZirconHandleInfoFUCHSIA; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ImportSemaphoreZirconHandleInfoFUCHSIABuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ImportSemaphoreZirconHandleInfoFUCHSIABuilder<'a> { + #[inline] + pub fn semaphore(mut self, semaphore: Semaphore) -> Self { + self.inner.semaphore = semaphore; + self + } + #[inline] + pub fn flags(mut self, flags: SemaphoreImportFlags) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn handle_type(mut self, handle_type: ExternalSemaphoreHandleTypeFlags) -> Self { + self.inner.handle_type = handle_type; + self + } + #[inline] + pub fn zircon_handle(mut self, zircon_handle: zx_handle_t) -> Self { + self.inner.zircon_handle = zircon_handle; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ImportSemaphoreZirconHandleInfoFUCHSIA { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SemaphoreGetZirconHandleInfoFUCHSIA { + pub s_type: StructureType, + pub p_next: *const c_void, + pub semaphore: Semaphore, + pub handle_type: ExternalSemaphoreHandleTypeFlags, +} +impl ::std::default::Default for SemaphoreGetZirconHandleInfoFUCHSIA { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + semaphore: Semaphore::default(), + handle_type: ExternalSemaphoreHandleTypeFlags::default(), + } + } +} +unsafe impl TaggedStructure for SemaphoreGetZirconHandleInfoFUCHSIA { + const STRUCTURE_TYPE: StructureType = StructureType::SEMAPHORE_GET_ZIRCON_HANDLE_INFO_FUCHSIA; +} +impl SemaphoreGetZirconHandleInfoFUCHSIA { + pub fn builder<'a>() -> SemaphoreGetZirconHandleInfoFUCHSIABuilder<'a> { + SemaphoreGetZirconHandleInfoFUCHSIABuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SemaphoreGetZirconHandleInfoFUCHSIABuilder<'a> { + inner: SemaphoreGetZirconHandleInfoFUCHSIA, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for SemaphoreGetZirconHandleInfoFUCHSIABuilder<'a> { + type Target = SemaphoreGetZirconHandleInfoFUCHSIA; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SemaphoreGetZirconHandleInfoFUCHSIABuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SemaphoreGetZirconHandleInfoFUCHSIABuilder<'a> { + #[inline] + pub fn semaphore(mut self, semaphore: Semaphore) -> Self { + self.inner.semaphore = semaphore; + self + } + #[inline] + pub fn handle_type(mut self, handle_type: ExternalSemaphoreHandleTypeFlags) -> Self { + self.inner.handle_type = handle_type; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SemaphoreGetZirconHandleInfoFUCHSIA { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceExternalFenceInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub handle_type: ExternalFenceHandleTypeFlags, +} +impl ::std::default::Default for PhysicalDeviceExternalFenceInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + handle_type: ExternalFenceHandleTypeFlags::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceExternalFenceInfo { + const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO; +} +impl PhysicalDeviceExternalFenceInfo { + pub fn builder<'a>() -> PhysicalDeviceExternalFenceInfoBuilder<'a> { + PhysicalDeviceExternalFenceInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceExternalFenceInfoBuilder<'a> { + inner: PhysicalDeviceExternalFenceInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PhysicalDeviceExternalFenceInfoBuilder<'a> { + type Target = PhysicalDeviceExternalFenceInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceExternalFenceInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceExternalFenceInfoBuilder<'a> { + #[inline] + pub fn handle_type(mut self, handle_type: ExternalFenceHandleTypeFlags) -> Self { + self.inner.handle_type = handle_type; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceExternalFenceInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ExternalFenceProperties { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub export_from_imported_handle_types: ExternalFenceHandleTypeFlags, + pub compatible_handle_types: ExternalFenceHandleTypeFlags, + pub external_fence_features: ExternalFenceFeatureFlags, +} +impl ::std::default::Default for ExternalFenceProperties { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + export_from_imported_handle_types: ExternalFenceHandleTypeFlags::default(), + compatible_handle_types: ExternalFenceHandleTypeFlags::default(), + external_fence_features: ExternalFenceFeatureFlags::default(), + } + } +} +unsafe impl TaggedStructure for ExternalFenceProperties { + const STRUCTURE_TYPE: StructureType = StructureType::EXTERNAL_FENCE_PROPERTIES; +} +impl ExternalFenceProperties { + pub fn builder<'a>() -> ExternalFencePropertiesBuilder<'a> { + ExternalFencePropertiesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ExternalFencePropertiesBuilder<'a> { + inner: ExternalFenceProperties, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ExternalFencePropertiesBuilder<'a> { + type Target = ExternalFenceProperties; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ExternalFencePropertiesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ExternalFencePropertiesBuilder<'a> { + #[inline] + pub fn export_from_imported_handle_types( + mut self, + export_from_imported_handle_types: ExternalFenceHandleTypeFlags, + ) -> Self { + self.inner.export_from_imported_handle_types = export_from_imported_handle_types; + self + } + #[inline] + pub fn compatible_handle_types( + mut self, + compatible_handle_types: ExternalFenceHandleTypeFlags, + ) -> Self { + self.inner.compatible_handle_types = compatible_handle_types; + self + } + #[inline] + pub fn external_fence_features( + mut self, + external_fence_features: ExternalFenceFeatureFlags, + ) -> Self { + self.inner.external_fence_features = external_fence_features; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ExternalFenceProperties { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ExportFenceCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub handle_types: ExternalFenceHandleTypeFlags, +} +impl ::std::default::Default for ExportFenceCreateInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + handle_types: ExternalFenceHandleTypeFlags::default(), + } + } +} +unsafe impl TaggedStructure for ExportFenceCreateInfo { + const STRUCTURE_TYPE: StructureType = StructureType::EXPORT_FENCE_CREATE_INFO; +} +impl ExportFenceCreateInfo { + pub fn builder<'a>() -> ExportFenceCreateInfoBuilder<'a> { + ExportFenceCreateInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ExportFenceCreateInfoBuilder<'a> { + inner: ExportFenceCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsFenceCreateInfo for ExportFenceCreateInfoBuilder<'_> {} +unsafe impl ExtendsFenceCreateInfo for ExportFenceCreateInfo {} +impl<'a> ::std::ops::Deref for ExportFenceCreateInfoBuilder<'a> { + type Target = ExportFenceCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ExportFenceCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ExportFenceCreateInfoBuilder<'a> { + #[inline] + pub fn handle_types(mut self, handle_types: ExternalFenceHandleTypeFlags) -> Self { + self.inner.handle_types = handle_types; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ExportFenceCreateInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ImportFenceWin32HandleInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub fence: Fence, + pub flags: FenceImportFlags, + pub handle_type: ExternalFenceHandleTypeFlags, + pub handle: HANDLE, + pub name: LPCWSTR, +} +impl ::std::default::Default for ImportFenceWin32HandleInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + fence: Fence::default(), + flags: FenceImportFlags::default(), + handle_type: ExternalFenceHandleTypeFlags::default(), + handle: unsafe { ::std::mem::zeroed() }, + name: unsafe { ::std::mem::zeroed() }, + } + } +} +unsafe impl TaggedStructure for ImportFenceWin32HandleInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::IMPORT_FENCE_WIN32_HANDLE_INFO_KHR; +} +impl ImportFenceWin32HandleInfoKHR { + pub fn builder<'a>() -> ImportFenceWin32HandleInfoKHRBuilder<'a> { + ImportFenceWin32HandleInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ImportFenceWin32HandleInfoKHRBuilder<'a> { + inner: ImportFenceWin32HandleInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ImportFenceWin32HandleInfoKHRBuilder<'a> { + type Target = ImportFenceWin32HandleInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ImportFenceWin32HandleInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ImportFenceWin32HandleInfoKHRBuilder<'a> { + #[inline] + pub fn fence(mut self, fence: Fence) -> Self { + self.inner.fence = fence; + self + } + #[inline] + pub fn flags(mut self, flags: FenceImportFlags) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn handle_type(mut self, handle_type: ExternalFenceHandleTypeFlags) -> Self { + self.inner.handle_type = handle_type; + self + } + #[inline] + pub fn handle(mut self, handle: HANDLE) -> Self { + self.inner.handle = handle; + self + } + #[inline] + pub fn name(mut self, name: LPCWSTR) -> Self { + self.inner.name = name; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ImportFenceWin32HandleInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ExportFenceWin32HandleInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub p_attributes: *const SECURITY_ATTRIBUTES, + pub dw_access: DWORD, + pub name: LPCWSTR, +} +impl ::std::default::Default for ExportFenceWin32HandleInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + p_attributes: ::std::ptr::null(), + dw_access: DWORD::default(), + name: unsafe { ::std::mem::zeroed() }, + } + } +} +unsafe impl TaggedStructure for ExportFenceWin32HandleInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::EXPORT_FENCE_WIN32_HANDLE_INFO_KHR; +} +impl ExportFenceWin32HandleInfoKHR { + pub fn builder<'a>() -> ExportFenceWin32HandleInfoKHRBuilder<'a> { + ExportFenceWin32HandleInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ExportFenceWin32HandleInfoKHRBuilder<'a> { + inner: ExportFenceWin32HandleInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsFenceCreateInfo for ExportFenceWin32HandleInfoKHRBuilder<'_> {} +unsafe impl ExtendsFenceCreateInfo for ExportFenceWin32HandleInfoKHR {} +impl<'a> ::std::ops::Deref for ExportFenceWin32HandleInfoKHRBuilder<'a> { + type Target = ExportFenceWin32HandleInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ExportFenceWin32HandleInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ExportFenceWin32HandleInfoKHRBuilder<'a> { + #[inline] + pub fn attributes(mut self, attributes: &'a SECURITY_ATTRIBUTES) -> Self { + self.inner.p_attributes = attributes; + self + } + #[inline] + pub fn dw_access(mut self, dw_access: DWORD) -> Self { + self.inner.dw_access = dw_access; + self + } + #[inline] + pub fn name(mut self, name: LPCWSTR) -> Self { + self.inner.name = name; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ExportFenceWin32HandleInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct FenceGetWin32HandleInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub fence: Fence, + pub handle_type: ExternalFenceHandleTypeFlags, +} +impl ::std::default::Default for FenceGetWin32HandleInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + fence: Fence::default(), + handle_type: ExternalFenceHandleTypeFlags::default(), + } + } +} +unsafe impl TaggedStructure for FenceGetWin32HandleInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::FENCE_GET_WIN32_HANDLE_INFO_KHR; +} +impl FenceGetWin32HandleInfoKHR { + pub fn builder<'a>() -> FenceGetWin32HandleInfoKHRBuilder<'a> { + FenceGetWin32HandleInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct FenceGetWin32HandleInfoKHRBuilder<'a> { + inner: FenceGetWin32HandleInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for FenceGetWin32HandleInfoKHRBuilder<'a> { + type Target = FenceGetWin32HandleInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for FenceGetWin32HandleInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> FenceGetWin32HandleInfoKHRBuilder<'a> { + #[inline] + pub fn fence(mut self, fence: Fence) -> Self { + self.inner.fence = fence; + self + } + #[inline] + pub fn handle_type(mut self, handle_type: ExternalFenceHandleTypeFlags) -> Self { + self.inner.handle_type = handle_type; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> FenceGetWin32HandleInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ImportFenceFdInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub fence: Fence, + pub flags: FenceImportFlags, + pub handle_type: ExternalFenceHandleTypeFlags, + pub fd: c_int, +} +impl ::std::default::Default for ImportFenceFdInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + fence: Fence::default(), + flags: FenceImportFlags::default(), + handle_type: ExternalFenceHandleTypeFlags::default(), + fd: c_int::default(), + } + } +} +unsafe impl TaggedStructure for ImportFenceFdInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::IMPORT_FENCE_FD_INFO_KHR; +} +impl ImportFenceFdInfoKHR { + pub fn builder<'a>() -> ImportFenceFdInfoKHRBuilder<'a> { + ImportFenceFdInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ImportFenceFdInfoKHRBuilder<'a> { + inner: ImportFenceFdInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ImportFenceFdInfoKHRBuilder<'a> { + type Target = ImportFenceFdInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ImportFenceFdInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ImportFenceFdInfoKHRBuilder<'a> { + #[inline] + pub fn fence(mut self, fence: Fence) -> Self { + self.inner.fence = fence; + self + } + #[inline] + pub fn flags(mut self, flags: FenceImportFlags) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn handle_type(mut self, handle_type: ExternalFenceHandleTypeFlags) -> Self { + self.inner.handle_type = handle_type; + self + } + #[inline] + pub fn fd(mut self, fd: c_int) -> Self { + self.inner.fd = fd; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ImportFenceFdInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct FenceGetFdInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub fence: Fence, + pub handle_type: ExternalFenceHandleTypeFlags, +} +impl ::std::default::Default for FenceGetFdInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + fence: Fence::default(), + handle_type: ExternalFenceHandleTypeFlags::default(), + } + } +} +unsafe impl TaggedStructure for FenceGetFdInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::FENCE_GET_FD_INFO_KHR; +} +impl FenceGetFdInfoKHR { + pub fn builder<'a>() -> FenceGetFdInfoKHRBuilder<'a> { + FenceGetFdInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct FenceGetFdInfoKHRBuilder<'a> { + inner: FenceGetFdInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for FenceGetFdInfoKHRBuilder<'a> { + type Target = FenceGetFdInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for FenceGetFdInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> FenceGetFdInfoKHRBuilder<'a> { + #[inline] + pub fn fence(mut self, fence: Fence) -> Self { + self.inner.fence = fence; + self + } + #[inline] + pub fn handle_type(mut self, handle_type: ExternalFenceHandleTypeFlags) -> Self { + self.inner.handle_type = handle_type; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> FenceGetFdInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceMultiviewFeatures { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub multiview: Bool32, + pub multiview_geometry_shader: Bool32, + pub multiview_tessellation_shader: Bool32, +} +impl ::std::default::Default for PhysicalDeviceMultiviewFeatures { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + multiview: Bool32::default(), + multiview_geometry_shader: Bool32::default(), + multiview_tessellation_shader: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceMultiviewFeatures { + const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_MULTIVIEW_FEATURES; +} +impl PhysicalDeviceMultiviewFeatures { + pub fn builder<'a>() -> PhysicalDeviceMultiviewFeaturesBuilder<'a> { + PhysicalDeviceMultiviewFeaturesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceMultiviewFeaturesBuilder<'a> { + inner: PhysicalDeviceMultiviewFeatures, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceMultiviewFeaturesBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceMultiviewFeatures {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMultiviewFeaturesBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMultiviewFeatures {} +impl<'a> ::std::ops::Deref for PhysicalDeviceMultiviewFeaturesBuilder<'a> { + type Target = PhysicalDeviceMultiviewFeatures; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceMultiviewFeaturesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceMultiviewFeaturesBuilder<'a> { + #[inline] + pub fn multiview(mut self, multiview: bool) -> Self { + self.inner.multiview = multiview.into(); + self + } + #[inline] + pub fn multiview_geometry_shader(mut self, multiview_geometry_shader: bool) -> Self { + self.inner.multiview_geometry_shader = multiview_geometry_shader.into(); + self + } + #[inline] + pub fn multiview_tessellation_shader(mut self, multiview_tessellation_shader: bool) -> Self { + self.inner.multiview_tessellation_shader = multiview_tessellation_shader.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceMultiviewFeatures { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceMultiviewProperties { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub max_multiview_view_count: u32, + pub max_multiview_instance_index: u32, +} +impl ::std::default::Default for PhysicalDeviceMultiviewProperties { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + max_multiview_view_count: u32::default(), + max_multiview_instance_index: u32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceMultiviewProperties { + const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES; +} +impl PhysicalDeviceMultiviewProperties { + pub fn builder<'a>() -> PhysicalDeviceMultiviewPropertiesBuilder<'a> { + PhysicalDeviceMultiviewPropertiesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceMultiviewPropertiesBuilder<'a> { + inner: PhysicalDeviceMultiviewProperties, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceMultiviewPropertiesBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceMultiviewProperties {} +impl<'a> ::std::ops::Deref for PhysicalDeviceMultiviewPropertiesBuilder<'a> { + type Target = PhysicalDeviceMultiviewProperties; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceMultiviewPropertiesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceMultiviewPropertiesBuilder<'a> { + #[inline] + pub fn max_multiview_view_count(mut self, max_multiview_view_count: u32) -> Self { + self.inner.max_multiview_view_count = max_multiview_view_count; + self + } + #[inline] + pub fn max_multiview_instance_index(mut self, max_multiview_instance_index: u32) -> Self { + self.inner.max_multiview_instance_index = max_multiview_instance_index; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceMultiviewProperties { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct RenderPassMultiviewCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub subpass_count: u32, + pub p_view_masks: *const u32, + pub dependency_count: u32, + pub p_view_offsets: *const i32, + pub correlation_mask_count: u32, + pub p_correlation_masks: *const u32, +} +impl ::std::default::Default for RenderPassMultiviewCreateInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + subpass_count: u32::default(), + p_view_masks: ::std::ptr::null(), + dependency_count: u32::default(), + p_view_offsets: ::std::ptr::null(), + correlation_mask_count: u32::default(), + p_correlation_masks: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for RenderPassMultiviewCreateInfo { + const STRUCTURE_TYPE: StructureType = StructureType::RENDER_PASS_MULTIVIEW_CREATE_INFO; +} +impl RenderPassMultiviewCreateInfo { + pub fn builder<'a>() -> RenderPassMultiviewCreateInfoBuilder<'a> { + RenderPassMultiviewCreateInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct RenderPassMultiviewCreateInfoBuilder<'a> { + inner: RenderPassMultiviewCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsRenderPassCreateInfo for RenderPassMultiviewCreateInfoBuilder<'_> {} +unsafe impl ExtendsRenderPassCreateInfo for RenderPassMultiviewCreateInfo {} +impl<'a> ::std::ops::Deref for RenderPassMultiviewCreateInfoBuilder<'a> { + type Target = RenderPassMultiviewCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for RenderPassMultiviewCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> RenderPassMultiviewCreateInfoBuilder<'a> { + #[inline] + pub fn view_masks(mut self, view_masks: &'a [u32]) -> Self { + self.inner.subpass_count = view_masks.len() as _; + self.inner.p_view_masks = view_masks.as_ptr(); + self + } + #[inline] + pub fn view_offsets(mut self, view_offsets: &'a [i32]) -> Self { + self.inner.dependency_count = view_offsets.len() as _; + self.inner.p_view_offsets = view_offsets.as_ptr(); + self + } + #[inline] + pub fn correlation_masks(mut self, correlation_masks: &'a [u32]) -> Self { + self.inner.correlation_mask_count = correlation_masks.len() as _; + self.inner.p_correlation_masks = correlation_masks.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> RenderPassMultiviewCreateInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SurfaceCapabilities2EXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub min_image_count: u32, + pub max_image_count: u32, + pub current_extent: Extent2D, + pub min_image_extent: Extent2D, + pub max_image_extent: Extent2D, + pub max_image_array_layers: u32, + pub supported_transforms: SurfaceTransformFlagsKHR, + pub current_transform: SurfaceTransformFlagsKHR, + pub supported_composite_alpha: CompositeAlphaFlagsKHR, + pub supported_usage_flags: ImageUsageFlags, + pub supported_surface_counters: SurfaceCounterFlagsEXT, +} +impl ::std::default::Default for SurfaceCapabilities2EXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + min_image_count: u32::default(), + max_image_count: u32::default(), + current_extent: Extent2D::default(), + min_image_extent: Extent2D::default(), + max_image_extent: Extent2D::default(), + max_image_array_layers: u32::default(), + supported_transforms: SurfaceTransformFlagsKHR::default(), + current_transform: SurfaceTransformFlagsKHR::default(), + supported_composite_alpha: CompositeAlphaFlagsKHR::default(), + supported_usage_flags: ImageUsageFlags::default(), + supported_surface_counters: SurfaceCounterFlagsEXT::default(), + } + } +} +unsafe impl TaggedStructure for SurfaceCapabilities2EXT { + const STRUCTURE_TYPE: StructureType = StructureType::SURFACE_CAPABILITIES_2_EXT; +} +impl SurfaceCapabilities2EXT { + pub fn builder<'a>() -> SurfaceCapabilities2EXTBuilder<'a> { + SurfaceCapabilities2EXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SurfaceCapabilities2EXTBuilder<'a> { + inner: SurfaceCapabilities2EXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for SurfaceCapabilities2EXTBuilder<'a> { + type Target = SurfaceCapabilities2EXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SurfaceCapabilities2EXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SurfaceCapabilities2EXTBuilder<'a> { + #[inline] + pub fn min_image_count(mut self, min_image_count: u32) -> Self { + self.inner.min_image_count = min_image_count; + self + } + #[inline] + pub fn max_image_count(mut self, max_image_count: u32) -> Self { + self.inner.max_image_count = max_image_count; + self + } + #[inline] + pub fn current_extent(mut self, current_extent: Extent2D) -> Self { + self.inner.current_extent = current_extent; + self + } + #[inline] + pub fn min_image_extent(mut self, min_image_extent: Extent2D) -> Self { + self.inner.min_image_extent = min_image_extent; + self + } + #[inline] + pub fn max_image_extent(mut self, max_image_extent: Extent2D) -> Self { + self.inner.max_image_extent = max_image_extent; + self + } + #[inline] + pub fn max_image_array_layers(mut self, max_image_array_layers: u32) -> Self { + self.inner.max_image_array_layers = max_image_array_layers; + self + } + #[inline] + pub fn supported_transforms(mut self, supported_transforms: SurfaceTransformFlagsKHR) -> Self { + self.inner.supported_transforms = supported_transforms; + self + } + #[inline] + pub fn current_transform(mut self, current_transform: SurfaceTransformFlagsKHR) -> Self { + self.inner.current_transform = current_transform; + self + } + #[inline] + pub fn supported_composite_alpha( + mut self, + supported_composite_alpha: CompositeAlphaFlagsKHR, + ) -> Self { + self.inner.supported_composite_alpha = supported_composite_alpha; + self + } + #[inline] + pub fn supported_usage_flags(mut self, supported_usage_flags: ImageUsageFlags) -> Self { + self.inner.supported_usage_flags = supported_usage_flags; + self + } + #[inline] + pub fn supported_surface_counters( + mut self, + supported_surface_counters: SurfaceCounterFlagsEXT, + ) -> Self { + self.inner.supported_surface_counters = supported_surface_counters; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SurfaceCapabilities2EXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DisplayPowerInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub power_state: DisplayPowerStateEXT, +} +impl ::std::default::Default for DisplayPowerInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + power_state: DisplayPowerStateEXT::default(), + } + } +} +unsafe impl TaggedStructure for DisplayPowerInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::DISPLAY_POWER_INFO_EXT; +} +impl DisplayPowerInfoEXT { + pub fn builder<'a>() -> DisplayPowerInfoEXTBuilder<'a> { + DisplayPowerInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DisplayPowerInfoEXTBuilder<'a> { + inner: DisplayPowerInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DisplayPowerInfoEXTBuilder<'a> { + type Target = DisplayPowerInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DisplayPowerInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DisplayPowerInfoEXTBuilder<'a> { + #[inline] + pub fn power_state(mut self, power_state: DisplayPowerStateEXT) -> Self { + self.inner.power_state = power_state; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DisplayPowerInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DeviceEventInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub device_event: DeviceEventTypeEXT, +} +impl ::std::default::Default for DeviceEventInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + device_event: DeviceEventTypeEXT::default(), + } + } +} +unsafe impl TaggedStructure for DeviceEventInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::DEVICE_EVENT_INFO_EXT; +} +impl DeviceEventInfoEXT { + pub fn builder<'a>() -> DeviceEventInfoEXTBuilder<'a> { + DeviceEventInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DeviceEventInfoEXTBuilder<'a> { + inner: DeviceEventInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DeviceEventInfoEXTBuilder<'a> { + type Target = DeviceEventInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DeviceEventInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DeviceEventInfoEXTBuilder<'a> { + #[inline] + pub fn device_event(mut self, device_event: DeviceEventTypeEXT) -> Self { + self.inner.device_event = device_event; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DeviceEventInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DisplayEventInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub display_event: DisplayEventTypeEXT, +} +impl ::std::default::Default for DisplayEventInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + display_event: DisplayEventTypeEXT::default(), + } + } +} +unsafe impl TaggedStructure for DisplayEventInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::DISPLAY_EVENT_INFO_EXT; +} +impl DisplayEventInfoEXT { + pub fn builder<'a>() -> DisplayEventInfoEXTBuilder<'a> { + DisplayEventInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DisplayEventInfoEXTBuilder<'a> { + inner: DisplayEventInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DisplayEventInfoEXTBuilder<'a> { + type Target = DisplayEventInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DisplayEventInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DisplayEventInfoEXTBuilder<'a> { + #[inline] + pub fn display_event(mut self, display_event: DisplayEventTypeEXT) -> Self { + self.inner.display_event = display_event; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DisplayEventInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SwapchainCounterCreateInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub surface_counters: SurfaceCounterFlagsEXT, +} +impl ::std::default::Default for SwapchainCounterCreateInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + surface_counters: SurfaceCounterFlagsEXT::default(), + } + } +} +unsafe impl TaggedStructure for SwapchainCounterCreateInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::SWAPCHAIN_COUNTER_CREATE_INFO_EXT; +} +impl SwapchainCounterCreateInfoEXT { + pub fn builder<'a>() -> SwapchainCounterCreateInfoEXTBuilder<'a> { + SwapchainCounterCreateInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SwapchainCounterCreateInfoEXTBuilder<'a> { + inner: SwapchainCounterCreateInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsSwapchainCreateInfoKHR for SwapchainCounterCreateInfoEXTBuilder<'_> {} +unsafe impl ExtendsSwapchainCreateInfoKHR for SwapchainCounterCreateInfoEXT {} +impl<'a> ::std::ops::Deref for SwapchainCounterCreateInfoEXTBuilder<'a> { + type Target = SwapchainCounterCreateInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SwapchainCounterCreateInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SwapchainCounterCreateInfoEXTBuilder<'a> { + #[inline] + pub fn surface_counters(mut self, surface_counters: SurfaceCounterFlagsEXT) -> Self { + self.inner.surface_counters = surface_counters; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SwapchainCounterCreateInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceGroupProperties { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub physical_device_count: u32, + pub physical_devices: [PhysicalDevice; MAX_DEVICE_GROUP_SIZE], + pub subset_allocation: Bool32, +} +impl ::std::default::Default for PhysicalDeviceGroupProperties { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + physical_device_count: u32::default(), + physical_devices: unsafe { ::std::mem::zeroed() }, + subset_allocation: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceGroupProperties { + const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_GROUP_PROPERTIES; +} +impl PhysicalDeviceGroupProperties { + pub fn builder<'a>() -> PhysicalDeviceGroupPropertiesBuilder<'a> { + PhysicalDeviceGroupPropertiesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceGroupPropertiesBuilder<'a> { + inner: PhysicalDeviceGroupProperties, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PhysicalDeviceGroupPropertiesBuilder<'a> { + type Target = PhysicalDeviceGroupProperties; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceGroupPropertiesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceGroupPropertiesBuilder<'a> { + #[inline] + pub fn physical_device_count(mut self, physical_device_count: u32) -> Self { + self.inner.physical_device_count = physical_device_count; + self + } + #[inline] + pub fn physical_devices( + mut self, + physical_devices: [PhysicalDevice; MAX_DEVICE_GROUP_SIZE], + ) -> Self { + self.inner.physical_devices = physical_devices; + self + } + #[inline] + pub fn subset_allocation(mut self, subset_allocation: bool) -> Self { + self.inner.subset_allocation = subset_allocation.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceGroupProperties { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct MemoryAllocateFlagsInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: MemoryAllocateFlags, + pub device_mask: u32, +} +impl ::std::default::Default for MemoryAllocateFlagsInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: MemoryAllocateFlags::default(), + device_mask: u32::default(), + } + } +} +unsafe impl TaggedStructure for MemoryAllocateFlagsInfo { + const STRUCTURE_TYPE: StructureType = StructureType::MEMORY_ALLOCATE_FLAGS_INFO; +} +impl MemoryAllocateFlagsInfo { + pub fn builder<'a>() -> MemoryAllocateFlagsInfoBuilder<'a> { + MemoryAllocateFlagsInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct MemoryAllocateFlagsInfoBuilder<'a> { + inner: MemoryAllocateFlagsInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsMemoryAllocateInfo for MemoryAllocateFlagsInfoBuilder<'_> {} +unsafe impl ExtendsMemoryAllocateInfo for MemoryAllocateFlagsInfo {} +impl<'a> ::std::ops::Deref for MemoryAllocateFlagsInfoBuilder<'a> { + type Target = MemoryAllocateFlagsInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for MemoryAllocateFlagsInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> MemoryAllocateFlagsInfoBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: MemoryAllocateFlags) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn device_mask(mut self, device_mask: u32) -> Self { + self.inner.device_mask = device_mask; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> MemoryAllocateFlagsInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct BindBufferMemoryInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub buffer: Buffer, + pub memory: DeviceMemory, + pub memory_offset: DeviceSize, +} +impl ::std::default::Default for BindBufferMemoryInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + buffer: Buffer::default(), + memory: DeviceMemory::default(), + memory_offset: DeviceSize::default(), + } + } +} +unsafe impl TaggedStructure for BindBufferMemoryInfo { + const STRUCTURE_TYPE: StructureType = StructureType::BIND_BUFFER_MEMORY_INFO; +} +impl BindBufferMemoryInfo { + pub fn builder<'a>() -> BindBufferMemoryInfoBuilder<'a> { + BindBufferMemoryInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct BindBufferMemoryInfoBuilder<'a> { + inner: BindBufferMemoryInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsBindBufferMemoryInfo {} +impl<'a> ::std::ops::Deref for BindBufferMemoryInfoBuilder<'a> { + type Target = BindBufferMemoryInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for BindBufferMemoryInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> BindBufferMemoryInfoBuilder<'a> { + #[inline] + pub fn buffer(mut self, buffer: Buffer) -> Self { + self.inner.buffer = buffer; + self + } + #[inline] + pub fn memory(mut self, memory: DeviceMemory) -> Self { + self.inner.memory = memory; + self + } + #[inline] + pub fn memory_offset(mut self, memory_offset: DeviceSize) -> Self { + self.inner.memory_offset = memory_offset; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> BindBufferMemoryInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct BindBufferMemoryDeviceGroupInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub device_index_count: u32, + pub p_device_indices: *const u32, +} +impl ::std::default::Default for BindBufferMemoryDeviceGroupInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + device_index_count: u32::default(), + p_device_indices: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for BindBufferMemoryDeviceGroupInfo { + const STRUCTURE_TYPE: StructureType = StructureType::BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO; +} +impl BindBufferMemoryDeviceGroupInfo { + pub fn builder<'a>() -> BindBufferMemoryDeviceGroupInfoBuilder<'a> { + BindBufferMemoryDeviceGroupInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct BindBufferMemoryDeviceGroupInfoBuilder<'a> { + inner: BindBufferMemoryDeviceGroupInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsBindBufferMemoryInfo for BindBufferMemoryDeviceGroupInfoBuilder<'_> {} +unsafe impl ExtendsBindBufferMemoryInfo for BindBufferMemoryDeviceGroupInfo {} +impl<'a> ::std::ops::Deref for BindBufferMemoryDeviceGroupInfoBuilder<'a> { + type Target = BindBufferMemoryDeviceGroupInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for BindBufferMemoryDeviceGroupInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> BindBufferMemoryDeviceGroupInfoBuilder<'a> { + #[inline] + pub fn device_indices(mut self, device_indices: &'a [u32]) -> Self { + self.inner.device_index_count = device_indices.len() as _; + self.inner.p_device_indices = device_indices.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> BindBufferMemoryDeviceGroupInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct BindImageMemoryInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub image: Image, + pub memory: DeviceMemory, + pub memory_offset: DeviceSize, +} +impl ::std::default::Default for BindImageMemoryInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + image: Image::default(), + memory: DeviceMemory::default(), + memory_offset: DeviceSize::default(), + } + } +} +unsafe impl TaggedStructure for BindImageMemoryInfo { + const STRUCTURE_TYPE: StructureType = StructureType::BIND_IMAGE_MEMORY_INFO; +} +impl BindImageMemoryInfo { + pub fn builder<'a>() -> BindImageMemoryInfoBuilder<'a> { + BindImageMemoryInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct BindImageMemoryInfoBuilder<'a> { + inner: BindImageMemoryInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsBindImageMemoryInfo {} +impl<'a> ::std::ops::Deref for BindImageMemoryInfoBuilder<'a> { + type Target = BindImageMemoryInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for BindImageMemoryInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> BindImageMemoryInfoBuilder<'a> { + #[inline] + pub fn image(mut self, image: Image) -> Self { + self.inner.image = image; + self + } + #[inline] + pub fn memory(mut self, memory: DeviceMemory) -> Self { + self.inner.memory = memory; + self + } + #[inline] + pub fn memory_offset(mut self, memory_offset: DeviceSize) -> Self { + self.inner.memory_offset = memory_offset; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> BindImageMemoryInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct BindImageMemoryDeviceGroupInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub device_index_count: u32, + pub p_device_indices: *const u32, + pub split_instance_bind_region_count: u32, + pub p_split_instance_bind_regions: *const Rect2D, +} +impl ::std::default::Default for BindImageMemoryDeviceGroupInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + device_index_count: u32::default(), + p_device_indices: ::std::ptr::null(), + split_instance_bind_region_count: u32::default(), + p_split_instance_bind_regions: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for BindImageMemoryDeviceGroupInfo { + const STRUCTURE_TYPE: StructureType = StructureType::BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO; +} +impl BindImageMemoryDeviceGroupInfo { + pub fn builder<'a>() -> BindImageMemoryDeviceGroupInfoBuilder<'a> { + BindImageMemoryDeviceGroupInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct BindImageMemoryDeviceGroupInfoBuilder<'a> { + inner: BindImageMemoryDeviceGroupInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsBindImageMemoryInfo for BindImageMemoryDeviceGroupInfoBuilder<'_> {} +unsafe impl ExtendsBindImageMemoryInfo for BindImageMemoryDeviceGroupInfo {} +impl<'a> ::std::ops::Deref for BindImageMemoryDeviceGroupInfoBuilder<'a> { + type Target = BindImageMemoryDeviceGroupInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for BindImageMemoryDeviceGroupInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> BindImageMemoryDeviceGroupInfoBuilder<'a> { + #[inline] + pub fn device_indices(mut self, device_indices: &'a [u32]) -> Self { + self.inner.device_index_count = device_indices.len() as _; + self.inner.p_device_indices = device_indices.as_ptr(); + self + } + #[inline] + pub fn split_instance_bind_regions( + mut self, + split_instance_bind_regions: &'a [Rect2D], + ) -> Self { + self.inner.split_instance_bind_region_count = split_instance_bind_regions.len() as _; + self.inner.p_split_instance_bind_regions = split_instance_bind_regions.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> BindImageMemoryDeviceGroupInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DeviceGroupRenderPassBeginInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub device_mask: u32, + pub device_render_area_count: u32, + pub p_device_render_areas: *const Rect2D, +} +impl ::std::default::Default for DeviceGroupRenderPassBeginInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + device_mask: u32::default(), + device_render_area_count: u32::default(), + p_device_render_areas: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for DeviceGroupRenderPassBeginInfo { + const STRUCTURE_TYPE: StructureType = StructureType::DEVICE_GROUP_RENDER_PASS_BEGIN_INFO; +} +impl DeviceGroupRenderPassBeginInfo { + pub fn builder<'a>() -> DeviceGroupRenderPassBeginInfoBuilder<'a> { + DeviceGroupRenderPassBeginInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DeviceGroupRenderPassBeginInfoBuilder<'a> { + inner: DeviceGroupRenderPassBeginInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsRenderPassBeginInfo for DeviceGroupRenderPassBeginInfoBuilder<'_> {} +unsafe impl ExtendsRenderPassBeginInfo for DeviceGroupRenderPassBeginInfo {} +unsafe impl ExtendsRenderingInfo for DeviceGroupRenderPassBeginInfoBuilder<'_> {} +unsafe impl ExtendsRenderingInfo for DeviceGroupRenderPassBeginInfo {} +impl<'a> ::std::ops::Deref for DeviceGroupRenderPassBeginInfoBuilder<'a> { + type Target = DeviceGroupRenderPassBeginInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DeviceGroupRenderPassBeginInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DeviceGroupRenderPassBeginInfoBuilder<'a> { + #[inline] + pub fn device_mask(mut self, device_mask: u32) -> Self { + self.inner.device_mask = device_mask; + self + } + #[inline] + pub fn device_render_areas(mut self, device_render_areas: &'a [Rect2D]) -> Self { + self.inner.device_render_area_count = device_render_areas.len() as _; + self.inner.p_device_render_areas = device_render_areas.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DeviceGroupRenderPassBeginInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DeviceGroupCommandBufferBeginInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub device_mask: u32, +} +impl ::std::default::Default for DeviceGroupCommandBufferBeginInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + device_mask: u32::default(), + } + } +} +unsafe impl TaggedStructure for DeviceGroupCommandBufferBeginInfo { + const STRUCTURE_TYPE: StructureType = StructureType::DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO; +} +impl DeviceGroupCommandBufferBeginInfo { + pub fn builder<'a>() -> DeviceGroupCommandBufferBeginInfoBuilder<'a> { + DeviceGroupCommandBufferBeginInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DeviceGroupCommandBufferBeginInfoBuilder<'a> { + inner: DeviceGroupCommandBufferBeginInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsCommandBufferBeginInfo for DeviceGroupCommandBufferBeginInfoBuilder<'_> {} +unsafe impl ExtendsCommandBufferBeginInfo for DeviceGroupCommandBufferBeginInfo {} +impl<'a> ::std::ops::Deref for DeviceGroupCommandBufferBeginInfoBuilder<'a> { + type Target = DeviceGroupCommandBufferBeginInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DeviceGroupCommandBufferBeginInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DeviceGroupCommandBufferBeginInfoBuilder<'a> { + #[inline] + pub fn device_mask(mut self, device_mask: u32) -> Self { + self.inner.device_mask = device_mask; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DeviceGroupCommandBufferBeginInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DeviceGroupSubmitInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub wait_semaphore_count: u32, + pub p_wait_semaphore_device_indices: *const u32, + pub command_buffer_count: u32, + pub p_command_buffer_device_masks: *const u32, + pub signal_semaphore_count: u32, + pub p_signal_semaphore_device_indices: *const u32, +} +impl ::std::default::Default for DeviceGroupSubmitInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + wait_semaphore_count: u32::default(), + p_wait_semaphore_device_indices: ::std::ptr::null(), + command_buffer_count: u32::default(), + p_command_buffer_device_masks: ::std::ptr::null(), + signal_semaphore_count: u32::default(), + p_signal_semaphore_device_indices: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for DeviceGroupSubmitInfo { + const STRUCTURE_TYPE: StructureType = StructureType::DEVICE_GROUP_SUBMIT_INFO; +} +impl DeviceGroupSubmitInfo { + pub fn builder<'a>() -> DeviceGroupSubmitInfoBuilder<'a> { + DeviceGroupSubmitInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DeviceGroupSubmitInfoBuilder<'a> { + inner: DeviceGroupSubmitInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsSubmitInfo for DeviceGroupSubmitInfoBuilder<'_> {} +unsafe impl ExtendsSubmitInfo for DeviceGroupSubmitInfo {} +impl<'a> ::std::ops::Deref for DeviceGroupSubmitInfoBuilder<'a> { + type Target = DeviceGroupSubmitInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DeviceGroupSubmitInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DeviceGroupSubmitInfoBuilder<'a> { + #[inline] + pub fn wait_semaphore_device_indices( + mut self, + wait_semaphore_device_indices: &'a [u32], + ) -> Self { + self.inner.wait_semaphore_count = wait_semaphore_device_indices.len() as _; + self.inner.p_wait_semaphore_device_indices = wait_semaphore_device_indices.as_ptr(); + self + } + #[inline] + pub fn command_buffer_device_masks(mut self, command_buffer_device_masks: &'a [u32]) -> Self { + self.inner.command_buffer_count = command_buffer_device_masks.len() as _; + self.inner.p_command_buffer_device_masks = command_buffer_device_masks.as_ptr(); + self + } + #[inline] + pub fn signal_semaphore_device_indices( + mut self, + signal_semaphore_device_indices: &'a [u32], + ) -> Self { + self.inner.signal_semaphore_count = signal_semaphore_device_indices.len() as _; + self.inner.p_signal_semaphore_device_indices = signal_semaphore_device_indices.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DeviceGroupSubmitInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DeviceGroupBindSparseInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub resource_device_index: u32, + pub memory_device_index: u32, +} +impl ::std::default::Default for DeviceGroupBindSparseInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + resource_device_index: u32::default(), + memory_device_index: u32::default(), + } + } +} +unsafe impl TaggedStructure for DeviceGroupBindSparseInfo { + const STRUCTURE_TYPE: StructureType = StructureType::DEVICE_GROUP_BIND_SPARSE_INFO; +} +impl DeviceGroupBindSparseInfo { + pub fn builder<'a>() -> DeviceGroupBindSparseInfoBuilder<'a> { + DeviceGroupBindSparseInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DeviceGroupBindSparseInfoBuilder<'a> { + inner: DeviceGroupBindSparseInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsBindSparseInfo for DeviceGroupBindSparseInfoBuilder<'_> {} +unsafe impl ExtendsBindSparseInfo for DeviceGroupBindSparseInfo {} +impl<'a> ::std::ops::Deref for DeviceGroupBindSparseInfoBuilder<'a> { + type Target = DeviceGroupBindSparseInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DeviceGroupBindSparseInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DeviceGroupBindSparseInfoBuilder<'a> { + #[inline] + pub fn resource_device_index(mut self, resource_device_index: u32) -> Self { + self.inner.resource_device_index = resource_device_index; + self + } + #[inline] + pub fn memory_device_index(mut self, memory_device_index: u32) -> Self { + self.inner.memory_device_index = memory_device_index; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DeviceGroupBindSparseInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DeviceGroupPresentCapabilitiesKHR { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub present_mask: [u32; MAX_DEVICE_GROUP_SIZE], + pub modes: DeviceGroupPresentModeFlagsKHR, +} +impl ::std::default::Default for DeviceGroupPresentCapabilitiesKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + present_mask: unsafe { ::std::mem::zeroed() }, + modes: DeviceGroupPresentModeFlagsKHR::default(), + } + } +} +unsafe impl TaggedStructure for DeviceGroupPresentCapabilitiesKHR { + const STRUCTURE_TYPE: StructureType = StructureType::DEVICE_GROUP_PRESENT_CAPABILITIES_KHR; +} +impl DeviceGroupPresentCapabilitiesKHR { + pub fn builder<'a>() -> DeviceGroupPresentCapabilitiesKHRBuilder<'a> { + DeviceGroupPresentCapabilitiesKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DeviceGroupPresentCapabilitiesKHRBuilder<'a> { + inner: DeviceGroupPresentCapabilitiesKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DeviceGroupPresentCapabilitiesKHRBuilder<'a> { + type Target = DeviceGroupPresentCapabilitiesKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DeviceGroupPresentCapabilitiesKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DeviceGroupPresentCapabilitiesKHRBuilder<'a> { + #[inline] + pub fn present_mask(mut self, present_mask: [u32; MAX_DEVICE_GROUP_SIZE]) -> Self { + self.inner.present_mask = present_mask; + self + } + #[inline] + pub fn modes(mut self, modes: DeviceGroupPresentModeFlagsKHR) -> Self { + self.inner.modes = modes; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DeviceGroupPresentCapabilitiesKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ImageSwapchainCreateInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub swapchain: SwapchainKHR, +} +impl ::std::default::Default for ImageSwapchainCreateInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + swapchain: SwapchainKHR::default(), + } + } +} +unsafe impl TaggedStructure for ImageSwapchainCreateInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_SWAPCHAIN_CREATE_INFO_KHR; +} +impl ImageSwapchainCreateInfoKHR { + pub fn builder<'a>() -> ImageSwapchainCreateInfoKHRBuilder<'a> { + ImageSwapchainCreateInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ImageSwapchainCreateInfoKHRBuilder<'a> { + inner: ImageSwapchainCreateInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsImageCreateInfo for ImageSwapchainCreateInfoKHRBuilder<'_> {} +unsafe impl ExtendsImageCreateInfo for ImageSwapchainCreateInfoKHR {} +impl<'a> ::std::ops::Deref for ImageSwapchainCreateInfoKHRBuilder<'a> { + type Target = ImageSwapchainCreateInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ImageSwapchainCreateInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ImageSwapchainCreateInfoKHRBuilder<'a> { + #[inline] + pub fn swapchain(mut self, swapchain: SwapchainKHR) -> Self { + self.inner.swapchain = swapchain; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ImageSwapchainCreateInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct BindImageMemorySwapchainInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub swapchain: SwapchainKHR, + pub image_index: u32, +} +impl ::std::default::Default for BindImageMemorySwapchainInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + swapchain: SwapchainKHR::default(), + image_index: u32::default(), + } + } +} +unsafe impl TaggedStructure for BindImageMemorySwapchainInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR; +} +impl BindImageMemorySwapchainInfoKHR { + pub fn builder<'a>() -> BindImageMemorySwapchainInfoKHRBuilder<'a> { + BindImageMemorySwapchainInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct BindImageMemorySwapchainInfoKHRBuilder<'a> { + inner: BindImageMemorySwapchainInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsBindImageMemoryInfo for BindImageMemorySwapchainInfoKHRBuilder<'_> {} +unsafe impl ExtendsBindImageMemoryInfo for BindImageMemorySwapchainInfoKHR {} +impl<'a> ::std::ops::Deref for BindImageMemorySwapchainInfoKHRBuilder<'a> { + type Target = BindImageMemorySwapchainInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for BindImageMemorySwapchainInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> BindImageMemorySwapchainInfoKHRBuilder<'a> { + #[inline] + pub fn swapchain(mut self, swapchain: SwapchainKHR) -> Self { + self.inner.swapchain = swapchain; + self + } + #[inline] + pub fn image_index(mut self, image_index: u32) -> Self { + self.inner.image_index = image_index; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> BindImageMemorySwapchainInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct AcquireNextImageInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub swapchain: SwapchainKHR, + pub timeout: u64, + pub semaphore: Semaphore, + pub fence: Fence, + pub device_mask: u32, +} +impl ::std::default::Default for AcquireNextImageInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + swapchain: SwapchainKHR::default(), + timeout: u64::default(), + semaphore: Semaphore::default(), + fence: Fence::default(), + device_mask: u32::default(), + } + } +} +unsafe impl TaggedStructure for AcquireNextImageInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::ACQUIRE_NEXT_IMAGE_INFO_KHR; +} +impl AcquireNextImageInfoKHR { + pub fn builder<'a>() -> AcquireNextImageInfoKHRBuilder<'a> { + AcquireNextImageInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct AcquireNextImageInfoKHRBuilder<'a> { + inner: AcquireNextImageInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for AcquireNextImageInfoKHRBuilder<'a> { + type Target = AcquireNextImageInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for AcquireNextImageInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> AcquireNextImageInfoKHRBuilder<'a> { + #[inline] + pub fn swapchain(mut self, swapchain: SwapchainKHR) -> Self { + self.inner.swapchain = swapchain; + self + } + #[inline] + pub fn timeout(mut self, timeout: u64) -> Self { + self.inner.timeout = timeout; + self + } + #[inline] + pub fn semaphore(mut self, semaphore: Semaphore) -> Self { + self.inner.semaphore = semaphore; + self + } + #[inline] + pub fn fence(mut self, fence: Fence) -> Self { + self.inner.fence = fence; + self + } + #[inline] + pub fn device_mask(mut self, device_mask: u32) -> Self { + self.inner.device_mask = device_mask; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> AcquireNextImageInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DeviceGroupPresentInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub swapchain_count: u32, + pub p_device_masks: *const u32, + pub mode: DeviceGroupPresentModeFlagsKHR, +} +impl ::std::default::Default for DeviceGroupPresentInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + swapchain_count: u32::default(), + p_device_masks: ::std::ptr::null(), + mode: DeviceGroupPresentModeFlagsKHR::default(), + } + } +} +unsafe impl TaggedStructure for DeviceGroupPresentInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::DEVICE_GROUP_PRESENT_INFO_KHR; +} +impl DeviceGroupPresentInfoKHR { + pub fn builder<'a>() -> DeviceGroupPresentInfoKHRBuilder<'a> { + DeviceGroupPresentInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DeviceGroupPresentInfoKHRBuilder<'a> { + inner: DeviceGroupPresentInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPresentInfoKHR for DeviceGroupPresentInfoKHRBuilder<'_> {} +unsafe impl ExtendsPresentInfoKHR for DeviceGroupPresentInfoKHR {} +impl<'a> ::std::ops::Deref for DeviceGroupPresentInfoKHRBuilder<'a> { + type Target = DeviceGroupPresentInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DeviceGroupPresentInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DeviceGroupPresentInfoKHRBuilder<'a> { + #[inline] + pub fn device_masks(mut self, device_masks: &'a [u32]) -> Self { + self.inner.swapchain_count = device_masks.len() as _; + self.inner.p_device_masks = device_masks.as_ptr(); + self + } + #[inline] + pub fn mode(mut self, mode: DeviceGroupPresentModeFlagsKHR) -> Self { + self.inner.mode = mode; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DeviceGroupPresentInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DeviceGroupDeviceCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub physical_device_count: u32, + pub p_physical_devices: *const PhysicalDevice, +} +impl ::std::default::Default for DeviceGroupDeviceCreateInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + physical_device_count: u32::default(), + p_physical_devices: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for DeviceGroupDeviceCreateInfo { + const STRUCTURE_TYPE: StructureType = StructureType::DEVICE_GROUP_DEVICE_CREATE_INFO; +} +impl DeviceGroupDeviceCreateInfo { + pub fn builder<'a>() -> DeviceGroupDeviceCreateInfoBuilder<'a> { + DeviceGroupDeviceCreateInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DeviceGroupDeviceCreateInfoBuilder<'a> { + inner: DeviceGroupDeviceCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsDeviceCreateInfo for DeviceGroupDeviceCreateInfoBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for DeviceGroupDeviceCreateInfo {} +impl<'a> ::std::ops::Deref for DeviceGroupDeviceCreateInfoBuilder<'a> { + type Target = DeviceGroupDeviceCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DeviceGroupDeviceCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DeviceGroupDeviceCreateInfoBuilder<'a> { + #[inline] + pub fn physical_devices(mut self, physical_devices: &'a [PhysicalDevice]) -> Self { + self.inner.physical_device_count = physical_devices.len() as _; + self.inner.p_physical_devices = physical_devices.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DeviceGroupDeviceCreateInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DeviceGroupSwapchainCreateInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub modes: DeviceGroupPresentModeFlagsKHR, +} +impl ::std::default::Default for DeviceGroupSwapchainCreateInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + modes: DeviceGroupPresentModeFlagsKHR::default(), + } + } +} +unsafe impl TaggedStructure for DeviceGroupSwapchainCreateInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR; +} +impl DeviceGroupSwapchainCreateInfoKHR { + pub fn builder<'a>() -> DeviceGroupSwapchainCreateInfoKHRBuilder<'a> { + DeviceGroupSwapchainCreateInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DeviceGroupSwapchainCreateInfoKHRBuilder<'a> { + inner: DeviceGroupSwapchainCreateInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsSwapchainCreateInfoKHR for DeviceGroupSwapchainCreateInfoKHRBuilder<'_> {} +unsafe impl ExtendsSwapchainCreateInfoKHR for DeviceGroupSwapchainCreateInfoKHR {} +impl<'a> ::std::ops::Deref for DeviceGroupSwapchainCreateInfoKHRBuilder<'a> { + type Target = DeviceGroupSwapchainCreateInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DeviceGroupSwapchainCreateInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DeviceGroupSwapchainCreateInfoKHRBuilder<'a> { + #[inline] + pub fn modes(mut self, modes: DeviceGroupPresentModeFlagsKHR) -> Self { + self.inner.modes = modes; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DeviceGroupSwapchainCreateInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct DescriptorUpdateTemplateEntry { + pub dst_binding: u32, + pub dst_array_element: u32, + pub descriptor_count: u32, + pub descriptor_type: DescriptorType, + pub offset: usize, + pub stride: usize, +} +impl DescriptorUpdateTemplateEntry { + pub fn builder<'a>() -> DescriptorUpdateTemplateEntryBuilder<'a> { + DescriptorUpdateTemplateEntryBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DescriptorUpdateTemplateEntryBuilder<'a> { + inner: DescriptorUpdateTemplateEntry, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DescriptorUpdateTemplateEntryBuilder<'a> { + type Target = DescriptorUpdateTemplateEntry; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DescriptorUpdateTemplateEntryBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DescriptorUpdateTemplateEntryBuilder<'a> { + #[inline] + pub fn dst_binding(mut self, dst_binding: u32) -> Self { + self.inner.dst_binding = dst_binding; + self + } + #[inline] + pub fn dst_array_element(mut self, dst_array_element: u32) -> Self { + self.inner.dst_array_element = dst_array_element; + self + } + #[inline] + pub fn descriptor_count(mut self, descriptor_count: u32) -> Self { + self.inner.descriptor_count = descriptor_count; + self + } + #[inline] + pub fn descriptor_type(mut self, descriptor_type: DescriptorType) -> Self { + self.inner.descriptor_type = descriptor_type; + self + } + #[inline] + pub fn offset(mut self, offset: usize) -> Self { + self.inner.offset = offset; + self + } + #[inline] + pub fn stride(mut self, stride: usize) -> Self { + self.inner.stride = stride; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DescriptorUpdateTemplateEntry { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DescriptorUpdateTemplateCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: DescriptorUpdateTemplateCreateFlags, + pub descriptor_update_entry_count: u32, + pub p_descriptor_update_entries: *const DescriptorUpdateTemplateEntry, + pub template_type: DescriptorUpdateTemplateType, + pub descriptor_set_layout: DescriptorSetLayout, + pub pipeline_bind_point: PipelineBindPoint, + pub pipeline_layout: PipelineLayout, + pub set: u32, +} +impl ::std::default::Default for DescriptorUpdateTemplateCreateInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: DescriptorUpdateTemplateCreateFlags::default(), + descriptor_update_entry_count: u32::default(), + p_descriptor_update_entries: ::std::ptr::null(), + template_type: DescriptorUpdateTemplateType::default(), + descriptor_set_layout: DescriptorSetLayout::default(), + pipeline_bind_point: PipelineBindPoint::default(), + pipeline_layout: PipelineLayout::default(), + set: u32::default(), + } + } +} +unsafe impl TaggedStructure for DescriptorUpdateTemplateCreateInfo { + const STRUCTURE_TYPE: StructureType = StructureType::DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO; +} +impl DescriptorUpdateTemplateCreateInfo { + pub fn builder<'a>() -> DescriptorUpdateTemplateCreateInfoBuilder<'a> { + DescriptorUpdateTemplateCreateInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DescriptorUpdateTemplateCreateInfoBuilder<'a> { + inner: DescriptorUpdateTemplateCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DescriptorUpdateTemplateCreateInfoBuilder<'a> { + type Target = DescriptorUpdateTemplateCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DescriptorUpdateTemplateCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DescriptorUpdateTemplateCreateInfoBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: DescriptorUpdateTemplateCreateFlags) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn descriptor_update_entries( + mut self, + descriptor_update_entries: &'a [DescriptorUpdateTemplateEntry], + ) -> Self { + self.inner.descriptor_update_entry_count = descriptor_update_entries.len() as _; + self.inner.p_descriptor_update_entries = descriptor_update_entries.as_ptr(); + self + } + #[inline] + pub fn template_type(mut self, template_type: DescriptorUpdateTemplateType) -> Self { + self.inner.template_type = template_type; + self + } + #[inline] + pub fn descriptor_set_layout(mut self, descriptor_set_layout: DescriptorSetLayout) -> Self { + self.inner.descriptor_set_layout = descriptor_set_layout; + self + } + #[inline] + pub fn pipeline_bind_point(mut self, pipeline_bind_point: PipelineBindPoint) -> Self { + self.inner.pipeline_bind_point = pipeline_bind_point; + self + } + #[inline] + pub fn pipeline_layout(mut self, pipeline_layout: PipelineLayout) -> Self { + self.inner.pipeline_layout = pipeline_layout; + self + } + #[inline] + pub fn set(mut self, set: u32) -> Self { + self.inner.set = set; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DescriptorUpdateTemplateCreateInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct XYColorEXT { + pub x: f32, + pub y: f32, +} +impl XYColorEXT { + pub fn builder<'a>() -> XYColorEXTBuilder<'a> { + XYColorEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct XYColorEXTBuilder<'a> { + inner: XYColorEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for XYColorEXTBuilder<'a> { + type Target = XYColorEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for XYColorEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> XYColorEXTBuilder<'a> { + #[inline] + pub fn x(mut self, x: f32) -> Self { + self.inner.x = x; + self + } + #[inline] + pub fn y(mut self, y: f32) -> Self { + self.inner.y = y; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> XYColorEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDevicePresentIdFeaturesKHR { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub present_id: Bool32, +} +impl ::std::default::Default for PhysicalDevicePresentIdFeaturesKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + present_id: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDevicePresentIdFeaturesKHR { + const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR; +} +impl PhysicalDevicePresentIdFeaturesKHR { + pub fn builder<'a>() -> PhysicalDevicePresentIdFeaturesKHRBuilder<'a> { + PhysicalDevicePresentIdFeaturesKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDevicePresentIdFeaturesKHRBuilder<'a> { + inner: PhysicalDevicePresentIdFeaturesKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePresentIdFeaturesKHRBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePresentIdFeaturesKHR {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePresentIdFeaturesKHRBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePresentIdFeaturesKHR {} +impl<'a> ::std::ops::Deref for PhysicalDevicePresentIdFeaturesKHRBuilder<'a> { + type Target = PhysicalDevicePresentIdFeaturesKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDevicePresentIdFeaturesKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDevicePresentIdFeaturesKHRBuilder<'a> { + #[inline] + pub fn present_id(mut self, present_id: bool) -> Self { + self.inner.present_id = present_id.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDevicePresentIdFeaturesKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PresentIdKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub swapchain_count: u32, + pub p_present_ids: *const u64, +} +impl ::std::default::Default for PresentIdKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + swapchain_count: u32::default(), + p_present_ids: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for PresentIdKHR { + const STRUCTURE_TYPE: StructureType = StructureType::PRESENT_ID_KHR; +} +impl PresentIdKHR { + pub fn builder<'a>() -> PresentIdKHRBuilder<'a> { + PresentIdKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PresentIdKHRBuilder<'a> { + inner: PresentIdKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPresentInfoKHR for PresentIdKHRBuilder<'_> {} +unsafe impl ExtendsPresentInfoKHR for PresentIdKHR {} +impl<'a> ::std::ops::Deref for PresentIdKHRBuilder<'a> { + type Target = PresentIdKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PresentIdKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PresentIdKHRBuilder<'a> { + #[inline] + pub fn present_ids(mut self, present_ids: &'a [u64]) -> Self { + self.inner.swapchain_count = present_ids.len() as _; + self.inner.p_present_ids = present_ids.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PresentIdKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDevicePresentWaitFeaturesKHR { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub present_wait: Bool32, +} +impl ::std::default::Default for PhysicalDevicePresentWaitFeaturesKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + present_wait: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDevicePresentWaitFeaturesKHR { + const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR; +} +impl PhysicalDevicePresentWaitFeaturesKHR { + pub fn builder<'a>() -> PhysicalDevicePresentWaitFeaturesKHRBuilder<'a> { + PhysicalDevicePresentWaitFeaturesKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDevicePresentWaitFeaturesKHRBuilder<'a> { + inner: PhysicalDevicePresentWaitFeaturesKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePresentWaitFeaturesKHRBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePresentWaitFeaturesKHR {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePresentWaitFeaturesKHRBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePresentWaitFeaturesKHR {} +impl<'a> ::std::ops::Deref for PhysicalDevicePresentWaitFeaturesKHRBuilder<'a> { + type Target = PhysicalDevicePresentWaitFeaturesKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDevicePresentWaitFeaturesKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDevicePresentWaitFeaturesKHRBuilder<'a> { + #[inline] + pub fn present_wait(mut self, present_wait: bool) -> Self { + self.inner.present_wait = present_wait.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDevicePresentWaitFeaturesKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct HdrMetadataEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub display_primary_red: XYColorEXT, + pub display_primary_green: XYColorEXT, + pub display_primary_blue: XYColorEXT, + pub white_point: XYColorEXT, + pub max_luminance: f32, + pub min_luminance: f32, + pub max_content_light_level: f32, + pub max_frame_average_light_level: f32, +} +impl ::std::default::Default for HdrMetadataEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + display_primary_red: XYColorEXT::default(), + display_primary_green: XYColorEXT::default(), + display_primary_blue: XYColorEXT::default(), + white_point: XYColorEXT::default(), + max_luminance: f32::default(), + min_luminance: f32::default(), + max_content_light_level: f32::default(), + max_frame_average_light_level: f32::default(), + } + } +} +unsafe impl TaggedStructure for HdrMetadataEXT { + const STRUCTURE_TYPE: StructureType = StructureType::HDR_METADATA_EXT; +} +impl HdrMetadataEXT { + pub fn builder<'a>() -> HdrMetadataEXTBuilder<'a> { + HdrMetadataEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct HdrMetadataEXTBuilder<'a> { + inner: HdrMetadataEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for HdrMetadataEXTBuilder<'a> { + type Target = HdrMetadataEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for HdrMetadataEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> HdrMetadataEXTBuilder<'a> { + #[inline] + pub fn display_primary_red(mut self, display_primary_red: XYColorEXT) -> Self { + self.inner.display_primary_red = display_primary_red; + self + } + #[inline] + pub fn display_primary_green(mut self, display_primary_green: XYColorEXT) -> Self { + self.inner.display_primary_green = display_primary_green; + self + } + #[inline] + pub fn display_primary_blue(mut self, display_primary_blue: XYColorEXT) -> Self { + self.inner.display_primary_blue = display_primary_blue; + self + } + #[inline] + pub fn white_point(mut self, white_point: XYColorEXT) -> Self { + self.inner.white_point = white_point; + self + } + #[inline] + pub fn max_luminance(mut self, max_luminance: f32) -> Self { + self.inner.max_luminance = max_luminance; + self + } + #[inline] + pub fn min_luminance(mut self, min_luminance: f32) -> Self { + self.inner.min_luminance = min_luminance; + self + } + #[inline] + pub fn max_content_light_level(mut self, max_content_light_level: f32) -> Self { + self.inner.max_content_light_level = max_content_light_level; + self + } + #[inline] + pub fn max_frame_average_light_level(mut self, max_frame_average_light_level: f32) -> Self { + self.inner.max_frame_average_light_level = max_frame_average_light_level; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> HdrMetadataEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DisplayNativeHdrSurfaceCapabilitiesAMD { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub local_dimming_support: Bool32, +} +impl ::std::default::Default for DisplayNativeHdrSurfaceCapabilitiesAMD { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + local_dimming_support: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for DisplayNativeHdrSurfaceCapabilitiesAMD { + const STRUCTURE_TYPE: StructureType = + StructureType::DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD; +} +impl DisplayNativeHdrSurfaceCapabilitiesAMD { + pub fn builder<'a>() -> DisplayNativeHdrSurfaceCapabilitiesAMDBuilder<'a> { + DisplayNativeHdrSurfaceCapabilitiesAMDBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DisplayNativeHdrSurfaceCapabilitiesAMDBuilder<'a> { + inner: DisplayNativeHdrSurfaceCapabilitiesAMD, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsSurfaceCapabilities2KHR for DisplayNativeHdrSurfaceCapabilitiesAMDBuilder<'_> {} +unsafe impl ExtendsSurfaceCapabilities2KHR for DisplayNativeHdrSurfaceCapabilitiesAMD {} +impl<'a> ::std::ops::Deref for DisplayNativeHdrSurfaceCapabilitiesAMDBuilder<'a> { + type Target = DisplayNativeHdrSurfaceCapabilitiesAMD; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DisplayNativeHdrSurfaceCapabilitiesAMDBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DisplayNativeHdrSurfaceCapabilitiesAMDBuilder<'a> { + #[inline] + pub fn local_dimming_support(mut self, local_dimming_support: bool) -> Self { + self.inner.local_dimming_support = local_dimming_support.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DisplayNativeHdrSurfaceCapabilitiesAMD { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SwapchainDisplayNativeHdrCreateInfoAMD { + pub s_type: StructureType, + pub p_next: *const c_void, + pub local_dimming_enable: Bool32, +} +impl ::std::default::Default for SwapchainDisplayNativeHdrCreateInfoAMD { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + local_dimming_enable: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for SwapchainDisplayNativeHdrCreateInfoAMD { + const STRUCTURE_TYPE: StructureType = + StructureType::SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD; +} +impl SwapchainDisplayNativeHdrCreateInfoAMD { + pub fn builder<'a>() -> SwapchainDisplayNativeHdrCreateInfoAMDBuilder<'a> { + SwapchainDisplayNativeHdrCreateInfoAMDBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SwapchainDisplayNativeHdrCreateInfoAMDBuilder<'a> { + inner: SwapchainDisplayNativeHdrCreateInfoAMD, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsSwapchainCreateInfoKHR for SwapchainDisplayNativeHdrCreateInfoAMDBuilder<'_> {} +unsafe impl ExtendsSwapchainCreateInfoKHR for SwapchainDisplayNativeHdrCreateInfoAMD {} +impl<'a> ::std::ops::Deref for SwapchainDisplayNativeHdrCreateInfoAMDBuilder<'a> { + type Target = SwapchainDisplayNativeHdrCreateInfoAMD; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SwapchainDisplayNativeHdrCreateInfoAMDBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SwapchainDisplayNativeHdrCreateInfoAMDBuilder<'a> { + #[inline] + pub fn local_dimming_enable(mut self, local_dimming_enable: bool) -> Self { + self.inner.local_dimming_enable = local_dimming_enable.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SwapchainDisplayNativeHdrCreateInfoAMD { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct RefreshCycleDurationGOOGLE { + pub refresh_duration: u64, +} +impl RefreshCycleDurationGOOGLE { + pub fn builder<'a>() -> RefreshCycleDurationGOOGLEBuilder<'a> { + RefreshCycleDurationGOOGLEBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct RefreshCycleDurationGOOGLEBuilder<'a> { + inner: RefreshCycleDurationGOOGLE, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for RefreshCycleDurationGOOGLEBuilder<'a> { + type Target = RefreshCycleDurationGOOGLE; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for RefreshCycleDurationGOOGLEBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> RefreshCycleDurationGOOGLEBuilder<'a> { + #[inline] + pub fn refresh_duration(mut self, refresh_duration: u64) -> Self { + self.inner.refresh_duration = refresh_duration; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> RefreshCycleDurationGOOGLE { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct PastPresentationTimingGOOGLE { + pub present_id: u32, + pub desired_present_time: u64, + pub actual_present_time: u64, + pub earliest_present_time: u64, + pub present_margin: u64, +} +impl PastPresentationTimingGOOGLE { + pub fn builder<'a>() -> PastPresentationTimingGOOGLEBuilder<'a> { + PastPresentationTimingGOOGLEBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PastPresentationTimingGOOGLEBuilder<'a> { + inner: PastPresentationTimingGOOGLE, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PastPresentationTimingGOOGLEBuilder<'a> { + type Target = PastPresentationTimingGOOGLE; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PastPresentationTimingGOOGLEBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PastPresentationTimingGOOGLEBuilder<'a> { + #[inline] + pub fn present_id(mut self, present_id: u32) -> Self { + self.inner.present_id = present_id; + self + } + #[inline] + pub fn desired_present_time(mut self, desired_present_time: u64) -> Self { + self.inner.desired_present_time = desired_present_time; + self + } + #[inline] + pub fn actual_present_time(mut self, actual_present_time: u64) -> Self { + self.inner.actual_present_time = actual_present_time; + self + } + #[inline] + pub fn earliest_present_time(mut self, earliest_present_time: u64) -> Self { + self.inner.earliest_present_time = earliest_present_time; + self + } + #[inline] + pub fn present_margin(mut self, present_margin: u64) -> Self { + self.inner.present_margin = present_margin; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PastPresentationTimingGOOGLE { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PresentTimesInfoGOOGLE { + pub s_type: StructureType, + pub p_next: *const c_void, + pub swapchain_count: u32, + pub p_times: *const PresentTimeGOOGLE, +} +impl ::std::default::Default for PresentTimesInfoGOOGLE { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + swapchain_count: u32::default(), + p_times: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for PresentTimesInfoGOOGLE { + const STRUCTURE_TYPE: StructureType = StructureType::PRESENT_TIMES_INFO_GOOGLE; +} +impl PresentTimesInfoGOOGLE { + pub fn builder<'a>() -> PresentTimesInfoGOOGLEBuilder<'a> { + PresentTimesInfoGOOGLEBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PresentTimesInfoGOOGLEBuilder<'a> { + inner: PresentTimesInfoGOOGLE, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPresentInfoKHR for PresentTimesInfoGOOGLEBuilder<'_> {} +unsafe impl ExtendsPresentInfoKHR for PresentTimesInfoGOOGLE {} +impl<'a> ::std::ops::Deref for PresentTimesInfoGOOGLEBuilder<'a> { + type Target = PresentTimesInfoGOOGLE; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PresentTimesInfoGOOGLEBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PresentTimesInfoGOOGLEBuilder<'a> { + #[inline] + pub fn times(mut self, times: &'a [PresentTimeGOOGLE]) -> Self { + self.inner.swapchain_count = times.len() as _; + self.inner.p_times = times.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PresentTimesInfoGOOGLE { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct PresentTimeGOOGLE { + pub present_id: u32, + pub desired_present_time: u64, +} +impl PresentTimeGOOGLE { + pub fn builder<'a>() -> PresentTimeGOOGLEBuilder<'a> { + PresentTimeGOOGLEBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PresentTimeGOOGLEBuilder<'a> { + inner: PresentTimeGOOGLE, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PresentTimeGOOGLEBuilder<'a> { + type Target = PresentTimeGOOGLE; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PresentTimeGOOGLEBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PresentTimeGOOGLEBuilder<'a> { + #[inline] + pub fn present_id(mut self, present_id: u32) -> Self { + self.inner.present_id = present_id; + self + } + #[inline] + pub fn desired_present_time(mut self, desired_present_time: u64) -> Self { + self.inner.desired_present_time = desired_present_time; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PresentTimeGOOGLE { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct IOSSurfaceCreateInfoMVK { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: IOSSurfaceCreateFlagsMVK, + pub p_view: *const c_void, +} +impl ::std::default::Default for IOSSurfaceCreateInfoMVK { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: IOSSurfaceCreateFlagsMVK::default(), + p_view: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for IOSSurfaceCreateInfoMVK { + const STRUCTURE_TYPE: StructureType = StructureType::IOS_SURFACE_CREATE_INFO_MVK; +} +impl IOSSurfaceCreateInfoMVK { + pub fn builder<'a>() -> IOSSurfaceCreateInfoMVKBuilder<'a> { + IOSSurfaceCreateInfoMVKBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct IOSSurfaceCreateInfoMVKBuilder<'a> { + inner: IOSSurfaceCreateInfoMVK, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for IOSSurfaceCreateInfoMVKBuilder<'a> { + type Target = IOSSurfaceCreateInfoMVK; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for IOSSurfaceCreateInfoMVKBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> IOSSurfaceCreateInfoMVKBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: IOSSurfaceCreateFlagsMVK) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn view(mut self, view: *const c_void) -> Self { + self.inner.p_view = view; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> IOSSurfaceCreateInfoMVK { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct MacOSSurfaceCreateInfoMVK { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: MacOSSurfaceCreateFlagsMVK, + pub p_view: *const c_void, +} +impl ::std::default::Default for MacOSSurfaceCreateInfoMVK { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: MacOSSurfaceCreateFlagsMVK::default(), + p_view: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for MacOSSurfaceCreateInfoMVK { + const STRUCTURE_TYPE: StructureType = StructureType::MACOS_SURFACE_CREATE_INFO_MVK; +} +impl MacOSSurfaceCreateInfoMVK { + pub fn builder<'a>() -> MacOSSurfaceCreateInfoMVKBuilder<'a> { + MacOSSurfaceCreateInfoMVKBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct MacOSSurfaceCreateInfoMVKBuilder<'a> { + inner: MacOSSurfaceCreateInfoMVK, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for MacOSSurfaceCreateInfoMVKBuilder<'a> { + type Target = MacOSSurfaceCreateInfoMVK; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for MacOSSurfaceCreateInfoMVKBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> MacOSSurfaceCreateInfoMVKBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: MacOSSurfaceCreateFlagsMVK) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn view(mut self, view: *const c_void) -> Self { + self.inner.p_view = view; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> MacOSSurfaceCreateInfoMVK { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct MetalSurfaceCreateInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: MetalSurfaceCreateFlagsEXT, + pub p_layer: *const CAMetalLayer, +} +impl ::std::default::Default for MetalSurfaceCreateInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: MetalSurfaceCreateFlagsEXT::default(), + p_layer: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for MetalSurfaceCreateInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::METAL_SURFACE_CREATE_INFO_EXT; +} +impl MetalSurfaceCreateInfoEXT { + pub fn builder<'a>() -> MetalSurfaceCreateInfoEXTBuilder<'a> { + MetalSurfaceCreateInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct MetalSurfaceCreateInfoEXTBuilder<'a> { + inner: MetalSurfaceCreateInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for MetalSurfaceCreateInfoEXTBuilder<'a> { + type Target = MetalSurfaceCreateInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for MetalSurfaceCreateInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> MetalSurfaceCreateInfoEXTBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: MetalSurfaceCreateFlagsEXT) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn layer(mut self, layer: *const CAMetalLayer) -> Self { + self.inner.p_layer = layer; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> MetalSurfaceCreateInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct ViewportWScalingNV { + pub xcoeff: f32, + pub ycoeff: f32, +} +impl ViewportWScalingNV { + pub fn builder<'a>() -> ViewportWScalingNVBuilder<'a> { + ViewportWScalingNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ViewportWScalingNVBuilder<'a> { + inner: ViewportWScalingNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ViewportWScalingNVBuilder<'a> { + type Target = ViewportWScalingNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ViewportWScalingNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ViewportWScalingNVBuilder<'a> { + #[inline] + pub fn xcoeff(mut self, xcoeff: f32) -> Self { + self.inner.xcoeff = xcoeff; + self + } + #[inline] + pub fn ycoeff(mut self, ycoeff: f32) -> Self { + self.inner.ycoeff = ycoeff; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ViewportWScalingNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PipelineViewportWScalingStateCreateInfoNV { + pub s_type: StructureType, + pub p_next: *const c_void, + pub viewport_w_scaling_enable: Bool32, + pub viewport_count: u32, + pub p_viewport_w_scalings: *const ViewportWScalingNV, +} +impl ::std::default::Default for PipelineViewportWScalingStateCreateInfoNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + viewport_w_scaling_enable: Bool32::default(), + viewport_count: u32::default(), + p_viewport_w_scalings: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for PipelineViewportWScalingStateCreateInfoNV { + const STRUCTURE_TYPE: StructureType = + StructureType::PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV; +} +impl PipelineViewportWScalingStateCreateInfoNV { + pub fn builder<'a>() -> PipelineViewportWScalingStateCreateInfoNVBuilder<'a> { + PipelineViewportWScalingStateCreateInfoNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PipelineViewportWScalingStateCreateInfoNVBuilder<'a> { + inner: PipelineViewportWScalingStateCreateInfoNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPipelineViewportStateCreateInfo + for PipelineViewportWScalingStateCreateInfoNVBuilder<'_> +{ +} +unsafe impl ExtendsPipelineViewportStateCreateInfo for PipelineViewportWScalingStateCreateInfoNV {} +impl<'a> ::std::ops::Deref for PipelineViewportWScalingStateCreateInfoNVBuilder<'a> { + type Target = PipelineViewportWScalingStateCreateInfoNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PipelineViewportWScalingStateCreateInfoNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PipelineViewportWScalingStateCreateInfoNVBuilder<'a> { + #[inline] + pub fn viewport_w_scaling_enable(mut self, viewport_w_scaling_enable: bool) -> Self { + self.inner.viewport_w_scaling_enable = viewport_w_scaling_enable.into(); + self + } + #[inline] + pub fn viewport_w_scalings(mut self, viewport_w_scalings: &'a [ViewportWScalingNV]) -> Self { + self.inner.viewport_count = viewport_w_scalings.len() as _; + self.inner.p_viewport_w_scalings = viewport_w_scalings.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PipelineViewportWScalingStateCreateInfoNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct ViewportSwizzleNV { + pub x: ViewportCoordinateSwizzleNV, + pub y: ViewportCoordinateSwizzleNV, + pub z: ViewportCoordinateSwizzleNV, + pub w: ViewportCoordinateSwizzleNV, +} +impl ViewportSwizzleNV { + pub fn builder<'a>() -> ViewportSwizzleNVBuilder<'a> { + ViewportSwizzleNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ViewportSwizzleNVBuilder<'a> { + inner: ViewportSwizzleNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ViewportSwizzleNVBuilder<'a> { + type Target = ViewportSwizzleNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ViewportSwizzleNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ViewportSwizzleNVBuilder<'a> { + #[inline] + pub fn x(mut self, x: ViewportCoordinateSwizzleNV) -> Self { + self.inner.x = x; + self + } + #[inline] + pub fn y(mut self, y: ViewportCoordinateSwizzleNV) -> Self { + self.inner.y = y; + self + } + #[inline] + pub fn z(mut self, z: ViewportCoordinateSwizzleNV) -> Self { + self.inner.z = z; + self + } + #[inline] + pub fn w(mut self, w: ViewportCoordinateSwizzleNV) -> Self { + self.inner.w = w; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ViewportSwizzleNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PipelineViewportSwizzleStateCreateInfoNV { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: PipelineViewportSwizzleStateCreateFlagsNV, + pub viewport_count: u32, + pub p_viewport_swizzles: *const ViewportSwizzleNV, +} +impl ::std::default::Default for PipelineViewportSwizzleStateCreateInfoNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: PipelineViewportSwizzleStateCreateFlagsNV::default(), + viewport_count: u32::default(), + p_viewport_swizzles: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for PipelineViewportSwizzleStateCreateInfoNV { + const STRUCTURE_TYPE: StructureType = + StructureType::PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV; +} +impl PipelineViewportSwizzleStateCreateInfoNV { + pub fn builder<'a>() -> PipelineViewportSwizzleStateCreateInfoNVBuilder<'a> { + PipelineViewportSwizzleStateCreateInfoNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PipelineViewportSwizzleStateCreateInfoNVBuilder<'a> { + inner: PipelineViewportSwizzleStateCreateInfoNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPipelineViewportStateCreateInfo + for PipelineViewportSwizzleStateCreateInfoNVBuilder<'_> +{ +} +unsafe impl ExtendsPipelineViewportStateCreateInfo for PipelineViewportSwizzleStateCreateInfoNV {} +impl<'a> ::std::ops::Deref for PipelineViewportSwizzleStateCreateInfoNVBuilder<'a> { + type Target = PipelineViewportSwizzleStateCreateInfoNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PipelineViewportSwizzleStateCreateInfoNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PipelineViewportSwizzleStateCreateInfoNVBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: PipelineViewportSwizzleStateCreateFlagsNV) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn viewport_swizzles(mut self, viewport_swizzles: &'a [ViewportSwizzleNV]) -> Self { + self.inner.viewport_count = viewport_swizzles.len() as _; + self.inner.p_viewport_swizzles = viewport_swizzles.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PipelineViewportSwizzleStateCreateInfoNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceDiscardRectanglePropertiesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub max_discard_rectangles: u32, +} +impl ::std::default::Default for PhysicalDeviceDiscardRectanglePropertiesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + max_discard_rectangles: u32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceDiscardRectanglePropertiesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT; +} +impl PhysicalDeviceDiscardRectanglePropertiesEXT { + pub fn builder<'a>() -> PhysicalDeviceDiscardRectanglePropertiesEXTBuilder<'a> { + PhysicalDeviceDiscardRectanglePropertiesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceDiscardRectanglePropertiesEXTBuilder<'a> { + inner: PhysicalDeviceDiscardRectanglePropertiesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceDiscardRectanglePropertiesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceDiscardRectanglePropertiesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceDiscardRectanglePropertiesEXTBuilder<'a> { + type Target = PhysicalDeviceDiscardRectanglePropertiesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceDiscardRectanglePropertiesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceDiscardRectanglePropertiesEXTBuilder<'a> { + #[inline] + pub fn max_discard_rectangles(mut self, max_discard_rectangles: u32) -> Self { + self.inner.max_discard_rectangles = max_discard_rectangles; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceDiscardRectanglePropertiesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PipelineDiscardRectangleStateCreateInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: PipelineDiscardRectangleStateCreateFlagsEXT, + pub discard_rectangle_mode: DiscardRectangleModeEXT, + pub discard_rectangle_count: u32, + pub p_discard_rectangles: *const Rect2D, +} +impl ::std::default::Default for PipelineDiscardRectangleStateCreateInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: PipelineDiscardRectangleStateCreateFlagsEXT::default(), + discard_rectangle_mode: DiscardRectangleModeEXT::default(), + discard_rectangle_count: u32::default(), + p_discard_rectangles: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for PipelineDiscardRectangleStateCreateInfoEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT; +} +impl PipelineDiscardRectangleStateCreateInfoEXT { + pub fn builder<'a>() -> PipelineDiscardRectangleStateCreateInfoEXTBuilder<'a> { + PipelineDiscardRectangleStateCreateInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PipelineDiscardRectangleStateCreateInfoEXTBuilder<'a> { + inner: PipelineDiscardRectangleStateCreateInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsGraphicsPipelineCreateInfo + for PipelineDiscardRectangleStateCreateInfoEXTBuilder<'_> +{ +} +unsafe impl ExtendsGraphicsPipelineCreateInfo for PipelineDiscardRectangleStateCreateInfoEXT {} +impl<'a> ::std::ops::Deref for PipelineDiscardRectangleStateCreateInfoEXTBuilder<'a> { + type Target = PipelineDiscardRectangleStateCreateInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PipelineDiscardRectangleStateCreateInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PipelineDiscardRectangleStateCreateInfoEXTBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: PipelineDiscardRectangleStateCreateFlagsEXT) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn discard_rectangle_mode( + mut self, + discard_rectangle_mode: DiscardRectangleModeEXT, + ) -> Self { + self.inner.discard_rectangle_mode = discard_rectangle_mode; + self + } + #[inline] + pub fn discard_rectangles(mut self, discard_rectangles: &'a [Rect2D]) -> Self { + self.inner.discard_rectangle_count = discard_rectangles.len() as _; + self.inner.p_discard_rectangles = discard_rectangles.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PipelineDiscardRectangleStateCreateInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub per_view_position_all_components: Bool32, +} +impl ::std::default::Default for PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + per_view_position_all_components: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX; +} +impl PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX { + pub fn builder<'a>() -> PhysicalDeviceMultiviewPerViewAttributesPropertiesNVXBuilder<'a> { + PhysicalDeviceMultiviewPerViewAttributesPropertiesNVXBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceMultiviewPerViewAttributesPropertiesNVXBuilder<'a> { + inner: PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceMultiviewPerViewAttributesPropertiesNVXBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX +{ +} +impl<'a> ::std::ops::Deref for PhysicalDeviceMultiviewPerViewAttributesPropertiesNVXBuilder<'a> { + type Target = PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceMultiviewPerViewAttributesPropertiesNVXBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceMultiviewPerViewAttributesPropertiesNVXBuilder<'a> { + #[inline] + pub fn per_view_position_all_components( + mut self, + per_view_position_all_components: bool, + ) -> Self { + self.inner.per_view_position_all_components = per_view_position_all_components.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct InputAttachmentAspectReference { + pub subpass: u32, + pub input_attachment_index: u32, + pub aspect_mask: ImageAspectFlags, +} +impl InputAttachmentAspectReference { + pub fn builder<'a>() -> InputAttachmentAspectReferenceBuilder<'a> { + InputAttachmentAspectReferenceBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct InputAttachmentAspectReferenceBuilder<'a> { + inner: InputAttachmentAspectReference, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for InputAttachmentAspectReferenceBuilder<'a> { + type Target = InputAttachmentAspectReference; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for InputAttachmentAspectReferenceBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> InputAttachmentAspectReferenceBuilder<'a> { + #[inline] + pub fn subpass(mut self, subpass: u32) -> Self { + self.inner.subpass = subpass; + self + } + #[inline] + pub fn input_attachment_index(mut self, input_attachment_index: u32) -> Self { + self.inner.input_attachment_index = input_attachment_index; + self + } + #[inline] + pub fn aspect_mask(mut self, aspect_mask: ImageAspectFlags) -> Self { + self.inner.aspect_mask = aspect_mask; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> InputAttachmentAspectReference { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct RenderPassInputAttachmentAspectCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub aspect_reference_count: u32, + pub p_aspect_references: *const InputAttachmentAspectReference, +} +impl ::std::default::Default for RenderPassInputAttachmentAspectCreateInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + aspect_reference_count: u32::default(), + p_aspect_references: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for RenderPassInputAttachmentAspectCreateInfo { + const STRUCTURE_TYPE: StructureType = + StructureType::RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO; +} +impl RenderPassInputAttachmentAspectCreateInfo { + pub fn builder<'a>() -> RenderPassInputAttachmentAspectCreateInfoBuilder<'a> { + RenderPassInputAttachmentAspectCreateInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct RenderPassInputAttachmentAspectCreateInfoBuilder<'a> { + inner: RenderPassInputAttachmentAspectCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsRenderPassCreateInfo for RenderPassInputAttachmentAspectCreateInfoBuilder<'_> {} +unsafe impl ExtendsRenderPassCreateInfo for RenderPassInputAttachmentAspectCreateInfo {} +impl<'a> ::std::ops::Deref for RenderPassInputAttachmentAspectCreateInfoBuilder<'a> { + type Target = RenderPassInputAttachmentAspectCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for RenderPassInputAttachmentAspectCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> RenderPassInputAttachmentAspectCreateInfoBuilder<'a> { + #[inline] + pub fn aspect_references( + mut self, + aspect_references: &'a [InputAttachmentAspectReference], + ) -> Self { + self.inner.aspect_reference_count = aspect_references.len() as _; + self.inner.p_aspect_references = aspect_references.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> RenderPassInputAttachmentAspectCreateInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceSurfaceInfo2KHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub surface: SurfaceKHR, +} +impl ::std::default::Default for PhysicalDeviceSurfaceInfo2KHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + surface: SurfaceKHR::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceSurfaceInfo2KHR { + const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_SURFACE_INFO_2_KHR; +} +impl PhysicalDeviceSurfaceInfo2KHR { + pub fn builder<'a>() -> PhysicalDeviceSurfaceInfo2KHRBuilder<'a> { + PhysicalDeviceSurfaceInfo2KHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceSurfaceInfo2KHRBuilder<'a> { + inner: PhysicalDeviceSurfaceInfo2KHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsPhysicalDeviceSurfaceInfo2KHR {} +impl<'a> ::std::ops::Deref for PhysicalDeviceSurfaceInfo2KHRBuilder<'a> { + type Target = PhysicalDeviceSurfaceInfo2KHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceSurfaceInfo2KHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceSurfaceInfo2KHRBuilder<'a> { + #[inline] + pub fn surface(mut self, surface: SurfaceKHR) -> Self { + self.inner.surface = surface; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceSurfaceInfo2KHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SurfaceCapabilities2KHR { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub surface_capabilities: SurfaceCapabilitiesKHR, +} +impl ::std::default::Default for SurfaceCapabilities2KHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + surface_capabilities: SurfaceCapabilitiesKHR::default(), + } + } +} +unsafe impl TaggedStructure for SurfaceCapabilities2KHR { + const STRUCTURE_TYPE: StructureType = StructureType::SURFACE_CAPABILITIES_2_KHR; +} +impl SurfaceCapabilities2KHR { + pub fn builder<'a>() -> SurfaceCapabilities2KHRBuilder<'a> { + SurfaceCapabilities2KHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SurfaceCapabilities2KHRBuilder<'a> { + inner: SurfaceCapabilities2KHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsSurfaceCapabilities2KHR {} +impl<'a> ::std::ops::Deref for SurfaceCapabilities2KHRBuilder<'a> { + type Target = SurfaceCapabilities2KHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SurfaceCapabilities2KHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SurfaceCapabilities2KHRBuilder<'a> { + #[inline] + pub fn surface_capabilities(mut self, surface_capabilities: SurfaceCapabilitiesKHR) -> Self { + self.inner.surface_capabilities = surface_capabilities; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*mut T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SurfaceCapabilities2KHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SurfaceFormat2KHR { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub surface_format: SurfaceFormatKHR, +} +impl ::std::default::Default for SurfaceFormat2KHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + surface_format: SurfaceFormatKHR::default(), + } + } +} +unsafe impl TaggedStructure for SurfaceFormat2KHR { + const STRUCTURE_TYPE: StructureType = StructureType::SURFACE_FORMAT_2_KHR; +} +impl SurfaceFormat2KHR { + pub fn builder<'a>() -> SurfaceFormat2KHRBuilder<'a> { + SurfaceFormat2KHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SurfaceFormat2KHRBuilder<'a> { + inner: SurfaceFormat2KHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsSurfaceFormat2KHR {} +impl<'a> ::std::ops::Deref for SurfaceFormat2KHRBuilder<'a> { + type Target = SurfaceFormat2KHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SurfaceFormat2KHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SurfaceFormat2KHRBuilder<'a> { + #[inline] + pub fn surface_format(mut self, surface_format: SurfaceFormatKHR) -> Self { + self.inner.surface_format = surface_format; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*mut T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SurfaceFormat2KHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DisplayProperties2KHR { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub display_properties: DisplayPropertiesKHR, +} +impl ::std::default::Default for DisplayProperties2KHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + display_properties: DisplayPropertiesKHR::default(), + } + } +} +unsafe impl TaggedStructure for DisplayProperties2KHR { + const STRUCTURE_TYPE: StructureType = StructureType::DISPLAY_PROPERTIES_2_KHR; +} +impl DisplayProperties2KHR { + pub fn builder<'a>() -> DisplayProperties2KHRBuilder<'a> { + DisplayProperties2KHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DisplayProperties2KHRBuilder<'a> { + inner: DisplayProperties2KHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DisplayProperties2KHRBuilder<'a> { + type Target = DisplayProperties2KHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DisplayProperties2KHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DisplayProperties2KHRBuilder<'a> { + #[inline] + pub fn display_properties(mut self, display_properties: DisplayPropertiesKHR) -> Self { + self.inner.display_properties = display_properties; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DisplayProperties2KHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DisplayPlaneProperties2KHR { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub display_plane_properties: DisplayPlanePropertiesKHR, +} +impl ::std::default::Default for DisplayPlaneProperties2KHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + display_plane_properties: DisplayPlanePropertiesKHR::default(), + } + } +} +unsafe impl TaggedStructure for DisplayPlaneProperties2KHR { + const STRUCTURE_TYPE: StructureType = StructureType::DISPLAY_PLANE_PROPERTIES_2_KHR; +} +impl DisplayPlaneProperties2KHR { + pub fn builder<'a>() -> DisplayPlaneProperties2KHRBuilder<'a> { + DisplayPlaneProperties2KHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DisplayPlaneProperties2KHRBuilder<'a> { + inner: DisplayPlaneProperties2KHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DisplayPlaneProperties2KHRBuilder<'a> { + type Target = DisplayPlaneProperties2KHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DisplayPlaneProperties2KHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DisplayPlaneProperties2KHRBuilder<'a> { + #[inline] + pub fn display_plane_properties( + mut self, + display_plane_properties: DisplayPlanePropertiesKHR, + ) -> Self { + self.inner.display_plane_properties = display_plane_properties; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DisplayPlaneProperties2KHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DisplayModeProperties2KHR { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub display_mode_properties: DisplayModePropertiesKHR, +} +impl ::std::default::Default for DisplayModeProperties2KHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + display_mode_properties: DisplayModePropertiesKHR::default(), + } + } +} +unsafe impl TaggedStructure for DisplayModeProperties2KHR { + const STRUCTURE_TYPE: StructureType = StructureType::DISPLAY_MODE_PROPERTIES_2_KHR; +} +impl DisplayModeProperties2KHR { + pub fn builder<'a>() -> DisplayModeProperties2KHRBuilder<'a> { + DisplayModeProperties2KHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DisplayModeProperties2KHRBuilder<'a> { + inner: DisplayModeProperties2KHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DisplayModeProperties2KHRBuilder<'a> { + type Target = DisplayModeProperties2KHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DisplayModeProperties2KHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DisplayModeProperties2KHRBuilder<'a> { + #[inline] + pub fn display_mode_properties( + mut self, + display_mode_properties: DisplayModePropertiesKHR, + ) -> Self { + self.inner.display_mode_properties = display_mode_properties; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DisplayModeProperties2KHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DisplayPlaneInfo2KHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub mode: DisplayModeKHR, + pub plane_index: u32, +} +impl ::std::default::Default for DisplayPlaneInfo2KHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + mode: DisplayModeKHR::default(), + plane_index: u32::default(), + } + } +} +unsafe impl TaggedStructure for DisplayPlaneInfo2KHR { + const STRUCTURE_TYPE: StructureType = StructureType::DISPLAY_PLANE_INFO_2_KHR; +} +impl DisplayPlaneInfo2KHR { + pub fn builder<'a>() -> DisplayPlaneInfo2KHRBuilder<'a> { + DisplayPlaneInfo2KHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DisplayPlaneInfo2KHRBuilder<'a> { + inner: DisplayPlaneInfo2KHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DisplayPlaneInfo2KHRBuilder<'a> { + type Target = DisplayPlaneInfo2KHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DisplayPlaneInfo2KHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DisplayPlaneInfo2KHRBuilder<'a> { + #[inline] + pub fn mode(mut self, mode: DisplayModeKHR) -> Self { + self.inner.mode = mode; + self + } + #[inline] + pub fn plane_index(mut self, plane_index: u32) -> Self { + self.inner.plane_index = plane_index; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DisplayPlaneInfo2KHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DisplayPlaneCapabilities2KHR { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub capabilities: DisplayPlaneCapabilitiesKHR, +} +impl ::std::default::Default for DisplayPlaneCapabilities2KHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + capabilities: DisplayPlaneCapabilitiesKHR::default(), + } + } +} +unsafe impl TaggedStructure for DisplayPlaneCapabilities2KHR { + const STRUCTURE_TYPE: StructureType = StructureType::DISPLAY_PLANE_CAPABILITIES_2_KHR; +} +impl DisplayPlaneCapabilities2KHR { + pub fn builder<'a>() -> DisplayPlaneCapabilities2KHRBuilder<'a> { + DisplayPlaneCapabilities2KHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DisplayPlaneCapabilities2KHRBuilder<'a> { + inner: DisplayPlaneCapabilities2KHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DisplayPlaneCapabilities2KHRBuilder<'a> { + type Target = DisplayPlaneCapabilities2KHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DisplayPlaneCapabilities2KHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DisplayPlaneCapabilities2KHRBuilder<'a> { + #[inline] + pub fn capabilities(mut self, capabilities: DisplayPlaneCapabilitiesKHR) -> Self { + self.inner.capabilities = capabilities; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DisplayPlaneCapabilities2KHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SharedPresentSurfaceCapabilitiesKHR { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub shared_present_supported_usage_flags: ImageUsageFlags, +} +impl ::std::default::Default for SharedPresentSurfaceCapabilitiesKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + shared_present_supported_usage_flags: ImageUsageFlags::default(), + } + } +} +unsafe impl TaggedStructure for SharedPresentSurfaceCapabilitiesKHR { + const STRUCTURE_TYPE: StructureType = StructureType::SHARED_PRESENT_SURFACE_CAPABILITIES_KHR; +} +impl SharedPresentSurfaceCapabilitiesKHR { + pub fn builder<'a>() -> SharedPresentSurfaceCapabilitiesKHRBuilder<'a> { + SharedPresentSurfaceCapabilitiesKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SharedPresentSurfaceCapabilitiesKHRBuilder<'a> { + inner: SharedPresentSurfaceCapabilitiesKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsSurfaceCapabilities2KHR for SharedPresentSurfaceCapabilitiesKHRBuilder<'_> {} +unsafe impl ExtendsSurfaceCapabilities2KHR for SharedPresentSurfaceCapabilitiesKHR {} +impl<'a> ::std::ops::Deref for SharedPresentSurfaceCapabilitiesKHRBuilder<'a> { + type Target = SharedPresentSurfaceCapabilitiesKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SharedPresentSurfaceCapabilitiesKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SharedPresentSurfaceCapabilitiesKHRBuilder<'a> { + #[inline] + pub fn shared_present_supported_usage_flags( + mut self, + shared_present_supported_usage_flags: ImageUsageFlags, + ) -> Self { + self.inner.shared_present_supported_usage_flags = shared_present_supported_usage_flags; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SharedPresentSurfaceCapabilitiesKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDevice16BitStorageFeatures { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub storage_buffer16_bit_access: Bool32, + pub uniform_and_storage_buffer16_bit_access: Bool32, + pub storage_push_constant16: Bool32, + pub storage_input_output16: Bool32, +} +impl ::std::default::Default for PhysicalDevice16BitStorageFeatures { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + storage_buffer16_bit_access: Bool32::default(), + uniform_and_storage_buffer16_bit_access: Bool32::default(), + storage_push_constant16: Bool32::default(), + storage_input_output16: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDevice16BitStorageFeatures { + const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES; +} +impl PhysicalDevice16BitStorageFeatures { + pub fn builder<'a>() -> PhysicalDevice16BitStorageFeaturesBuilder<'a> { + PhysicalDevice16BitStorageFeaturesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDevice16BitStorageFeaturesBuilder<'a> { + inner: PhysicalDevice16BitStorageFeatures, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevice16BitStorageFeaturesBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevice16BitStorageFeatures {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDevice16BitStorageFeaturesBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDevice16BitStorageFeatures {} +impl<'a> ::std::ops::Deref for PhysicalDevice16BitStorageFeaturesBuilder<'a> { + type Target = PhysicalDevice16BitStorageFeatures; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDevice16BitStorageFeaturesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDevice16BitStorageFeaturesBuilder<'a> { + #[inline] + pub fn storage_buffer16_bit_access(mut self, storage_buffer16_bit_access: bool) -> Self { + self.inner.storage_buffer16_bit_access = storage_buffer16_bit_access.into(); + self + } + #[inline] + pub fn uniform_and_storage_buffer16_bit_access( + mut self, + uniform_and_storage_buffer16_bit_access: bool, + ) -> Self { + self.inner.uniform_and_storage_buffer16_bit_access = + uniform_and_storage_buffer16_bit_access.into(); + self + } + #[inline] + pub fn storage_push_constant16(mut self, storage_push_constant16: bool) -> Self { + self.inner.storage_push_constant16 = storage_push_constant16.into(); + self + } + #[inline] + pub fn storage_input_output16(mut self, storage_input_output16: bool) -> Self { + self.inner.storage_input_output16 = storage_input_output16.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDevice16BitStorageFeatures { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceSubgroupProperties { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub subgroup_size: u32, + pub supported_stages: ShaderStageFlags, + pub supported_operations: SubgroupFeatureFlags, + pub quad_operations_in_all_stages: Bool32, +} +impl ::std::default::Default for PhysicalDeviceSubgroupProperties { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + subgroup_size: u32::default(), + supported_stages: ShaderStageFlags::default(), + supported_operations: SubgroupFeatureFlags::default(), + quad_operations_in_all_stages: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceSubgroupProperties { + const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_SUBGROUP_PROPERTIES; +} +impl PhysicalDeviceSubgroupProperties { + pub fn builder<'a>() -> PhysicalDeviceSubgroupPropertiesBuilder<'a> { + PhysicalDeviceSubgroupPropertiesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceSubgroupPropertiesBuilder<'a> { + inner: PhysicalDeviceSubgroupProperties, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceSubgroupPropertiesBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceSubgroupProperties {} +impl<'a> ::std::ops::Deref for PhysicalDeviceSubgroupPropertiesBuilder<'a> { + type Target = PhysicalDeviceSubgroupProperties; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceSubgroupPropertiesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceSubgroupPropertiesBuilder<'a> { + #[inline] + pub fn subgroup_size(mut self, subgroup_size: u32) -> Self { + self.inner.subgroup_size = subgroup_size; + self + } + #[inline] + pub fn supported_stages(mut self, supported_stages: ShaderStageFlags) -> Self { + self.inner.supported_stages = supported_stages; + self + } + #[inline] + pub fn supported_operations(mut self, supported_operations: SubgroupFeatureFlags) -> Self { + self.inner.supported_operations = supported_operations; + self + } + #[inline] + pub fn quad_operations_in_all_stages(mut self, quad_operations_in_all_stages: bool) -> Self { + self.inner.quad_operations_in_all_stages = quad_operations_in_all_stages.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceSubgroupProperties { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceShaderSubgroupExtendedTypesFeatures { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub shader_subgroup_extended_types: Bool32, +} +impl ::std::default::Default for PhysicalDeviceShaderSubgroupExtendedTypesFeatures { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + shader_subgroup_extended_types: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceShaderSubgroupExtendedTypesFeatures { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES; +} +impl PhysicalDeviceShaderSubgroupExtendedTypesFeatures { + pub fn builder<'a>() -> PhysicalDeviceShaderSubgroupExtendedTypesFeaturesBuilder<'a> { + PhysicalDeviceShaderSubgroupExtendedTypesFeaturesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceShaderSubgroupExtendedTypesFeaturesBuilder<'a> { + inner: PhysicalDeviceShaderSubgroupExtendedTypesFeatures, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceShaderSubgroupExtendedTypesFeaturesBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderSubgroupExtendedTypesFeatures {} +unsafe impl ExtendsDeviceCreateInfo + for PhysicalDeviceShaderSubgroupExtendedTypesFeaturesBuilder<'_> +{ +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderSubgroupExtendedTypesFeatures {} +impl<'a> ::std::ops::Deref for PhysicalDeviceShaderSubgroupExtendedTypesFeaturesBuilder<'a> { + type Target = PhysicalDeviceShaderSubgroupExtendedTypesFeatures; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderSubgroupExtendedTypesFeaturesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceShaderSubgroupExtendedTypesFeaturesBuilder<'a> { + #[inline] + pub fn shader_subgroup_extended_types(mut self, shader_subgroup_extended_types: bool) -> Self { + self.inner.shader_subgroup_extended_types = shader_subgroup_extended_types.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceShaderSubgroupExtendedTypesFeatures { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct BufferMemoryRequirementsInfo2 { + pub s_type: StructureType, + pub p_next: *const c_void, + pub buffer: Buffer, +} +impl ::std::default::Default for BufferMemoryRequirementsInfo2 { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + buffer: Buffer::default(), + } + } +} +unsafe impl TaggedStructure for BufferMemoryRequirementsInfo2 { + const STRUCTURE_TYPE: StructureType = StructureType::BUFFER_MEMORY_REQUIREMENTS_INFO_2; +} +impl BufferMemoryRequirementsInfo2 { + pub fn builder<'a>() -> BufferMemoryRequirementsInfo2Builder<'a> { + BufferMemoryRequirementsInfo2Builder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct BufferMemoryRequirementsInfo2Builder<'a> { + inner: BufferMemoryRequirementsInfo2, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for BufferMemoryRequirementsInfo2Builder<'a> { + type Target = BufferMemoryRequirementsInfo2; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for BufferMemoryRequirementsInfo2Builder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> BufferMemoryRequirementsInfo2Builder<'a> { + #[inline] + pub fn buffer(mut self, buffer: Buffer) -> Self { + self.inner.buffer = buffer; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> BufferMemoryRequirementsInfo2 { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DeviceBufferMemoryRequirements { + pub s_type: StructureType, + pub p_next: *const c_void, + pub p_create_info: *const BufferCreateInfo, +} +impl ::std::default::Default for DeviceBufferMemoryRequirements { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + p_create_info: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for DeviceBufferMemoryRequirements { + const STRUCTURE_TYPE: StructureType = StructureType::DEVICE_BUFFER_MEMORY_REQUIREMENTS; +} +impl DeviceBufferMemoryRequirements { + pub fn builder<'a>() -> DeviceBufferMemoryRequirementsBuilder<'a> { + DeviceBufferMemoryRequirementsBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DeviceBufferMemoryRequirementsBuilder<'a> { + inner: DeviceBufferMemoryRequirements, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DeviceBufferMemoryRequirementsBuilder<'a> { + type Target = DeviceBufferMemoryRequirements; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DeviceBufferMemoryRequirementsBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DeviceBufferMemoryRequirementsBuilder<'a> { + #[inline] + pub fn create_info(mut self, create_info: &'a BufferCreateInfo) -> Self { + self.inner.p_create_info = create_info; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DeviceBufferMemoryRequirements { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ImageMemoryRequirementsInfo2 { + pub s_type: StructureType, + pub p_next: *const c_void, + pub image: Image, +} +impl ::std::default::Default for ImageMemoryRequirementsInfo2 { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + image: Image::default(), + } + } +} +unsafe impl TaggedStructure for ImageMemoryRequirementsInfo2 { + const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_MEMORY_REQUIREMENTS_INFO_2; +} +impl ImageMemoryRequirementsInfo2 { + pub fn builder<'a>() -> ImageMemoryRequirementsInfo2Builder<'a> { + ImageMemoryRequirementsInfo2Builder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ImageMemoryRequirementsInfo2Builder<'a> { + inner: ImageMemoryRequirementsInfo2, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsImageMemoryRequirementsInfo2 {} +impl<'a> ::std::ops::Deref for ImageMemoryRequirementsInfo2Builder<'a> { + type Target = ImageMemoryRequirementsInfo2; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ImageMemoryRequirementsInfo2Builder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ImageMemoryRequirementsInfo2Builder<'a> { + #[inline] + pub fn image(mut self, image: Image) -> Self { + self.inner.image = image; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ImageMemoryRequirementsInfo2 { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ImageSparseMemoryRequirementsInfo2 { + pub s_type: StructureType, + pub p_next: *const c_void, + pub image: Image, +} +impl ::std::default::Default for ImageSparseMemoryRequirementsInfo2 { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + image: Image::default(), + } + } +} +unsafe impl TaggedStructure for ImageSparseMemoryRequirementsInfo2 { + const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2; +} +impl ImageSparseMemoryRequirementsInfo2 { + pub fn builder<'a>() -> ImageSparseMemoryRequirementsInfo2Builder<'a> { + ImageSparseMemoryRequirementsInfo2Builder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ImageSparseMemoryRequirementsInfo2Builder<'a> { + inner: ImageSparseMemoryRequirementsInfo2, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ImageSparseMemoryRequirementsInfo2Builder<'a> { + type Target = ImageSparseMemoryRequirementsInfo2; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ImageSparseMemoryRequirementsInfo2Builder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ImageSparseMemoryRequirementsInfo2Builder<'a> { + #[inline] + pub fn image(mut self, image: Image) -> Self { + self.inner.image = image; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ImageSparseMemoryRequirementsInfo2 { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DeviceImageMemoryRequirements { + pub s_type: StructureType, + pub p_next: *const c_void, + pub p_create_info: *const ImageCreateInfo, + pub plane_aspect: ImageAspectFlags, +} +impl ::std::default::Default for DeviceImageMemoryRequirements { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + p_create_info: ::std::ptr::null(), + plane_aspect: ImageAspectFlags::default(), + } + } +} +unsafe impl TaggedStructure for DeviceImageMemoryRequirements { + const STRUCTURE_TYPE: StructureType = StructureType::DEVICE_IMAGE_MEMORY_REQUIREMENTS; +} +impl DeviceImageMemoryRequirements { + pub fn builder<'a>() -> DeviceImageMemoryRequirementsBuilder<'a> { + DeviceImageMemoryRequirementsBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DeviceImageMemoryRequirementsBuilder<'a> { + inner: DeviceImageMemoryRequirements, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DeviceImageMemoryRequirementsBuilder<'a> { + type Target = DeviceImageMemoryRequirements; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DeviceImageMemoryRequirementsBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DeviceImageMemoryRequirementsBuilder<'a> { + #[inline] + pub fn create_info(mut self, create_info: &'a ImageCreateInfo) -> Self { + self.inner.p_create_info = create_info; + self + } + #[inline] + pub fn plane_aspect(mut self, plane_aspect: ImageAspectFlags) -> Self { + self.inner.plane_aspect = plane_aspect; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DeviceImageMemoryRequirements { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct MemoryRequirements2 { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub memory_requirements: MemoryRequirements, +} +impl ::std::default::Default for MemoryRequirements2 { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + memory_requirements: MemoryRequirements::default(), + } + } +} +unsafe impl TaggedStructure for MemoryRequirements2 { + const STRUCTURE_TYPE: StructureType = StructureType::MEMORY_REQUIREMENTS_2; +} +impl MemoryRequirements2 { + pub fn builder<'a>() -> MemoryRequirements2Builder<'a> { + MemoryRequirements2Builder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct MemoryRequirements2Builder<'a> { + inner: MemoryRequirements2, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsMemoryRequirements2 {} +impl<'a> ::std::ops::Deref for MemoryRequirements2Builder<'a> { + type Target = MemoryRequirements2; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for MemoryRequirements2Builder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> MemoryRequirements2Builder<'a> { + #[inline] + pub fn memory_requirements(mut self, memory_requirements: MemoryRequirements) -> Self { + self.inner.memory_requirements = memory_requirements; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*mut T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> MemoryRequirements2 { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SparseImageMemoryRequirements2 { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub memory_requirements: SparseImageMemoryRequirements, +} +impl ::std::default::Default for SparseImageMemoryRequirements2 { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + memory_requirements: SparseImageMemoryRequirements::default(), + } + } +} +unsafe impl TaggedStructure for SparseImageMemoryRequirements2 { + const STRUCTURE_TYPE: StructureType = StructureType::SPARSE_IMAGE_MEMORY_REQUIREMENTS_2; +} +impl SparseImageMemoryRequirements2 { + pub fn builder<'a>() -> SparseImageMemoryRequirements2Builder<'a> { + SparseImageMemoryRequirements2Builder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SparseImageMemoryRequirements2Builder<'a> { + inner: SparseImageMemoryRequirements2, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for SparseImageMemoryRequirements2Builder<'a> { + type Target = SparseImageMemoryRequirements2; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SparseImageMemoryRequirements2Builder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SparseImageMemoryRequirements2Builder<'a> { + #[inline] + pub fn memory_requirements( + mut self, + memory_requirements: SparseImageMemoryRequirements, + ) -> Self { + self.inner.memory_requirements = memory_requirements; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SparseImageMemoryRequirements2 { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDevicePointClippingProperties { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub point_clipping_behavior: PointClippingBehavior, +} +impl ::std::default::Default for PhysicalDevicePointClippingProperties { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + point_clipping_behavior: PointClippingBehavior::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDevicePointClippingProperties { + const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES; +} +impl PhysicalDevicePointClippingProperties { + pub fn builder<'a>() -> PhysicalDevicePointClippingPropertiesBuilder<'a> { + PhysicalDevicePointClippingPropertiesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDevicePointClippingPropertiesBuilder<'a> { + inner: PhysicalDevicePointClippingProperties, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDevicePointClippingPropertiesBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDevicePointClippingProperties {} +impl<'a> ::std::ops::Deref for PhysicalDevicePointClippingPropertiesBuilder<'a> { + type Target = PhysicalDevicePointClippingProperties; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDevicePointClippingPropertiesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDevicePointClippingPropertiesBuilder<'a> { + #[inline] + pub fn point_clipping_behavior( + mut self, + point_clipping_behavior: PointClippingBehavior, + ) -> Self { + self.inner.point_clipping_behavior = point_clipping_behavior; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDevicePointClippingProperties { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct MemoryDedicatedRequirements { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub prefers_dedicated_allocation: Bool32, + pub requires_dedicated_allocation: Bool32, +} +impl ::std::default::Default for MemoryDedicatedRequirements { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + prefers_dedicated_allocation: Bool32::default(), + requires_dedicated_allocation: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for MemoryDedicatedRequirements { + const STRUCTURE_TYPE: StructureType = StructureType::MEMORY_DEDICATED_REQUIREMENTS; +} +impl MemoryDedicatedRequirements { + pub fn builder<'a>() -> MemoryDedicatedRequirementsBuilder<'a> { + MemoryDedicatedRequirementsBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct MemoryDedicatedRequirementsBuilder<'a> { + inner: MemoryDedicatedRequirements, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsMemoryRequirements2 for MemoryDedicatedRequirementsBuilder<'_> {} +unsafe impl ExtendsMemoryRequirements2 for MemoryDedicatedRequirements {} +impl<'a> ::std::ops::Deref for MemoryDedicatedRequirementsBuilder<'a> { + type Target = MemoryDedicatedRequirements; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for MemoryDedicatedRequirementsBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> MemoryDedicatedRequirementsBuilder<'a> { + #[inline] + pub fn prefers_dedicated_allocation(mut self, prefers_dedicated_allocation: bool) -> Self { + self.inner.prefers_dedicated_allocation = prefers_dedicated_allocation.into(); + self + } + #[inline] + pub fn requires_dedicated_allocation(mut self, requires_dedicated_allocation: bool) -> Self { + self.inner.requires_dedicated_allocation = requires_dedicated_allocation.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> MemoryDedicatedRequirements { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct MemoryDedicatedAllocateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub image: Image, + pub buffer: Buffer, +} +impl ::std::default::Default for MemoryDedicatedAllocateInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + image: Image::default(), + buffer: Buffer::default(), + } + } +} +unsafe impl TaggedStructure for MemoryDedicatedAllocateInfo { + const STRUCTURE_TYPE: StructureType = StructureType::MEMORY_DEDICATED_ALLOCATE_INFO; +} +impl MemoryDedicatedAllocateInfo { + pub fn builder<'a>() -> MemoryDedicatedAllocateInfoBuilder<'a> { + MemoryDedicatedAllocateInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct MemoryDedicatedAllocateInfoBuilder<'a> { + inner: MemoryDedicatedAllocateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsMemoryAllocateInfo for MemoryDedicatedAllocateInfoBuilder<'_> {} +unsafe impl ExtendsMemoryAllocateInfo for MemoryDedicatedAllocateInfo {} +impl<'a> ::std::ops::Deref for MemoryDedicatedAllocateInfoBuilder<'a> { + type Target = MemoryDedicatedAllocateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for MemoryDedicatedAllocateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> MemoryDedicatedAllocateInfoBuilder<'a> { + #[inline] + pub fn image(mut self, image: Image) -> Self { + self.inner.image = image; + self + } + #[inline] + pub fn buffer(mut self, buffer: Buffer) -> Self { + self.inner.buffer = buffer; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> MemoryDedicatedAllocateInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ImageViewUsageCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub usage: ImageUsageFlags, +} +impl ::std::default::Default for ImageViewUsageCreateInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + usage: ImageUsageFlags::default(), + } + } +} +unsafe impl TaggedStructure for ImageViewUsageCreateInfo { + const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_VIEW_USAGE_CREATE_INFO; +} +impl ImageViewUsageCreateInfo { + pub fn builder<'a>() -> ImageViewUsageCreateInfoBuilder<'a> { + ImageViewUsageCreateInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ImageViewUsageCreateInfoBuilder<'a> { + inner: ImageViewUsageCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsImageViewCreateInfo for ImageViewUsageCreateInfoBuilder<'_> {} +unsafe impl ExtendsImageViewCreateInfo for ImageViewUsageCreateInfo {} +impl<'a> ::std::ops::Deref for ImageViewUsageCreateInfoBuilder<'a> { + type Target = ImageViewUsageCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ImageViewUsageCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ImageViewUsageCreateInfoBuilder<'a> { + #[inline] + pub fn usage(mut self, usage: ImageUsageFlags) -> Self { + self.inner.usage = usage; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ImageViewUsageCreateInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PipelineTessellationDomainOriginStateCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub domain_origin: TessellationDomainOrigin, +} +impl ::std::default::Default for PipelineTessellationDomainOriginStateCreateInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + domain_origin: TessellationDomainOrigin::default(), + } + } +} +unsafe impl TaggedStructure for PipelineTessellationDomainOriginStateCreateInfo { + const STRUCTURE_TYPE: StructureType = + StructureType::PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO; +} +impl PipelineTessellationDomainOriginStateCreateInfo { + pub fn builder<'a>() -> PipelineTessellationDomainOriginStateCreateInfoBuilder<'a> { + PipelineTessellationDomainOriginStateCreateInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PipelineTessellationDomainOriginStateCreateInfoBuilder<'a> { + inner: PipelineTessellationDomainOriginStateCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPipelineTessellationStateCreateInfo + for PipelineTessellationDomainOriginStateCreateInfoBuilder<'_> +{ +} +unsafe impl ExtendsPipelineTessellationStateCreateInfo + for PipelineTessellationDomainOriginStateCreateInfo +{ +} +impl<'a> ::std::ops::Deref for PipelineTessellationDomainOriginStateCreateInfoBuilder<'a> { + type Target = PipelineTessellationDomainOriginStateCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PipelineTessellationDomainOriginStateCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PipelineTessellationDomainOriginStateCreateInfoBuilder<'a> { + #[inline] + pub fn domain_origin(mut self, domain_origin: TessellationDomainOrigin) -> Self { + self.inner.domain_origin = domain_origin; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PipelineTessellationDomainOriginStateCreateInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SamplerYcbcrConversionInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub conversion: SamplerYcbcrConversion, +} +impl ::std::default::Default for SamplerYcbcrConversionInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + conversion: SamplerYcbcrConversion::default(), + } + } +} +unsafe impl TaggedStructure for SamplerYcbcrConversionInfo { + const STRUCTURE_TYPE: StructureType = StructureType::SAMPLER_YCBCR_CONVERSION_INFO; +} +impl SamplerYcbcrConversionInfo { + pub fn builder<'a>() -> SamplerYcbcrConversionInfoBuilder<'a> { + SamplerYcbcrConversionInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SamplerYcbcrConversionInfoBuilder<'a> { + inner: SamplerYcbcrConversionInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsSamplerCreateInfo for SamplerYcbcrConversionInfoBuilder<'_> {} +unsafe impl ExtendsSamplerCreateInfo for SamplerYcbcrConversionInfo {} +unsafe impl ExtendsImageViewCreateInfo for SamplerYcbcrConversionInfoBuilder<'_> {} +unsafe impl ExtendsImageViewCreateInfo for SamplerYcbcrConversionInfo {} +impl<'a> ::std::ops::Deref for SamplerYcbcrConversionInfoBuilder<'a> { + type Target = SamplerYcbcrConversionInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SamplerYcbcrConversionInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SamplerYcbcrConversionInfoBuilder<'a> { + #[inline] + pub fn conversion(mut self, conversion: SamplerYcbcrConversion) -> Self { + self.inner.conversion = conversion; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SamplerYcbcrConversionInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SamplerYcbcrConversionCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub format: Format, + pub ycbcr_model: SamplerYcbcrModelConversion, + pub ycbcr_range: SamplerYcbcrRange, + pub components: ComponentMapping, + pub x_chroma_offset: ChromaLocation, + pub y_chroma_offset: ChromaLocation, + pub chroma_filter: Filter, + pub force_explicit_reconstruction: Bool32, +} +impl ::std::default::Default for SamplerYcbcrConversionCreateInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + format: Format::default(), + ycbcr_model: SamplerYcbcrModelConversion::default(), + ycbcr_range: SamplerYcbcrRange::default(), + components: ComponentMapping::default(), + x_chroma_offset: ChromaLocation::default(), + y_chroma_offset: ChromaLocation::default(), + chroma_filter: Filter::default(), + force_explicit_reconstruction: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for SamplerYcbcrConversionCreateInfo { + const STRUCTURE_TYPE: StructureType = StructureType::SAMPLER_YCBCR_CONVERSION_CREATE_INFO; +} +impl SamplerYcbcrConversionCreateInfo { + pub fn builder<'a>() -> SamplerYcbcrConversionCreateInfoBuilder<'a> { + SamplerYcbcrConversionCreateInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SamplerYcbcrConversionCreateInfoBuilder<'a> { + inner: SamplerYcbcrConversionCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsSamplerYcbcrConversionCreateInfo {} +impl<'a> ::std::ops::Deref for SamplerYcbcrConversionCreateInfoBuilder<'a> { + type Target = SamplerYcbcrConversionCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SamplerYcbcrConversionCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SamplerYcbcrConversionCreateInfoBuilder<'a> { + #[inline] + pub fn format(mut self, format: Format) -> Self { + self.inner.format = format; + self + } + #[inline] + pub fn ycbcr_model(mut self, ycbcr_model: SamplerYcbcrModelConversion) -> Self { + self.inner.ycbcr_model = ycbcr_model; + self + } + #[inline] + pub fn ycbcr_range(mut self, ycbcr_range: SamplerYcbcrRange) -> Self { + self.inner.ycbcr_range = ycbcr_range; + self + } + #[inline] + pub fn components(mut self, components: ComponentMapping) -> Self { + self.inner.components = components; + self + } + #[inline] + pub fn x_chroma_offset(mut self, x_chroma_offset: ChromaLocation) -> Self { + self.inner.x_chroma_offset = x_chroma_offset; + self + } + #[inline] + pub fn y_chroma_offset(mut self, y_chroma_offset: ChromaLocation) -> Self { + self.inner.y_chroma_offset = y_chroma_offset; + self + } + #[inline] + pub fn chroma_filter(mut self, chroma_filter: Filter) -> Self { + self.inner.chroma_filter = chroma_filter; + self + } + #[inline] + pub fn force_explicit_reconstruction(mut self, force_explicit_reconstruction: bool) -> Self { + self.inner.force_explicit_reconstruction = force_explicit_reconstruction.into(); + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next( + mut self, + next: &'a mut T, + ) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SamplerYcbcrConversionCreateInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct BindImagePlaneMemoryInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub plane_aspect: ImageAspectFlags, +} +impl ::std::default::Default for BindImagePlaneMemoryInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + plane_aspect: ImageAspectFlags::default(), + } + } +} +unsafe impl TaggedStructure for BindImagePlaneMemoryInfo { + const STRUCTURE_TYPE: StructureType = StructureType::BIND_IMAGE_PLANE_MEMORY_INFO; +} +impl BindImagePlaneMemoryInfo { + pub fn builder<'a>() -> BindImagePlaneMemoryInfoBuilder<'a> { + BindImagePlaneMemoryInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct BindImagePlaneMemoryInfoBuilder<'a> { + inner: BindImagePlaneMemoryInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsBindImageMemoryInfo for BindImagePlaneMemoryInfoBuilder<'_> {} +unsafe impl ExtendsBindImageMemoryInfo for BindImagePlaneMemoryInfo {} +impl<'a> ::std::ops::Deref for BindImagePlaneMemoryInfoBuilder<'a> { + type Target = BindImagePlaneMemoryInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for BindImagePlaneMemoryInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> BindImagePlaneMemoryInfoBuilder<'a> { + #[inline] + pub fn plane_aspect(mut self, plane_aspect: ImageAspectFlags) -> Self { + self.inner.plane_aspect = plane_aspect; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> BindImagePlaneMemoryInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ImagePlaneMemoryRequirementsInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub plane_aspect: ImageAspectFlags, +} +impl ::std::default::Default for ImagePlaneMemoryRequirementsInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + plane_aspect: ImageAspectFlags::default(), + } + } +} +unsafe impl TaggedStructure for ImagePlaneMemoryRequirementsInfo { + const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO; +} +impl ImagePlaneMemoryRequirementsInfo { + pub fn builder<'a>() -> ImagePlaneMemoryRequirementsInfoBuilder<'a> { + ImagePlaneMemoryRequirementsInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ImagePlaneMemoryRequirementsInfoBuilder<'a> { + inner: ImagePlaneMemoryRequirementsInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsImageMemoryRequirementsInfo2 for ImagePlaneMemoryRequirementsInfoBuilder<'_> {} +unsafe impl ExtendsImageMemoryRequirementsInfo2 for ImagePlaneMemoryRequirementsInfo {} +impl<'a> ::std::ops::Deref for ImagePlaneMemoryRequirementsInfoBuilder<'a> { + type Target = ImagePlaneMemoryRequirementsInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ImagePlaneMemoryRequirementsInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ImagePlaneMemoryRequirementsInfoBuilder<'a> { + #[inline] + pub fn plane_aspect(mut self, plane_aspect: ImageAspectFlags) -> Self { + self.inner.plane_aspect = plane_aspect; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ImagePlaneMemoryRequirementsInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceSamplerYcbcrConversionFeatures { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub sampler_ycbcr_conversion: Bool32, +} +impl ::std::default::Default for PhysicalDeviceSamplerYcbcrConversionFeatures { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + sampler_ycbcr_conversion: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceSamplerYcbcrConversionFeatures { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES; +} +impl PhysicalDeviceSamplerYcbcrConversionFeatures { + pub fn builder<'a>() -> PhysicalDeviceSamplerYcbcrConversionFeaturesBuilder<'a> { + PhysicalDeviceSamplerYcbcrConversionFeaturesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceSamplerYcbcrConversionFeaturesBuilder<'a> { + inner: PhysicalDeviceSamplerYcbcrConversionFeatures, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceSamplerYcbcrConversionFeaturesBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceSamplerYcbcrConversionFeatures {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceSamplerYcbcrConversionFeaturesBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceSamplerYcbcrConversionFeatures {} +impl<'a> ::std::ops::Deref for PhysicalDeviceSamplerYcbcrConversionFeaturesBuilder<'a> { + type Target = PhysicalDeviceSamplerYcbcrConversionFeatures; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceSamplerYcbcrConversionFeaturesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceSamplerYcbcrConversionFeaturesBuilder<'a> { + #[inline] + pub fn sampler_ycbcr_conversion(mut self, sampler_ycbcr_conversion: bool) -> Self { + self.inner.sampler_ycbcr_conversion = sampler_ycbcr_conversion.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceSamplerYcbcrConversionFeatures { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SamplerYcbcrConversionImageFormatProperties { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub combined_image_sampler_descriptor_count: u32, +} +impl ::std::default::Default for SamplerYcbcrConversionImageFormatProperties { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + combined_image_sampler_descriptor_count: u32::default(), + } + } +} +unsafe impl TaggedStructure for SamplerYcbcrConversionImageFormatProperties { + const STRUCTURE_TYPE: StructureType = + StructureType::SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES; +} +impl SamplerYcbcrConversionImageFormatProperties { + pub fn builder<'a>() -> SamplerYcbcrConversionImageFormatPropertiesBuilder<'a> { + SamplerYcbcrConversionImageFormatPropertiesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SamplerYcbcrConversionImageFormatPropertiesBuilder<'a> { + inner: SamplerYcbcrConversionImageFormatProperties, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsImageFormatProperties2 + for SamplerYcbcrConversionImageFormatPropertiesBuilder<'_> +{ +} +unsafe impl ExtendsImageFormatProperties2 for SamplerYcbcrConversionImageFormatProperties {} +impl<'a> ::std::ops::Deref for SamplerYcbcrConversionImageFormatPropertiesBuilder<'a> { + type Target = SamplerYcbcrConversionImageFormatProperties; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SamplerYcbcrConversionImageFormatPropertiesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SamplerYcbcrConversionImageFormatPropertiesBuilder<'a> { + #[inline] + pub fn combined_image_sampler_descriptor_count( + mut self, + combined_image_sampler_descriptor_count: u32, + ) -> Self { + self.inner.combined_image_sampler_descriptor_count = + combined_image_sampler_descriptor_count; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SamplerYcbcrConversionImageFormatProperties { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct TextureLODGatherFormatPropertiesAMD { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub supports_texture_gather_lod_bias_amd: Bool32, +} +impl ::std::default::Default for TextureLODGatherFormatPropertiesAMD { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + supports_texture_gather_lod_bias_amd: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for TextureLODGatherFormatPropertiesAMD { + const STRUCTURE_TYPE: StructureType = StructureType::TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD; +} +impl TextureLODGatherFormatPropertiesAMD { + pub fn builder<'a>() -> TextureLODGatherFormatPropertiesAMDBuilder<'a> { + TextureLODGatherFormatPropertiesAMDBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct TextureLODGatherFormatPropertiesAMDBuilder<'a> { + inner: TextureLODGatherFormatPropertiesAMD, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsImageFormatProperties2 for TextureLODGatherFormatPropertiesAMDBuilder<'_> {} +unsafe impl ExtendsImageFormatProperties2 for TextureLODGatherFormatPropertiesAMD {} +impl<'a> ::std::ops::Deref for TextureLODGatherFormatPropertiesAMDBuilder<'a> { + type Target = TextureLODGatherFormatPropertiesAMD; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for TextureLODGatherFormatPropertiesAMDBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> TextureLODGatherFormatPropertiesAMDBuilder<'a> { + #[inline] + pub fn supports_texture_gather_lod_bias_amd( + mut self, + supports_texture_gather_lod_bias_amd: bool, + ) -> Self { + self.inner.supports_texture_gather_lod_bias_amd = + supports_texture_gather_lod_bias_amd.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> TextureLODGatherFormatPropertiesAMD { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ConditionalRenderingBeginInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub buffer: Buffer, + pub offset: DeviceSize, + pub flags: ConditionalRenderingFlagsEXT, +} +impl ::std::default::Default for ConditionalRenderingBeginInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + buffer: Buffer::default(), + offset: DeviceSize::default(), + flags: ConditionalRenderingFlagsEXT::default(), + } + } +} +unsafe impl TaggedStructure for ConditionalRenderingBeginInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::CONDITIONAL_RENDERING_BEGIN_INFO_EXT; +} +impl ConditionalRenderingBeginInfoEXT { + pub fn builder<'a>() -> ConditionalRenderingBeginInfoEXTBuilder<'a> { + ConditionalRenderingBeginInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ConditionalRenderingBeginInfoEXTBuilder<'a> { + inner: ConditionalRenderingBeginInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ConditionalRenderingBeginInfoEXTBuilder<'a> { + type Target = ConditionalRenderingBeginInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ConditionalRenderingBeginInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ConditionalRenderingBeginInfoEXTBuilder<'a> { + #[inline] + pub fn buffer(mut self, buffer: Buffer) -> Self { + self.inner.buffer = buffer; + self + } + #[inline] + pub fn offset(mut self, offset: DeviceSize) -> Self { + self.inner.offset = offset; + self + } + #[inline] + pub fn flags(mut self, flags: ConditionalRenderingFlagsEXT) -> Self { + self.inner.flags = flags; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ConditionalRenderingBeginInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ProtectedSubmitInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub protected_submit: Bool32, +} +impl ::std::default::Default for ProtectedSubmitInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + protected_submit: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for ProtectedSubmitInfo { + const STRUCTURE_TYPE: StructureType = StructureType::PROTECTED_SUBMIT_INFO; +} +impl ProtectedSubmitInfo { + pub fn builder<'a>() -> ProtectedSubmitInfoBuilder<'a> { + ProtectedSubmitInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ProtectedSubmitInfoBuilder<'a> { + inner: ProtectedSubmitInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsSubmitInfo for ProtectedSubmitInfoBuilder<'_> {} +unsafe impl ExtendsSubmitInfo for ProtectedSubmitInfo {} +impl<'a> ::std::ops::Deref for ProtectedSubmitInfoBuilder<'a> { + type Target = ProtectedSubmitInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ProtectedSubmitInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ProtectedSubmitInfoBuilder<'a> { + #[inline] + pub fn protected_submit(mut self, protected_submit: bool) -> Self { + self.inner.protected_submit = protected_submit.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ProtectedSubmitInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceProtectedMemoryFeatures { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub protected_memory: Bool32, +} +impl ::std::default::Default for PhysicalDeviceProtectedMemoryFeatures { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + protected_memory: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceProtectedMemoryFeatures { + const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES; +} +impl PhysicalDeviceProtectedMemoryFeatures { + pub fn builder<'a>() -> PhysicalDeviceProtectedMemoryFeaturesBuilder<'a> { + PhysicalDeviceProtectedMemoryFeaturesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceProtectedMemoryFeaturesBuilder<'a> { + inner: PhysicalDeviceProtectedMemoryFeatures, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceProtectedMemoryFeaturesBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceProtectedMemoryFeatures {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceProtectedMemoryFeaturesBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceProtectedMemoryFeatures {} +impl<'a> ::std::ops::Deref for PhysicalDeviceProtectedMemoryFeaturesBuilder<'a> { + type Target = PhysicalDeviceProtectedMemoryFeatures; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceProtectedMemoryFeaturesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceProtectedMemoryFeaturesBuilder<'a> { + #[inline] + pub fn protected_memory(mut self, protected_memory: bool) -> Self { + self.inner.protected_memory = protected_memory.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceProtectedMemoryFeatures { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceProtectedMemoryProperties { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub protected_no_fault: Bool32, +} +impl ::std::default::Default for PhysicalDeviceProtectedMemoryProperties { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + protected_no_fault: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceProtectedMemoryProperties { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES; +} +impl PhysicalDeviceProtectedMemoryProperties { + pub fn builder<'a>() -> PhysicalDeviceProtectedMemoryPropertiesBuilder<'a> { + PhysicalDeviceProtectedMemoryPropertiesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceProtectedMemoryPropertiesBuilder<'a> { + inner: PhysicalDeviceProtectedMemoryProperties, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceProtectedMemoryPropertiesBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceProtectedMemoryProperties {} +impl<'a> ::std::ops::Deref for PhysicalDeviceProtectedMemoryPropertiesBuilder<'a> { + type Target = PhysicalDeviceProtectedMemoryProperties; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceProtectedMemoryPropertiesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceProtectedMemoryPropertiesBuilder<'a> { + #[inline] + pub fn protected_no_fault(mut self, protected_no_fault: bool) -> Self { + self.inner.protected_no_fault = protected_no_fault.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceProtectedMemoryProperties { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DeviceQueueInfo2 { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: DeviceQueueCreateFlags, + pub queue_family_index: u32, + pub queue_index: u32, +} +impl ::std::default::Default for DeviceQueueInfo2 { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: DeviceQueueCreateFlags::default(), + queue_family_index: u32::default(), + queue_index: u32::default(), + } + } +} +unsafe impl TaggedStructure for DeviceQueueInfo2 { + const STRUCTURE_TYPE: StructureType = StructureType::DEVICE_QUEUE_INFO_2; +} +impl DeviceQueueInfo2 { + pub fn builder<'a>() -> DeviceQueueInfo2Builder<'a> { + DeviceQueueInfo2Builder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DeviceQueueInfo2Builder<'a> { + inner: DeviceQueueInfo2, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DeviceQueueInfo2Builder<'a> { + type Target = DeviceQueueInfo2; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DeviceQueueInfo2Builder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DeviceQueueInfo2Builder<'a> { + #[inline] + pub fn flags(mut self, flags: DeviceQueueCreateFlags) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn queue_family_index(mut self, queue_family_index: u32) -> Self { + self.inner.queue_family_index = queue_family_index; + self + } + #[inline] + pub fn queue_index(mut self, queue_index: u32) -> Self { + self.inner.queue_index = queue_index; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DeviceQueueInfo2 { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PipelineCoverageToColorStateCreateInfoNV { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: PipelineCoverageToColorStateCreateFlagsNV, + pub coverage_to_color_enable: Bool32, + pub coverage_to_color_location: u32, +} +impl ::std::default::Default for PipelineCoverageToColorStateCreateInfoNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: PipelineCoverageToColorStateCreateFlagsNV::default(), + coverage_to_color_enable: Bool32::default(), + coverage_to_color_location: u32::default(), + } + } +} +unsafe impl TaggedStructure for PipelineCoverageToColorStateCreateInfoNV { + const STRUCTURE_TYPE: StructureType = + StructureType::PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV; +} +impl PipelineCoverageToColorStateCreateInfoNV { + pub fn builder<'a>() -> PipelineCoverageToColorStateCreateInfoNVBuilder<'a> { + PipelineCoverageToColorStateCreateInfoNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PipelineCoverageToColorStateCreateInfoNVBuilder<'a> { + inner: PipelineCoverageToColorStateCreateInfoNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPipelineMultisampleStateCreateInfo + for PipelineCoverageToColorStateCreateInfoNVBuilder<'_> +{ +} +unsafe impl ExtendsPipelineMultisampleStateCreateInfo for PipelineCoverageToColorStateCreateInfoNV {} +impl<'a> ::std::ops::Deref for PipelineCoverageToColorStateCreateInfoNVBuilder<'a> { + type Target = PipelineCoverageToColorStateCreateInfoNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PipelineCoverageToColorStateCreateInfoNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PipelineCoverageToColorStateCreateInfoNVBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: PipelineCoverageToColorStateCreateFlagsNV) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn coverage_to_color_enable(mut self, coverage_to_color_enable: bool) -> Self { + self.inner.coverage_to_color_enable = coverage_to_color_enable.into(); + self + } + #[inline] + pub fn coverage_to_color_location(mut self, coverage_to_color_location: u32) -> Self { + self.inner.coverage_to_color_location = coverage_to_color_location; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PipelineCoverageToColorStateCreateInfoNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceSamplerFilterMinmaxProperties { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub filter_minmax_single_component_formats: Bool32, + pub filter_minmax_image_component_mapping: Bool32, +} +impl ::std::default::Default for PhysicalDeviceSamplerFilterMinmaxProperties { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + filter_minmax_single_component_formats: Bool32::default(), + filter_minmax_image_component_mapping: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceSamplerFilterMinmaxProperties { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES; +} +impl PhysicalDeviceSamplerFilterMinmaxProperties { + pub fn builder<'a>() -> PhysicalDeviceSamplerFilterMinmaxPropertiesBuilder<'a> { + PhysicalDeviceSamplerFilterMinmaxPropertiesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceSamplerFilterMinmaxPropertiesBuilder<'a> { + inner: PhysicalDeviceSamplerFilterMinmaxProperties, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceSamplerFilterMinmaxPropertiesBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceSamplerFilterMinmaxProperties {} +impl<'a> ::std::ops::Deref for PhysicalDeviceSamplerFilterMinmaxPropertiesBuilder<'a> { + type Target = PhysicalDeviceSamplerFilterMinmaxProperties; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceSamplerFilterMinmaxPropertiesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceSamplerFilterMinmaxPropertiesBuilder<'a> { + #[inline] + pub fn filter_minmax_single_component_formats( + mut self, + filter_minmax_single_component_formats: bool, + ) -> Self { + self.inner.filter_minmax_single_component_formats = + filter_minmax_single_component_formats.into(); + self + } + #[inline] + pub fn filter_minmax_image_component_mapping( + mut self, + filter_minmax_image_component_mapping: bool, + ) -> Self { + self.inner.filter_minmax_image_component_mapping = + filter_minmax_image_component_mapping.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceSamplerFilterMinmaxProperties { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct SampleLocationEXT { + pub x: f32, + pub y: f32, +} +impl SampleLocationEXT { + pub fn builder<'a>() -> SampleLocationEXTBuilder<'a> { + SampleLocationEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SampleLocationEXTBuilder<'a> { + inner: SampleLocationEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for SampleLocationEXTBuilder<'a> { + type Target = SampleLocationEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SampleLocationEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SampleLocationEXTBuilder<'a> { + #[inline] + pub fn x(mut self, x: f32) -> Self { + self.inner.x = x; + self + } + #[inline] + pub fn y(mut self, y: f32) -> Self { + self.inner.y = y; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SampleLocationEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SampleLocationsInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub sample_locations_per_pixel: SampleCountFlags, + pub sample_location_grid_size: Extent2D, + pub sample_locations_count: u32, + pub p_sample_locations: *const SampleLocationEXT, +} +impl ::std::default::Default for SampleLocationsInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + sample_locations_per_pixel: SampleCountFlags::default(), + sample_location_grid_size: Extent2D::default(), + sample_locations_count: u32::default(), + p_sample_locations: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for SampleLocationsInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::SAMPLE_LOCATIONS_INFO_EXT; +} +impl SampleLocationsInfoEXT { + pub fn builder<'a>() -> SampleLocationsInfoEXTBuilder<'a> { + SampleLocationsInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SampleLocationsInfoEXTBuilder<'a> { + inner: SampleLocationsInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsImageMemoryBarrier for SampleLocationsInfoEXTBuilder<'_> {} +unsafe impl ExtendsImageMemoryBarrier for SampleLocationsInfoEXT {} +unsafe impl ExtendsImageMemoryBarrier2 for SampleLocationsInfoEXTBuilder<'_> {} +unsafe impl ExtendsImageMemoryBarrier2 for SampleLocationsInfoEXT {} +impl<'a> ::std::ops::Deref for SampleLocationsInfoEXTBuilder<'a> { + type Target = SampleLocationsInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SampleLocationsInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SampleLocationsInfoEXTBuilder<'a> { + #[inline] + pub fn sample_locations_per_pixel( + mut self, + sample_locations_per_pixel: SampleCountFlags, + ) -> Self { + self.inner.sample_locations_per_pixel = sample_locations_per_pixel; + self + } + #[inline] + pub fn sample_location_grid_size(mut self, sample_location_grid_size: Extent2D) -> Self { + self.inner.sample_location_grid_size = sample_location_grid_size; + self + } + #[inline] + pub fn sample_locations(mut self, sample_locations: &'a [SampleLocationEXT]) -> Self { + self.inner.sample_locations_count = sample_locations.len() as _; + self.inner.p_sample_locations = sample_locations.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SampleLocationsInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct AttachmentSampleLocationsEXT { + pub attachment_index: u32, + pub sample_locations_info: SampleLocationsInfoEXT, +} +impl AttachmentSampleLocationsEXT { + pub fn builder<'a>() -> AttachmentSampleLocationsEXTBuilder<'a> { + AttachmentSampleLocationsEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct AttachmentSampleLocationsEXTBuilder<'a> { + inner: AttachmentSampleLocationsEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for AttachmentSampleLocationsEXTBuilder<'a> { + type Target = AttachmentSampleLocationsEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for AttachmentSampleLocationsEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> AttachmentSampleLocationsEXTBuilder<'a> { + #[inline] + pub fn attachment_index(mut self, attachment_index: u32) -> Self { + self.inner.attachment_index = attachment_index; + self + } + #[inline] + pub fn sample_locations_info(mut self, sample_locations_info: SampleLocationsInfoEXT) -> Self { + self.inner.sample_locations_info = sample_locations_info; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> AttachmentSampleLocationsEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct SubpassSampleLocationsEXT { + pub subpass_index: u32, + pub sample_locations_info: SampleLocationsInfoEXT, +} +impl SubpassSampleLocationsEXT { + pub fn builder<'a>() -> SubpassSampleLocationsEXTBuilder<'a> { + SubpassSampleLocationsEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SubpassSampleLocationsEXTBuilder<'a> { + inner: SubpassSampleLocationsEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for SubpassSampleLocationsEXTBuilder<'a> { + type Target = SubpassSampleLocationsEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SubpassSampleLocationsEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SubpassSampleLocationsEXTBuilder<'a> { + #[inline] + pub fn subpass_index(mut self, subpass_index: u32) -> Self { + self.inner.subpass_index = subpass_index; + self + } + #[inline] + pub fn sample_locations_info(mut self, sample_locations_info: SampleLocationsInfoEXT) -> Self { + self.inner.sample_locations_info = sample_locations_info; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SubpassSampleLocationsEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct RenderPassSampleLocationsBeginInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub attachment_initial_sample_locations_count: u32, + pub p_attachment_initial_sample_locations: *const AttachmentSampleLocationsEXT, + pub post_subpass_sample_locations_count: u32, + pub p_post_subpass_sample_locations: *const SubpassSampleLocationsEXT, +} +impl ::std::default::Default for RenderPassSampleLocationsBeginInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + attachment_initial_sample_locations_count: u32::default(), + p_attachment_initial_sample_locations: ::std::ptr::null(), + post_subpass_sample_locations_count: u32::default(), + p_post_subpass_sample_locations: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for RenderPassSampleLocationsBeginInfoEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT; +} +impl RenderPassSampleLocationsBeginInfoEXT { + pub fn builder<'a>() -> RenderPassSampleLocationsBeginInfoEXTBuilder<'a> { + RenderPassSampleLocationsBeginInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct RenderPassSampleLocationsBeginInfoEXTBuilder<'a> { + inner: RenderPassSampleLocationsBeginInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsRenderPassBeginInfo for RenderPassSampleLocationsBeginInfoEXTBuilder<'_> {} +unsafe impl ExtendsRenderPassBeginInfo for RenderPassSampleLocationsBeginInfoEXT {} +impl<'a> ::std::ops::Deref for RenderPassSampleLocationsBeginInfoEXTBuilder<'a> { + type Target = RenderPassSampleLocationsBeginInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for RenderPassSampleLocationsBeginInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> RenderPassSampleLocationsBeginInfoEXTBuilder<'a> { + #[inline] + pub fn attachment_initial_sample_locations( + mut self, + attachment_initial_sample_locations: &'a [AttachmentSampleLocationsEXT], + ) -> Self { + self.inner.attachment_initial_sample_locations_count = + attachment_initial_sample_locations.len() as _; + self.inner.p_attachment_initial_sample_locations = + attachment_initial_sample_locations.as_ptr(); + self + } + #[inline] + pub fn post_subpass_sample_locations( + mut self, + post_subpass_sample_locations: &'a [SubpassSampleLocationsEXT], + ) -> Self { + self.inner.post_subpass_sample_locations_count = post_subpass_sample_locations.len() as _; + self.inner.p_post_subpass_sample_locations = post_subpass_sample_locations.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> RenderPassSampleLocationsBeginInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PipelineSampleLocationsStateCreateInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub sample_locations_enable: Bool32, + pub sample_locations_info: SampleLocationsInfoEXT, +} +impl ::std::default::Default for PipelineSampleLocationsStateCreateInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + sample_locations_enable: Bool32::default(), + sample_locations_info: SampleLocationsInfoEXT::default(), + } + } +} +unsafe impl TaggedStructure for PipelineSampleLocationsStateCreateInfoEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT; +} +impl PipelineSampleLocationsStateCreateInfoEXT { + pub fn builder<'a>() -> PipelineSampleLocationsStateCreateInfoEXTBuilder<'a> { + PipelineSampleLocationsStateCreateInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PipelineSampleLocationsStateCreateInfoEXTBuilder<'a> { + inner: PipelineSampleLocationsStateCreateInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPipelineMultisampleStateCreateInfo + for PipelineSampleLocationsStateCreateInfoEXTBuilder<'_> +{ +} +unsafe impl ExtendsPipelineMultisampleStateCreateInfo + for PipelineSampleLocationsStateCreateInfoEXT +{ +} +impl<'a> ::std::ops::Deref for PipelineSampleLocationsStateCreateInfoEXTBuilder<'a> { + type Target = PipelineSampleLocationsStateCreateInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PipelineSampleLocationsStateCreateInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PipelineSampleLocationsStateCreateInfoEXTBuilder<'a> { + #[inline] + pub fn sample_locations_enable(mut self, sample_locations_enable: bool) -> Self { + self.inner.sample_locations_enable = sample_locations_enable.into(); + self + } + #[inline] + pub fn sample_locations_info(mut self, sample_locations_info: SampleLocationsInfoEXT) -> Self { + self.inner.sample_locations_info = sample_locations_info; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PipelineSampleLocationsStateCreateInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceSampleLocationsPropertiesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub sample_location_sample_counts: SampleCountFlags, + pub max_sample_location_grid_size: Extent2D, + pub sample_location_coordinate_range: [f32; 2], + pub sample_location_sub_pixel_bits: u32, + pub variable_sample_locations: Bool32, +} +impl ::std::default::Default for PhysicalDeviceSampleLocationsPropertiesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + sample_location_sample_counts: SampleCountFlags::default(), + max_sample_location_grid_size: Extent2D::default(), + sample_location_coordinate_range: unsafe { ::std::mem::zeroed() }, + sample_location_sub_pixel_bits: u32::default(), + variable_sample_locations: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceSampleLocationsPropertiesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT; +} +impl PhysicalDeviceSampleLocationsPropertiesEXT { + pub fn builder<'a>() -> PhysicalDeviceSampleLocationsPropertiesEXTBuilder<'a> { + PhysicalDeviceSampleLocationsPropertiesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceSampleLocationsPropertiesEXTBuilder<'a> { + inner: PhysicalDeviceSampleLocationsPropertiesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceSampleLocationsPropertiesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceSampleLocationsPropertiesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceSampleLocationsPropertiesEXTBuilder<'a> { + type Target = PhysicalDeviceSampleLocationsPropertiesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceSampleLocationsPropertiesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceSampleLocationsPropertiesEXTBuilder<'a> { + #[inline] + pub fn sample_location_sample_counts( + mut self, + sample_location_sample_counts: SampleCountFlags, + ) -> Self { + self.inner.sample_location_sample_counts = sample_location_sample_counts; + self + } + #[inline] + pub fn max_sample_location_grid_size( + mut self, + max_sample_location_grid_size: Extent2D, + ) -> Self { + self.inner.max_sample_location_grid_size = max_sample_location_grid_size; + self + } + #[inline] + pub fn sample_location_coordinate_range( + mut self, + sample_location_coordinate_range: [f32; 2], + ) -> Self { + self.inner.sample_location_coordinate_range = sample_location_coordinate_range; + self + } + #[inline] + pub fn sample_location_sub_pixel_bits(mut self, sample_location_sub_pixel_bits: u32) -> Self { + self.inner.sample_location_sub_pixel_bits = sample_location_sub_pixel_bits; + self + } + #[inline] + pub fn variable_sample_locations(mut self, variable_sample_locations: bool) -> Self { + self.inner.variable_sample_locations = variable_sample_locations.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceSampleLocationsPropertiesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct MultisamplePropertiesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub max_sample_location_grid_size: Extent2D, +} +impl ::std::default::Default for MultisamplePropertiesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + max_sample_location_grid_size: Extent2D::default(), + } + } +} +unsafe impl TaggedStructure for MultisamplePropertiesEXT { + const STRUCTURE_TYPE: StructureType = StructureType::MULTISAMPLE_PROPERTIES_EXT; +} +impl MultisamplePropertiesEXT { + pub fn builder<'a>() -> MultisamplePropertiesEXTBuilder<'a> { + MultisamplePropertiesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct MultisamplePropertiesEXTBuilder<'a> { + inner: MultisamplePropertiesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for MultisamplePropertiesEXTBuilder<'a> { + type Target = MultisamplePropertiesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for MultisamplePropertiesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> MultisamplePropertiesEXTBuilder<'a> { + #[inline] + pub fn max_sample_location_grid_size( + mut self, + max_sample_location_grid_size: Extent2D, + ) -> Self { + self.inner.max_sample_location_grid_size = max_sample_location_grid_size; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> MultisamplePropertiesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SamplerReductionModeCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub reduction_mode: SamplerReductionMode, +} +impl ::std::default::Default for SamplerReductionModeCreateInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + reduction_mode: SamplerReductionMode::default(), + } + } +} +unsafe impl TaggedStructure for SamplerReductionModeCreateInfo { + const STRUCTURE_TYPE: StructureType = StructureType::SAMPLER_REDUCTION_MODE_CREATE_INFO; +} +impl SamplerReductionModeCreateInfo { + pub fn builder<'a>() -> SamplerReductionModeCreateInfoBuilder<'a> { + SamplerReductionModeCreateInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SamplerReductionModeCreateInfoBuilder<'a> { + inner: SamplerReductionModeCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsSamplerCreateInfo for SamplerReductionModeCreateInfoBuilder<'_> {} +unsafe impl ExtendsSamplerCreateInfo for SamplerReductionModeCreateInfo {} +impl<'a> ::std::ops::Deref for SamplerReductionModeCreateInfoBuilder<'a> { + type Target = SamplerReductionModeCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SamplerReductionModeCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SamplerReductionModeCreateInfoBuilder<'a> { + #[inline] + pub fn reduction_mode(mut self, reduction_mode: SamplerReductionMode) -> Self { + self.inner.reduction_mode = reduction_mode; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SamplerReductionModeCreateInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceBlendOperationAdvancedFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub advanced_blend_coherent_operations: Bool32, +} +impl ::std::default::Default for PhysicalDeviceBlendOperationAdvancedFeaturesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + advanced_blend_coherent_operations: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceBlendOperationAdvancedFeaturesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT; +} +impl PhysicalDeviceBlendOperationAdvancedFeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceBlendOperationAdvancedFeaturesEXTBuilder<'a> { + PhysicalDeviceBlendOperationAdvancedFeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceBlendOperationAdvancedFeaturesEXTBuilder<'a> { + inner: PhysicalDeviceBlendOperationAdvancedFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceBlendOperationAdvancedFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceBlendOperationAdvancedFeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceBlendOperationAdvancedFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceBlendOperationAdvancedFeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceBlendOperationAdvancedFeaturesEXTBuilder<'a> { + type Target = PhysicalDeviceBlendOperationAdvancedFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceBlendOperationAdvancedFeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceBlendOperationAdvancedFeaturesEXTBuilder<'a> { + #[inline] + pub fn advanced_blend_coherent_operations( + mut self, + advanced_blend_coherent_operations: bool, + ) -> Self { + self.inner.advanced_blend_coherent_operations = advanced_blend_coherent_operations.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceBlendOperationAdvancedFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceMultiDrawFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub multi_draw: Bool32, +} +impl ::std::default::Default for PhysicalDeviceMultiDrawFeaturesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + multi_draw: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceMultiDrawFeaturesEXT { + const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT; +} +impl PhysicalDeviceMultiDrawFeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceMultiDrawFeaturesEXTBuilder<'a> { + PhysicalDeviceMultiDrawFeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceMultiDrawFeaturesEXTBuilder<'a> { + inner: PhysicalDeviceMultiDrawFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceMultiDrawFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceMultiDrawFeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMultiDrawFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMultiDrawFeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceMultiDrawFeaturesEXTBuilder<'a> { + type Target = PhysicalDeviceMultiDrawFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceMultiDrawFeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceMultiDrawFeaturesEXTBuilder<'a> { + #[inline] + pub fn multi_draw(mut self, multi_draw: bool) -> Self { + self.inner.multi_draw = multi_draw.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceMultiDrawFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceBlendOperationAdvancedPropertiesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub advanced_blend_max_color_attachments: u32, + pub advanced_blend_independent_blend: Bool32, + pub advanced_blend_non_premultiplied_src_color: Bool32, + pub advanced_blend_non_premultiplied_dst_color: Bool32, + pub advanced_blend_correlated_overlap: Bool32, + pub advanced_blend_all_operations: Bool32, +} +impl ::std::default::Default for PhysicalDeviceBlendOperationAdvancedPropertiesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + advanced_blend_max_color_attachments: u32::default(), + advanced_blend_independent_blend: Bool32::default(), + advanced_blend_non_premultiplied_src_color: Bool32::default(), + advanced_blend_non_premultiplied_dst_color: Bool32::default(), + advanced_blend_correlated_overlap: Bool32::default(), + advanced_blend_all_operations: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceBlendOperationAdvancedPropertiesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT; +} +impl PhysicalDeviceBlendOperationAdvancedPropertiesEXT { + pub fn builder<'a>() -> PhysicalDeviceBlendOperationAdvancedPropertiesEXTBuilder<'a> { + PhysicalDeviceBlendOperationAdvancedPropertiesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceBlendOperationAdvancedPropertiesEXTBuilder<'a> { + inner: PhysicalDeviceBlendOperationAdvancedPropertiesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceBlendOperationAdvancedPropertiesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceBlendOperationAdvancedPropertiesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceBlendOperationAdvancedPropertiesEXTBuilder<'a> { + type Target = PhysicalDeviceBlendOperationAdvancedPropertiesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceBlendOperationAdvancedPropertiesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceBlendOperationAdvancedPropertiesEXTBuilder<'a> { + #[inline] + pub fn advanced_blend_max_color_attachments( + mut self, + advanced_blend_max_color_attachments: u32, + ) -> Self { + self.inner.advanced_blend_max_color_attachments = advanced_blend_max_color_attachments; + self + } + #[inline] + pub fn advanced_blend_independent_blend( + mut self, + advanced_blend_independent_blend: bool, + ) -> Self { + self.inner.advanced_blend_independent_blend = advanced_blend_independent_blend.into(); + self + } + #[inline] + pub fn advanced_blend_non_premultiplied_src_color( + mut self, + advanced_blend_non_premultiplied_src_color: bool, + ) -> Self { + self.inner.advanced_blend_non_premultiplied_src_color = + advanced_blend_non_premultiplied_src_color.into(); + self + } + #[inline] + pub fn advanced_blend_non_premultiplied_dst_color( + mut self, + advanced_blend_non_premultiplied_dst_color: bool, + ) -> Self { + self.inner.advanced_blend_non_premultiplied_dst_color = + advanced_blend_non_premultiplied_dst_color.into(); + self + } + #[inline] + pub fn advanced_blend_correlated_overlap( + mut self, + advanced_blend_correlated_overlap: bool, + ) -> Self { + self.inner.advanced_blend_correlated_overlap = advanced_blend_correlated_overlap.into(); + self + } + #[inline] + pub fn advanced_blend_all_operations(mut self, advanced_blend_all_operations: bool) -> Self { + self.inner.advanced_blend_all_operations = advanced_blend_all_operations.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceBlendOperationAdvancedPropertiesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PipelineColorBlendAdvancedStateCreateInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub src_premultiplied: Bool32, + pub dst_premultiplied: Bool32, + pub blend_overlap: BlendOverlapEXT, +} +impl ::std::default::Default for PipelineColorBlendAdvancedStateCreateInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + src_premultiplied: Bool32::default(), + dst_premultiplied: Bool32::default(), + blend_overlap: BlendOverlapEXT::default(), + } + } +} +unsafe impl TaggedStructure for PipelineColorBlendAdvancedStateCreateInfoEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT; +} +impl PipelineColorBlendAdvancedStateCreateInfoEXT { + pub fn builder<'a>() -> PipelineColorBlendAdvancedStateCreateInfoEXTBuilder<'a> { + PipelineColorBlendAdvancedStateCreateInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PipelineColorBlendAdvancedStateCreateInfoEXTBuilder<'a> { + inner: PipelineColorBlendAdvancedStateCreateInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPipelineColorBlendStateCreateInfo + for PipelineColorBlendAdvancedStateCreateInfoEXTBuilder<'_> +{ +} +unsafe impl ExtendsPipelineColorBlendStateCreateInfo + for PipelineColorBlendAdvancedStateCreateInfoEXT +{ +} +impl<'a> ::std::ops::Deref for PipelineColorBlendAdvancedStateCreateInfoEXTBuilder<'a> { + type Target = PipelineColorBlendAdvancedStateCreateInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PipelineColorBlendAdvancedStateCreateInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PipelineColorBlendAdvancedStateCreateInfoEXTBuilder<'a> { + #[inline] + pub fn src_premultiplied(mut self, src_premultiplied: bool) -> Self { + self.inner.src_premultiplied = src_premultiplied.into(); + self + } + #[inline] + pub fn dst_premultiplied(mut self, dst_premultiplied: bool) -> Self { + self.inner.dst_premultiplied = dst_premultiplied.into(); + self + } + #[inline] + pub fn blend_overlap(mut self, blend_overlap: BlendOverlapEXT) -> Self { + self.inner.blend_overlap = blend_overlap; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PipelineColorBlendAdvancedStateCreateInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceInlineUniformBlockFeatures { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub inline_uniform_block: Bool32, + pub descriptor_binding_inline_uniform_block_update_after_bind: Bool32, +} +impl ::std::default::Default for PhysicalDeviceInlineUniformBlockFeatures { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + inline_uniform_block: Bool32::default(), + descriptor_binding_inline_uniform_block_update_after_bind: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceInlineUniformBlockFeatures { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES; +} +impl PhysicalDeviceInlineUniformBlockFeatures { + pub fn builder<'a>() -> PhysicalDeviceInlineUniformBlockFeaturesBuilder<'a> { + PhysicalDeviceInlineUniformBlockFeaturesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceInlineUniformBlockFeaturesBuilder<'a> { + inner: PhysicalDeviceInlineUniformBlockFeatures, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceInlineUniformBlockFeaturesBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceInlineUniformBlockFeatures {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceInlineUniformBlockFeaturesBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceInlineUniformBlockFeatures {} +impl<'a> ::std::ops::Deref for PhysicalDeviceInlineUniformBlockFeaturesBuilder<'a> { + type Target = PhysicalDeviceInlineUniformBlockFeatures; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceInlineUniformBlockFeaturesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceInlineUniformBlockFeaturesBuilder<'a> { + #[inline] + pub fn inline_uniform_block(mut self, inline_uniform_block: bool) -> Self { + self.inner.inline_uniform_block = inline_uniform_block.into(); + self + } + #[inline] + pub fn descriptor_binding_inline_uniform_block_update_after_bind( + mut self, + descriptor_binding_inline_uniform_block_update_after_bind: bool, + ) -> Self { + self.inner + .descriptor_binding_inline_uniform_block_update_after_bind = + descriptor_binding_inline_uniform_block_update_after_bind.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceInlineUniformBlockFeatures { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceInlineUniformBlockProperties { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub max_inline_uniform_block_size: u32, + pub max_per_stage_descriptor_inline_uniform_blocks: u32, + pub max_per_stage_descriptor_update_after_bind_inline_uniform_blocks: u32, + pub max_descriptor_set_inline_uniform_blocks: u32, + pub max_descriptor_set_update_after_bind_inline_uniform_blocks: u32, +} +impl ::std::default::Default for PhysicalDeviceInlineUniformBlockProperties { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + max_inline_uniform_block_size: u32::default(), + max_per_stage_descriptor_inline_uniform_blocks: u32::default(), + max_per_stage_descriptor_update_after_bind_inline_uniform_blocks: u32::default(), + max_descriptor_set_inline_uniform_blocks: u32::default(), + max_descriptor_set_update_after_bind_inline_uniform_blocks: u32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceInlineUniformBlockProperties { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES; +} +impl PhysicalDeviceInlineUniformBlockProperties { + pub fn builder<'a>() -> PhysicalDeviceInlineUniformBlockPropertiesBuilder<'a> { + PhysicalDeviceInlineUniformBlockPropertiesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceInlineUniformBlockPropertiesBuilder<'a> { + inner: PhysicalDeviceInlineUniformBlockProperties, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceInlineUniformBlockPropertiesBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceInlineUniformBlockProperties {} +impl<'a> ::std::ops::Deref for PhysicalDeviceInlineUniformBlockPropertiesBuilder<'a> { + type Target = PhysicalDeviceInlineUniformBlockProperties; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceInlineUniformBlockPropertiesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceInlineUniformBlockPropertiesBuilder<'a> { + #[inline] + pub fn max_inline_uniform_block_size(mut self, max_inline_uniform_block_size: u32) -> Self { + self.inner.max_inline_uniform_block_size = max_inline_uniform_block_size; + self + } + #[inline] + pub fn max_per_stage_descriptor_inline_uniform_blocks( + mut self, + max_per_stage_descriptor_inline_uniform_blocks: u32, + ) -> Self { + self.inner.max_per_stage_descriptor_inline_uniform_blocks = + max_per_stage_descriptor_inline_uniform_blocks; + self + } + #[inline] + pub fn max_per_stage_descriptor_update_after_bind_inline_uniform_blocks( + mut self, + max_per_stage_descriptor_update_after_bind_inline_uniform_blocks: u32, + ) -> Self { + self.inner + .max_per_stage_descriptor_update_after_bind_inline_uniform_blocks = + max_per_stage_descriptor_update_after_bind_inline_uniform_blocks; + self + } + #[inline] + pub fn max_descriptor_set_inline_uniform_blocks( + mut self, + max_descriptor_set_inline_uniform_blocks: u32, + ) -> Self { + self.inner.max_descriptor_set_inline_uniform_blocks = + max_descriptor_set_inline_uniform_blocks; + self + } + #[inline] + pub fn max_descriptor_set_update_after_bind_inline_uniform_blocks( + mut self, + max_descriptor_set_update_after_bind_inline_uniform_blocks: u32, + ) -> Self { + self.inner + .max_descriptor_set_update_after_bind_inline_uniform_blocks = + max_descriptor_set_update_after_bind_inline_uniform_blocks; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceInlineUniformBlockProperties { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct WriteDescriptorSetInlineUniformBlock { + pub s_type: StructureType, + pub p_next: *const c_void, + pub data_size: u32, + pub p_data: *const c_void, +} +impl ::std::default::Default for WriteDescriptorSetInlineUniformBlock { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + data_size: u32::default(), + p_data: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for WriteDescriptorSetInlineUniformBlock { + const STRUCTURE_TYPE: StructureType = StructureType::WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK; +} +impl WriteDescriptorSetInlineUniformBlock { + pub fn builder<'a>() -> WriteDescriptorSetInlineUniformBlockBuilder<'a> { + WriteDescriptorSetInlineUniformBlockBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct WriteDescriptorSetInlineUniformBlockBuilder<'a> { + inner: WriteDescriptorSetInlineUniformBlock, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsWriteDescriptorSet for WriteDescriptorSetInlineUniformBlockBuilder<'_> {} +unsafe impl ExtendsWriteDescriptorSet for WriteDescriptorSetInlineUniformBlock {} +impl<'a> ::std::ops::Deref for WriteDescriptorSetInlineUniformBlockBuilder<'a> { + type Target = WriteDescriptorSetInlineUniformBlock; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for WriteDescriptorSetInlineUniformBlockBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> WriteDescriptorSetInlineUniformBlockBuilder<'a> { + #[inline] + pub fn data(mut self, data: &'a [u8]) -> Self { + self.inner.data_size = data.len() as _; + self.inner.p_data = data.as_ptr().cast(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> WriteDescriptorSetInlineUniformBlock { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DescriptorPoolInlineUniformBlockCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub max_inline_uniform_block_bindings: u32, +} +impl ::std::default::Default for DescriptorPoolInlineUniformBlockCreateInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + max_inline_uniform_block_bindings: u32::default(), + } + } +} +unsafe impl TaggedStructure for DescriptorPoolInlineUniformBlockCreateInfo { + const STRUCTURE_TYPE: StructureType = + StructureType::DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO; +} +impl DescriptorPoolInlineUniformBlockCreateInfo { + pub fn builder<'a>() -> DescriptorPoolInlineUniformBlockCreateInfoBuilder<'a> { + DescriptorPoolInlineUniformBlockCreateInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DescriptorPoolInlineUniformBlockCreateInfoBuilder<'a> { + inner: DescriptorPoolInlineUniformBlockCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsDescriptorPoolCreateInfo + for DescriptorPoolInlineUniformBlockCreateInfoBuilder<'_> +{ +} +unsafe impl ExtendsDescriptorPoolCreateInfo for DescriptorPoolInlineUniformBlockCreateInfo {} +impl<'a> ::std::ops::Deref for DescriptorPoolInlineUniformBlockCreateInfoBuilder<'a> { + type Target = DescriptorPoolInlineUniformBlockCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DescriptorPoolInlineUniformBlockCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DescriptorPoolInlineUniformBlockCreateInfoBuilder<'a> { + #[inline] + pub fn max_inline_uniform_block_bindings( + mut self, + max_inline_uniform_block_bindings: u32, + ) -> Self { + self.inner.max_inline_uniform_block_bindings = max_inline_uniform_block_bindings; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DescriptorPoolInlineUniformBlockCreateInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PipelineCoverageModulationStateCreateInfoNV { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: PipelineCoverageModulationStateCreateFlagsNV, + pub coverage_modulation_mode: CoverageModulationModeNV, + pub coverage_modulation_table_enable: Bool32, + pub coverage_modulation_table_count: u32, + pub p_coverage_modulation_table: *const f32, +} +impl ::std::default::Default for PipelineCoverageModulationStateCreateInfoNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: PipelineCoverageModulationStateCreateFlagsNV::default(), + coverage_modulation_mode: CoverageModulationModeNV::default(), + coverage_modulation_table_enable: Bool32::default(), + coverage_modulation_table_count: u32::default(), + p_coverage_modulation_table: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for PipelineCoverageModulationStateCreateInfoNV { + const STRUCTURE_TYPE: StructureType = + StructureType::PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV; +} +impl PipelineCoverageModulationStateCreateInfoNV { + pub fn builder<'a>() -> PipelineCoverageModulationStateCreateInfoNVBuilder<'a> { + PipelineCoverageModulationStateCreateInfoNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PipelineCoverageModulationStateCreateInfoNVBuilder<'a> { + inner: PipelineCoverageModulationStateCreateInfoNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPipelineMultisampleStateCreateInfo + for PipelineCoverageModulationStateCreateInfoNVBuilder<'_> +{ +} +unsafe impl ExtendsPipelineMultisampleStateCreateInfo + for PipelineCoverageModulationStateCreateInfoNV +{ +} +impl<'a> ::std::ops::Deref for PipelineCoverageModulationStateCreateInfoNVBuilder<'a> { + type Target = PipelineCoverageModulationStateCreateInfoNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PipelineCoverageModulationStateCreateInfoNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PipelineCoverageModulationStateCreateInfoNVBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: PipelineCoverageModulationStateCreateFlagsNV) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn coverage_modulation_mode( + mut self, + coverage_modulation_mode: CoverageModulationModeNV, + ) -> Self { + self.inner.coverage_modulation_mode = coverage_modulation_mode; + self + } + #[inline] + pub fn coverage_modulation_table_enable( + mut self, + coverage_modulation_table_enable: bool, + ) -> Self { + self.inner.coverage_modulation_table_enable = coverage_modulation_table_enable.into(); + self + } + #[inline] + pub fn coverage_modulation_table(mut self, coverage_modulation_table: &'a [f32]) -> Self { + self.inner.coverage_modulation_table_count = coverage_modulation_table.len() as _; + self.inner.p_coverage_modulation_table = coverage_modulation_table.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PipelineCoverageModulationStateCreateInfoNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ImageFormatListCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub view_format_count: u32, + pub p_view_formats: *const Format, +} +impl ::std::default::Default for ImageFormatListCreateInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + view_format_count: u32::default(), + p_view_formats: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for ImageFormatListCreateInfo { + const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_FORMAT_LIST_CREATE_INFO; +} +impl ImageFormatListCreateInfo { + pub fn builder<'a>() -> ImageFormatListCreateInfoBuilder<'a> { + ImageFormatListCreateInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ImageFormatListCreateInfoBuilder<'a> { + inner: ImageFormatListCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsImageCreateInfo for ImageFormatListCreateInfoBuilder<'_> {} +unsafe impl ExtendsImageCreateInfo for ImageFormatListCreateInfo {} +unsafe impl ExtendsSwapchainCreateInfoKHR for ImageFormatListCreateInfoBuilder<'_> {} +unsafe impl ExtendsSwapchainCreateInfoKHR for ImageFormatListCreateInfo {} +unsafe impl ExtendsPhysicalDeviceImageFormatInfo2 for ImageFormatListCreateInfoBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceImageFormatInfo2 for ImageFormatListCreateInfo {} +impl<'a> ::std::ops::Deref for ImageFormatListCreateInfoBuilder<'a> { + type Target = ImageFormatListCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ImageFormatListCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ImageFormatListCreateInfoBuilder<'a> { + #[inline] + pub fn view_formats(mut self, view_formats: &'a [Format]) -> Self { + self.inner.view_format_count = view_formats.len() as _; + self.inner.p_view_formats = view_formats.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ImageFormatListCreateInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ValidationCacheCreateInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: ValidationCacheCreateFlagsEXT, + pub initial_data_size: usize, + pub p_initial_data: *const c_void, +} +impl ::std::default::Default for ValidationCacheCreateInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: ValidationCacheCreateFlagsEXT::default(), + initial_data_size: usize::default(), + p_initial_data: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for ValidationCacheCreateInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::VALIDATION_CACHE_CREATE_INFO_EXT; +} +impl ValidationCacheCreateInfoEXT { + pub fn builder<'a>() -> ValidationCacheCreateInfoEXTBuilder<'a> { + ValidationCacheCreateInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ValidationCacheCreateInfoEXTBuilder<'a> { + inner: ValidationCacheCreateInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ValidationCacheCreateInfoEXTBuilder<'a> { + type Target = ValidationCacheCreateInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ValidationCacheCreateInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ValidationCacheCreateInfoEXTBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: ValidationCacheCreateFlagsEXT) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn initial_data(mut self, initial_data: &'a [u8]) -> Self { + self.inner.initial_data_size = initial_data.len(); + self.inner.p_initial_data = initial_data.as_ptr().cast(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ValidationCacheCreateInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ShaderModuleValidationCacheCreateInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub validation_cache: ValidationCacheEXT, +} +impl ::std::default::Default for ShaderModuleValidationCacheCreateInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + validation_cache: ValidationCacheEXT::default(), + } + } +} +unsafe impl TaggedStructure for ShaderModuleValidationCacheCreateInfoEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT; +} +impl ShaderModuleValidationCacheCreateInfoEXT { + pub fn builder<'a>() -> ShaderModuleValidationCacheCreateInfoEXTBuilder<'a> { + ShaderModuleValidationCacheCreateInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ShaderModuleValidationCacheCreateInfoEXTBuilder<'a> { + inner: ShaderModuleValidationCacheCreateInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsShaderModuleCreateInfo for ShaderModuleValidationCacheCreateInfoEXTBuilder<'_> {} +unsafe impl ExtendsShaderModuleCreateInfo for ShaderModuleValidationCacheCreateInfoEXT {} +unsafe impl ExtendsPipelineShaderStageCreateInfo + for ShaderModuleValidationCacheCreateInfoEXTBuilder<'_> +{ +} +unsafe impl ExtendsPipelineShaderStageCreateInfo for ShaderModuleValidationCacheCreateInfoEXT {} +impl<'a> ::std::ops::Deref for ShaderModuleValidationCacheCreateInfoEXTBuilder<'a> { + type Target = ShaderModuleValidationCacheCreateInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ShaderModuleValidationCacheCreateInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ShaderModuleValidationCacheCreateInfoEXTBuilder<'a> { + #[inline] + pub fn validation_cache(mut self, validation_cache: ValidationCacheEXT) -> Self { + self.inner.validation_cache = validation_cache; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ShaderModuleValidationCacheCreateInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceMaintenance3Properties { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub max_per_set_descriptors: u32, + pub max_memory_allocation_size: DeviceSize, +} +impl ::std::default::Default for PhysicalDeviceMaintenance3Properties { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + max_per_set_descriptors: u32::default(), + max_memory_allocation_size: DeviceSize::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceMaintenance3Properties { + const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES; +} +impl PhysicalDeviceMaintenance3Properties { + pub fn builder<'a>() -> PhysicalDeviceMaintenance3PropertiesBuilder<'a> { + PhysicalDeviceMaintenance3PropertiesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceMaintenance3PropertiesBuilder<'a> { + inner: PhysicalDeviceMaintenance3Properties, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceMaintenance3PropertiesBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceMaintenance3Properties {} +impl<'a> ::std::ops::Deref for PhysicalDeviceMaintenance3PropertiesBuilder<'a> { + type Target = PhysicalDeviceMaintenance3Properties; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceMaintenance3PropertiesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceMaintenance3PropertiesBuilder<'a> { + #[inline] + pub fn max_per_set_descriptors(mut self, max_per_set_descriptors: u32) -> Self { + self.inner.max_per_set_descriptors = max_per_set_descriptors; + self + } + #[inline] + pub fn max_memory_allocation_size(mut self, max_memory_allocation_size: DeviceSize) -> Self { + self.inner.max_memory_allocation_size = max_memory_allocation_size; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceMaintenance3Properties { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceMaintenance4Features { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub maintenance4: Bool32, +} +impl ::std::default::Default for PhysicalDeviceMaintenance4Features { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + maintenance4: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceMaintenance4Features { + const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES; +} +impl PhysicalDeviceMaintenance4Features { + pub fn builder<'a>() -> PhysicalDeviceMaintenance4FeaturesBuilder<'a> { + PhysicalDeviceMaintenance4FeaturesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceMaintenance4FeaturesBuilder<'a> { + inner: PhysicalDeviceMaintenance4Features, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceMaintenance4FeaturesBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceMaintenance4Features {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMaintenance4FeaturesBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMaintenance4Features {} +impl<'a> ::std::ops::Deref for PhysicalDeviceMaintenance4FeaturesBuilder<'a> { + type Target = PhysicalDeviceMaintenance4Features; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceMaintenance4FeaturesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceMaintenance4FeaturesBuilder<'a> { + #[inline] + pub fn maintenance4(mut self, maintenance4: bool) -> Self { + self.inner.maintenance4 = maintenance4.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceMaintenance4Features { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceMaintenance4Properties { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub max_buffer_size: DeviceSize, +} +impl ::std::default::Default for PhysicalDeviceMaintenance4Properties { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + max_buffer_size: DeviceSize::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceMaintenance4Properties { + const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES; +} +impl PhysicalDeviceMaintenance4Properties { + pub fn builder<'a>() -> PhysicalDeviceMaintenance4PropertiesBuilder<'a> { + PhysicalDeviceMaintenance4PropertiesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceMaintenance4PropertiesBuilder<'a> { + inner: PhysicalDeviceMaintenance4Properties, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceMaintenance4PropertiesBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceMaintenance4Properties {} +impl<'a> ::std::ops::Deref for PhysicalDeviceMaintenance4PropertiesBuilder<'a> { + type Target = PhysicalDeviceMaintenance4Properties; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceMaintenance4PropertiesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceMaintenance4PropertiesBuilder<'a> { + #[inline] + pub fn max_buffer_size(mut self, max_buffer_size: DeviceSize) -> Self { + self.inner.max_buffer_size = max_buffer_size; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceMaintenance4Properties { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DescriptorSetLayoutSupport { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub supported: Bool32, +} +impl ::std::default::Default for DescriptorSetLayoutSupport { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + supported: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for DescriptorSetLayoutSupport { + const STRUCTURE_TYPE: StructureType = StructureType::DESCRIPTOR_SET_LAYOUT_SUPPORT; +} +impl DescriptorSetLayoutSupport { + pub fn builder<'a>() -> DescriptorSetLayoutSupportBuilder<'a> { + DescriptorSetLayoutSupportBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DescriptorSetLayoutSupportBuilder<'a> { + inner: DescriptorSetLayoutSupport, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsDescriptorSetLayoutSupport {} +impl<'a> ::std::ops::Deref for DescriptorSetLayoutSupportBuilder<'a> { + type Target = DescriptorSetLayoutSupport; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DescriptorSetLayoutSupportBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DescriptorSetLayoutSupportBuilder<'a> { + #[inline] + pub fn supported(mut self, supported: bool) -> Self { + self.inner.supported = supported.into(); + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*mut T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DescriptorSetLayoutSupport { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceShaderDrawParametersFeatures { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub shader_draw_parameters: Bool32, +} +impl ::std::default::Default for PhysicalDeviceShaderDrawParametersFeatures { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + shader_draw_parameters: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceShaderDrawParametersFeatures { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES; +} +impl PhysicalDeviceShaderDrawParametersFeatures { + pub fn builder<'a>() -> PhysicalDeviceShaderDrawParametersFeaturesBuilder<'a> { + PhysicalDeviceShaderDrawParametersFeaturesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceShaderDrawParametersFeaturesBuilder<'a> { + inner: PhysicalDeviceShaderDrawParametersFeatures, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceShaderDrawParametersFeaturesBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderDrawParametersFeatures {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderDrawParametersFeaturesBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderDrawParametersFeatures {} +impl<'a> ::std::ops::Deref for PhysicalDeviceShaderDrawParametersFeaturesBuilder<'a> { + type Target = PhysicalDeviceShaderDrawParametersFeatures; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderDrawParametersFeaturesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceShaderDrawParametersFeaturesBuilder<'a> { + #[inline] + pub fn shader_draw_parameters(mut self, shader_draw_parameters: bool) -> Self { + self.inner.shader_draw_parameters = shader_draw_parameters.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceShaderDrawParametersFeatures { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceShaderFloat16Int8Features { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub shader_float16: Bool32, + pub shader_int8: Bool32, +} +impl ::std::default::Default for PhysicalDeviceShaderFloat16Int8Features { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + shader_float16: Bool32::default(), + shader_int8: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceShaderFloat16Int8Features { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES; +} +impl PhysicalDeviceShaderFloat16Int8Features { + pub fn builder<'a>() -> PhysicalDeviceShaderFloat16Int8FeaturesBuilder<'a> { + PhysicalDeviceShaderFloat16Int8FeaturesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceShaderFloat16Int8FeaturesBuilder<'a> { + inner: PhysicalDeviceShaderFloat16Int8Features, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderFloat16Int8FeaturesBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderFloat16Int8Features {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderFloat16Int8FeaturesBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderFloat16Int8Features {} +impl<'a> ::std::ops::Deref for PhysicalDeviceShaderFloat16Int8FeaturesBuilder<'a> { + type Target = PhysicalDeviceShaderFloat16Int8Features; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderFloat16Int8FeaturesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceShaderFloat16Int8FeaturesBuilder<'a> { + #[inline] + pub fn shader_float16(mut self, shader_float16: bool) -> Self { + self.inner.shader_float16 = shader_float16.into(); + self + } + #[inline] + pub fn shader_int8(mut self, shader_int8: bool) -> Self { + self.inner.shader_int8 = shader_int8.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceShaderFloat16Int8Features { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceFloatControlsProperties { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub denorm_behavior_independence: ShaderFloatControlsIndependence, + pub rounding_mode_independence: ShaderFloatControlsIndependence, + pub shader_signed_zero_inf_nan_preserve_float16: Bool32, + pub shader_signed_zero_inf_nan_preserve_float32: Bool32, + pub shader_signed_zero_inf_nan_preserve_float64: Bool32, + pub shader_denorm_preserve_float16: Bool32, + pub shader_denorm_preserve_float32: Bool32, + pub shader_denorm_preserve_float64: Bool32, + pub shader_denorm_flush_to_zero_float16: Bool32, + pub shader_denorm_flush_to_zero_float32: Bool32, + pub shader_denorm_flush_to_zero_float64: Bool32, + pub shader_rounding_mode_rte_float16: Bool32, + pub shader_rounding_mode_rte_float32: Bool32, + pub shader_rounding_mode_rte_float64: Bool32, + pub shader_rounding_mode_rtz_float16: Bool32, + pub shader_rounding_mode_rtz_float32: Bool32, + pub shader_rounding_mode_rtz_float64: Bool32, +} +impl ::std::default::Default for PhysicalDeviceFloatControlsProperties { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + denorm_behavior_independence: ShaderFloatControlsIndependence::default(), + rounding_mode_independence: ShaderFloatControlsIndependence::default(), + shader_signed_zero_inf_nan_preserve_float16: Bool32::default(), + shader_signed_zero_inf_nan_preserve_float32: Bool32::default(), + shader_signed_zero_inf_nan_preserve_float64: Bool32::default(), + shader_denorm_preserve_float16: Bool32::default(), + shader_denorm_preserve_float32: Bool32::default(), + shader_denorm_preserve_float64: Bool32::default(), + shader_denorm_flush_to_zero_float16: Bool32::default(), + shader_denorm_flush_to_zero_float32: Bool32::default(), + shader_denorm_flush_to_zero_float64: Bool32::default(), + shader_rounding_mode_rte_float16: Bool32::default(), + shader_rounding_mode_rte_float32: Bool32::default(), + shader_rounding_mode_rte_float64: Bool32::default(), + shader_rounding_mode_rtz_float16: Bool32::default(), + shader_rounding_mode_rtz_float32: Bool32::default(), + shader_rounding_mode_rtz_float64: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceFloatControlsProperties { + const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES; +} +impl PhysicalDeviceFloatControlsProperties { + pub fn builder<'a>() -> PhysicalDeviceFloatControlsPropertiesBuilder<'a> { + PhysicalDeviceFloatControlsPropertiesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceFloatControlsPropertiesBuilder<'a> { + inner: PhysicalDeviceFloatControlsProperties, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceFloatControlsPropertiesBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceFloatControlsProperties {} +impl<'a> ::std::ops::Deref for PhysicalDeviceFloatControlsPropertiesBuilder<'a> { + type Target = PhysicalDeviceFloatControlsProperties; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceFloatControlsPropertiesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceFloatControlsPropertiesBuilder<'a> { + #[inline] + pub fn denorm_behavior_independence( + mut self, + denorm_behavior_independence: ShaderFloatControlsIndependence, + ) -> Self { + self.inner.denorm_behavior_independence = denorm_behavior_independence; + self + } + #[inline] + pub fn rounding_mode_independence( + mut self, + rounding_mode_independence: ShaderFloatControlsIndependence, + ) -> Self { + self.inner.rounding_mode_independence = rounding_mode_independence; + self + } + #[inline] + pub fn shader_signed_zero_inf_nan_preserve_float16( + mut self, + shader_signed_zero_inf_nan_preserve_float16: bool, + ) -> Self { + self.inner.shader_signed_zero_inf_nan_preserve_float16 = + shader_signed_zero_inf_nan_preserve_float16.into(); + self + } + #[inline] + pub fn shader_signed_zero_inf_nan_preserve_float32( + mut self, + shader_signed_zero_inf_nan_preserve_float32: bool, + ) -> Self { + self.inner.shader_signed_zero_inf_nan_preserve_float32 = + shader_signed_zero_inf_nan_preserve_float32.into(); + self + } + #[inline] + pub fn shader_signed_zero_inf_nan_preserve_float64( + mut self, + shader_signed_zero_inf_nan_preserve_float64: bool, + ) -> Self { + self.inner.shader_signed_zero_inf_nan_preserve_float64 = + shader_signed_zero_inf_nan_preserve_float64.into(); + self + } + #[inline] + pub fn shader_denorm_preserve_float16(mut self, shader_denorm_preserve_float16: bool) -> Self { + self.inner.shader_denorm_preserve_float16 = shader_denorm_preserve_float16.into(); + self + } + #[inline] + pub fn shader_denorm_preserve_float32(mut self, shader_denorm_preserve_float32: bool) -> Self { + self.inner.shader_denorm_preserve_float32 = shader_denorm_preserve_float32.into(); + self + } + #[inline] + pub fn shader_denorm_preserve_float64(mut self, shader_denorm_preserve_float64: bool) -> Self { + self.inner.shader_denorm_preserve_float64 = shader_denorm_preserve_float64.into(); + self + } + #[inline] + pub fn shader_denorm_flush_to_zero_float16( + mut self, + shader_denorm_flush_to_zero_float16: bool, + ) -> Self { + self.inner.shader_denorm_flush_to_zero_float16 = shader_denorm_flush_to_zero_float16.into(); + self + } + #[inline] + pub fn shader_denorm_flush_to_zero_float32( + mut self, + shader_denorm_flush_to_zero_float32: bool, + ) -> Self { + self.inner.shader_denorm_flush_to_zero_float32 = shader_denorm_flush_to_zero_float32.into(); + self + } + #[inline] + pub fn shader_denorm_flush_to_zero_float64( + mut self, + shader_denorm_flush_to_zero_float64: bool, + ) -> Self { + self.inner.shader_denorm_flush_to_zero_float64 = shader_denorm_flush_to_zero_float64.into(); + self + } + #[inline] + pub fn shader_rounding_mode_rte_float16( + mut self, + shader_rounding_mode_rte_float16: bool, + ) -> Self { + self.inner.shader_rounding_mode_rte_float16 = shader_rounding_mode_rte_float16.into(); + self + } + #[inline] + pub fn shader_rounding_mode_rte_float32( + mut self, + shader_rounding_mode_rte_float32: bool, + ) -> Self { + self.inner.shader_rounding_mode_rte_float32 = shader_rounding_mode_rte_float32.into(); + self + } + #[inline] + pub fn shader_rounding_mode_rte_float64( + mut self, + shader_rounding_mode_rte_float64: bool, + ) -> Self { + self.inner.shader_rounding_mode_rte_float64 = shader_rounding_mode_rte_float64.into(); + self + } + #[inline] + pub fn shader_rounding_mode_rtz_float16( + mut self, + shader_rounding_mode_rtz_float16: bool, + ) -> Self { + self.inner.shader_rounding_mode_rtz_float16 = shader_rounding_mode_rtz_float16.into(); + self + } + #[inline] + pub fn shader_rounding_mode_rtz_float32( + mut self, + shader_rounding_mode_rtz_float32: bool, + ) -> Self { + self.inner.shader_rounding_mode_rtz_float32 = shader_rounding_mode_rtz_float32.into(); + self + } + #[inline] + pub fn shader_rounding_mode_rtz_float64( + mut self, + shader_rounding_mode_rtz_float64: bool, + ) -> Self { + self.inner.shader_rounding_mode_rtz_float64 = shader_rounding_mode_rtz_float64.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceFloatControlsProperties { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceHostQueryResetFeatures { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub host_query_reset: Bool32, +} +impl ::std::default::Default for PhysicalDeviceHostQueryResetFeatures { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + host_query_reset: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceHostQueryResetFeatures { + const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES; +} +impl PhysicalDeviceHostQueryResetFeatures { + pub fn builder<'a>() -> PhysicalDeviceHostQueryResetFeaturesBuilder<'a> { + PhysicalDeviceHostQueryResetFeaturesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceHostQueryResetFeaturesBuilder<'a> { + inner: PhysicalDeviceHostQueryResetFeatures, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceHostQueryResetFeaturesBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceHostQueryResetFeatures {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceHostQueryResetFeaturesBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceHostQueryResetFeatures {} +impl<'a> ::std::ops::Deref for PhysicalDeviceHostQueryResetFeaturesBuilder<'a> { + type Target = PhysicalDeviceHostQueryResetFeatures; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceHostQueryResetFeaturesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceHostQueryResetFeaturesBuilder<'a> { + #[inline] + pub fn host_query_reset(mut self, host_query_reset: bool) -> Self { + self.inner.host_query_reset = host_query_reset.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceHostQueryResetFeatures { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct NativeBufferUsage2ANDROID { + pub consumer: u64, + pub producer: u64, +} +impl NativeBufferUsage2ANDROID { + pub fn builder<'a>() -> NativeBufferUsage2ANDROIDBuilder<'a> { + NativeBufferUsage2ANDROIDBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct NativeBufferUsage2ANDROIDBuilder<'a> { + inner: NativeBufferUsage2ANDROID, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for NativeBufferUsage2ANDROIDBuilder<'a> { + type Target = NativeBufferUsage2ANDROID; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for NativeBufferUsage2ANDROIDBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> NativeBufferUsage2ANDROIDBuilder<'a> { + #[inline] + pub fn consumer(mut self, consumer: u64) -> Self { + self.inner.consumer = consumer; + self + } + #[inline] + pub fn producer(mut self, producer: u64) -> Self { + self.inner.producer = producer; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> NativeBufferUsage2ANDROID { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct NativeBufferANDROID { + pub s_type: StructureType, + pub p_next: *const c_void, + pub handle: *const c_void, + pub stride: c_int, + pub format: c_int, + pub usage: c_int, + pub usage2: NativeBufferUsage2ANDROID, +} +impl ::std::default::Default for NativeBufferANDROID { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + handle: ::std::ptr::null(), + stride: c_int::default(), + format: c_int::default(), + usage: c_int::default(), + usage2: NativeBufferUsage2ANDROID::default(), + } + } +} +unsafe impl TaggedStructure for NativeBufferANDROID { + const STRUCTURE_TYPE: StructureType = StructureType::NATIVE_BUFFER_ANDROID; +} +impl NativeBufferANDROID { + pub fn builder<'a>() -> NativeBufferANDROIDBuilder<'a> { + NativeBufferANDROIDBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct NativeBufferANDROIDBuilder<'a> { + inner: NativeBufferANDROID, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for NativeBufferANDROIDBuilder<'a> { + type Target = NativeBufferANDROID; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for NativeBufferANDROIDBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> NativeBufferANDROIDBuilder<'a> { + #[inline] + pub fn handle(mut self, handle: *const c_void) -> Self { + self.inner.handle = handle; + self + } + #[inline] + pub fn stride(mut self, stride: c_int) -> Self { + self.inner.stride = stride; + self + } + #[inline] + pub fn format(mut self, format: c_int) -> Self { + self.inner.format = format; + self + } + #[inline] + pub fn usage(mut self, usage: c_int) -> Self { + self.inner.usage = usage; + self + } + #[inline] + pub fn usage2(mut self, usage2: NativeBufferUsage2ANDROID) -> Self { + self.inner.usage2 = usage2; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> NativeBufferANDROID { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SwapchainImageCreateInfoANDROID { + pub s_type: StructureType, + pub p_next: *const c_void, + pub usage: SwapchainImageUsageFlagsANDROID, +} +impl ::std::default::Default for SwapchainImageCreateInfoANDROID { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + usage: SwapchainImageUsageFlagsANDROID::default(), + } + } +} +unsafe impl TaggedStructure for SwapchainImageCreateInfoANDROID { + const STRUCTURE_TYPE: StructureType = StructureType::SWAPCHAIN_IMAGE_CREATE_INFO_ANDROID; +} +impl SwapchainImageCreateInfoANDROID { + pub fn builder<'a>() -> SwapchainImageCreateInfoANDROIDBuilder<'a> { + SwapchainImageCreateInfoANDROIDBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SwapchainImageCreateInfoANDROIDBuilder<'a> { + inner: SwapchainImageCreateInfoANDROID, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for SwapchainImageCreateInfoANDROIDBuilder<'a> { + type Target = SwapchainImageCreateInfoANDROID; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SwapchainImageCreateInfoANDROIDBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SwapchainImageCreateInfoANDROIDBuilder<'a> { + #[inline] + pub fn usage(mut self, usage: SwapchainImageUsageFlagsANDROID) -> Self { + self.inner.usage = usage; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SwapchainImageCreateInfoANDROID { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDevicePresentationPropertiesANDROID { + pub s_type: StructureType, + pub p_next: *const c_void, + pub shared_image: Bool32, +} +impl ::std::default::Default for PhysicalDevicePresentationPropertiesANDROID { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + shared_image: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDevicePresentationPropertiesANDROID { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_PRESENTATION_PROPERTIES_ANDROID; +} +impl PhysicalDevicePresentationPropertiesANDROID { + pub fn builder<'a>() -> PhysicalDevicePresentationPropertiesANDROIDBuilder<'a> { + PhysicalDevicePresentationPropertiesANDROIDBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDevicePresentationPropertiesANDROIDBuilder<'a> { + inner: PhysicalDevicePresentationPropertiesANDROID, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PhysicalDevicePresentationPropertiesANDROIDBuilder<'a> { + type Target = PhysicalDevicePresentationPropertiesANDROID; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDevicePresentationPropertiesANDROIDBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDevicePresentationPropertiesANDROIDBuilder<'a> { + #[inline] + pub fn shared_image(mut self, shared_image: bool) -> Self { + self.inner.shared_image = shared_image.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDevicePresentationPropertiesANDROID { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct ShaderResourceUsageAMD { + pub num_used_vgprs: u32, + pub num_used_sgprs: u32, + pub lds_size_per_local_work_group: u32, + pub lds_usage_size_in_bytes: usize, + pub scratch_mem_usage_in_bytes: usize, +} +impl ShaderResourceUsageAMD { + pub fn builder<'a>() -> ShaderResourceUsageAMDBuilder<'a> { + ShaderResourceUsageAMDBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ShaderResourceUsageAMDBuilder<'a> { + inner: ShaderResourceUsageAMD, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ShaderResourceUsageAMDBuilder<'a> { + type Target = ShaderResourceUsageAMD; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ShaderResourceUsageAMDBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ShaderResourceUsageAMDBuilder<'a> { + #[inline] + pub fn num_used_vgprs(mut self, num_used_vgprs: u32) -> Self { + self.inner.num_used_vgprs = num_used_vgprs; + self + } + #[inline] + pub fn num_used_sgprs(mut self, num_used_sgprs: u32) -> Self { + self.inner.num_used_sgprs = num_used_sgprs; + self + } + #[inline] + pub fn lds_size_per_local_work_group(mut self, lds_size_per_local_work_group: u32) -> Self { + self.inner.lds_size_per_local_work_group = lds_size_per_local_work_group; + self + } + #[inline] + pub fn lds_usage_size_in_bytes(mut self, lds_usage_size_in_bytes: usize) -> Self { + self.inner.lds_usage_size_in_bytes = lds_usage_size_in_bytes; + self + } + #[inline] + pub fn scratch_mem_usage_in_bytes(mut self, scratch_mem_usage_in_bytes: usize) -> Self { + self.inner.scratch_mem_usage_in_bytes = scratch_mem_usage_in_bytes; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ShaderResourceUsageAMD { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ShaderStatisticsInfoAMD { + pub shader_stage_mask: ShaderStageFlags, + pub resource_usage: ShaderResourceUsageAMD, + pub num_physical_vgprs: u32, + pub num_physical_sgprs: u32, + pub num_available_vgprs: u32, + pub num_available_sgprs: u32, + pub compute_work_group_size: [u32; 3], +} +impl ::std::default::Default for ShaderStatisticsInfoAMD { + #[inline] + fn default() -> Self { + Self { + shader_stage_mask: ShaderStageFlags::default(), + resource_usage: ShaderResourceUsageAMD::default(), + num_physical_vgprs: u32::default(), + num_physical_sgprs: u32::default(), + num_available_vgprs: u32::default(), + num_available_sgprs: u32::default(), + compute_work_group_size: unsafe { ::std::mem::zeroed() }, + } + } +} +impl ShaderStatisticsInfoAMD { + pub fn builder<'a>() -> ShaderStatisticsInfoAMDBuilder<'a> { + ShaderStatisticsInfoAMDBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ShaderStatisticsInfoAMDBuilder<'a> { + inner: ShaderStatisticsInfoAMD, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ShaderStatisticsInfoAMDBuilder<'a> { + type Target = ShaderStatisticsInfoAMD; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ShaderStatisticsInfoAMDBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ShaderStatisticsInfoAMDBuilder<'a> { + #[inline] + pub fn shader_stage_mask(mut self, shader_stage_mask: ShaderStageFlags) -> Self { + self.inner.shader_stage_mask = shader_stage_mask; + self + } + #[inline] + pub fn resource_usage(mut self, resource_usage: ShaderResourceUsageAMD) -> Self { + self.inner.resource_usage = resource_usage; + self + } + #[inline] + pub fn num_physical_vgprs(mut self, num_physical_vgprs: u32) -> Self { + self.inner.num_physical_vgprs = num_physical_vgprs; + self + } + #[inline] + pub fn num_physical_sgprs(mut self, num_physical_sgprs: u32) -> Self { + self.inner.num_physical_sgprs = num_physical_sgprs; + self + } + #[inline] + pub fn num_available_vgprs(mut self, num_available_vgprs: u32) -> Self { + self.inner.num_available_vgprs = num_available_vgprs; + self + } + #[inline] + pub fn num_available_sgprs(mut self, num_available_sgprs: u32) -> Self { + self.inner.num_available_sgprs = num_available_sgprs; + self + } + #[inline] + pub fn compute_work_group_size(mut self, compute_work_group_size: [u32; 3]) -> Self { + self.inner.compute_work_group_size = compute_work_group_size; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ShaderStatisticsInfoAMD { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DeviceQueueGlobalPriorityCreateInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub global_priority: QueueGlobalPriorityKHR, +} +impl ::std::default::Default for DeviceQueueGlobalPriorityCreateInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + global_priority: QueueGlobalPriorityKHR::default(), + } + } +} +unsafe impl TaggedStructure for DeviceQueueGlobalPriorityCreateInfoKHR { + const STRUCTURE_TYPE: StructureType = + StructureType::DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_KHR; +} +impl DeviceQueueGlobalPriorityCreateInfoKHR { + pub fn builder<'a>() -> DeviceQueueGlobalPriorityCreateInfoKHRBuilder<'a> { + DeviceQueueGlobalPriorityCreateInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DeviceQueueGlobalPriorityCreateInfoKHRBuilder<'a> { + inner: DeviceQueueGlobalPriorityCreateInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsDeviceQueueCreateInfo for DeviceQueueGlobalPriorityCreateInfoKHRBuilder<'_> {} +unsafe impl ExtendsDeviceQueueCreateInfo for DeviceQueueGlobalPriorityCreateInfoKHR {} +impl<'a> ::std::ops::Deref for DeviceQueueGlobalPriorityCreateInfoKHRBuilder<'a> { + type Target = DeviceQueueGlobalPriorityCreateInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DeviceQueueGlobalPriorityCreateInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DeviceQueueGlobalPriorityCreateInfoKHRBuilder<'a> { + #[inline] + pub fn global_priority(mut self, global_priority: QueueGlobalPriorityKHR) -> Self { + self.inner.global_priority = global_priority; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DeviceQueueGlobalPriorityCreateInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceGlobalPriorityQueryFeaturesKHR { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub global_priority_query: Bool32, +} +impl ::std::default::Default for PhysicalDeviceGlobalPriorityQueryFeaturesKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + global_priority_query: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceGlobalPriorityQueryFeaturesKHR { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR; +} +impl PhysicalDeviceGlobalPriorityQueryFeaturesKHR { + pub fn builder<'a>() -> PhysicalDeviceGlobalPriorityQueryFeaturesKHRBuilder<'a> { + PhysicalDeviceGlobalPriorityQueryFeaturesKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceGlobalPriorityQueryFeaturesKHRBuilder<'a> { + inner: PhysicalDeviceGlobalPriorityQueryFeaturesKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceGlobalPriorityQueryFeaturesKHRBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceGlobalPriorityQueryFeaturesKHR {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceGlobalPriorityQueryFeaturesKHRBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceGlobalPriorityQueryFeaturesKHR {} +impl<'a> ::std::ops::Deref for PhysicalDeviceGlobalPriorityQueryFeaturesKHRBuilder<'a> { + type Target = PhysicalDeviceGlobalPriorityQueryFeaturesKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceGlobalPriorityQueryFeaturesKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceGlobalPriorityQueryFeaturesKHRBuilder<'a> { + #[inline] + pub fn global_priority_query(mut self, global_priority_query: bool) -> Self { + self.inner.global_priority_query = global_priority_query.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceGlobalPriorityQueryFeaturesKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct QueueFamilyGlobalPriorityPropertiesKHR { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub priority_count: u32, + pub priorities: [QueueGlobalPriorityKHR; MAX_GLOBAL_PRIORITY_SIZE_KHR], +} +impl ::std::default::Default for QueueFamilyGlobalPriorityPropertiesKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + priority_count: u32::default(), + priorities: unsafe { ::std::mem::zeroed() }, + } + } +} +unsafe impl TaggedStructure for QueueFamilyGlobalPriorityPropertiesKHR { + const STRUCTURE_TYPE: StructureType = + StructureType::QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR; +} +impl QueueFamilyGlobalPriorityPropertiesKHR { + pub fn builder<'a>() -> QueueFamilyGlobalPriorityPropertiesKHRBuilder<'a> { + QueueFamilyGlobalPriorityPropertiesKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct QueueFamilyGlobalPriorityPropertiesKHRBuilder<'a> { + inner: QueueFamilyGlobalPriorityPropertiesKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsQueueFamilyProperties2 for QueueFamilyGlobalPriorityPropertiesKHRBuilder<'_> {} +unsafe impl ExtendsQueueFamilyProperties2 for QueueFamilyGlobalPriorityPropertiesKHR {} +impl<'a> ::std::ops::Deref for QueueFamilyGlobalPriorityPropertiesKHRBuilder<'a> { + type Target = QueueFamilyGlobalPriorityPropertiesKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for QueueFamilyGlobalPriorityPropertiesKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> QueueFamilyGlobalPriorityPropertiesKHRBuilder<'a> { + #[inline] + pub fn priority_count(mut self, priority_count: u32) -> Self { + self.inner.priority_count = priority_count; + self + } + #[inline] + pub fn priorities( + mut self, + priorities: [QueueGlobalPriorityKHR; MAX_GLOBAL_PRIORITY_SIZE_KHR], + ) -> Self { + self.inner.priorities = priorities; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> QueueFamilyGlobalPriorityPropertiesKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DebugUtilsObjectNameInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub object_type: ObjectType, + pub object_handle: u64, + pub p_object_name: *const c_char, +} +impl ::std::default::Default for DebugUtilsObjectNameInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + object_type: ObjectType::default(), + object_handle: u64::default(), + p_object_name: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for DebugUtilsObjectNameInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::DEBUG_UTILS_OBJECT_NAME_INFO_EXT; +} +impl DebugUtilsObjectNameInfoEXT { + pub fn builder<'a>() -> DebugUtilsObjectNameInfoEXTBuilder<'a> { + DebugUtilsObjectNameInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DebugUtilsObjectNameInfoEXTBuilder<'a> { + inner: DebugUtilsObjectNameInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPipelineShaderStageCreateInfo for DebugUtilsObjectNameInfoEXTBuilder<'_> {} +unsafe impl ExtendsPipelineShaderStageCreateInfo for DebugUtilsObjectNameInfoEXT {} +impl<'a> ::std::ops::Deref for DebugUtilsObjectNameInfoEXTBuilder<'a> { + type Target = DebugUtilsObjectNameInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DebugUtilsObjectNameInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DebugUtilsObjectNameInfoEXTBuilder<'a> { + #[inline] + pub fn object_type(mut self, object_type: ObjectType) -> Self { + self.inner.object_type = object_type; + self + } + #[inline] + pub fn object_handle(mut self, object_handle: u64) -> Self { + self.inner.object_handle = object_handle; + self + } + #[inline] + pub fn object_name(mut self, object_name: &'a ::std::ffi::CStr) -> Self { + self.inner.p_object_name = object_name.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DebugUtilsObjectNameInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DebugUtilsObjectTagInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub object_type: ObjectType, + pub object_handle: u64, + pub tag_name: u64, + pub tag_size: usize, + pub p_tag: *const c_void, +} +impl ::std::default::Default for DebugUtilsObjectTagInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + object_type: ObjectType::default(), + object_handle: u64::default(), + tag_name: u64::default(), + tag_size: usize::default(), + p_tag: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for DebugUtilsObjectTagInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::DEBUG_UTILS_OBJECT_TAG_INFO_EXT; +} +impl DebugUtilsObjectTagInfoEXT { + pub fn builder<'a>() -> DebugUtilsObjectTagInfoEXTBuilder<'a> { + DebugUtilsObjectTagInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DebugUtilsObjectTagInfoEXTBuilder<'a> { + inner: DebugUtilsObjectTagInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DebugUtilsObjectTagInfoEXTBuilder<'a> { + type Target = DebugUtilsObjectTagInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DebugUtilsObjectTagInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DebugUtilsObjectTagInfoEXTBuilder<'a> { + #[inline] + pub fn object_type(mut self, object_type: ObjectType) -> Self { + self.inner.object_type = object_type; + self + } + #[inline] + pub fn object_handle(mut self, object_handle: u64) -> Self { + self.inner.object_handle = object_handle; + self + } + #[inline] + pub fn tag_name(mut self, tag_name: u64) -> Self { + self.inner.tag_name = tag_name; + self + } + #[inline] + pub fn tag(mut self, tag: &'a [u8]) -> Self { + self.inner.tag_size = tag.len(); + self.inner.p_tag = tag.as_ptr().cast(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DebugUtilsObjectTagInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DebugUtilsLabelEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub p_label_name: *const c_char, + pub color: [f32; 4], +} +impl ::std::default::Default for DebugUtilsLabelEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + p_label_name: ::std::ptr::null(), + color: unsafe { ::std::mem::zeroed() }, + } + } +} +unsafe impl TaggedStructure for DebugUtilsLabelEXT { + const STRUCTURE_TYPE: StructureType = StructureType::DEBUG_UTILS_LABEL_EXT; +} +impl DebugUtilsLabelEXT { + pub fn builder<'a>() -> DebugUtilsLabelEXTBuilder<'a> { + DebugUtilsLabelEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DebugUtilsLabelEXTBuilder<'a> { + inner: DebugUtilsLabelEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DebugUtilsLabelEXTBuilder<'a> { + type Target = DebugUtilsLabelEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DebugUtilsLabelEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DebugUtilsLabelEXTBuilder<'a> { + #[inline] + pub fn label_name(mut self, label_name: &'a ::std::ffi::CStr) -> Self { + self.inner.p_label_name = label_name.as_ptr(); + self + } + #[inline] + pub fn color(mut self, color: [f32; 4]) -> Self { + self.inner.color = color; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DebugUtilsLabelEXT { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DebugUtilsMessengerCreateInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: DebugUtilsMessengerCreateFlagsEXT, + pub message_severity: DebugUtilsMessageSeverityFlagsEXT, + pub message_type: DebugUtilsMessageTypeFlagsEXT, + pub pfn_user_callback: PFN_vkDebugUtilsMessengerCallbackEXT, + pub p_user_data: *mut c_void, +} +#[cfg(feature = "debug")] +impl fmt::Debug for DebugUtilsMessengerCreateInfoEXT { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fmt.debug_struct("DebugUtilsMessengerCreateInfoEXT") + .field("s_type", &self.s_type) + .field("p_next", &self.p_next) + .field("flags", &self.flags) + .field("message_severity", &self.message_severity) + .field("message_type", &self.message_type) + .field( + "pfn_user_callback", + &(self.pfn_user_callback.map(|x| x as *const ())), + ) + .field("p_user_data", &self.p_user_data) + .finish() + } +} +impl ::std::default::Default for DebugUtilsMessengerCreateInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: DebugUtilsMessengerCreateFlagsEXT::default(), + message_severity: DebugUtilsMessageSeverityFlagsEXT::default(), + message_type: DebugUtilsMessageTypeFlagsEXT::default(), + pfn_user_callback: PFN_vkDebugUtilsMessengerCallbackEXT::default(), + p_user_data: ::std::ptr::null_mut(), + } + } +} +unsafe impl TaggedStructure for DebugUtilsMessengerCreateInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT; +} +impl DebugUtilsMessengerCreateInfoEXT { + pub fn builder<'a>() -> DebugUtilsMessengerCreateInfoEXTBuilder<'a> { + DebugUtilsMessengerCreateInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DebugUtilsMessengerCreateInfoEXTBuilder<'a> { + inner: DebugUtilsMessengerCreateInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsInstanceCreateInfo for DebugUtilsMessengerCreateInfoEXTBuilder<'_> {} +unsafe impl ExtendsInstanceCreateInfo for DebugUtilsMessengerCreateInfoEXT {} +impl<'a> ::std::ops::Deref for DebugUtilsMessengerCreateInfoEXTBuilder<'a> { + type Target = DebugUtilsMessengerCreateInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DebugUtilsMessengerCreateInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DebugUtilsMessengerCreateInfoEXTBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: DebugUtilsMessengerCreateFlagsEXT) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn message_severity(mut self, message_severity: DebugUtilsMessageSeverityFlagsEXT) -> Self { + self.inner.message_severity = message_severity; + self + } + #[inline] + pub fn message_type(mut self, message_type: DebugUtilsMessageTypeFlagsEXT) -> Self { + self.inner.message_type = message_type; + self + } + #[inline] + pub fn pfn_user_callback( + mut self, + pfn_user_callback: PFN_vkDebugUtilsMessengerCallbackEXT, + ) -> Self { + self.inner.pfn_user_callback = pfn_user_callback; + self + } + #[inline] + pub fn user_data(mut self, user_data: *mut c_void) -> Self { + self.inner.p_user_data = user_data; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DebugUtilsMessengerCreateInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DebugUtilsMessengerCallbackDataEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: DebugUtilsMessengerCallbackDataFlagsEXT, + pub p_message_id_name: *const c_char, + pub message_id_number: i32, + pub p_message: *const c_char, + pub queue_label_count: u32, + pub p_queue_labels: *const DebugUtilsLabelEXT, + pub cmd_buf_label_count: u32, + pub p_cmd_buf_labels: *const DebugUtilsLabelEXT, + pub object_count: u32, + pub p_objects: *const DebugUtilsObjectNameInfoEXT, +} +impl ::std::default::Default for DebugUtilsMessengerCallbackDataEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: DebugUtilsMessengerCallbackDataFlagsEXT::default(), + p_message_id_name: ::std::ptr::null(), + message_id_number: i32::default(), + p_message: ::std::ptr::null(), + queue_label_count: u32::default(), + p_queue_labels: ::std::ptr::null(), + cmd_buf_label_count: u32::default(), + p_cmd_buf_labels: ::std::ptr::null(), + object_count: u32::default(), + p_objects: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for DebugUtilsMessengerCallbackDataEXT { + const STRUCTURE_TYPE: StructureType = StructureType::DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT; +} +impl DebugUtilsMessengerCallbackDataEXT { + pub fn builder<'a>() -> DebugUtilsMessengerCallbackDataEXTBuilder<'a> { + DebugUtilsMessengerCallbackDataEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DebugUtilsMessengerCallbackDataEXTBuilder<'a> { + inner: DebugUtilsMessengerCallbackDataEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsDebugUtilsMessengerCallbackDataEXT {} +impl<'a> ::std::ops::Deref for DebugUtilsMessengerCallbackDataEXTBuilder<'a> { + type Target = DebugUtilsMessengerCallbackDataEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DebugUtilsMessengerCallbackDataEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DebugUtilsMessengerCallbackDataEXTBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: DebugUtilsMessengerCallbackDataFlagsEXT) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn message_id_name(mut self, message_id_name: &'a ::std::ffi::CStr) -> Self { + self.inner.p_message_id_name = message_id_name.as_ptr(); + self + } + #[inline] + pub fn message_id_number(mut self, message_id_number: i32) -> Self { + self.inner.message_id_number = message_id_number; + self + } + #[inline] + pub fn message(mut self, message: &'a ::std::ffi::CStr) -> Self { + self.inner.p_message = message.as_ptr(); + self + } + #[inline] + pub fn queue_labels(mut self, queue_labels: &'a [DebugUtilsLabelEXT]) -> Self { + self.inner.queue_label_count = queue_labels.len() as _; + self.inner.p_queue_labels = queue_labels.as_ptr(); + self + } + #[inline] + pub fn cmd_buf_labels(mut self, cmd_buf_labels: &'a [DebugUtilsLabelEXT]) -> Self { + self.inner.cmd_buf_label_count = cmd_buf_labels.len() as _; + self.inner.p_cmd_buf_labels = cmd_buf_labels.as_ptr(); + self + } + #[inline] + pub fn objects(mut self, objects: &'a [DebugUtilsObjectNameInfoEXT]) -> Self { + self.inner.object_count = objects.len() as _; + self.inner.p_objects = objects.as_ptr(); + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next( + mut self, + next: &'a mut T, + ) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DebugUtilsMessengerCallbackDataEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceDeviceMemoryReportFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub device_memory_report: Bool32, +} +impl ::std::default::Default for PhysicalDeviceDeviceMemoryReportFeaturesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + device_memory_report: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceDeviceMemoryReportFeaturesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT; +} +impl PhysicalDeviceDeviceMemoryReportFeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceDeviceMemoryReportFeaturesEXTBuilder<'a> { + PhysicalDeviceDeviceMemoryReportFeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceDeviceMemoryReportFeaturesEXTBuilder<'a> { + inner: PhysicalDeviceDeviceMemoryReportFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceDeviceMemoryReportFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceDeviceMemoryReportFeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDeviceMemoryReportFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDeviceMemoryReportFeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceDeviceMemoryReportFeaturesEXTBuilder<'a> { + type Target = PhysicalDeviceDeviceMemoryReportFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceDeviceMemoryReportFeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceDeviceMemoryReportFeaturesEXTBuilder<'a> { + #[inline] + pub fn device_memory_report(mut self, device_memory_report: bool) -> Self { + self.inner.device_memory_report = device_memory_report.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceDeviceMemoryReportFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DeviceDeviceMemoryReportCreateInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: DeviceMemoryReportFlagsEXT, + pub pfn_user_callback: PFN_vkDeviceMemoryReportCallbackEXT, + pub p_user_data: *mut c_void, +} +#[cfg(feature = "debug")] +impl fmt::Debug for DeviceDeviceMemoryReportCreateInfoEXT { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fmt.debug_struct("DeviceDeviceMemoryReportCreateInfoEXT") + .field("s_type", &self.s_type) + .field("p_next", &self.p_next) + .field("flags", &self.flags) + .field( + "pfn_user_callback", + &(self.pfn_user_callback.map(|x| x as *const ())), + ) + .field("p_user_data", &self.p_user_data) + .finish() + } +} +impl ::std::default::Default for DeviceDeviceMemoryReportCreateInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: DeviceMemoryReportFlagsEXT::default(), + pfn_user_callback: PFN_vkDeviceMemoryReportCallbackEXT::default(), + p_user_data: ::std::ptr::null_mut(), + } + } +} +unsafe impl TaggedStructure for DeviceDeviceMemoryReportCreateInfoEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT; +} +impl DeviceDeviceMemoryReportCreateInfoEXT { + pub fn builder<'a>() -> DeviceDeviceMemoryReportCreateInfoEXTBuilder<'a> { + DeviceDeviceMemoryReportCreateInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DeviceDeviceMemoryReportCreateInfoEXTBuilder<'a> { + inner: DeviceDeviceMemoryReportCreateInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsDeviceCreateInfo for DeviceDeviceMemoryReportCreateInfoEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for DeviceDeviceMemoryReportCreateInfoEXT {} +impl<'a> ::std::ops::Deref for DeviceDeviceMemoryReportCreateInfoEXTBuilder<'a> { + type Target = DeviceDeviceMemoryReportCreateInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DeviceDeviceMemoryReportCreateInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DeviceDeviceMemoryReportCreateInfoEXTBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: DeviceMemoryReportFlagsEXT) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn pfn_user_callback( + mut self, + pfn_user_callback: PFN_vkDeviceMemoryReportCallbackEXT, + ) -> Self { + self.inner.pfn_user_callback = pfn_user_callback; + self + } + #[inline] + pub fn user_data(mut self, user_data: *mut c_void) -> Self { + self.inner.p_user_data = user_data; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DeviceDeviceMemoryReportCreateInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DeviceMemoryReportCallbackDataEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub flags: DeviceMemoryReportFlagsEXT, + pub ty: DeviceMemoryReportEventTypeEXT, + pub memory_object_id: u64, + pub size: DeviceSize, + pub object_type: ObjectType, + pub object_handle: u64, + pub heap_index: u32, +} +impl ::std::default::Default for DeviceMemoryReportCallbackDataEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + flags: DeviceMemoryReportFlagsEXT::default(), + ty: DeviceMemoryReportEventTypeEXT::default(), + memory_object_id: u64::default(), + size: DeviceSize::default(), + object_type: ObjectType::default(), + object_handle: u64::default(), + heap_index: u32::default(), + } + } +} +unsafe impl TaggedStructure for DeviceMemoryReportCallbackDataEXT { + const STRUCTURE_TYPE: StructureType = StructureType::DEVICE_MEMORY_REPORT_CALLBACK_DATA_EXT; +} +impl DeviceMemoryReportCallbackDataEXT { + pub fn builder<'a>() -> DeviceMemoryReportCallbackDataEXTBuilder<'a> { + DeviceMemoryReportCallbackDataEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DeviceMemoryReportCallbackDataEXTBuilder<'a> { + inner: DeviceMemoryReportCallbackDataEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DeviceMemoryReportCallbackDataEXTBuilder<'a> { + type Target = DeviceMemoryReportCallbackDataEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DeviceMemoryReportCallbackDataEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DeviceMemoryReportCallbackDataEXTBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: DeviceMemoryReportFlagsEXT) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn ty(mut self, ty: DeviceMemoryReportEventTypeEXT) -> Self { + self.inner.ty = ty; + self + } + #[inline] + pub fn memory_object_id(mut self, memory_object_id: u64) -> Self { + self.inner.memory_object_id = memory_object_id; + self + } + #[inline] + pub fn size(mut self, size: DeviceSize) -> Self { + self.inner.size = size; + self + } + #[inline] + pub fn object_type(mut self, object_type: ObjectType) -> Self { + self.inner.object_type = object_type; + self + } + #[inline] + pub fn object_handle(mut self, object_handle: u64) -> Self { + self.inner.object_handle = object_handle; + self + } + #[inline] + pub fn heap_index(mut self, heap_index: u32) -> Self { + self.inner.heap_index = heap_index; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DeviceMemoryReportCallbackDataEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ImportMemoryHostPointerInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub handle_type: ExternalMemoryHandleTypeFlags, + pub p_host_pointer: *mut c_void, +} +impl ::std::default::Default for ImportMemoryHostPointerInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + handle_type: ExternalMemoryHandleTypeFlags::default(), + p_host_pointer: ::std::ptr::null_mut(), + } + } +} +unsafe impl TaggedStructure for ImportMemoryHostPointerInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::IMPORT_MEMORY_HOST_POINTER_INFO_EXT; +} +impl ImportMemoryHostPointerInfoEXT { + pub fn builder<'a>() -> ImportMemoryHostPointerInfoEXTBuilder<'a> { + ImportMemoryHostPointerInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ImportMemoryHostPointerInfoEXTBuilder<'a> { + inner: ImportMemoryHostPointerInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsMemoryAllocateInfo for ImportMemoryHostPointerInfoEXTBuilder<'_> {} +unsafe impl ExtendsMemoryAllocateInfo for ImportMemoryHostPointerInfoEXT {} +impl<'a> ::std::ops::Deref for ImportMemoryHostPointerInfoEXTBuilder<'a> { + type Target = ImportMemoryHostPointerInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ImportMemoryHostPointerInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ImportMemoryHostPointerInfoEXTBuilder<'a> { + #[inline] + pub fn handle_type(mut self, handle_type: ExternalMemoryHandleTypeFlags) -> Self { + self.inner.handle_type = handle_type; + self + } + #[inline] + pub fn host_pointer(mut self, host_pointer: *mut c_void) -> Self { + self.inner.p_host_pointer = host_pointer; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ImportMemoryHostPointerInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct MemoryHostPointerPropertiesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub memory_type_bits: u32, +} +impl ::std::default::Default for MemoryHostPointerPropertiesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + memory_type_bits: u32::default(), + } + } +} +unsafe impl TaggedStructure for MemoryHostPointerPropertiesEXT { + const STRUCTURE_TYPE: StructureType = StructureType::MEMORY_HOST_POINTER_PROPERTIES_EXT; +} +impl MemoryHostPointerPropertiesEXT { + pub fn builder<'a>() -> MemoryHostPointerPropertiesEXTBuilder<'a> { + MemoryHostPointerPropertiesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct MemoryHostPointerPropertiesEXTBuilder<'a> { + inner: MemoryHostPointerPropertiesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for MemoryHostPointerPropertiesEXTBuilder<'a> { + type Target = MemoryHostPointerPropertiesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for MemoryHostPointerPropertiesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> MemoryHostPointerPropertiesEXTBuilder<'a> { + #[inline] + pub fn memory_type_bits(mut self, memory_type_bits: u32) -> Self { + self.inner.memory_type_bits = memory_type_bits; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> MemoryHostPointerPropertiesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceExternalMemoryHostPropertiesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub min_imported_host_pointer_alignment: DeviceSize, +} +impl ::std::default::Default for PhysicalDeviceExternalMemoryHostPropertiesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + min_imported_host_pointer_alignment: DeviceSize::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceExternalMemoryHostPropertiesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT; +} +impl PhysicalDeviceExternalMemoryHostPropertiesEXT { + pub fn builder<'a>() -> PhysicalDeviceExternalMemoryHostPropertiesEXTBuilder<'a> { + PhysicalDeviceExternalMemoryHostPropertiesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceExternalMemoryHostPropertiesEXTBuilder<'a> { + inner: PhysicalDeviceExternalMemoryHostPropertiesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceExternalMemoryHostPropertiesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceExternalMemoryHostPropertiesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceExternalMemoryHostPropertiesEXTBuilder<'a> { + type Target = PhysicalDeviceExternalMemoryHostPropertiesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceExternalMemoryHostPropertiesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceExternalMemoryHostPropertiesEXTBuilder<'a> { + #[inline] + pub fn min_imported_host_pointer_alignment( + mut self, + min_imported_host_pointer_alignment: DeviceSize, + ) -> Self { + self.inner.min_imported_host_pointer_alignment = min_imported_host_pointer_alignment; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceExternalMemoryHostPropertiesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceConservativeRasterizationPropertiesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub primitive_overestimation_size: f32, + pub max_extra_primitive_overestimation_size: f32, + pub extra_primitive_overestimation_size_granularity: f32, + pub primitive_underestimation: Bool32, + pub conservative_point_and_line_rasterization: Bool32, + pub degenerate_triangles_rasterized: Bool32, + pub degenerate_lines_rasterized: Bool32, + pub fully_covered_fragment_shader_input_variable: Bool32, + pub conservative_rasterization_post_depth_coverage: Bool32, +} +impl ::std::default::Default for PhysicalDeviceConservativeRasterizationPropertiesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + primitive_overestimation_size: f32::default(), + max_extra_primitive_overestimation_size: f32::default(), + extra_primitive_overestimation_size_granularity: f32::default(), + primitive_underestimation: Bool32::default(), + conservative_point_and_line_rasterization: Bool32::default(), + degenerate_triangles_rasterized: Bool32::default(), + degenerate_lines_rasterized: Bool32::default(), + fully_covered_fragment_shader_input_variable: Bool32::default(), + conservative_rasterization_post_depth_coverage: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceConservativeRasterizationPropertiesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT; +} +impl PhysicalDeviceConservativeRasterizationPropertiesEXT { + pub fn builder<'a>() -> PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder<'a> { + PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder<'a> { + inner: PhysicalDeviceConservativeRasterizationPropertiesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceConservativeRasterizationPropertiesEXT +{ +} +impl<'a> ::std::ops::Deref for PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder<'a> { + type Target = PhysicalDeviceConservativeRasterizationPropertiesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder<'a> { + #[inline] + pub fn primitive_overestimation_size(mut self, primitive_overestimation_size: f32) -> Self { + self.inner.primitive_overestimation_size = primitive_overestimation_size; + self + } + #[inline] + pub fn max_extra_primitive_overestimation_size( + mut self, + max_extra_primitive_overestimation_size: f32, + ) -> Self { + self.inner.max_extra_primitive_overestimation_size = + max_extra_primitive_overestimation_size; + self + } + #[inline] + pub fn extra_primitive_overestimation_size_granularity( + mut self, + extra_primitive_overestimation_size_granularity: f32, + ) -> Self { + self.inner.extra_primitive_overestimation_size_granularity = + extra_primitive_overestimation_size_granularity; + self + } + #[inline] + pub fn primitive_underestimation(mut self, primitive_underestimation: bool) -> Self { + self.inner.primitive_underestimation = primitive_underestimation.into(); + self + } + #[inline] + pub fn conservative_point_and_line_rasterization( + mut self, + conservative_point_and_line_rasterization: bool, + ) -> Self { + self.inner.conservative_point_and_line_rasterization = + conservative_point_and_line_rasterization.into(); + self + } + #[inline] + pub fn degenerate_triangles_rasterized( + mut self, + degenerate_triangles_rasterized: bool, + ) -> Self { + self.inner.degenerate_triangles_rasterized = degenerate_triangles_rasterized.into(); + self + } + #[inline] + pub fn degenerate_lines_rasterized(mut self, degenerate_lines_rasterized: bool) -> Self { + self.inner.degenerate_lines_rasterized = degenerate_lines_rasterized.into(); + self + } + #[inline] + pub fn fully_covered_fragment_shader_input_variable( + mut self, + fully_covered_fragment_shader_input_variable: bool, + ) -> Self { + self.inner.fully_covered_fragment_shader_input_variable = + fully_covered_fragment_shader_input_variable.into(); + self + } + #[inline] + pub fn conservative_rasterization_post_depth_coverage( + mut self, + conservative_rasterization_post_depth_coverage: bool, + ) -> Self { + self.inner.conservative_rasterization_post_depth_coverage = + conservative_rasterization_post_depth_coverage.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceConservativeRasterizationPropertiesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct CalibratedTimestampInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub time_domain: TimeDomainEXT, +} +impl ::std::default::Default for CalibratedTimestampInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + time_domain: TimeDomainEXT::default(), + } + } +} +unsafe impl TaggedStructure for CalibratedTimestampInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::CALIBRATED_TIMESTAMP_INFO_EXT; +} +impl CalibratedTimestampInfoEXT { + pub fn builder<'a>() -> CalibratedTimestampInfoEXTBuilder<'a> { + CalibratedTimestampInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct CalibratedTimestampInfoEXTBuilder<'a> { + inner: CalibratedTimestampInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for CalibratedTimestampInfoEXTBuilder<'a> { + type Target = CalibratedTimestampInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for CalibratedTimestampInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> CalibratedTimestampInfoEXTBuilder<'a> { + #[inline] + pub fn time_domain(mut self, time_domain: TimeDomainEXT) -> Self { + self.inner.time_domain = time_domain; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> CalibratedTimestampInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceShaderCorePropertiesAMD { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub shader_engine_count: u32, + pub shader_arrays_per_engine_count: u32, + pub compute_units_per_shader_array: u32, + pub simd_per_compute_unit: u32, + pub wavefronts_per_simd: u32, + pub wavefront_size: u32, + pub sgprs_per_simd: u32, + pub min_sgpr_allocation: u32, + pub max_sgpr_allocation: u32, + pub sgpr_allocation_granularity: u32, + pub vgprs_per_simd: u32, + pub min_vgpr_allocation: u32, + pub max_vgpr_allocation: u32, + pub vgpr_allocation_granularity: u32, +} +impl ::std::default::Default for PhysicalDeviceShaderCorePropertiesAMD { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + shader_engine_count: u32::default(), + shader_arrays_per_engine_count: u32::default(), + compute_units_per_shader_array: u32::default(), + simd_per_compute_unit: u32::default(), + wavefronts_per_simd: u32::default(), + wavefront_size: u32::default(), + sgprs_per_simd: u32::default(), + min_sgpr_allocation: u32::default(), + max_sgpr_allocation: u32::default(), + sgpr_allocation_granularity: u32::default(), + vgprs_per_simd: u32::default(), + min_vgpr_allocation: u32::default(), + max_vgpr_allocation: u32::default(), + vgpr_allocation_granularity: u32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceShaderCorePropertiesAMD { + const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD; +} +impl PhysicalDeviceShaderCorePropertiesAMD { + pub fn builder<'a>() -> PhysicalDeviceShaderCorePropertiesAMDBuilder<'a> { + PhysicalDeviceShaderCorePropertiesAMDBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceShaderCorePropertiesAMDBuilder<'a> { + inner: PhysicalDeviceShaderCorePropertiesAMD, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceShaderCorePropertiesAMDBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceShaderCorePropertiesAMD {} +impl<'a> ::std::ops::Deref for PhysicalDeviceShaderCorePropertiesAMDBuilder<'a> { + type Target = PhysicalDeviceShaderCorePropertiesAMD; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderCorePropertiesAMDBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceShaderCorePropertiesAMDBuilder<'a> { + #[inline] + pub fn shader_engine_count(mut self, shader_engine_count: u32) -> Self { + self.inner.shader_engine_count = shader_engine_count; + self + } + #[inline] + pub fn shader_arrays_per_engine_count(mut self, shader_arrays_per_engine_count: u32) -> Self { + self.inner.shader_arrays_per_engine_count = shader_arrays_per_engine_count; + self + } + #[inline] + pub fn compute_units_per_shader_array(mut self, compute_units_per_shader_array: u32) -> Self { + self.inner.compute_units_per_shader_array = compute_units_per_shader_array; + self + } + #[inline] + pub fn simd_per_compute_unit(mut self, simd_per_compute_unit: u32) -> Self { + self.inner.simd_per_compute_unit = simd_per_compute_unit; + self + } + #[inline] + pub fn wavefronts_per_simd(mut self, wavefronts_per_simd: u32) -> Self { + self.inner.wavefronts_per_simd = wavefronts_per_simd; + self + } + #[inline] + pub fn wavefront_size(mut self, wavefront_size: u32) -> Self { + self.inner.wavefront_size = wavefront_size; + self + } + #[inline] + pub fn sgprs_per_simd(mut self, sgprs_per_simd: u32) -> Self { + self.inner.sgprs_per_simd = sgprs_per_simd; + self + } + #[inline] + pub fn min_sgpr_allocation(mut self, min_sgpr_allocation: u32) -> Self { + self.inner.min_sgpr_allocation = min_sgpr_allocation; + self + } + #[inline] + pub fn max_sgpr_allocation(mut self, max_sgpr_allocation: u32) -> Self { + self.inner.max_sgpr_allocation = max_sgpr_allocation; + self + } + #[inline] + pub fn sgpr_allocation_granularity(mut self, sgpr_allocation_granularity: u32) -> Self { + self.inner.sgpr_allocation_granularity = sgpr_allocation_granularity; + self + } + #[inline] + pub fn vgprs_per_simd(mut self, vgprs_per_simd: u32) -> Self { + self.inner.vgprs_per_simd = vgprs_per_simd; + self + } + #[inline] + pub fn min_vgpr_allocation(mut self, min_vgpr_allocation: u32) -> Self { + self.inner.min_vgpr_allocation = min_vgpr_allocation; + self + } + #[inline] + pub fn max_vgpr_allocation(mut self, max_vgpr_allocation: u32) -> Self { + self.inner.max_vgpr_allocation = max_vgpr_allocation; + self + } + #[inline] + pub fn vgpr_allocation_granularity(mut self, vgpr_allocation_granularity: u32) -> Self { + self.inner.vgpr_allocation_granularity = vgpr_allocation_granularity; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceShaderCorePropertiesAMD { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceShaderCoreProperties2AMD { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub shader_core_features: ShaderCorePropertiesFlagsAMD, + pub active_compute_unit_count: u32, +} +impl ::std::default::Default for PhysicalDeviceShaderCoreProperties2AMD { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + shader_core_features: ShaderCorePropertiesFlagsAMD::default(), + active_compute_unit_count: u32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceShaderCoreProperties2AMD { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD; +} +impl PhysicalDeviceShaderCoreProperties2AMD { + pub fn builder<'a>() -> PhysicalDeviceShaderCoreProperties2AMDBuilder<'a> { + PhysicalDeviceShaderCoreProperties2AMDBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceShaderCoreProperties2AMDBuilder<'a> { + inner: PhysicalDeviceShaderCoreProperties2AMD, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceShaderCoreProperties2AMDBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceShaderCoreProperties2AMD {} +impl<'a> ::std::ops::Deref for PhysicalDeviceShaderCoreProperties2AMDBuilder<'a> { + type Target = PhysicalDeviceShaderCoreProperties2AMD; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderCoreProperties2AMDBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceShaderCoreProperties2AMDBuilder<'a> { + #[inline] + pub fn shader_core_features( + mut self, + shader_core_features: ShaderCorePropertiesFlagsAMD, + ) -> Self { + self.inner.shader_core_features = shader_core_features; + self + } + #[inline] + pub fn active_compute_unit_count(mut self, active_compute_unit_count: u32) -> Self { + self.inner.active_compute_unit_count = active_compute_unit_count; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceShaderCoreProperties2AMD { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PipelineRasterizationConservativeStateCreateInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: PipelineRasterizationConservativeStateCreateFlagsEXT, + pub conservative_rasterization_mode: ConservativeRasterizationModeEXT, + pub extra_primitive_overestimation_size: f32, +} +impl ::std::default::Default for PipelineRasterizationConservativeStateCreateInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: PipelineRasterizationConservativeStateCreateFlagsEXT::default(), + conservative_rasterization_mode: ConservativeRasterizationModeEXT::default(), + extra_primitive_overestimation_size: f32::default(), + } + } +} +unsafe impl TaggedStructure for PipelineRasterizationConservativeStateCreateInfoEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT; +} +impl PipelineRasterizationConservativeStateCreateInfoEXT { + pub fn builder<'a>() -> PipelineRasterizationConservativeStateCreateInfoEXTBuilder<'a> { + PipelineRasterizationConservativeStateCreateInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PipelineRasterizationConservativeStateCreateInfoEXTBuilder<'a> { + inner: PipelineRasterizationConservativeStateCreateInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPipelineRasterizationStateCreateInfo + for PipelineRasterizationConservativeStateCreateInfoEXTBuilder<'_> +{ +} +unsafe impl ExtendsPipelineRasterizationStateCreateInfo + for PipelineRasterizationConservativeStateCreateInfoEXT +{ +} +impl<'a> ::std::ops::Deref for PipelineRasterizationConservativeStateCreateInfoEXTBuilder<'a> { + type Target = PipelineRasterizationConservativeStateCreateInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PipelineRasterizationConservativeStateCreateInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PipelineRasterizationConservativeStateCreateInfoEXTBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: PipelineRasterizationConservativeStateCreateFlagsEXT) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn conservative_rasterization_mode( + mut self, + conservative_rasterization_mode: ConservativeRasterizationModeEXT, + ) -> Self { + self.inner.conservative_rasterization_mode = conservative_rasterization_mode; + self + } + #[inline] + pub fn extra_primitive_overestimation_size( + mut self, + extra_primitive_overestimation_size: f32, + ) -> Self { + self.inner.extra_primitive_overestimation_size = extra_primitive_overestimation_size; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PipelineRasterizationConservativeStateCreateInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceDescriptorIndexingFeatures { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub shader_input_attachment_array_dynamic_indexing: Bool32, + pub shader_uniform_texel_buffer_array_dynamic_indexing: Bool32, + pub shader_storage_texel_buffer_array_dynamic_indexing: Bool32, + pub shader_uniform_buffer_array_non_uniform_indexing: Bool32, + pub shader_sampled_image_array_non_uniform_indexing: Bool32, + pub shader_storage_buffer_array_non_uniform_indexing: Bool32, + pub shader_storage_image_array_non_uniform_indexing: Bool32, + pub shader_input_attachment_array_non_uniform_indexing: Bool32, + pub shader_uniform_texel_buffer_array_non_uniform_indexing: Bool32, + pub shader_storage_texel_buffer_array_non_uniform_indexing: Bool32, + pub descriptor_binding_uniform_buffer_update_after_bind: Bool32, + pub descriptor_binding_sampled_image_update_after_bind: Bool32, + pub descriptor_binding_storage_image_update_after_bind: Bool32, + pub descriptor_binding_storage_buffer_update_after_bind: Bool32, + pub descriptor_binding_uniform_texel_buffer_update_after_bind: Bool32, + pub descriptor_binding_storage_texel_buffer_update_after_bind: Bool32, + pub descriptor_binding_update_unused_while_pending: Bool32, + pub descriptor_binding_partially_bound: Bool32, + pub descriptor_binding_variable_descriptor_count: Bool32, + pub runtime_descriptor_array: Bool32, +} +impl ::std::default::Default for PhysicalDeviceDescriptorIndexingFeatures { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + shader_input_attachment_array_dynamic_indexing: Bool32::default(), + shader_uniform_texel_buffer_array_dynamic_indexing: Bool32::default(), + shader_storage_texel_buffer_array_dynamic_indexing: Bool32::default(), + shader_uniform_buffer_array_non_uniform_indexing: Bool32::default(), + shader_sampled_image_array_non_uniform_indexing: Bool32::default(), + shader_storage_buffer_array_non_uniform_indexing: Bool32::default(), + shader_storage_image_array_non_uniform_indexing: Bool32::default(), + shader_input_attachment_array_non_uniform_indexing: Bool32::default(), + shader_uniform_texel_buffer_array_non_uniform_indexing: Bool32::default(), + shader_storage_texel_buffer_array_non_uniform_indexing: Bool32::default(), + descriptor_binding_uniform_buffer_update_after_bind: Bool32::default(), + descriptor_binding_sampled_image_update_after_bind: Bool32::default(), + descriptor_binding_storage_image_update_after_bind: Bool32::default(), + descriptor_binding_storage_buffer_update_after_bind: Bool32::default(), + descriptor_binding_uniform_texel_buffer_update_after_bind: Bool32::default(), + descriptor_binding_storage_texel_buffer_update_after_bind: Bool32::default(), + descriptor_binding_update_unused_while_pending: Bool32::default(), + descriptor_binding_partially_bound: Bool32::default(), + descriptor_binding_variable_descriptor_count: Bool32::default(), + runtime_descriptor_array: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceDescriptorIndexingFeatures { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES; +} +impl PhysicalDeviceDescriptorIndexingFeatures { + pub fn builder<'a>() -> PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a> { + PhysicalDeviceDescriptorIndexingFeaturesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a> { + inner: PhysicalDeviceDescriptorIndexingFeatures, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceDescriptorIndexingFeaturesBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceDescriptorIndexingFeatures {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDescriptorIndexingFeaturesBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDescriptorIndexingFeatures {} +impl<'a> ::std::ops::Deref for PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a> { + type Target = PhysicalDeviceDescriptorIndexingFeatures; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a> { + #[inline] + pub fn shader_input_attachment_array_dynamic_indexing( + mut self, + shader_input_attachment_array_dynamic_indexing: bool, + ) -> Self { + self.inner.shader_input_attachment_array_dynamic_indexing = + shader_input_attachment_array_dynamic_indexing.into(); + self + } + #[inline] + pub fn shader_uniform_texel_buffer_array_dynamic_indexing( + mut self, + shader_uniform_texel_buffer_array_dynamic_indexing: bool, + ) -> Self { + self.inner + .shader_uniform_texel_buffer_array_dynamic_indexing = + shader_uniform_texel_buffer_array_dynamic_indexing.into(); + self + } + #[inline] + pub fn shader_storage_texel_buffer_array_dynamic_indexing( + mut self, + shader_storage_texel_buffer_array_dynamic_indexing: bool, + ) -> Self { + self.inner + .shader_storage_texel_buffer_array_dynamic_indexing = + shader_storage_texel_buffer_array_dynamic_indexing.into(); + self + } + #[inline] + pub fn shader_uniform_buffer_array_non_uniform_indexing( + mut self, + shader_uniform_buffer_array_non_uniform_indexing: bool, + ) -> Self { + self.inner.shader_uniform_buffer_array_non_uniform_indexing = + shader_uniform_buffer_array_non_uniform_indexing.into(); + self + } + #[inline] + pub fn shader_sampled_image_array_non_uniform_indexing( + mut self, + shader_sampled_image_array_non_uniform_indexing: bool, + ) -> Self { + self.inner.shader_sampled_image_array_non_uniform_indexing = + shader_sampled_image_array_non_uniform_indexing.into(); + self + } + #[inline] + pub fn shader_storage_buffer_array_non_uniform_indexing( + mut self, + shader_storage_buffer_array_non_uniform_indexing: bool, + ) -> Self { + self.inner.shader_storage_buffer_array_non_uniform_indexing = + shader_storage_buffer_array_non_uniform_indexing.into(); + self + } + #[inline] + pub fn shader_storage_image_array_non_uniform_indexing( + mut self, + shader_storage_image_array_non_uniform_indexing: bool, + ) -> Self { + self.inner.shader_storage_image_array_non_uniform_indexing = + shader_storage_image_array_non_uniform_indexing.into(); + self + } + #[inline] + pub fn shader_input_attachment_array_non_uniform_indexing( + mut self, + shader_input_attachment_array_non_uniform_indexing: bool, + ) -> Self { + self.inner + .shader_input_attachment_array_non_uniform_indexing = + shader_input_attachment_array_non_uniform_indexing.into(); + self + } + #[inline] + pub fn shader_uniform_texel_buffer_array_non_uniform_indexing( + mut self, + shader_uniform_texel_buffer_array_non_uniform_indexing: bool, + ) -> Self { + self.inner + .shader_uniform_texel_buffer_array_non_uniform_indexing = + shader_uniform_texel_buffer_array_non_uniform_indexing.into(); + self + } + #[inline] + pub fn shader_storage_texel_buffer_array_non_uniform_indexing( + mut self, + shader_storage_texel_buffer_array_non_uniform_indexing: bool, + ) -> Self { + self.inner + .shader_storage_texel_buffer_array_non_uniform_indexing = + shader_storage_texel_buffer_array_non_uniform_indexing.into(); + self + } + #[inline] + pub fn descriptor_binding_uniform_buffer_update_after_bind( + mut self, + descriptor_binding_uniform_buffer_update_after_bind: bool, + ) -> Self { + self.inner + .descriptor_binding_uniform_buffer_update_after_bind = + descriptor_binding_uniform_buffer_update_after_bind.into(); + self + } + #[inline] + pub fn descriptor_binding_sampled_image_update_after_bind( + mut self, + descriptor_binding_sampled_image_update_after_bind: bool, + ) -> Self { + self.inner + .descriptor_binding_sampled_image_update_after_bind = + descriptor_binding_sampled_image_update_after_bind.into(); + self + } + #[inline] + pub fn descriptor_binding_storage_image_update_after_bind( + mut self, + descriptor_binding_storage_image_update_after_bind: bool, + ) -> Self { + self.inner + .descriptor_binding_storage_image_update_after_bind = + descriptor_binding_storage_image_update_after_bind.into(); + self + } + #[inline] + pub fn descriptor_binding_storage_buffer_update_after_bind( + mut self, + descriptor_binding_storage_buffer_update_after_bind: bool, + ) -> Self { + self.inner + .descriptor_binding_storage_buffer_update_after_bind = + descriptor_binding_storage_buffer_update_after_bind.into(); + self + } + #[inline] + pub fn descriptor_binding_uniform_texel_buffer_update_after_bind( + mut self, + descriptor_binding_uniform_texel_buffer_update_after_bind: bool, + ) -> Self { + self.inner + .descriptor_binding_uniform_texel_buffer_update_after_bind = + descriptor_binding_uniform_texel_buffer_update_after_bind.into(); + self + } + #[inline] + pub fn descriptor_binding_storage_texel_buffer_update_after_bind( + mut self, + descriptor_binding_storage_texel_buffer_update_after_bind: bool, + ) -> Self { + self.inner + .descriptor_binding_storage_texel_buffer_update_after_bind = + descriptor_binding_storage_texel_buffer_update_after_bind.into(); + self + } + #[inline] + pub fn descriptor_binding_update_unused_while_pending( + mut self, + descriptor_binding_update_unused_while_pending: bool, + ) -> Self { + self.inner.descriptor_binding_update_unused_while_pending = + descriptor_binding_update_unused_while_pending.into(); + self + } + #[inline] + pub fn descriptor_binding_partially_bound( + mut self, + descriptor_binding_partially_bound: bool, + ) -> Self { + self.inner.descriptor_binding_partially_bound = descriptor_binding_partially_bound.into(); + self + } + #[inline] + pub fn descriptor_binding_variable_descriptor_count( + mut self, + descriptor_binding_variable_descriptor_count: bool, + ) -> Self { + self.inner.descriptor_binding_variable_descriptor_count = + descriptor_binding_variable_descriptor_count.into(); + self + } + #[inline] + pub fn runtime_descriptor_array(mut self, runtime_descriptor_array: bool) -> Self { + self.inner.runtime_descriptor_array = runtime_descriptor_array.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceDescriptorIndexingFeatures { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceDescriptorIndexingProperties { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub max_update_after_bind_descriptors_in_all_pools: u32, + pub shader_uniform_buffer_array_non_uniform_indexing_native: Bool32, + pub shader_sampled_image_array_non_uniform_indexing_native: Bool32, + pub shader_storage_buffer_array_non_uniform_indexing_native: Bool32, + pub shader_storage_image_array_non_uniform_indexing_native: Bool32, + pub shader_input_attachment_array_non_uniform_indexing_native: Bool32, + pub robust_buffer_access_update_after_bind: Bool32, + pub quad_divergent_implicit_lod: Bool32, + pub max_per_stage_descriptor_update_after_bind_samplers: u32, + pub max_per_stage_descriptor_update_after_bind_uniform_buffers: u32, + pub max_per_stage_descriptor_update_after_bind_storage_buffers: u32, + pub max_per_stage_descriptor_update_after_bind_sampled_images: u32, + pub max_per_stage_descriptor_update_after_bind_storage_images: u32, + pub max_per_stage_descriptor_update_after_bind_input_attachments: u32, + pub max_per_stage_update_after_bind_resources: u32, + pub max_descriptor_set_update_after_bind_samplers: u32, + pub max_descriptor_set_update_after_bind_uniform_buffers: u32, + pub max_descriptor_set_update_after_bind_uniform_buffers_dynamic: u32, + pub max_descriptor_set_update_after_bind_storage_buffers: u32, + pub max_descriptor_set_update_after_bind_storage_buffers_dynamic: u32, + pub max_descriptor_set_update_after_bind_sampled_images: u32, + pub max_descriptor_set_update_after_bind_storage_images: u32, + pub max_descriptor_set_update_after_bind_input_attachments: u32, +} +impl ::std::default::Default for PhysicalDeviceDescriptorIndexingProperties { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + max_update_after_bind_descriptors_in_all_pools: u32::default(), + shader_uniform_buffer_array_non_uniform_indexing_native: Bool32::default(), + shader_sampled_image_array_non_uniform_indexing_native: Bool32::default(), + shader_storage_buffer_array_non_uniform_indexing_native: Bool32::default(), + shader_storage_image_array_non_uniform_indexing_native: Bool32::default(), + shader_input_attachment_array_non_uniform_indexing_native: Bool32::default(), + robust_buffer_access_update_after_bind: Bool32::default(), + quad_divergent_implicit_lod: Bool32::default(), + max_per_stage_descriptor_update_after_bind_samplers: u32::default(), + max_per_stage_descriptor_update_after_bind_uniform_buffers: u32::default(), + max_per_stage_descriptor_update_after_bind_storage_buffers: u32::default(), + max_per_stage_descriptor_update_after_bind_sampled_images: u32::default(), + max_per_stage_descriptor_update_after_bind_storage_images: u32::default(), + max_per_stage_descriptor_update_after_bind_input_attachments: u32::default(), + max_per_stage_update_after_bind_resources: u32::default(), + max_descriptor_set_update_after_bind_samplers: u32::default(), + max_descriptor_set_update_after_bind_uniform_buffers: u32::default(), + max_descriptor_set_update_after_bind_uniform_buffers_dynamic: u32::default(), + max_descriptor_set_update_after_bind_storage_buffers: u32::default(), + max_descriptor_set_update_after_bind_storage_buffers_dynamic: u32::default(), + max_descriptor_set_update_after_bind_sampled_images: u32::default(), + max_descriptor_set_update_after_bind_storage_images: u32::default(), + max_descriptor_set_update_after_bind_input_attachments: u32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceDescriptorIndexingProperties { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES; +} +impl PhysicalDeviceDescriptorIndexingProperties { + pub fn builder<'a>() -> PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a> { + PhysicalDeviceDescriptorIndexingPropertiesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a> { + inner: PhysicalDeviceDescriptorIndexingProperties, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceDescriptorIndexingPropertiesBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceDescriptorIndexingProperties {} +impl<'a> ::std::ops::Deref for PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a> { + type Target = PhysicalDeviceDescriptorIndexingProperties; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a> { + #[inline] + pub fn max_update_after_bind_descriptors_in_all_pools( + mut self, + max_update_after_bind_descriptors_in_all_pools: u32, + ) -> Self { + self.inner.max_update_after_bind_descriptors_in_all_pools = + max_update_after_bind_descriptors_in_all_pools; + self + } + #[inline] + pub fn shader_uniform_buffer_array_non_uniform_indexing_native( + mut self, + shader_uniform_buffer_array_non_uniform_indexing_native: bool, + ) -> Self { + self.inner + .shader_uniform_buffer_array_non_uniform_indexing_native = + shader_uniform_buffer_array_non_uniform_indexing_native.into(); + self + } + #[inline] + pub fn shader_sampled_image_array_non_uniform_indexing_native( + mut self, + shader_sampled_image_array_non_uniform_indexing_native: bool, + ) -> Self { + self.inner + .shader_sampled_image_array_non_uniform_indexing_native = + shader_sampled_image_array_non_uniform_indexing_native.into(); + self + } + #[inline] + pub fn shader_storage_buffer_array_non_uniform_indexing_native( + mut self, + shader_storage_buffer_array_non_uniform_indexing_native: bool, + ) -> Self { + self.inner + .shader_storage_buffer_array_non_uniform_indexing_native = + shader_storage_buffer_array_non_uniform_indexing_native.into(); + self + } + #[inline] + pub fn shader_storage_image_array_non_uniform_indexing_native( + mut self, + shader_storage_image_array_non_uniform_indexing_native: bool, + ) -> Self { + self.inner + .shader_storage_image_array_non_uniform_indexing_native = + shader_storage_image_array_non_uniform_indexing_native.into(); + self + } + #[inline] + pub fn shader_input_attachment_array_non_uniform_indexing_native( + mut self, + shader_input_attachment_array_non_uniform_indexing_native: bool, + ) -> Self { + self.inner + .shader_input_attachment_array_non_uniform_indexing_native = + shader_input_attachment_array_non_uniform_indexing_native.into(); + self + } + #[inline] + pub fn robust_buffer_access_update_after_bind( + mut self, + robust_buffer_access_update_after_bind: bool, + ) -> Self { + self.inner.robust_buffer_access_update_after_bind = + robust_buffer_access_update_after_bind.into(); + self + } + #[inline] + pub fn quad_divergent_implicit_lod(mut self, quad_divergent_implicit_lod: bool) -> Self { + self.inner.quad_divergent_implicit_lod = quad_divergent_implicit_lod.into(); + self + } + #[inline] + pub fn max_per_stage_descriptor_update_after_bind_samplers( + mut self, + max_per_stage_descriptor_update_after_bind_samplers: u32, + ) -> Self { + self.inner + .max_per_stage_descriptor_update_after_bind_samplers = + max_per_stage_descriptor_update_after_bind_samplers; + self + } + #[inline] + pub fn max_per_stage_descriptor_update_after_bind_uniform_buffers( + mut self, + max_per_stage_descriptor_update_after_bind_uniform_buffers: u32, + ) -> Self { + self.inner + .max_per_stage_descriptor_update_after_bind_uniform_buffers = + max_per_stage_descriptor_update_after_bind_uniform_buffers; + self + } + #[inline] + pub fn max_per_stage_descriptor_update_after_bind_storage_buffers( + mut self, + max_per_stage_descriptor_update_after_bind_storage_buffers: u32, + ) -> Self { + self.inner + .max_per_stage_descriptor_update_after_bind_storage_buffers = + max_per_stage_descriptor_update_after_bind_storage_buffers; + self + } + #[inline] + pub fn max_per_stage_descriptor_update_after_bind_sampled_images( + mut self, + max_per_stage_descriptor_update_after_bind_sampled_images: u32, + ) -> Self { + self.inner + .max_per_stage_descriptor_update_after_bind_sampled_images = + max_per_stage_descriptor_update_after_bind_sampled_images; + self + } + #[inline] + pub fn max_per_stage_descriptor_update_after_bind_storage_images( + mut self, + max_per_stage_descriptor_update_after_bind_storage_images: u32, + ) -> Self { + self.inner + .max_per_stage_descriptor_update_after_bind_storage_images = + max_per_stage_descriptor_update_after_bind_storage_images; + self + } + #[inline] + pub fn max_per_stage_descriptor_update_after_bind_input_attachments( + mut self, + max_per_stage_descriptor_update_after_bind_input_attachments: u32, + ) -> Self { + self.inner + .max_per_stage_descriptor_update_after_bind_input_attachments = + max_per_stage_descriptor_update_after_bind_input_attachments; + self + } + #[inline] + pub fn max_per_stage_update_after_bind_resources( + mut self, + max_per_stage_update_after_bind_resources: u32, + ) -> Self { + self.inner.max_per_stage_update_after_bind_resources = + max_per_stage_update_after_bind_resources; + self + } + #[inline] + pub fn max_descriptor_set_update_after_bind_samplers( + mut self, + max_descriptor_set_update_after_bind_samplers: u32, + ) -> Self { + self.inner.max_descriptor_set_update_after_bind_samplers = + max_descriptor_set_update_after_bind_samplers; + self + } + #[inline] + pub fn max_descriptor_set_update_after_bind_uniform_buffers( + mut self, + max_descriptor_set_update_after_bind_uniform_buffers: u32, + ) -> Self { + self.inner + .max_descriptor_set_update_after_bind_uniform_buffers = + max_descriptor_set_update_after_bind_uniform_buffers; + self + } + #[inline] + pub fn max_descriptor_set_update_after_bind_uniform_buffers_dynamic( + mut self, + max_descriptor_set_update_after_bind_uniform_buffers_dynamic: u32, + ) -> Self { + self.inner + .max_descriptor_set_update_after_bind_uniform_buffers_dynamic = + max_descriptor_set_update_after_bind_uniform_buffers_dynamic; + self + } + #[inline] + pub fn max_descriptor_set_update_after_bind_storage_buffers( + mut self, + max_descriptor_set_update_after_bind_storage_buffers: u32, + ) -> Self { + self.inner + .max_descriptor_set_update_after_bind_storage_buffers = + max_descriptor_set_update_after_bind_storage_buffers; + self + } + #[inline] + pub fn max_descriptor_set_update_after_bind_storage_buffers_dynamic( + mut self, + max_descriptor_set_update_after_bind_storage_buffers_dynamic: u32, + ) -> Self { + self.inner + .max_descriptor_set_update_after_bind_storage_buffers_dynamic = + max_descriptor_set_update_after_bind_storage_buffers_dynamic; + self + } + #[inline] + pub fn max_descriptor_set_update_after_bind_sampled_images( + mut self, + max_descriptor_set_update_after_bind_sampled_images: u32, + ) -> Self { + self.inner + .max_descriptor_set_update_after_bind_sampled_images = + max_descriptor_set_update_after_bind_sampled_images; + self + } + #[inline] + pub fn max_descriptor_set_update_after_bind_storage_images( + mut self, + max_descriptor_set_update_after_bind_storage_images: u32, + ) -> Self { + self.inner + .max_descriptor_set_update_after_bind_storage_images = + max_descriptor_set_update_after_bind_storage_images; + self + } + #[inline] + pub fn max_descriptor_set_update_after_bind_input_attachments( + mut self, + max_descriptor_set_update_after_bind_input_attachments: u32, + ) -> Self { + self.inner + .max_descriptor_set_update_after_bind_input_attachments = + max_descriptor_set_update_after_bind_input_attachments; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceDescriptorIndexingProperties { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DescriptorSetLayoutBindingFlagsCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub binding_count: u32, + pub p_binding_flags: *const DescriptorBindingFlags, +} +impl ::std::default::Default for DescriptorSetLayoutBindingFlagsCreateInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + binding_count: u32::default(), + p_binding_flags: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for DescriptorSetLayoutBindingFlagsCreateInfo { + const STRUCTURE_TYPE: StructureType = + StructureType::DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO; +} +impl DescriptorSetLayoutBindingFlagsCreateInfo { + pub fn builder<'a>() -> DescriptorSetLayoutBindingFlagsCreateInfoBuilder<'a> { + DescriptorSetLayoutBindingFlagsCreateInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DescriptorSetLayoutBindingFlagsCreateInfoBuilder<'a> { + inner: DescriptorSetLayoutBindingFlagsCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsDescriptorSetLayoutCreateInfo + for DescriptorSetLayoutBindingFlagsCreateInfoBuilder<'_> +{ +} +unsafe impl ExtendsDescriptorSetLayoutCreateInfo for DescriptorSetLayoutBindingFlagsCreateInfo {} +impl<'a> ::std::ops::Deref for DescriptorSetLayoutBindingFlagsCreateInfoBuilder<'a> { + type Target = DescriptorSetLayoutBindingFlagsCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DescriptorSetLayoutBindingFlagsCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DescriptorSetLayoutBindingFlagsCreateInfoBuilder<'a> { + #[inline] + pub fn binding_flags(mut self, binding_flags: &'a [DescriptorBindingFlags]) -> Self { + self.inner.binding_count = binding_flags.len() as _; + self.inner.p_binding_flags = binding_flags.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DescriptorSetLayoutBindingFlagsCreateInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DescriptorSetVariableDescriptorCountAllocateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub descriptor_set_count: u32, + pub p_descriptor_counts: *const u32, +} +impl ::std::default::Default for DescriptorSetVariableDescriptorCountAllocateInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + descriptor_set_count: u32::default(), + p_descriptor_counts: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for DescriptorSetVariableDescriptorCountAllocateInfo { + const STRUCTURE_TYPE: StructureType = + StructureType::DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO; +} +impl DescriptorSetVariableDescriptorCountAllocateInfo { + pub fn builder<'a>() -> DescriptorSetVariableDescriptorCountAllocateInfoBuilder<'a> { + DescriptorSetVariableDescriptorCountAllocateInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DescriptorSetVariableDescriptorCountAllocateInfoBuilder<'a> { + inner: DescriptorSetVariableDescriptorCountAllocateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsDescriptorSetAllocateInfo + for DescriptorSetVariableDescriptorCountAllocateInfoBuilder<'_> +{ +} +unsafe impl ExtendsDescriptorSetAllocateInfo for DescriptorSetVariableDescriptorCountAllocateInfo {} +impl<'a> ::std::ops::Deref for DescriptorSetVariableDescriptorCountAllocateInfoBuilder<'a> { + type Target = DescriptorSetVariableDescriptorCountAllocateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DescriptorSetVariableDescriptorCountAllocateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DescriptorSetVariableDescriptorCountAllocateInfoBuilder<'a> { + #[inline] + pub fn descriptor_counts(mut self, descriptor_counts: &'a [u32]) -> Self { + self.inner.descriptor_set_count = descriptor_counts.len() as _; + self.inner.p_descriptor_counts = descriptor_counts.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DescriptorSetVariableDescriptorCountAllocateInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DescriptorSetVariableDescriptorCountLayoutSupport { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub max_variable_descriptor_count: u32, +} +impl ::std::default::Default for DescriptorSetVariableDescriptorCountLayoutSupport { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + max_variable_descriptor_count: u32::default(), + } + } +} +unsafe impl TaggedStructure for DescriptorSetVariableDescriptorCountLayoutSupport { + const STRUCTURE_TYPE: StructureType = + StructureType::DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT; +} +impl DescriptorSetVariableDescriptorCountLayoutSupport { + pub fn builder<'a>() -> DescriptorSetVariableDescriptorCountLayoutSupportBuilder<'a> { + DescriptorSetVariableDescriptorCountLayoutSupportBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DescriptorSetVariableDescriptorCountLayoutSupportBuilder<'a> { + inner: DescriptorSetVariableDescriptorCountLayoutSupport, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsDescriptorSetLayoutSupport + for DescriptorSetVariableDescriptorCountLayoutSupportBuilder<'_> +{ +} +unsafe impl ExtendsDescriptorSetLayoutSupport + for DescriptorSetVariableDescriptorCountLayoutSupport +{ +} +impl<'a> ::std::ops::Deref for DescriptorSetVariableDescriptorCountLayoutSupportBuilder<'a> { + type Target = DescriptorSetVariableDescriptorCountLayoutSupport; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DescriptorSetVariableDescriptorCountLayoutSupportBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DescriptorSetVariableDescriptorCountLayoutSupportBuilder<'a> { + #[inline] + pub fn max_variable_descriptor_count(mut self, max_variable_descriptor_count: u32) -> Self { + self.inner.max_variable_descriptor_count = max_variable_descriptor_count; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DescriptorSetVariableDescriptorCountLayoutSupport { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct AttachmentDescription2 { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: AttachmentDescriptionFlags, + pub format: Format, + pub samples: SampleCountFlags, + pub load_op: AttachmentLoadOp, + pub store_op: AttachmentStoreOp, + pub stencil_load_op: AttachmentLoadOp, + pub stencil_store_op: AttachmentStoreOp, + pub initial_layout: ImageLayout, + pub final_layout: ImageLayout, +} +impl ::std::default::Default for AttachmentDescription2 { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: AttachmentDescriptionFlags::default(), + format: Format::default(), + samples: SampleCountFlags::default(), + load_op: AttachmentLoadOp::default(), + store_op: AttachmentStoreOp::default(), + stencil_load_op: AttachmentLoadOp::default(), + stencil_store_op: AttachmentStoreOp::default(), + initial_layout: ImageLayout::default(), + final_layout: ImageLayout::default(), + } + } +} +unsafe impl TaggedStructure for AttachmentDescription2 { + const STRUCTURE_TYPE: StructureType = StructureType::ATTACHMENT_DESCRIPTION_2; +} +impl AttachmentDescription2 { + pub fn builder<'a>() -> AttachmentDescription2Builder<'a> { + AttachmentDescription2Builder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct AttachmentDescription2Builder<'a> { + inner: AttachmentDescription2, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsAttachmentDescription2 {} +impl<'a> ::std::ops::Deref for AttachmentDescription2Builder<'a> { + type Target = AttachmentDescription2; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for AttachmentDescription2Builder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> AttachmentDescription2Builder<'a> { + #[inline] + pub fn flags(mut self, flags: AttachmentDescriptionFlags) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn format(mut self, format: Format) -> Self { + self.inner.format = format; + self + } + #[inline] + pub fn samples(mut self, samples: SampleCountFlags) -> Self { + self.inner.samples = samples; + self + } + #[inline] + pub fn load_op(mut self, load_op: AttachmentLoadOp) -> Self { + self.inner.load_op = load_op; + self + } + #[inline] + pub fn store_op(mut self, store_op: AttachmentStoreOp) -> Self { + self.inner.store_op = store_op; + self + } + #[inline] + pub fn stencil_load_op(mut self, stencil_load_op: AttachmentLoadOp) -> Self { + self.inner.stencil_load_op = stencil_load_op; + self + } + #[inline] + pub fn stencil_store_op(mut self, stencil_store_op: AttachmentStoreOp) -> Self { + self.inner.stencil_store_op = stencil_store_op; + self + } + #[inline] + pub fn initial_layout(mut self, initial_layout: ImageLayout) -> Self { + self.inner.initial_layout = initial_layout; + self + } + #[inline] + pub fn final_layout(mut self, final_layout: ImageLayout) -> Self { + self.inner.final_layout = final_layout; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> AttachmentDescription2 { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct AttachmentReference2 { + pub s_type: StructureType, + pub p_next: *const c_void, + pub attachment: u32, + pub layout: ImageLayout, + pub aspect_mask: ImageAspectFlags, +} +impl ::std::default::Default for AttachmentReference2 { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + attachment: u32::default(), + layout: ImageLayout::default(), + aspect_mask: ImageAspectFlags::default(), + } + } +} +unsafe impl TaggedStructure for AttachmentReference2 { + const STRUCTURE_TYPE: StructureType = StructureType::ATTACHMENT_REFERENCE_2; +} +impl AttachmentReference2 { + pub fn builder<'a>() -> AttachmentReference2Builder<'a> { + AttachmentReference2Builder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct AttachmentReference2Builder<'a> { + inner: AttachmentReference2, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsAttachmentReference2 {} +impl<'a> ::std::ops::Deref for AttachmentReference2Builder<'a> { + type Target = AttachmentReference2; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for AttachmentReference2Builder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> AttachmentReference2Builder<'a> { + #[inline] + pub fn attachment(mut self, attachment: u32) -> Self { + self.inner.attachment = attachment; + self + } + #[inline] + pub fn layout(mut self, layout: ImageLayout) -> Self { + self.inner.layout = layout; + self + } + #[inline] + pub fn aspect_mask(mut self, aspect_mask: ImageAspectFlags) -> Self { + self.inner.aspect_mask = aspect_mask; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> AttachmentReference2 { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SubpassDescription2 { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: SubpassDescriptionFlags, + pub pipeline_bind_point: PipelineBindPoint, + pub view_mask: u32, + pub input_attachment_count: u32, + pub p_input_attachments: *const AttachmentReference2, + pub color_attachment_count: u32, + pub p_color_attachments: *const AttachmentReference2, + pub p_resolve_attachments: *const AttachmentReference2, + pub p_depth_stencil_attachment: *const AttachmentReference2, + pub preserve_attachment_count: u32, + pub p_preserve_attachments: *const u32, +} +impl ::std::default::Default for SubpassDescription2 { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: SubpassDescriptionFlags::default(), + pipeline_bind_point: PipelineBindPoint::default(), + view_mask: u32::default(), + input_attachment_count: u32::default(), + p_input_attachments: ::std::ptr::null(), + color_attachment_count: u32::default(), + p_color_attachments: ::std::ptr::null(), + p_resolve_attachments: ::std::ptr::null(), + p_depth_stencil_attachment: ::std::ptr::null(), + preserve_attachment_count: u32::default(), + p_preserve_attachments: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for SubpassDescription2 { + const STRUCTURE_TYPE: StructureType = StructureType::SUBPASS_DESCRIPTION_2; +} +impl SubpassDescription2 { + pub fn builder<'a>() -> SubpassDescription2Builder<'a> { + SubpassDescription2Builder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SubpassDescription2Builder<'a> { + inner: SubpassDescription2, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsSubpassDescription2 {} +impl<'a> ::std::ops::Deref for SubpassDescription2Builder<'a> { + type Target = SubpassDescription2; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SubpassDescription2Builder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SubpassDescription2Builder<'a> { + #[inline] + pub fn flags(mut self, flags: SubpassDescriptionFlags) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn pipeline_bind_point(mut self, pipeline_bind_point: PipelineBindPoint) -> Self { + self.inner.pipeline_bind_point = pipeline_bind_point; + self + } + #[inline] + pub fn view_mask(mut self, view_mask: u32) -> Self { + self.inner.view_mask = view_mask; + self + } + #[inline] + pub fn input_attachments(mut self, input_attachments: &'a [AttachmentReference2]) -> Self { + self.inner.input_attachment_count = input_attachments.len() as _; + self.inner.p_input_attachments = input_attachments.as_ptr(); + self + } + #[inline] + pub fn color_attachments(mut self, color_attachments: &'a [AttachmentReference2]) -> Self { + self.inner.color_attachment_count = color_attachments.len() as _; + self.inner.p_color_attachments = color_attachments.as_ptr(); + self + } + #[inline] + pub fn resolve_attachments(mut self, resolve_attachments: &'a [AttachmentReference2]) -> Self { + self.inner.color_attachment_count = resolve_attachments.len() as _; + self.inner.p_resolve_attachments = resolve_attachments.as_ptr(); + self + } + #[inline] + pub fn depth_stencil_attachment( + mut self, + depth_stencil_attachment: &'a AttachmentReference2, + ) -> Self { + self.inner.p_depth_stencil_attachment = depth_stencil_attachment; + self + } + #[inline] + pub fn preserve_attachments(mut self, preserve_attachments: &'a [u32]) -> Self { + self.inner.preserve_attachment_count = preserve_attachments.len() as _; + self.inner.p_preserve_attachments = preserve_attachments.as_ptr(); + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SubpassDescription2 { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SubpassDependency2 { + pub s_type: StructureType, + pub p_next: *const c_void, + pub src_subpass: u32, + pub dst_subpass: u32, + pub src_stage_mask: PipelineStageFlags, + pub dst_stage_mask: PipelineStageFlags, + pub src_access_mask: AccessFlags, + pub dst_access_mask: AccessFlags, + pub dependency_flags: DependencyFlags, + pub view_offset: i32, +} +impl ::std::default::Default for SubpassDependency2 { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + src_subpass: u32::default(), + dst_subpass: u32::default(), + src_stage_mask: PipelineStageFlags::default(), + dst_stage_mask: PipelineStageFlags::default(), + src_access_mask: AccessFlags::default(), + dst_access_mask: AccessFlags::default(), + dependency_flags: DependencyFlags::default(), + view_offset: i32::default(), + } + } +} +unsafe impl TaggedStructure for SubpassDependency2 { + const STRUCTURE_TYPE: StructureType = StructureType::SUBPASS_DEPENDENCY_2; +} +impl SubpassDependency2 { + pub fn builder<'a>() -> SubpassDependency2Builder<'a> { + SubpassDependency2Builder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SubpassDependency2Builder<'a> { + inner: SubpassDependency2, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsSubpassDependency2 {} +impl<'a> ::std::ops::Deref for SubpassDependency2Builder<'a> { + type Target = SubpassDependency2; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SubpassDependency2Builder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SubpassDependency2Builder<'a> { + #[inline] + pub fn src_subpass(mut self, src_subpass: u32) -> Self { + self.inner.src_subpass = src_subpass; + self + } + #[inline] + pub fn dst_subpass(mut self, dst_subpass: u32) -> Self { + self.inner.dst_subpass = dst_subpass; + self + } + #[inline] + pub fn src_stage_mask(mut self, src_stage_mask: PipelineStageFlags) -> Self { + self.inner.src_stage_mask = src_stage_mask; + self + } + #[inline] + pub fn dst_stage_mask(mut self, dst_stage_mask: PipelineStageFlags) -> Self { + self.inner.dst_stage_mask = dst_stage_mask; + self + } + #[inline] + pub fn src_access_mask(mut self, src_access_mask: AccessFlags) -> Self { + self.inner.src_access_mask = src_access_mask; + self + } + #[inline] + pub fn dst_access_mask(mut self, dst_access_mask: AccessFlags) -> Self { + self.inner.dst_access_mask = dst_access_mask; + self + } + #[inline] + pub fn dependency_flags(mut self, dependency_flags: DependencyFlags) -> Self { + self.inner.dependency_flags = dependency_flags; + self + } + #[inline] + pub fn view_offset(mut self, view_offset: i32) -> Self { + self.inner.view_offset = view_offset; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SubpassDependency2 { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct RenderPassCreateInfo2 { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: RenderPassCreateFlags, + pub attachment_count: u32, + pub p_attachments: *const AttachmentDescription2, + pub subpass_count: u32, + pub p_subpasses: *const SubpassDescription2, + pub dependency_count: u32, + pub p_dependencies: *const SubpassDependency2, + pub correlated_view_mask_count: u32, + pub p_correlated_view_masks: *const u32, +} +impl ::std::default::Default for RenderPassCreateInfo2 { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: RenderPassCreateFlags::default(), + attachment_count: u32::default(), + p_attachments: ::std::ptr::null(), + subpass_count: u32::default(), + p_subpasses: ::std::ptr::null(), + dependency_count: u32::default(), + p_dependencies: ::std::ptr::null(), + correlated_view_mask_count: u32::default(), + p_correlated_view_masks: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for RenderPassCreateInfo2 { + const STRUCTURE_TYPE: StructureType = StructureType::RENDER_PASS_CREATE_INFO_2; +} +impl RenderPassCreateInfo2 { + pub fn builder<'a>() -> RenderPassCreateInfo2Builder<'a> { + RenderPassCreateInfo2Builder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct RenderPassCreateInfo2Builder<'a> { + inner: RenderPassCreateInfo2, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsRenderPassCreateInfo2 {} +impl<'a> ::std::ops::Deref for RenderPassCreateInfo2Builder<'a> { + type Target = RenderPassCreateInfo2; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for RenderPassCreateInfo2Builder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> RenderPassCreateInfo2Builder<'a> { + #[inline] + pub fn flags(mut self, flags: RenderPassCreateFlags) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn attachments(mut self, attachments: &'a [AttachmentDescription2]) -> Self { + self.inner.attachment_count = attachments.len() as _; + self.inner.p_attachments = attachments.as_ptr(); + self + } + #[inline] + pub fn subpasses(mut self, subpasses: &'a [SubpassDescription2]) -> Self { + self.inner.subpass_count = subpasses.len() as _; + self.inner.p_subpasses = subpasses.as_ptr(); + self + } + #[inline] + pub fn dependencies(mut self, dependencies: &'a [SubpassDependency2]) -> Self { + self.inner.dependency_count = dependencies.len() as _; + self.inner.p_dependencies = dependencies.as_ptr(); + self + } + #[inline] + pub fn correlated_view_masks(mut self, correlated_view_masks: &'a [u32]) -> Self { + self.inner.correlated_view_mask_count = correlated_view_masks.len() as _; + self.inner.p_correlated_view_masks = correlated_view_masks.as_ptr(); + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> RenderPassCreateInfo2 { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SubpassBeginInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub contents: SubpassContents, +} +impl ::std::default::Default for SubpassBeginInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + contents: SubpassContents::default(), + } + } +} +unsafe impl TaggedStructure for SubpassBeginInfo { + const STRUCTURE_TYPE: StructureType = StructureType::SUBPASS_BEGIN_INFO; +} +impl SubpassBeginInfo { + pub fn builder<'a>() -> SubpassBeginInfoBuilder<'a> { + SubpassBeginInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SubpassBeginInfoBuilder<'a> { + inner: SubpassBeginInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for SubpassBeginInfoBuilder<'a> { + type Target = SubpassBeginInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SubpassBeginInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SubpassBeginInfoBuilder<'a> { + #[inline] + pub fn contents(mut self, contents: SubpassContents) -> Self { + self.inner.contents = contents; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SubpassBeginInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SubpassEndInfo { + pub s_type: StructureType, + pub p_next: *const c_void, +} +impl ::std::default::Default for SubpassEndInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for SubpassEndInfo { + const STRUCTURE_TYPE: StructureType = StructureType::SUBPASS_END_INFO; +} +impl SubpassEndInfo { + pub fn builder<'a>() -> SubpassEndInfoBuilder<'a> { + SubpassEndInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SubpassEndInfoBuilder<'a> { + inner: SubpassEndInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsSubpassEndInfo {} +impl<'a> ::std::ops::Deref for SubpassEndInfoBuilder<'a> { + type Target = SubpassEndInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SubpassEndInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SubpassEndInfoBuilder<'a> { + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SubpassEndInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceTimelineSemaphoreFeatures { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub timeline_semaphore: Bool32, +} +impl ::std::default::Default for PhysicalDeviceTimelineSemaphoreFeatures { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + timeline_semaphore: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceTimelineSemaphoreFeatures { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES; +} +impl PhysicalDeviceTimelineSemaphoreFeatures { + pub fn builder<'a>() -> PhysicalDeviceTimelineSemaphoreFeaturesBuilder<'a> { + PhysicalDeviceTimelineSemaphoreFeaturesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceTimelineSemaphoreFeaturesBuilder<'a> { + inner: PhysicalDeviceTimelineSemaphoreFeatures, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceTimelineSemaphoreFeaturesBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceTimelineSemaphoreFeatures {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceTimelineSemaphoreFeaturesBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceTimelineSemaphoreFeatures {} +impl<'a> ::std::ops::Deref for PhysicalDeviceTimelineSemaphoreFeaturesBuilder<'a> { + type Target = PhysicalDeviceTimelineSemaphoreFeatures; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceTimelineSemaphoreFeaturesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceTimelineSemaphoreFeaturesBuilder<'a> { + #[inline] + pub fn timeline_semaphore(mut self, timeline_semaphore: bool) -> Self { + self.inner.timeline_semaphore = timeline_semaphore.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceTimelineSemaphoreFeatures { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceTimelineSemaphoreProperties { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub max_timeline_semaphore_value_difference: u64, +} +impl ::std::default::Default for PhysicalDeviceTimelineSemaphoreProperties { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + max_timeline_semaphore_value_difference: u64::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceTimelineSemaphoreProperties { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES; +} +impl PhysicalDeviceTimelineSemaphoreProperties { + pub fn builder<'a>() -> PhysicalDeviceTimelineSemaphorePropertiesBuilder<'a> { + PhysicalDeviceTimelineSemaphorePropertiesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceTimelineSemaphorePropertiesBuilder<'a> { + inner: PhysicalDeviceTimelineSemaphoreProperties, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceTimelineSemaphorePropertiesBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceTimelineSemaphoreProperties {} +impl<'a> ::std::ops::Deref for PhysicalDeviceTimelineSemaphorePropertiesBuilder<'a> { + type Target = PhysicalDeviceTimelineSemaphoreProperties; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceTimelineSemaphorePropertiesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceTimelineSemaphorePropertiesBuilder<'a> { + #[inline] + pub fn max_timeline_semaphore_value_difference( + mut self, + max_timeline_semaphore_value_difference: u64, + ) -> Self { + self.inner.max_timeline_semaphore_value_difference = + max_timeline_semaphore_value_difference; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceTimelineSemaphoreProperties { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SemaphoreTypeCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub semaphore_type: SemaphoreType, + pub initial_value: u64, +} +impl ::std::default::Default for SemaphoreTypeCreateInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + semaphore_type: SemaphoreType::default(), + initial_value: u64::default(), + } + } +} +unsafe impl TaggedStructure for SemaphoreTypeCreateInfo { + const STRUCTURE_TYPE: StructureType = StructureType::SEMAPHORE_TYPE_CREATE_INFO; +} +impl SemaphoreTypeCreateInfo { + pub fn builder<'a>() -> SemaphoreTypeCreateInfoBuilder<'a> { + SemaphoreTypeCreateInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SemaphoreTypeCreateInfoBuilder<'a> { + inner: SemaphoreTypeCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsSemaphoreCreateInfo for SemaphoreTypeCreateInfoBuilder<'_> {} +unsafe impl ExtendsSemaphoreCreateInfo for SemaphoreTypeCreateInfo {} +unsafe impl ExtendsPhysicalDeviceExternalSemaphoreInfo for SemaphoreTypeCreateInfoBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceExternalSemaphoreInfo for SemaphoreTypeCreateInfo {} +impl<'a> ::std::ops::Deref for SemaphoreTypeCreateInfoBuilder<'a> { + type Target = SemaphoreTypeCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SemaphoreTypeCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SemaphoreTypeCreateInfoBuilder<'a> { + #[inline] + pub fn semaphore_type(mut self, semaphore_type: SemaphoreType) -> Self { + self.inner.semaphore_type = semaphore_type; + self + } + #[inline] + pub fn initial_value(mut self, initial_value: u64) -> Self { + self.inner.initial_value = initial_value; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SemaphoreTypeCreateInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct TimelineSemaphoreSubmitInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub wait_semaphore_value_count: u32, + pub p_wait_semaphore_values: *const u64, + pub signal_semaphore_value_count: u32, + pub p_signal_semaphore_values: *const u64, +} +impl ::std::default::Default for TimelineSemaphoreSubmitInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + wait_semaphore_value_count: u32::default(), + p_wait_semaphore_values: ::std::ptr::null(), + signal_semaphore_value_count: u32::default(), + p_signal_semaphore_values: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for TimelineSemaphoreSubmitInfo { + const STRUCTURE_TYPE: StructureType = StructureType::TIMELINE_SEMAPHORE_SUBMIT_INFO; +} +impl TimelineSemaphoreSubmitInfo { + pub fn builder<'a>() -> TimelineSemaphoreSubmitInfoBuilder<'a> { + TimelineSemaphoreSubmitInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct TimelineSemaphoreSubmitInfoBuilder<'a> { + inner: TimelineSemaphoreSubmitInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsSubmitInfo for TimelineSemaphoreSubmitInfoBuilder<'_> {} +unsafe impl ExtendsSubmitInfo for TimelineSemaphoreSubmitInfo {} +unsafe impl ExtendsBindSparseInfo for TimelineSemaphoreSubmitInfoBuilder<'_> {} +unsafe impl ExtendsBindSparseInfo for TimelineSemaphoreSubmitInfo {} +impl<'a> ::std::ops::Deref for TimelineSemaphoreSubmitInfoBuilder<'a> { + type Target = TimelineSemaphoreSubmitInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for TimelineSemaphoreSubmitInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> TimelineSemaphoreSubmitInfoBuilder<'a> { + #[inline] + pub fn wait_semaphore_values(mut self, wait_semaphore_values: &'a [u64]) -> Self { + self.inner.wait_semaphore_value_count = wait_semaphore_values.len() as _; + self.inner.p_wait_semaphore_values = wait_semaphore_values.as_ptr(); + self + } + #[inline] + pub fn signal_semaphore_values(mut self, signal_semaphore_values: &'a [u64]) -> Self { + self.inner.signal_semaphore_value_count = signal_semaphore_values.len() as _; + self.inner.p_signal_semaphore_values = signal_semaphore_values.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> TimelineSemaphoreSubmitInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SemaphoreWaitInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: SemaphoreWaitFlags, + pub semaphore_count: u32, + pub p_semaphores: *const Semaphore, + pub p_values: *const u64, +} +impl ::std::default::Default for SemaphoreWaitInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: SemaphoreWaitFlags::default(), + semaphore_count: u32::default(), + p_semaphores: ::std::ptr::null(), + p_values: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for SemaphoreWaitInfo { + const STRUCTURE_TYPE: StructureType = StructureType::SEMAPHORE_WAIT_INFO; +} +impl SemaphoreWaitInfo { + pub fn builder<'a>() -> SemaphoreWaitInfoBuilder<'a> { + SemaphoreWaitInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SemaphoreWaitInfoBuilder<'a> { + inner: SemaphoreWaitInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for SemaphoreWaitInfoBuilder<'a> { + type Target = SemaphoreWaitInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SemaphoreWaitInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SemaphoreWaitInfoBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: SemaphoreWaitFlags) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn semaphores(mut self, semaphores: &'a [Semaphore]) -> Self { + self.inner.semaphore_count = semaphores.len() as _; + self.inner.p_semaphores = semaphores.as_ptr(); + self + } + #[inline] + pub fn values(mut self, values: &'a [u64]) -> Self { + self.inner.semaphore_count = values.len() as _; + self.inner.p_values = values.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SemaphoreWaitInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SemaphoreSignalInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub semaphore: Semaphore, + pub value: u64, +} +impl ::std::default::Default for SemaphoreSignalInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + semaphore: Semaphore::default(), + value: u64::default(), + } + } +} +unsafe impl TaggedStructure for SemaphoreSignalInfo { + const STRUCTURE_TYPE: StructureType = StructureType::SEMAPHORE_SIGNAL_INFO; +} +impl SemaphoreSignalInfo { + pub fn builder<'a>() -> SemaphoreSignalInfoBuilder<'a> { + SemaphoreSignalInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SemaphoreSignalInfoBuilder<'a> { + inner: SemaphoreSignalInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for SemaphoreSignalInfoBuilder<'a> { + type Target = SemaphoreSignalInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SemaphoreSignalInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SemaphoreSignalInfoBuilder<'a> { + #[inline] + pub fn semaphore(mut self, semaphore: Semaphore) -> Self { + self.inner.semaphore = semaphore; + self + } + #[inline] + pub fn value(mut self, value: u64) -> Self { + self.inner.value = value; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SemaphoreSignalInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct VertexInputBindingDivisorDescriptionEXT { + pub binding: u32, + pub divisor: u32, +} +impl VertexInputBindingDivisorDescriptionEXT { + pub fn builder<'a>() -> VertexInputBindingDivisorDescriptionEXTBuilder<'a> { + VertexInputBindingDivisorDescriptionEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VertexInputBindingDivisorDescriptionEXTBuilder<'a> { + inner: VertexInputBindingDivisorDescriptionEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for VertexInputBindingDivisorDescriptionEXTBuilder<'a> { + type Target = VertexInputBindingDivisorDescriptionEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VertexInputBindingDivisorDescriptionEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VertexInputBindingDivisorDescriptionEXTBuilder<'a> { + #[inline] + pub fn binding(mut self, binding: u32) -> Self { + self.inner.binding = binding; + self + } + #[inline] + pub fn divisor(mut self, divisor: u32) -> Self { + self.inner.divisor = divisor; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VertexInputBindingDivisorDescriptionEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PipelineVertexInputDivisorStateCreateInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub vertex_binding_divisor_count: u32, + pub p_vertex_binding_divisors: *const VertexInputBindingDivisorDescriptionEXT, +} +impl ::std::default::Default for PipelineVertexInputDivisorStateCreateInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + vertex_binding_divisor_count: u32::default(), + p_vertex_binding_divisors: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for PipelineVertexInputDivisorStateCreateInfoEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT; +} +impl PipelineVertexInputDivisorStateCreateInfoEXT { + pub fn builder<'a>() -> PipelineVertexInputDivisorStateCreateInfoEXTBuilder<'a> { + PipelineVertexInputDivisorStateCreateInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PipelineVertexInputDivisorStateCreateInfoEXTBuilder<'a> { + inner: PipelineVertexInputDivisorStateCreateInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPipelineVertexInputStateCreateInfo + for PipelineVertexInputDivisorStateCreateInfoEXTBuilder<'_> +{ +} +unsafe impl ExtendsPipelineVertexInputStateCreateInfo + for PipelineVertexInputDivisorStateCreateInfoEXT +{ +} +impl<'a> ::std::ops::Deref for PipelineVertexInputDivisorStateCreateInfoEXTBuilder<'a> { + type Target = PipelineVertexInputDivisorStateCreateInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PipelineVertexInputDivisorStateCreateInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PipelineVertexInputDivisorStateCreateInfoEXTBuilder<'a> { + #[inline] + pub fn vertex_binding_divisors( + mut self, + vertex_binding_divisors: &'a [VertexInputBindingDivisorDescriptionEXT], + ) -> Self { + self.inner.vertex_binding_divisor_count = vertex_binding_divisors.len() as _; + self.inner.p_vertex_binding_divisors = vertex_binding_divisors.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PipelineVertexInputDivisorStateCreateInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceVertexAttributeDivisorPropertiesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub max_vertex_attrib_divisor: u32, +} +impl ::std::default::Default for PhysicalDeviceVertexAttributeDivisorPropertiesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + max_vertex_attrib_divisor: u32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceVertexAttributeDivisorPropertiesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT; +} +impl PhysicalDeviceVertexAttributeDivisorPropertiesEXT { + pub fn builder<'a>() -> PhysicalDeviceVertexAttributeDivisorPropertiesEXTBuilder<'a> { + PhysicalDeviceVertexAttributeDivisorPropertiesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceVertexAttributeDivisorPropertiesEXTBuilder<'a> { + inner: PhysicalDeviceVertexAttributeDivisorPropertiesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceVertexAttributeDivisorPropertiesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceVertexAttributeDivisorPropertiesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceVertexAttributeDivisorPropertiesEXTBuilder<'a> { + type Target = PhysicalDeviceVertexAttributeDivisorPropertiesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceVertexAttributeDivisorPropertiesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceVertexAttributeDivisorPropertiesEXTBuilder<'a> { + #[inline] + pub fn max_vertex_attrib_divisor(mut self, max_vertex_attrib_divisor: u32) -> Self { + self.inner.max_vertex_attrib_divisor = max_vertex_attrib_divisor; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceVertexAttributeDivisorPropertiesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDevicePCIBusInfoPropertiesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub pci_domain: u32, + pub pci_bus: u32, + pub pci_device: u32, + pub pci_function: u32, +} +impl ::std::default::Default for PhysicalDevicePCIBusInfoPropertiesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + pci_domain: u32::default(), + pci_bus: u32::default(), + pci_device: u32::default(), + pci_function: u32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDevicePCIBusInfoPropertiesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT; +} +impl PhysicalDevicePCIBusInfoPropertiesEXT { + pub fn builder<'a>() -> PhysicalDevicePCIBusInfoPropertiesEXTBuilder<'a> { + PhysicalDevicePCIBusInfoPropertiesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDevicePCIBusInfoPropertiesEXTBuilder<'a> { + inner: PhysicalDevicePCIBusInfoPropertiesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDevicePCIBusInfoPropertiesEXTBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDevicePCIBusInfoPropertiesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDevicePCIBusInfoPropertiesEXTBuilder<'a> { + type Target = PhysicalDevicePCIBusInfoPropertiesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDevicePCIBusInfoPropertiesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDevicePCIBusInfoPropertiesEXTBuilder<'a> { + #[inline] + pub fn pci_domain(mut self, pci_domain: u32) -> Self { + self.inner.pci_domain = pci_domain; + self + } + #[inline] + pub fn pci_bus(mut self, pci_bus: u32) -> Self { + self.inner.pci_bus = pci_bus; + self + } + #[inline] + pub fn pci_device(mut self, pci_device: u32) -> Self { + self.inner.pci_device = pci_device; + self + } + #[inline] + pub fn pci_function(mut self, pci_function: u32) -> Self { + self.inner.pci_function = pci_function; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDevicePCIBusInfoPropertiesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ImportAndroidHardwareBufferInfoANDROID { + pub s_type: StructureType, + pub p_next: *const c_void, + pub buffer: *mut AHardwareBuffer, +} +impl ::std::default::Default for ImportAndroidHardwareBufferInfoANDROID { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + buffer: ::std::ptr::null_mut(), + } + } +} +unsafe impl TaggedStructure for ImportAndroidHardwareBufferInfoANDROID { + const STRUCTURE_TYPE: StructureType = + StructureType::IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID; +} +impl ImportAndroidHardwareBufferInfoANDROID { + pub fn builder<'a>() -> ImportAndroidHardwareBufferInfoANDROIDBuilder<'a> { + ImportAndroidHardwareBufferInfoANDROIDBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ImportAndroidHardwareBufferInfoANDROIDBuilder<'a> { + inner: ImportAndroidHardwareBufferInfoANDROID, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsMemoryAllocateInfo for ImportAndroidHardwareBufferInfoANDROIDBuilder<'_> {} +unsafe impl ExtendsMemoryAllocateInfo for ImportAndroidHardwareBufferInfoANDROID {} +impl<'a> ::std::ops::Deref for ImportAndroidHardwareBufferInfoANDROIDBuilder<'a> { + type Target = ImportAndroidHardwareBufferInfoANDROID; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ImportAndroidHardwareBufferInfoANDROIDBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ImportAndroidHardwareBufferInfoANDROIDBuilder<'a> { + #[inline] + pub fn buffer(mut self, buffer: *mut AHardwareBuffer) -> Self { + self.inner.buffer = buffer; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ImportAndroidHardwareBufferInfoANDROID { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct AndroidHardwareBufferUsageANDROID { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub android_hardware_buffer_usage: u64, +} +impl ::std::default::Default for AndroidHardwareBufferUsageANDROID { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + android_hardware_buffer_usage: u64::default(), + } + } +} +unsafe impl TaggedStructure for AndroidHardwareBufferUsageANDROID { + const STRUCTURE_TYPE: StructureType = StructureType::ANDROID_HARDWARE_BUFFER_USAGE_ANDROID; +} +impl AndroidHardwareBufferUsageANDROID { + pub fn builder<'a>() -> AndroidHardwareBufferUsageANDROIDBuilder<'a> { + AndroidHardwareBufferUsageANDROIDBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct AndroidHardwareBufferUsageANDROIDBuilder<'a> { + inner: AndroidHardwareBufferUsageANDROID, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsImageFormatProperties2 for AndroidHardwareBufferUsageANDROIDBuilder<'_> {} +unsafe impl ExtendsImageFormatProperties2 for AndroidHardwareBufferUsageANDROID {} +impl<'a> ::std::ops::Deref for AndroidHardwareBufferUsageANDROIDBuilder<'a> { + type Target = AndroidHardwareBufferUsageANDROID; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for AndroidHardwareBufferUsageANDROIDBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> AndroidHardwareBufferUsageANDROIDBuilder<'a> { + #[inline] + pub fn android_hardware_buffer_usage(mut self, android_hardware_buffer_usage: u64) -> Self { + self.inner.android_hardware_buffer_usage = android_hardware_buffer_usage; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> AndroidHardwareBufferUsageANDROID { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct AndroidHardwareBufferPropertiesANDROID { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub allocation_size: DeviceSize, + pub memory_type_bits: u32, +} +impl ::std::default::Default for AndroidHardwareBufferPropertiesANDROID { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + allocation_size: DeviceSize::default(), + memory_type_bits: u32::default(), + } + } +} +unsafe impl TaggedStructure for AndroidHardwareBufferPropertiesANDROID { + const STRUCTURE_TYPE: StructureType = StructureType::ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID; +} +impl AndroidHardwareBufferPropertiesANDROID { + pub fn builder<'a>() -> AndroidHardwareBufferPropertiesANDROIDBuilder<'a> { + AndroidHardwareBufferPropertiesANDROIDBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct AndroidHardwareBufferPropertiesANDROIDBuilder<'a> { + inner: AndroidHardwareBufferPropertiesANDROID, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsAndroidHardwareBufferPropertiesANDROID {} +impl<'a> ::std::ops::Deref for AndroidHardwareBufferPropertiesANDROIDBuilder<'a> { + type Target = AndroidHardwareBufferPropertiesANDROID; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for AndroidHardwareBufferPropertiesANDROIDBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> AndroidHardwareBufferPropertiesANDROIDBuilder<'a> { + #[inline] + pub fn allocation_size(mut self, allocation_size: DeviceSize) -> Self { + self.inner.allocation_size = allocation_size; + self + } + #[inline] + pub fn memory_type_bits(mut self, memory_type_bits: u32) -> Self { + self.inner.memory_type_bits = memory_type_bits; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next( + mut self, + next: &'a mut T, + ) -> Self { + unsafe { + let next_ptr = <*mut T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> AndroidHardwareBufferPropertiesANDROID { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct MemoryGetAndroidHardwareBufferInfoANDROID { + pub s_type: StructureType, + pub p_next: *const c_void, + pub memory: DeviceMemory, +} +impl ::std::default::Default for MemoryGetAndroidHardwareBufferInfoANDROID { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + memory: DeviceMemory::default(), + } + } +} +unsafe impl TaggedStructure for MemoryGetAndroidHardwareBufferInfoANDROID { + const STRUCTURE_TYPE: StructureType = + StructureType::MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID; +} +impl MemoryGetAndroidHardwareBufferInfoANDROID { + pub fn builder<'a>() -> MemoryGetAndroidHardwareBufferInfoANDROIDBuilder<'a> { + MemoryGetAndroidHardwareBufferInfoANDROIDBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct MemoryGetAndroidHardwareBufferInfoANDROIDBuilder<'a> { + inner: MemoryGetAndroidHardwareBufferInfoANDROID, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for MemoryGetAndroidHardwareBufferInfoANDROIDBuilder<'a> { + type Target = MemoryGetAndroidHardwareBufferInfoANDROID; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for MemoryGetAndroidHardwareBufferInfoANDROIDBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> MemoryGetAndroidHardwareBufferInfoANDROIDBuilder<'a> { + #[inline] + pub fn memory(mut self, memory: DeviceMemory) -> Self { + self.inner.memory = memory; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> MemoryGetAndroidHardwareBufferInfoANDROID { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct AndroidHardwareBufferFormatPropertiesANDROID { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub format: Format, + pub external_format: u64, + pub format_features: FormatFeatureFlags, + pub sampler_ycbcr_conversion_components: ComponentMapping, + pub suggested_ycbcr_model: SamplerYcbcrModelConversion, + pub suggested_ycbcr_range: SamplerYcbcrRange, + pub suggested_x_chroma_offset: ChromaLocation, + pub suggested_y_chroma_offset: ChromaLocation, +} +impl ::std::default::Default for AndroidHardwareBufferFormatPropertiesANDROID { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + format: Format::default(), + external_format: u64::default(), + format_features: FormatFeatureFlags::default(), + sampler_ycbcr_conversion_components: ComponentMapping::default(), + suggested_ycbcr_model: SamplerYcbcrModelConversion::default(), + suggested_ycbcr_range: SamplerYcbcrRange::default(), + suggested_x_chroma_offset: ChromaLocation::default(), + suggested_y_chroma_offset: ChromaLocation::default(), + } + } +} +unsafe impl TaggedStructure for AndroidHardwareBufferFormatPropertiesANDROID { + const STRUCTURE_TYPE: StructureType = + StructureType::ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID; +} +impl AndroidHardwareBufferFormatPropertiesANDROID { + pub fn builder<'a>() -> AndroidHardwareBufferFormatPropertiesANDROIDBuilder<'a> { + AndroidHardwareBufferFormatPropertiesANDROIDBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct AndroidHardwareBufferFormatPropertiesANDROIDBuilder<'a> { + inner: AndroidHardwareBufferFormatPropertiesANDROID, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsAndroidHardwareBufferPropertiesANDROID + for AndroidHardwareBufferFormatPropertiesANDROIDBuilder<'_> +{ +} +unsafe impl ExtendsAndroidHardwareBufferPropertiesANDROID + for AndroidHardwareBufferFormatPropertiesANDROID +{ +} +impl<'a> ::std::ops::Deref for AndroidHardwareBufferFormatPropertiesANDROIDBuilder<'a> { + type Target = AndroidHardwareBufferFormatPropertiesANDROID; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for AndroidHardwareBufferFormatPropertiesANDROIDBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> AndroidHardwareBufferFormatPropertiesANDROIDBuilder<'a> { + #[inline] + pub fn format(mut self, format: Format) -> Self { + self.inner.format = format; + self + } + #[inline] + pub fn external_format(mut self, external_format: u64) -> Self { + self.inner.external_format = external_format; + self + } + #[inline] + pub fn format_features(mut self, format_features: FormatFeatureFlags) -> Self { + self.inner.format_features = format_features; + self + } + #[inline] + pub fn sampler_ycbcr_conversion_components( + mut self, + sampler_ycbcr_conversion_components: ComponentMapping, + ) -> Self { + self.inner.sampler_ycbcr_conversion_components = sampler_ycbcr_conversion_components; + self + } + #[inline] + pub fn suggested_ycbcr_model( + mut self, + suggested_ycbcr_model: SamplerYcbcrModelConversion, + ) -> Self { + self.inner.suggested_ycbcr_model = suggested_ycbcr_model; + self + } + #[inline] + pub fn suggested_ycbcr_range(mut self, suggested_ycbcr_range: SamplerYcbcrRange) -> Self { + self.inner.suggested_ycbcr_range = suggested_ycbcr_range; + self + } + #[inline] + pub fn suggested_x_chroma_offset(mut self, suggested_x_chroma_offset: ChromaLocation) -> Self { + self.inner.suggested_x_chroma_offset = suggested_x_chroma_offset; + self + } + #[inline] + pub fn suggested_y_chroma_offset(mut self, suggested_y_chroma_offset: ChromaLocation) -> Self { + self.inner.suggested_y_chroma_offset = suggested_y_chroma_offset; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> AndroidHardwareBufferFormatPropertiesANDROID { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct CommandBufferInheritanceConditionalRenderingInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub conditional_rendering_enable: Bool32, +} +impl ::std::default::Default for CommandBufferInheritanceConditionalRenderingInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + conditional_rendering_enable: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for CommandBufferInheritanceConditionalRenderingInfoEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT; +} +impl CommandBufferInheritanceConditionalRenderingInfoEXT { + pub fn builder<'a>() -> CommandBufferInheritanceConditionalRenderingInfoEXTBuilder<'a> { + CommandBufferInheritanceConditionalRenderingInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct CommandBufferInheritanceConditionalRenderingInfoEXTBuilder<'a> { + inner: CommandBufferInheritanceConditionalRenderingInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsCommandBufferInheritanceInfo + for CommandBufferInheritanceConditionalRenderingInfoEXTBuilder<'_> +{ +} +unsafe impl ExtendsCommandBufferInheritanceInfo + for CommandBufferInheritanceConditionalRenderingInfoEXT +{ +} +impl<'a> ::std::ops::Deref for CommandBufferInheritanceConditionalRenderingInfoEXTBuilder<'a> { + type Target = CommandBufferInheritanceConditionalRenderingInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for CommandBufferInheritanceConditionalRenderingInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> CommandBufferInheritanceConditionalRenderingInfoEXTBuilder<'a> { + #[inline] + pub fn conditional_rendering_enable(mut self, conditional_rendering_enable: bool) -> Self { + self.inner.conditional_rendering_enable = conditional_rendering_enable.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> CommandBufferInheritanceConditionalRenderingInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ExternalFormatANDROID { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub external_format: u64, +} +impl ::std::default::Default for ExternalFormatANDROID { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + external_format: u64::default(), + } + } +} +unsafe impl TaggedStructure for ExternalFormatANDROID { + const STRUCTURE_TYPE: StructureType = StructureType::EXTERNAL_FORMAT_ANDROID; +} +impl ExternalFormatANDROID { + pub fn builder<'a>() -> ExternalFormatANDROIDBuilder<'a> { + ExternalFormatANDROIDBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ExternalFormatANDROIDBuilder<'a> { + inner: ExternalFormatANDROID, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsImageCreateInfo for ExternalFormatANDROIDBuilder<'_> {} +unsafe impl ExtendsImageCreateInfo for ExternalFormatANDROID {} +unsafe impl ExtendsSamplerYcbcrConversionCreateInfo for ExternalFormatANDROIDBuilder<'_> {} +unsafe impl ExtendsSamplerYcbcrConversionCreateInfo for ExternalFormatANDROID {} +impl<'a> ::std::ops::Deref for ExternalFormatANDROIDBuilder<'a> { + type Target = ExternalFormatANDROID; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ExternalFormatANDROIDBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ExternalFormatANDROIDBuilder<'a> { + #[inline] + pub fn external_format(mut self, external_format: u64) -> Self { + self.inner.external_format = external_format; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ExternalFormatANDROID { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDevice8BitStorageFeatures { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub storage_buffer8_bit_access: Bool32, + pub uniform_and_storage_buffer8_bit_access: Bool32, + pub storage_push_constant8: Bool32, +} +impl ::std::default::Default for PhysicalDevice8BitStorageFeatures { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + storage_buffer8_bit_access: Bool32::default(), + uniform_and_storage_buffer8_bit_access: Bool32::default(), + storage_push_constant8: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDevice8BitStorageFeatures { + const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES; +} +impl PhysicalDevice8BitStorageFeatures { + pub fn builder<'a>() -> PhysicalDevice8BitStorageFeaturesBuilder<'a> { + PhysicalDevice8BitStorageFeaturesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDevice8BitStorageFeaturesBuilder<'a> { + inner: PhysicalDevice8BitStorageFeatures, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevice8BitStorageFeaturesBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevice8BitStorageFeatures {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDevice8BitStorageFeaturesBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDevice8BitStorageFeatures {} +impl<'a> ::std::ops::Deref for PhysicalDevice8BitStorageFeaturesBuilder<'a> { + type Target = PhysicalDevice8BitStorageFeatures; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDevice8BitStorageFeaturesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDevice8BitStorageFeaturesBuilder<'a> { + #[inline] + pub fn storage_buffer8_bit_access(mut self, storage_buffer8_bit_access: bool) -> Self { + self.inner.storage_buffer8_bit_access = storage_buffer8_bit_access.into(); + self + } + #[inline] + pub fn uniform_and_storage_buffer8_bit_access( + mut self, + uniform_and_storage_buffer8_bit_access: bool, + ) -> Self { + self.inner.uniform_and_storage_buffer8_bit_access = + uniform_and_storage_buffer8_bit_access.into(); + self + } + #[inline] + pub fn storage_push_constant8(mut self, storage_push_constant8: bool) -> Self { + self.inner.storage_push_constant8 = storage_push_constant8.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDevice8BitStorageFeatures { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceConditionalRenderingFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub conditional_rendering: Bool32, + pub inherited_conditional_rendering: Bool32, +} +impl ::std::default::Default for PhysicalDeviceConditionalRenderingFeaturesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + conditional_rendering: Bool32::default(), + inherited_conditional_rendering: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceConditionalRenderingFeaturesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT; +} +impl PhysicalDeviceConditionalRenderingFeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceConditionalRenderingFeaturesEXTBuilder<'a> { + PhysicalDeviceConditionalRenderingFeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceConditionalRenderingFeaturesEXTBuilder<'a> { + inner: PhysicalDeviceConditionalRenderingFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceConditionalRenderingFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceConditionalRenderingFeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceConditionalRenderingFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceConditionalRenderingFeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceConditionalRenderingFeaturesEXTBuilder<'a> { + type Target = PhysicalDeviceConditionalRenderingFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceConditionalRenderingFeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceConditionalRenderingFeaturesEXTBuilder<'a> { + #[inline] + pub fn conditional_rendering(mut self, conditional_rendering: bool) -> Self { + self.inner.conditional_rendering = conditional_rendering.into(); + self + } + #[inline] + pub fn inherited_conditional_rendering( + mut self, + inherited_conditional_rendering: bool, + ) -> Self { + self.inner.inherited_conditional_rendering = inherited_conditional_rendering.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceConditionalRenderingFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceVulkanMemoryModelFeatures { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub vulkan_memory_model: Bool32, + pub vulkan_memory_model_device_scope: Bool32, + pub vulkan_memory_model_availability_visibility_chains: Bool32, +} +impl ::std::default::Default for PhysicalDeviceVulkanMemoryModelFeatures { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + vulkan_memory_model: Bool32::default(), + vulkan_memory_model_device_scope: Bool32::default(), + vulkan_memory_model_availability_visibility_chains: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceVulkanMemoryModelFeatures { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES; +} +impl PhysicalDeviceVulkanMemoryModelFeatures { + pub fn builder<'a>() -> PhysicalDeviceVulkanMemoryModelFeaturesBuilder<'a> { + PhysicalDeviceVulkanMemoryModelFeaturesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceVulkanMemoryModelFeaturesBuilder<'a> { + inner: PhysicalDeviceVulkanMemoryModelFeatures, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceVulkanMemoryModelFeaturesBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceVulkanMemoryModelFeatures {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVulkanMemoryModelFeaturesBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVulkanMemoryModelFeatures {} +impl<'a> ::std::ops::Deref for PhysicalDeviceVulkanMemoryModelFeaturesBuilder<'a> { + type Target = PhysicalDeviceVulkanMemoryModelFeatures; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceVulkanMemoryModelFeaturesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceVulkanMemoryModelFeaturesBuilder<'a> { + #[inline] + pub fn vulkan_memory_model(mut self, vulkan_memory_model: bool) -> Self { + self.inner.vulkan_memory_model = vulkan_memory_model.into(); + self + } + #[inline] + pub fn vulkan_memory_model_device_scope( + mut self, + vulkan_memory_model_device_scope: bool, + ) -> Self { + self.inner.vulkan_memory_model_device_scope = vulkan_memory_model_device_scope.into(); + self + } + #[inline] + pub fn vulkan_memory_model_availability_visibility_chains( + mut self, + vulkan_memory_model_availability_visibility_chains: bool, + ) -> Self { + self.inner + .vulkan_memory_model_availability_visibility_chains = + vulkan_memory_model_availability_visibility_chains.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceVulkanMemoryModelFeatures { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceShaderAtomicInt64Features { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub shader_buffer_int64_atomics: Bool32, + pub shader_shared_int64_atomics: Bool32, +} +impl ::std::default::Default for PhysicalDeviceShaderAtomicInt64Features { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + shader_buffer_int64_atomics: Bool32::default(), + shader_shared_int64_atomics: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceShaderAtomicInt64Features { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES; +} +impl PhysicalDeviceShaderAtomicInt64Features { + pub fn builder<'a>() -> PhysicalDeviceShaderAtomicInt64FeaturesBuilder<'a> { + PhysicalDeviceShaderAtomicInt64FeaturesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceShaderAtomicInt64FeaturesBuilder<'a> { + inner: PhysicalDeviceShaderAtomicInt64Features, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderAtomicInt64FeaturesBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderAtomicInt64Features {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderAtomicInt64FeaturesBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderAtomicInt64Features {} +impl<'a> ::std::ops::Deref for PhysicalDeviceShaderAtomicInt64FeaturesBuilder<'a> { + type Target = PhysicalDeviceShaderAtomicInt64Features; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderAtomicInt64FeaturesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceShaderAtomicInt64FeaturesBuilder<'a> { + #[inline] + pub fn shader_buffer_int64_atomics(mut self, shader_buffer_int64_atomics: bool) -> Self { + self.inner.shader_buffer_int64_atomics = shader_buffer_int64_atomics.into(); + self + } + #[inline] + pub fn shader_shared_int64_atomics(mut self, shader_shared_int64_atomics: bool) -> Self { + self.inner.shader_shared_int64_atomics = shader_shared_int64_atomics.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceShaderAtomicInt64Features { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceShaderAtomicFloatFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub shader_buffer_float32_atomics: Bool32, + pub shader_buffer_float32_atomic_add: Bool32, + pub shader_buffer_float64_atomics: Bool32, + pub shader_buffer_float64_atomic_add: Bool32, + pub shader_shared_float32_atomics: Bool32, + pub shader_shared_float32_atomic_add: Bool32, + pub shader_shared_float64_atomics: Bool32, + pub shader_shared_float64_atomic_add: Bool32, + pub shader_image_float32_atomics: Bool32, + pub shader_image_float32_atomic_add: Bool32, + pub sparse_image_float32_atomics: Bool32, + pub sparse_image_float32_atomic_add: Bool32, +} +impl ::std::default::Default for PhysicalDeviceShaderAtomicFloatFeaturesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + shader_buffer_float32_atomics: Bool32::default(), + shader_buffer_float32_atomic_add: Bool32::default(), + shader_buffer_float64_atomics: Bool32::default(), + shader_buffer_float64_atomic_add: Bool32::default(), + shader_shared_float32_atomics: Bool32::default(), + shader_shared_float32_atomic_add: Bool32::default(), + shader_shared_float64_atomics: Bool32::default(), + shader_shared_float64_atomic_add: Bool32::default(), + shader_image_float32_atomics: Bool32::default(), + shader_image_float32_atomic_add: Bool32::default(), + sparse_image_float32_atomics: Bool32::default(), + sparse_image_float32_atomic_add: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceShaderAtomicFloatFeaturesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT; +} +impl PhysicalDeviceShaderAtomicFloatFeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceShaderAtomicFloatFeaturesEXTBuilder<'a> { + PhysicalDeviceShaderAtomicFloatFeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceShaderAtomicFloatFeaturesEXTBuilder<'a> { + inner: PhysicalDeviceShaderAtomicFloatFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceShaderAtomicFloatFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderAtomicFloatFeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderAtomicFloatFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderAtomicFloatFeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceShaderAtomicFloatFeaturesEXTBuilder<'a> { + type Target = PhysicalDeviceShaderAtomicFloatFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderAtomicFloatFeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceShaderAtomicFloatFeaturesEXTBuilder<'a> { + #[inline] + pub fn shader_buffer_float32_atomics(mut self, shader_buffer_float32_atomics: bool) -> Self { + self.inner.shader_buffer_float32_atomics = shader_buffer_float32_atomics.into(); + self + } + #[inline] + pub fn shader_buffer_float32_atomic_add( + mut self, + shader_buffer_float32_atomic_add: bool, + ) -> Self { + self.inner.shader_buffer_float32_atomic_add = shader_buffer_float32_atomic_add.into(); + self + } + #[inline] + pub fn shader_buffer_float64_atomics(mut self, shader_buffer_float64_atomics: bool) -> Self { + self.inner.shader_buffer_float64_atomics = shader_buffer_float64_atomics.into(); + self + } + #[inline] + pub fn shader_buffer_float64_atomic_add( + mut self, + shader_buffer_float64_atomic_add: bool, + ) -> Self { + self.inner.shader_buffer_float64_atomic_add = shader_buffer_float64_atomic_add.into(); + self + } + #[inline] + pub fn shader_shared_float32_atomics(mut self, shader_shared_float32_atomics: bool) -> Self { + self.inner.shader_shared_float32_atomics = shader_shared_float32_atomics.into(); + self + } + #[inline] + pub fn shader_shared_float32_atomic_add( + mut self, + shader_shared_float32_atomic_add: bool, + ) -> Self { + self.inner.shader_shared_float32_atomic_add = shader_shared_float32_atomic_add.into(); + self + } + #[inline] + pub fn shader_shared_float64_atomics(mut self, shader_shared_float64_atomics: bool) -> Self { + self.inner.shader_shared_float64_atomics = shader_shared_float64_atomics.into(); + self + } + #[inline] + pub fn shader_shared_float64_atomic_add( + mut self, + shader_shared_float64_atomic_add: bool, + ) -> Self { + self.inner.shader_shared_float64_atomic_add = shader_shared_float64_atomic_add.into(); + self + } + #[inline] + pub fn shader_image_float32_atomics(mut self, shader_image_float32_atomics: bool) -> Self { + self.inner.shader_image_float32_atomics = shader_image_float32_atomics.into(); + self + } + #[inline] + pub fn shader_image_float32_atomic_add( + mut self, + shader_image_float32_atomic_add: bool, + ) -> Self { + self.inner.shader_image_float32_atomic_add = shader_image_float32_atomic_add.into(); + self + } + #[inline] + pub fn sparse_image_float32_atomics(mut self, sparse_image_float32_atomics: bool) -> Self { + self.inner.sparse_image_float32_atomics = sparse_image_float32_atomics.into(); + self + } + #[inline] + pub fn sparse_image_float32_atomic_add( + mut self, + sparse_image_float32_atomic_add: bool, + ) -> Self { + self.inner.sparse_image_float32_atomic_add = sparse_image_float32_atomic_add.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceShaderAtomicFloatFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceShaderAtomicFloat2FeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub shader_buffer_float16_atomics: Bool32, + pub shader_buffer_float16_atomic_add: Bool32, + pub shader_buffer_float16_atomic_min_max: Bool32, + pub shader_buffer_float32_atomic_min_max: Bool32, + pub shader_buffer_float64_atomic_min_max: Bool32, + pub shader_shared_float16_atomics: Bool32, + pub shader_shared_float16_atomic_add: Bool32, + pub shader_shared_float16_atomic_min_max: Bool32, + pub shader_shared_float32_atomic_min_max: Bool32, + pub shader_shared_float64_atomic_min_max: Bool32, + pub shader_image_float32_atomic_min_max: Bool32, + pub sparse_image_float32_atomic_min_max: Bool32, +} +impl ::std::default::Default for PhysicalDeviceShaderAtomicFloat2FeaturesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + shader_buffer_float16_atomics: Bool32::default(), + shader_buffer_float16_atomic_add: Bool32::default(), + shader_buffer_float16_atomic_min_max: Bool32::default(), + shader_buffer_float32_atomic_min_max: Bool32::default(), + shader_buffer_float64_atomic_min_max: Bool32::default(), + shader_shared_float16_atomics: Bool32::default(), + shader_shared_float16_atomic_add: Bool32::default(), + shader_shared_float16_atomic_min_max: Bool32::default(), + shader_shared_float32_atomic_min_max: Bool32::default(), + shader_shared_float64_atomic_min_max: Bool32::default(), + shader_image_float32_atomic_min_max: Bool32::default(), + sparse_image_float32_atomic_min_max: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceShaderAtomicFloat2FeaturesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT; +} +impl PhysicalDeviceShaderAtomicFloat2FeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceShaderAtomicFloat2FeaturesEXTBuilder<'a> { + PhysicalDeviceShaderAtomicFloat2FeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceShaderAtomicFloat2FeaturesEXTBuilder<'a> { + inner: PhysicalDeviceShaderAtomicFloat2FeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceShaderAtomicFloat2FeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderAtomicFloat2FeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderAtomicFloat2FeaturesEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderAtomicFloat2FeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceShaderAtomicFloat2FeaturesEXTBuilder<'a> { + type Target = PhysicalDeviceShaderAtomicFloat2FeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderAtomicFloat2FeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceShaderAtomicFloat2FeaturesEXTBuilder<'a> { + #[inline] + pub fn shader_buffer_float16_atomics(mut self, shader_buffer_float16_atomics: bool) -> Self { + self.inner.shader_buffer_float16_atomics = shader_buffer_float16_atomics.into(); + self + } + #[inline] + pub fn shader_buffer_float16_atomic_add( + mut self, + shader_buffer_float16_atomic_add: bool, + ) -> Self { + self.inner.shader_buffer_float16_atomic_add = shader_buffer_float16_atomic_add.into(); + self + } + #[inline] + pub fn shader_buffer_float16_atomic_min_max( + mut self, + shader_buffer_float16_atomic_min_max: bool, + ) -> Self { + self.inner.shader_buffer_float16_atomic_min_max = + shader_buffer_float16_atomic_min_max.into(); + self + } + #[inline] + pub fn shader_buffer_float32_atomic_min_max( + mut self, + shader_buffer_float32_atomic_min_max: bool, + ) -> Self { + self.inner.shader_buffer_float32_atomic_min_max = + shader_buffer_float32_atomic_min_max.into(); + self + } + #[inline] + pub fn shader_buffer_float64_atomic_min_max( + mut self, + shader_buffer_float64_atomic_min_max: bool, + ) -> Self { + self.inner.shader_buffer_float64_atomic_min_max = + shader_buffer_float64_atomic_min_max.into(); + self + } + #[inline] + pub fn shader_shared_float16_atomics(mut self, shader_shared_float16_atomics: bool) -> Self { + self.inner.shader_shared_float16_atomics = shader_shared_float16_atomics.into(); + self + } + #[inline] + pub fn shader_shared_float16_atomic_add( + mut self, + shader_shared_float16_atomic_add: bool, + ) -> Self { + self.inner.shader_shared_float16_atomic_add = shader_shared_float16_atomic_add.into(); + self + } + #[inline] + pub fn shader_shared_float16_atomic_min_max( + mut self, + shader_shared_float16_atomic_min_max: bool, + ) -> Self { + self.inner.shader_shared_float16_atomic_min_max = + shader_shared_float16_atomic_min_max.into(); + self + } + #[inline] + pub fn shader_shared_float32_atomic_min_max( + mut self, + shader_shared_float32_atomic_min_max: bool, + ) -> Self { + self.inner.shader_shared_float32_atomic_min_max = + shader_shared_float32_atomic_min_max.into(); + self + } + #[inline] + pub fn shader_shared_float64_atomic_min_max( + mut self, + shader_shared_float64_atomic_min_max: bool, + ) -> Self { + self.inner.shader_shared_float64_atomic_min_max = + shader_shared_float64_atomic_min_max.into(); + self + } + #[inline] + pub fn shader_image_float32_atomic_min_max( + mut self, + shader_image_float32_atomic_min_max: bool, + ) -> Self { + self.inner.shader_image_float32_atomic_min_max = shader_image_float32_atomic_min_max.into(); + self + } + #[inline] + pub fn sparse_image_float32_atomic_min_max( + mut self, + sparse_image_float32_atomic_min_max: bool, + ) -> Self { + self.inner.sparse_image_float32_atomic_min_max = sparse_image_float32_atomic_min_max.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceShaderAtomicFloat2FeaturesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceVertexAttributeDivisorFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub vertex_attribute_instance_rate_divisor: Bool32, + pub vertex_attribute_instance_rate_zero_divisor: Bool32, +} +impl ::std::default::Default for PhysicalDeviceVertexAttributeDivisorFeaturesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + vertex_attribute_instance_rate_divisor: Bool32::default(), + vertex_attribute_instance_rate_zero_divisor: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceVertexAttributeDivisorFeaturesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT; +} +impl PhysicalDeviceVertexAttributeDivisorFeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceVertexAttributeDivisorFeaturesEXTBuilder<'a> { + PhysicalDeviceVertexAttributeDivisorFeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceVertexAttributeDivisorFeaturesEXTBuilder<'a> { + inner: PhysicalDeviceVertexAttributeDivisorFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceVertexAttributeDivisorFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceVertexAttributeDivisorFeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVertexAttributeDivisorFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVertexAttributeDivisorFeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceVertexAttributeDivisorFeaturesEXTBuilder<'a> { + type Target = PhysicalDeviceVertexAttributeDivisorFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceVertexAttributeDivisorFeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceVertexAttributeDivisorFeaturesEXTBuilder<'a> { + #[inline] + pub fn vertex_attribute_instance_rate_divisor( + mut self, + vertex_attribute_instance_rate_divisor: bool, + ) -> Self { + self.inner.vertex_attribute_instance_rate_divisor = + vertex_attribute_instance_rate_divisor.into(); + self + } + #[inline] + pub fn vertex_attribute_instance_rate_zero_divisor( + mut self, + vertex_attribute_instance_rate_zero_divisor: bool, + ) -> Self { + self.inner.vertex_attribute_instance_rate_zero_divisor = + vertex_attribute_instance_rate_zero_divisor.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceVertexAttributeDivisorFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct QueueFamilyCheckpointPropertiesNV { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub checkpoint_execution_stage_mask: PipelineStageFlags, +} +impl ::std::default::Default for QueueFamilyCheckpointPropertiesNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + checkpoint_execution_stage_mask: PipelineStageFlags::default(), + } + } +} +unsafe impl TaggedStructure for QueueFamilyCheckpointPropertiesNV { + const STRUCTURE_TYPE: StructureType = StructureType::QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV; +} +impl QueueFamilyCheckpointPropertiesNV { + pub fn builder<'a>() -> QueueFamilyCheckpointPropertiesNVBuilder<'a> { + QueueFamilyCheckpointPropertiesNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct QueueFamilyCheckpointPropertiesNVBuilder<'a> { + inner: QueueFamilyCheckpointPropertiesNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsQueueFamilyProperties2 for QueueFamilyCheckpointPropertiesNVBuilder<'_> {} +unsafe impl ExtendsQueueFamilyProperties2 for QueueFamilyCheckpointPropertiesNV {} +impl<'a> ::std::ops::Deref for QueueFamilyCheckpointPropertiesNVBuilder<'a> { + type Target = QueueFamilyCheckpointPropertiesNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for QueueFamilyCheckpointPropertiesNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> QueueFamilyCheckpointPropertiesNVBuilder<'a> { + #[inline] + pub fn checkpoint_execution_stage_mask( + mut self, + checkpoint_execution_stage_mask: PipelineStageFlags, + ) -> Self { + self.inner.checkpoint_execution_stage_mask = checkpoint_execution_stage_mask; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> QueueFamilyCheckpointPropertiesNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct CheckpointDataNV { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub stage: PipelineStageFlags, + pub p_checkpoint_marker: *mut c_void, +} +impl ::std::default::Default for CheckpointDataNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + stage: PipelineStageFlags::default(), + p_checkpoint_marker: ::std::ptr::null_mut(), + } + } +} +unsafe impl TaggedStructure for CheckpointDataNV { + const STRUCTURE_TYPE: StructureType = StructureType::CHECKPOINT_DATA_NV; +} +impl CheckpointDataNV { + pub fn builder<'a>() -> CheckpointDataNVBuilder<'a> { + CheckpointDataNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct CheckpointDataNVBuilder<'a> { + inner: CheckpointDataNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for CheckpointDataNVBuilder<'a> { + type Target = CheckpointDataNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for CheckpointDataNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> CheckpointDataNVBuilder<'a> { + #[inline] + pub fn stage(mut self, stage: PipelineStageFlags) -> Self { + self.inner.stage = stage; + self + } + #[inline] + pub fn checkpoint_marker(mut self, checkpoint_marker: *mut c_void) -> Self { + self.inner.p_checkpoint_marker = checkpoint_marker; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> CheckpointDataNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceDepthStencilResolveProperties { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub supported_depth_resolve_modes: ResolveModeFlags, + pub supported_stencil_resolve_modes: ResolveModeFlags, + pub independent_resolve_none: Bool32, + pub independent_resolve: Bool32, +} +impl ::std::default::Default for PhysicalDeviceDepthStencilResolveProperties { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + supported_depth_resolve_modes: ResolveModeFlags::default(), + supported_stencil_resolve_modes: ResolveModeFlags::default(), + independent_resolve_none: Bool32::default(), + independent_resolve: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceDepthStencilResolveProperties { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES; +} +impl PhysicalDeviceDepthStencilResolveProperties { + pub fn builder<'a>() -> PhysicalDeviceDepthStencilResolvePropertiesBuilder<'a> { + PhysicalDeviceDepthStencilResolvePropertiesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceDepthStencilResolvePropertiesBuilder<'a> { + inner: PhysicalDeviceDepthStencilResolveProperties, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceDepthStencilResolvePropertiesBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceDepthStencilResolveProperties {} +impl<'a> ::std::ops::Deref for PhysicalDeviceDepthStencilResolvePropertiesBuilder<'a> { + type Target = PhysicalDeviceDepthStencilResolveProperties; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceDepthStencilResolvePropertiesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceDepthStencilResolvePropertiesBuilder<'a> { + #[inline] + pub fn supported_depth_resolve_modes( + mut self, + supported_depth_resolve_modes: ResolveModeFlags, + ) -> Self { + self.inner.supported_depth_resolve_modes = supported_depth_resolve_modes; + self + } + #[inline] + pub fn supported_stencil_resolve_modes( + mut self, + supported_stencil_resolve_modes: ResolveModeFlags, + ) -> Self { + self.inner.supported_stencil_resolve_modes = supported_stencil_resolve_modes; + self + } + #[inline] + pub fn independent_resolve_none(mut self, independent_resolve_none: bool) -> Self { + self.inner.independent_resolve_none = independent_resolve_none.into(); + self + } + #[inline] + pub fn independent_resolve(mut self, independent_resolve: bool) -> Self { + self.inner.independent_resolve = independent_resolve.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceDepthStencilResolveProperties { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SubpassDescriptionDepthStencilResolve { + pub s_type: StructureType, + pub p_next: *const c_void, + pub depth_resolve_mode: ResolveModeFlags, + pub stencil_resolve_mode: ResolveModeFlags, + pub p_depth_stencil_resolve_attachment: *const AttachmentReference2, +} +impl ::std::default::Default for SubpassDescriptionDepthStencilResolve { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + depth_resolve_mode: ResolveModeFlags::default(), + stencil_resolve_mode: ResolveModeFlags::default(), + p_depth_stencil_resolve_attachment: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for SubpassDescriptionDepthStencilResolve { + const STRUCTURE_TYPE: StructureType = StructureType::SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE; +} +impl SubpassDescriptionDepthStencilResolve { + pub fn builder<'a>() -> SubpassDescriptionDepthStencilResolveBuilder<'a> { + SubpassDescriptionDepthStencilResolveBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SubpassDescriptionDepthStencilResolveBuilder<'a> { + inner: SubpassDescriptionDepthStencilResolve, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsSubpassDescription2 for SubpassDescriptionDepthStencilResolveBuilder<'_> {} +unsafe impl ExtendsSubpassDescription2 for SubpassDescriptionDepthStencilResolve {} +impl<'a> ::std::ops::Deref for SubpassDescriptionDepthStencilResolveBuilder<'a> { + type Target = SubpassDescriptionDepthStencilResolve; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SubpassDescriptionDepthStencilResolveBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SubpassDescriptionDepthStencilResolveBuilder<'a> { + #[inline] + pub fn depth_resolve_mode(mut self, depth_resolve_mode: ResolveModeFlags) -> Self { + self.inner.depth_resolve_mode = depth_resolve_mode; + self + } + #[inline] + pub fn stencil_resolve_mode(mut self, stencil_resolve_mode: ResolveModeFlags) -> Self { + self.inner.stencil_resolve_mode = stencil_resolve_mode; + self + } + #[inline] + pub fn depth_stencil_resolve_attachment( + mut self, + depth_stencil_resolve_attachment: &'a AttachmentReference2, + ) -> Self { + self.inner.p_depth_stencil_resolve_attachment = depth_stencil_resolve_attachment; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SubpassDescriptionDepthStencilResolve { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ImageViewASTCDecodeModeEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub decode_mode: Format, +} +impl ::std::default::Default for ImageViewASTCDecodeModeEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + decode_mode: Format::default(), + } + } +} +unsafe impl TaggedStructure for ImageViewASTCDecodeModeEXT { + const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_VIEW_ASTC_DECODE_MODE_EXT; +} +impl ImageViewASTCDecodeModeEXT { + pub fn builder<'a>() -> ImageViewASTCDecodeModeEXTBuilder<'a> { + ImageViewASTCDecodeModeEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ImageViewASTCDecodeModeEXTBuilder<'a> { + inner: ImageViewASTCDecodeModeEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsImageViewCreateInfo for ImageViewASTCDecodeModeEXTBuilder<'_> {} +unsafe impl ExtendsImageViewCreateInfo for ImageViewASTCDecodeModeEXT {} +impl<'a> ::std::ops::Deref for ImageViewASTCDecodeModeEXTBuilder<'a> { + type Target = ImageViewASTCDecodeModeEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ImageViewASTCDecodeModeEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ImageViewASTCDecodeModeEXTBuilder<'a> { + #[inline] + pub fn decode_mode(mut self, decode_mode: Format) -> Self { + self.inner.decode_mode = decode_mode; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ImageViewASTCDecodeModeEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceASTCDecodeFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub decode_mode_shared_exponent: Bool32, +} +impl ::std::default::Default for PhysicalDeviceASTCDecodeFeaturesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + decode_mode_shared_exponent: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceASTCDecodeFeaturesEXT { + const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT; +} +impl PhysicalDeviceASTCDecodeFeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceASTCDecodeFeaturesEXTBuilder<'a> { + PhysicalDeviceASTCDecodeFeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceASTCDecodeFeaturesEXTBuilder<'a> { + inner: PhysicalDeviceASTCDecodeFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceASTCDecodeFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceASTCDecodeFeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceASTCDecodeFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceASTCDecodeFeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceASTCDecodeFeaturesEXTBuilder<'a> { + type Target = PhysicalDeviceASTCDecodeFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceASTCDecodeFeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceASTCDecodeFeaturesEXTBuilder<'a> { + #[inline] + pub fn decode_mode_shared_exponent(mut self, decode_mode_shared_exponent: bool) -> Self { + self.inner.decode_mode_shared_exponent = decode_mode_shared_exponent.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceASTCDecodeFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceTransformFeedbackFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub transform_feedback: Bool32, + pub geometry_streams: Bool32, +} +impl ::std::default::Default for PhysicalDeviceTransformFeedbackFeaturesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + transform_feedback: Bool32::default(), + geometry_streams: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceTransformFeedbackFeaturesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT; +} +impl PhysicalDeviceTransformFeedbackFeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceTransformFeedbackFeaturesEXTBuilder<'a> { + PhysicalDeviceTransformFeedbackFeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceTransformFeedbackFeaturesEXTBuilder<'a> { + inner: PhysicalDeviceTransformFeedbackFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceTransformFeedbackFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceTransformFeedbackFeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceTransformFeedbackFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceTransformFeedbackFeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceTransformFeedbackFeaturesEXTBuilder<'a> { + type Target = PhysicalDeviceTransformFeedbackFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceTransformFeedbackFeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceTransformFeedbackFeaturesEXTBuilder<'a> { + #[inline] + pub fn transform_feedback(mut self, transform_feedback: bool) -> Self { + self.inner.transform_feedback = transform_feedback.into(); + self + } + #[inline] + pub fn geometry_streams(mut self, geometry_streams: bool) -> Self { + self.inner.geometry_streams = geometry_streams.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceTransformFeedbackFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceTransformFeedbackPropertiesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub max_transform_feedback_streams: u32, + pub max_transform_feedback_buffers: u32, + pub max_transform_feedback_buffer_size: DeviceSize, + pub max_transform_feedback_stream_data_size: u32, + pub max_transform_feedback_buffer_data_size: u32, + pub max_transform_feedback_buffer_data_stride: u32, + pub transform_feedback_queries: Bool32, + pub transform_feedback_streams_lines_triangles: Bool32, + pub transform_feedback_rasterization_stream_select: Bool32, + pub transform_feedback_draw: Bool32, +} +impl ::std::default::Default for PhysicalDeviceTransformFeedbackPropertiesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + max_transform_feedback_streams: u32::default(), + max_transform_feedback_buffers: u32::default(), + max_transform_feedback_buffer_size: DeviceSize::default(), + max_transform_feedback_stream_data_size: u32::default(), + max_transform_feedback_buffer_data_size: u32::default(), + max_transform_feedback_buffer_data_stride: u32::default(), + transform_feedback_queries: Bool32::default(), + transform_feedback_streams_lines_triangles: Bool32::default(), + transform_feedback_rasterization_stream_select: Bool32::default(), + transform_feedback_draw: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceTransformFeedbackPropertiesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT; +} +impl PhysicalDeviceTransformFeedbackPropertiesEXT { + pub fn builder<'a>() -> PhysicalDeviceTransformFeedbackPropertiesEXTBuilder<'a> { + PhysicalDeviceTransformFeedbackPropertiesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceTransformFeedbackPropertiesEXTBuilder<'a> { + inner: PhysicalDeviceTransformFeedbackPropertiesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceTransformFeedbackPropertiesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceTransformFeedbackPropertiesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceTransformFeedbackPropertiesEXTBuilder<'a> { + type Target = PhysicalDeviceTransformFeedbackPropertiesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceTransformFeedbackPropertiesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceTransformFeedbackPropertiesEXTBuilder<'a> { + #[inline] + pub fn max_transform_feedback_streams(mut self, max_transform_feedback_streams: u32) -> Self { + self.inner.max_transform_feedback_streams = max_transform_feedback_streams; + self + } + #[inline] + pub fn max_transform_feedback_buffers(mut self, max_transform_feedback_buffers: u32) -> Self { + self.inner.max_transform_feedback_buffers = max_transform_feedback_buffers; + self + } + #[inline] + pub fn max_transform_feedback_buffer_size( + mut self, + max_transform_feedback_buffer_size: DeviceSize, + ) -> Self { + self.inner.max_transform_feedback_buffer_size = max_transform_feedback_buffer_size; + self + } + #[inline] + pub fn max_transform_feedback_stream_data_size( + mut self, + max_transform_feedback_stream_data_size: u32, + ) -> Self { + self.inner.max_transform_feedback_stream_data_size = + max_transform_feedback_stream_data_size; + self + } + #[inline] + pub fn max_transform_feedback_buffer_data_size( + mut self, + max_transform_feedback_buffer_data_size: u32, + ) -> Self { + self.inner.max_transform_feedback_buffer_data_size = + max_transform_feedback_buffer_data_size; + self + } + #[inline] + pub fn max_transform_feedback_buffer_data_stride( + mut self, + max_transform_feedback_buffer_data_stride: u32, + ) -> Self { + self.inner.max_transform_feedback_buffer_data_stride = + max_transform_feedback_buffer_data_stride; + self + } + #[inline] + pub fn transform_feedback_queries(mut self, transform_feedback_queries: bool) -> Self { + self.inner.transform_feedback_queries = transform_feedback_queries.into(); + self + } + #[inline] + pub fn transform_feedback_streams_lines_triangles( + mut self, + transform_feedback_streams_lines_triangles: bool, + ) -> Self { + self.inner.transform_feedback_streams_lines_triangles = + transform_feedback_streams_lines_triangles.into(); + self + } + #[inline] + pub fn transform_feedback_rasterization_stream_select( + mut self, + transform_feedback_rasterization_stream_select: bool, + ) -> Self { + self.inner.transform_feedback_rasterization_stream_select = + transform_feedback_rasterization_stream_select.into(); + self + } + #[inline] + pub fn transform_feedback_draw(mut self, transform_feedback_draw: bool) -> Self { + self.inner.transform_feedback_draw = transform_feedback_draw.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceTransformFeedbackPropertiesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PipelineRasterizationStateStreamCreateInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: PipelineRasterizationStateStreamCreateFlagsEXT, + pub rasterization_stream: u32, +} +impl ::std::default::Default for PipelineRasterizationStateStreamCreateInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: PipelineRasterizationStateStreamCreateFlagsEXT::default(), + rasterization_stream: u32::default(), + } + } +} +unsafe impl TaggedStructure for PipelineRasterizationStateStreamCreateInfoEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT; +} +impl PipelineRasterizationStateStreamCreateInfoEXT { + pub fn builder<'a>() -> PipelineRasterizationStateStreamCreateInfoEXTBuilder<'a> { + PipelineRasterizationStateStreamCreateInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PipelineRasterizationStateStreamCreateInfoEXTBuilder<'a> { + inner: PipelineRasterizationStateStreamCreateInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPipelineRasterizationStateCreateInfo + for PipelineRasterizationStateStreamCreateInfoEXTBuilder<'_> +{ +} +unsafe impl ExtendsPipelineRasterizationStateCreateInfo + for PipelineRasterizationStateStreamCreateInfoEXT +{ +} +impl<'a> ::std::ops::Deref for PipelineRasterizationStateStreamCreateInfoEXTBuilder<'a> { + type Target = PipelineRasterizationStateStreamCreateInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PipelineRasterizationStateStreamCreateInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PipelineRasterizationStateStreamCreateInfoEXTBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: PipelineRasterizationStateStreamCreateFlagsEXT) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn rasterization_stream(mut self, rasterization_stream: u32) -> Self { + self.inner.rasterization_stream = rasterization_stream; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PipelineRasterizationStateStreamCreateInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceRepresentativeFragmentTestFeaturesNV { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub representative_fragment_test: Bool32, +} +impl ::std::default::Default for PhysicalDeviceRepresentativeFragmentTestFeaturesNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + representative_fragment_test: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceRepresentativeFragmentTestFeaturesNV { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV; +} +impl PhysicalDeviceRepresentativeFragmentTestFeaturesNV { + pub fn builder<'a>() -> PhysicalDeviceRepresentativeFragmentTestFeaturesNVBuilder<'a> { + PhysicalDeviceRepresentativeFragmentTestFeaturesNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceRepresentativeFragmentTestFeaturesNVBuilder<'a> { + inner: PhysicalDeviceRepresentativeFragmentTestFeaturesNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceRepresentativeFragmentTestFeaturesNVBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceRepresentativeFragmentTestFeaturesNV {} +unsafe impl ExtendsDeviceCreateInfo + for PhysicalDeviceRepresentativeFragmentTestFeaturesNVBuilder<'_> +{ +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceRepresentativeFragmentTestFeaturesNV {} +impl<'a> ::std::ops::Deref for PhysicalDeviceRepresentativeFragmentTestFeaturesNVBuilder<'a> { + type Target = PhysicalDeviceRepresentativeFragmentTestFeaturesNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceRepresentativeFragmentTestFeaturesNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceRepresentativeFragmentTestFeaturesNVBuilder<'a> { + #[inline] + pub fn representative_fragment_test(mut self, representative_fragment_test: bool) -> Self { + self.inner.representative_fragment_test = representative_fragment_test.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceRepresentativeFragmentTestFeaturesNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PipelineRepresentativeFragmentTestStateCreateInfoNV { + pub s_type: StructureType, + pub p_next: *const c_void, + pub representative_fragment_test_enable: Bool32, +} +impl ::std::default::Default for PipelineRepresentativeFragmentTestStateCreateInfoNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + representative_fragment_test_enable: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PipelineRepresentativeFragmentTestStateCreateInfoNV { + const STRUCTURE_TYPE: StructureType = + StructureType::PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV; +} +impl PipelineRepresentativeFragmentTestStateCreateInfoNV { + pub fn builder<'a>() -> PipelineRepresentativeFragmentTestStateCreateInfoNVBuilder<'a> { + PipelineRepresentativeFragmentTestStateCreateInfoNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PipelineRepresentativeFragmentTestStateCreateInfoNVBuilder<'a> { + inner: PipelineRepresentativeFragmentTestStateCreateInfoNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsGraphicsPipelineCreateInfo + for PipelineRepresentativeFragmentTestStateCreateInfoNVBuilder<'_> +{ +} +unsafe impl ExtendsGraphicsPipelineCreateInfo + for PipelineRepresentativeFragmentTestStateCreateInfoNV +{ +} +impl<'a> ::std::ops::Deref for PipelineRepresentativeFragmentTestStateCreateInfoNVBuilder<'a> { + type Target = PipelineRepresentativeFragmentTestStateCreateInfoNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PipelineRepresentativeFragmentTestStateCreateInfoNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PipelineRepresentativeFragmentTestStateCreateInfoNVBuilder<'a> { + #[inline] + pub fn representative_fragment_test_enable( + mut self, + representative_fragment_test_enable: bool, + ) -> Self { + self.inner.representative_fragment_test_enable = representative_fragment_test_enable.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PipelineRepresentativeFragmentTestStateCreateInfoNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceExclusiveScissorFeaturesNV { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub exclusive_scissor: Bool32, +} +impl ::std::default::Default for PhysicalDeviceExclusiveScissorFeaturesNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + exclusive_scissor: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceExclusiveScissorFeaturesNV { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV; +} +impl PhysicalDeviceExclusiveScissorFeaturesNV { + pub fn builder<'a>() -> PhysicalDeviceExclusiveScissorFeaturesNVBuilder<'a> { + PhysicalDeviceExclusiveScissorFeaturesNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceExclusiveScissorFeaturesNVBuilder<'a> { + inner: PhysicalDeviceExclusiveScissorFeaturesNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceExclusiveScissorFeaturesNVBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceExclusiveScissorFeaturesNV {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceExclusiveScissorFeaturesNVBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceExclusiveScissorFeaturesNV {} +impl<'a> ::std::ops::Deref for PhysicalDeviceExclusiveScissorFeaturesNVBuilder<'a> { + type Target = PhysicalDeviceExclusiveScissorFeaturesNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceExclusiveScissorFeaturesNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceExclusiveScissorFeaturesNVBuilder<'a> { + #[inline] + pub fn exclusive_scissor(mut self, exclusive_scissor: bool) -> Self { + self.inner.exclusive_scissor = exclusive_scissor.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceExclusiveScissorFeaturesNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PipelineViewportExclusiveScissorStateCreateInfoNV { + pub s_type: StructureType, + pub p_next: *const c_void, + pub exclusive_scissor_count: u32, + pub p_exclusive_scissors: *const Rect2D, +} +impl ::std::default::Default for PipelineViewportExclusiveScissorStateCreateInfoNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + exclusive_scissor_count: u32::default(), + p_exclusive_scissors: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for PipelineViewportExclusiveScissorStateCreateInfoNV { + const STRUCTURE_TYPE: StructureType = + StructureType::PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV; +} +impl PipelineViewportExclusiveScissorStateCreateInfoNV { + pub fn builder<'a>() -> PipelineViewportExclusiveScissorStateCreateInfoNVBuilder<'a> { + PipelineViewportExclusiveScissorStateCreateInfoNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PipelineViewportExclusiveScissorStateCreateInfoNVBuilder<'a> { + inner: PipelineViewportExclusiveScissorStateCreateInfoNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPipelineViewportStateCreateInfo + for PipelineViewportExclusiveScissorStateCreateInfoNVBuilder<'_> +{ +} +unsafe impl ExtendsPipelineViewportStateCreateInfo + for PipelineViewportExclusiveScissorStateCreateInfoNV +{ +} +impl<'a> ::std::ops::Deref for PipelineViewportExclusiveScissorStateCreateInfoNVBuilder<'a> { + type Target = PipelineViewportExclusiveScissorStateCreateInfoNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PipelineViewportExclusiveScissorStateCreateInfoNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PipelineViewportExclusiveScissorStateCreateInfoNVBuilder<'a> { + #[inline] + pub fn exclusive_scissors(mut self, exclusive_scissors: &'a [Rect2D]) -> Self { + self.inner.exclusive_scissor_count = exclusive_scissors.len() as _; + self.inner.p_exclusive_scissors = exclusive_scissors.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PipelineViewportExclusiveScissorStateCreateInfoNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceCornerSampledImageFeaturesNV { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub corner_sampled_image: Bool32, +} +impl ::std::default::Default for PhysicalDeviceCornerSampledImageFeaturesNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + corner_sampled_image: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceCornerSampledImageFeaturesNV { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV; +} +impl PhysicalDeviceCornerSampledImageFeaturesNV { + pub fn builder<'a>() -> PhysicalDeviceCornerSampledImageFeaturesNVBuilder<'a> { + PhysicalDeviceCornerSampledImageFeaturesNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceCornerSampledImageFeaturesNVBuilder<'a> { + inner: PhysicalDeviceCornerSampledImageFeaturesNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceCornerSampledImageFeaturesNVBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceCornerSampledImageFeaturesNV {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceCornerSampledImageFeaturesNVBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceCornerSampledImageFeaturesNV {} +impl<'a> ::std::ops::Deref for PhysicalDeviceCornerSampledImageFeaturesNVBuilder<'a> { + type Target = PhysicalDeviceCornerSampledImageFeaturesNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceCornerSampledImageFeaturesNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceCornerSampledImageFeaturesNVBuilder<'a> { + #[inline] + pub fn corner_sampled_image(mut self, corner_sampled_image: bool) -> Self { + self.inner.corner_sampled_image = corner_sampled_image.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceCornerSampledImageFeaturesNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceComputeShaderDerivativesFeaturesNV { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub compute_derivative_group_quads: Bool32, + pub compute_derivative_group_linear: Bool32, +} +impl ::std::default::Default for PhysicalDeviceComputeShaderDerivativesFeaturesNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + compute_derivative_group_quads: Bool32::default(), + compute_derivative_group_linear: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceComputeShaderDerivativesFeaturesNV { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV; +} +impl PhysicalDeviceComputeShaderDerivativesFeaturesNV { + pub fn builder<'a>() -> PhysicalDeviceComputeShaderDerivativesFeaturesNVBuilder<'a> { + PhysicalDeviceComputeShaderDerivativesFeaturesNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceComputeShaderDerivativesFeaturesNVBuilder<'a> { + inner: PhysicalDeviceComputeShaderDerivativesFeaturesNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceComputeShaderDerivativesFeaturesNVBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceComputeShaderDerivativesFeaturesNV {} +unsafe impl ExtendsDeviceCreateInfo + for PhysicalDeviceComputeShaderDerivativesFeaturesNVBuilder<'_> +{ +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceComputeShaderDerivativesFeaturesNV {} +impl<'a> ::std::ops::Deref for PhysicalDeviceComputeShaderDerivativesFeaturesNVBuilder<'a> { + type Target = PhysicalDeviceComputeShaderDerivativesFeaturesNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceComputeShaderDerivativesFeaturesNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceComputeShaderDerivativesFeaturesNVBuilder<'a> { + #[inline] + pub fn compute_derivative_group_quads(mut self, compute_derivative_group_quads: bool) -> Self { + self.inner.compute_derivative_group_quads = compute_derivative_group_quads.into(); + self + } + #[inline] + pub fn compute_derivative_group_linear( + mut self, + compute_derivative_group_linear: bool, + ) -> Self { + self.inner.compute_derivative_group_linear = compute_derivative_group_linear.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceComputeShaderDerivativesFeaturesNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceShaderImageFootprintFeaturesNV { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub image_footprint: Bool32, +} +impl ::std::default::Default for PhysicalDeviceShaderImageFootprintFeaturesNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + image_footprint: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceShaderImageFootprintFeaturesNV { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV; +} +impl PhysicalDeviceShaderImageFootprintFeaturesNV { + pub fn builder<'a>() -> PhysicalDeviceShaderImageFootprintFeaturesNVBuilder<'a> { + PhysicalDeviceShaderImageFootprintFeaturesNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceShaderImageFootprintFeaturesNVBuilder<'a> { + inner: PhysicalDeviceShaderImageFootprintFeaturesNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceShaderImageFootprintFeaturesNVBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderImageFootprintFeaturesNV {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderImageFootprintFeaturesNVBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderImageFootprintFeaturesNV {} +impl<'a> ::std::ops::Deref for PhysicalDeviceShaderImageFootprintFeaturesNVBuilder<'a> { + type Target = PhysicalDeviceShaderImageFootprintFeaturesNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderImageFootprintFeaturesNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceShaderImageFootprintFeaturesNVBuilder<'a> { + #[inline] + pub fn image_footprint(mut self, image_footprint: bool) -> Self { + self.inner.image_footprint = image_footprint.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceShaderImageFootprintFeaturesNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub dedicated_allocation_image_aliasing: Bool32, +} +impl ::std::default::Default for PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + dedicated_allocation_image_aliasing: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV; +} +impl PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV { + pub fn builder<'a>() -> PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNVBuilder<'a> { + PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNVBuilder<'a> { + inner: PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNVBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV +{ +} +unsafe impl ExtendsDeviceCreateInfo + for PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNVBuilder<'_> +{ +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV {} +impl<'a> ::std::ops::Deref for PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNVBuilder<'a> { + type Target = PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut + for PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNVBuilder<'a> +{ + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNVBuilder<'a> { + #[inline] + pub fn dedicated_allocation_image_aliasing( + mut self, + dedicated_allocation_image_aliasing: bool, + ) -> Self { + self.inner.dedicated_allocation_image_aliasing = dedicated_allocation_image_aliasing.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceCopyMemoryIndirectFeaturesNV { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub indirect_copy: Bool32, +} +impl ::std::default::Default for PhysicalDeviceCopyMemoryIndirectFeaturesNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + indirect_copy: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceCopyMemoryIndirectFeaturesNV { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV; +} +impl PhysicalDeviceCopyMemoryIndirectFeaturesNV { + pub fn builder<'a>() -> PhysicalDeviceCopyMemoryIndirectFeaturesNVBuilder<'a> { + PhysicalDeviceCopyMemoryIndirectFeaturesNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceCopyMemoryIndirectFeaturesNVBuilder<'a> { + inner: PhysicalDeviceCopyMemoryIndirectFeaturesNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceCopyMemoryIndirectFeaturesNVBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceCopyMemoryIndirectFeaturesNV {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceCopyMemoryIndirectFeaturesNVBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceCopyMemoryIndirectFeaturesNV {} +impl<'a> ::std::ops::Deref for PhysicalDeviceCopyMemoryIndirectFeaturesNVBuilder<'a> { + type Target = PhysicalDeviceCopyMemoryIndirectFeaturesNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceCopyMemoryIndirectFeaturesNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceCopyMemoryIndirectFeaturesNVBuilder<'a> { + #[inline] + pub fn indirect_copy(mut self, indirect_copy: bool) -> Self { + self.inner.indirect_copy = indirect_copy.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceCopyMemoryIndirectFeaturesNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceCopyMemoryIndirectPropertiesNV { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub supported_queues: QueueFlags, +} +impl ::std::default::Default for PhysicalDeviceCopyMemoryIndirectPropertiesNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + supported_queues: QueueFlags::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceCopyMemoryIndirectPropertiesNV { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV; +} +impl PhysicalDeviceCopyMemoryIndirectPropertiesNV { + pub fn builder<'a>() -> PhysicalDeviceCopyMemoryIndirectPropertiesNVBuilder<'a> { + PhysicalDeviceCopyMemoryIndirectPropertiesNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceCopyMemoryIndirectPropertiesNVBuilder<'a> { + inner: PhysicalDeviceCopyMemoryIndirectPropertiesNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceCopyMemoryIndirectPropertiesNVBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceCopyMemoryIndirectPropertiesNV {} +impl<'a> ::std::ops::Deref for PhysicalDeviceCopyMemoryIndirectPropertiesNVBuilder<'a> { + type Target = PhysicalDeviceCopyMemoryIndirectPropertiesNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceCopyMemoryIndirectPropertiesNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceCopyMemoryIndirectPropertiesNVBuilder<'a> { + #[inline] + pub fn supported_queues(mut self, supported_queues: QueueFlags) -> Self { + self.inner.supported_queues = supported_queues; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceCopyMemoryIndirectPropertiesNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceMemoryDecompressionFeaturesNV { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub memory_decompression: Bool32, +} +impl ::std::default::Default for PhysicalDeviceMemoryDecompressionFeaturesNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + memory_decompression: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceMemoryDecompressionFeaturesNV { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV; +} +impl PhysicalDeviceMemoryDecompressionFeaturesNV { + pub fn builder<'a>() -> PhysicalDeviceMemoryDecompressionFeaturesNVBuilder<'a> { + PhysicalDeviceMemoryDecompressionFeaturesNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceMemoryDecompressionFeaturesNVBuilder<'a> { + inner: PhysicalDeviceMemoryDecompressionFeaturesNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceMemoryDecompressionFeaturesNVBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceMemoryDecompressionFeaturesNV {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMemoryDecompressionFeaturesNVBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMemoryDecompressionFeaturesNV {} +impl<'a> ::std::ops::Deref for PhysicalDeviceMemoryDecompressionFeaturesNVBuilder<'a> { + type Target = PhysicalDeviceMemoryDecompressionFeaturesNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceMemoryDecompressionFeaturesNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceMemoryDecompressionFeaturesNVBuilder<'a> { + #[inline] + pub fn memory_decompression(mut self, memory_decompression: bool) -> Self { + self.inner.memory_decompression = memory_decompression.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceMemoryDecompressionFeaturesNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceMemoryDecompressionPropertiesNV { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub decompression_methods: MemoryDecompressionMethodFlagsNV, + pub max_decompression_indirect_count: u64, +} +impl ::std::default::Default for PhysicalDeviceMemoryDecompressionPropertiesNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + decompression_methods: MemoryDecompressionMethodFlagsNV::default(), + max_decompression_indirect_count: u64::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceMemoryDecompressionPropertiesNV { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV; +} +impl PhysicalDeviceMemoryDecompressionPropertiesNV { + pub fn builder<'a>() -> PhysicalDeviceMemoryDecompressionPropertiesNVBuilder<'a> { + PhysicalDeviceMemoryDecompressionPropertiesNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceMemoryDecompressionPropertiesNVBuilder<'a> { + inner: PhysicalDeviceMemoryDecompressionPropertiesNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceMemoryDecompressionPropertiesNVBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceMemoryDecompressionPropertiesNV {} +impl<'a> ::std::ops::Deref for PhysicalDeviceMemoryDecompressionPropertiesNVBuilder<'a> { + type Target = PhysicalDeviceMemoryDecompressionPropertiesNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceMemoryDecompressionPropertiesNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceMemoryDecompressionPropertiesNVBuilder<'a> { + #[inline] + pub fn decompression_methods( + mut self, + decompression_methods: MemoryDecompressionMethodFlagsNV, + ) -> Self { + self.inner.decompression_methods = decompression_methods; + self + } + #[inline] + pub fn max_decompression_indirect_count( + mut self, + max_decompression_indirect_count: u64, + ) -> Self { + self.inner.max_decompression_indirect_count = max_decompression_indirect_count; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceMemoryDecompressionPropertiesNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ShadingRatePaletteNV { + pub shading_rate_palette_entry_count: u32, + pub p_shading_rate_palette_entries: *const ShadingRatePaletteEntryNV, +} +impl ::std::default::Default for ShadingRatePaletteNV { + #[inline] + fn default() -> Self { + Self { + shading_rate_palette_entry_count: u32::default(), + p_shading_rate_palette_entries: ::std::ptr::null(), + } + } +} +impl ShadingRatePaletteNV { + pub fn builder<'a>() -> ShadingRatePaletteNVBuilder<'a> { + ShadingRatePaletteNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ShadingRatePaletteNVBuilder<'a> { + inner: ShadingRatePaletteNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ShadingRatePaletteNVBuilder<'a> { + type Target = ShadingRatePaletteNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ShadingRatePaletteNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ShadingRatePaletteNVBuilder<'a> { + #[inline] + pub fn shading_rate_palette_entries( + mut self, + shading_rate_palette_entries: &'a [ShadingRatePaletteEntryNV], + ) -> Self { + self.inner.shading_rate_palette_entry_count = shading_rate_palette_entries.len() as _; + self.inner.p_shading_rate_palette_entries = shading_rate_palette_entries.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ShadingRatePaletteNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PipelineViewportShadingRateImageStateCreateInfoNV { + pub s_type: StructureType, + pub p_next: *const c_void, + pub shading_rate_image_enable: Bool32, + pub viewport_count: u32, + pub p_shading_rate_palettes: *const ShadingRatePaletteNV, +} +impl ::std::default::Default for PipelineViewportShadingRateImageStateCreateInfoNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + shading_rate_image_enable: Bool32::default(), + viewport_count: u32::default(), + p_shading_rate_palettes: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for PipelineViewportShadingRateImageStateCreateInfoNV { + const STRUCTURE_TYPE: StructureType = + StructureType::PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV; +} +impl PipelineViewportShadingRateImageStateCreateInfoNV { + pub fn builder<'a>() -> PipelineViewportShadingRateImageStateCreateInfoNVBuilder<'a> { + PipelineViewportShadingRateImageStateCreateInfoNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PipelineViewportShadingRateImageStateCreateInfoNVBuilder<'a> { + inner: PipelineViewportShadingRateImageStateCreateInfoNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPipelineViewportStateCreateInfo + for PipelineViewportShadingRateImageStateCreateInfoNVBuilder<'_> +{ +} +unsafe impl ExtendsPipelineViewportStateCreateInfo + for PipelineViewportShadingRateImageStateCreateInfoNV +{ +} +impl<'a> ::std::ops::Deref for PipelineViewportShadingRateImageStateCreateInfoNVBuilder<'a> { + type Target = PipelineViewportShadingRateImageStateCreateInfoNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PipelineViewportShadingRateImageStateCreateInfoNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PipelineViewportShadingRateImageStateCreateInfoNVBuilder<'a> { + #[inline] + pub fn shading_rate_image_enable(mut self, shading_rate_image_enable: bool) -> Self { + self.inner.shading_rate_image_enable = shading_rate_image_enable.into(); + self + } + #[inline] + pub fn shading_rate_palettes( + mut self, + shading_rate_palettes: &'a [ShadingRatePaletteNV], + ) -> Self { + self.inner.viewport_count = shading_rate_palettes.len() as _; + self.inner.p_shading_rate_palettes = shading_rate_palettes.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PipelineViewportShadingRateImageStateCreateInfoNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceShadingRateImageFeaturesNV { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub shading_rate_image: Bool32, + pub shading_rate_coarse_sample_order: Bool32, +} +impl ::std::default::Default for PhysicalDeviceShadingRateImageFeaturesNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + shading_rate_image: Bool32::default(), + shading_rate_coarse_sample_order: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceShadingRateImageFeaturesNV { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV; +} +impl PhysicalDeviceShadingRateImageFeaturesNV { + pub fn builder<'a>() -> PhysicalDeviceShadingRateImageFeaturesNVBuilder<'a> { + PhysicalDeviceShadingRateImageFeaturesNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceShadingRateImageFeaturesNVBuilder<'a> { + inner: PhysicalDeviceShadingRateImageFeaturesNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShadingRateImageFeaturesNVBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShadingRateImageFeaturesNV {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShadingRateImageFeaturesNVBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShadingRateImageFeaturesNV {} +impl<'a> ::std::ops::Deref for PhysicalDeviceShadingRateImageFeaturesNVBuilder<'a> { + type Target = PhysicalDeviceShadingRateImageFeaturesNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceShadingRateImageFeaturesNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceShadingRateImageFeaturesNVBuilder<'a> { + #[inline] + pub fn shading_rate_image(mut self, shading_rate_image: bool) -> Self { + self.inner.shading_rate_image = shading_rate_image.into(); + self + } + #[inline] + pub fn shading_rate_coarse_sample_order( + mut self, + shading_rate_coarse_sample_order: bool, + ) -> Self { + self.inner.shading_rate_coarse_sample_order = shading_rate_coarse_sample_order.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceShadingRateImageFeaturesNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceShadingRateImagePropertiesNV { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub shading_rate_texel_size: Extent2D, + pub shading_rate_palette_size: u32, + pub shading_rate_max_coarse_samples: u32, +} +impl ::std::default::Default for PhysicalDeviceShadingRateImagePropertiesNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + shading_rate_texel_size: Extent2D::default(), + shading_rate_palette_size: u32::default(), + shading_rate_max_coarse_samples: u32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceShadingRateImagePropertiesNV { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV; +} +impl PhysicalDeviceShadingRateImagePropertiesNV { + pub fn builder<'a>() -> PhysicalDeviceShadingRateImagePropertiesNVBuilder<'a> { + PhysicalDeviceShadingRateImagePropertiesNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceShadingRateImagePropertiesNVBuilder<'a> { + inner: PhysicalDeviceShadingRateImagePropertiesNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceShadingRateImagePropertiesNVBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceShadingRateImagePropertiesNV {} +impl<'a> ::std::ops::Deref for PhysicalDeviceShadingRateImagePropertiesNVBuilder<'a> { + type Target = PhysicalDeviceShadingRateImagePropertiesNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceShadingRateImagePropertiesNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceShadingRateImagePropertiesNVBuilder<'a> { + #[inline] + pub fn shading_rate_texel_size(mut self, shading_rate_texel_size: Extent2D) -> Self { + self.inner.shading_rate_texel_size = shading_rate_texel_size; + self + } + #[inline] + pub fn shading_rate_palette_size(mut self, shading_rate_palette_size: u32) -> Self { + self.inner.shading_rate_palette_size = shading_rate_palette_size; + self + } + #[inline] + pub fn shading_rate_max_coarse_samples(mut self, shading_rate_max_coarse_samples: u32) -> Self { + self.inner.shading_rate_max_coarse_samples = shading_rate_max_coarse_samples; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceShadingRateImagePropertiesNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceInvocationMaskFeaturesHUAWEI { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub invocation_mask: Bool32, +} +impl ::std::default::Default for PhysicalDeviceInvocationMaskFeaturesHUAWEI { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + invocation_mask: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceInvocationMaskFeaturesHUAWEI { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI; +} +impl PhysicalDeviceInvocationMaskFeaturesHUAWEI { + pub fn builder<'a>() -> PhysicalDeviceInvocationMaskFeaturesHUAWEIBuilder<'a> { + PhysicalDeviceInvocationMaskFeaturesHUAWEIBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceInvocationMaskFeaturesHUAWEIBuilder<'a> { + inner: PhysicalDeviceInvocationMaskFeaturesHUAWEI, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceInvocationMaskFeaturesHUAWEIBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceInvocationMaskFeaturesHUAWEI {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceInvocationMaskFeaturesHUAWEIBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceInvocationMaskFeaturesHUAWEI {} +impl<'a> ::std::ops::Deref for PhysicalDeviceInvocationMaskFeaturesHUAWEIBuilder<'a> { + type Target = PhysicalDeviceInvocationMaskFeaturesHUAWEI; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceInvocationMaskFeaturesHUAWEIBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceInvocationMaskFeaturesHUAWEIBuilder<'a> { + #[inline] + pub fn invocation_mask(mut self, invocation_mask: bool) -> Self { + self.inner.invocation_mask = invocation_mask.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceInvocationMaskFeaturesHUAWEI { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct CoarseSampleLocationNV { + pub pixel_x: u32, + pub pixel_y: u32, + pub sample: u32, +} +impl CoarseSampleLocationNV { + pub fn builder<'a>() -> CoarseSampleLocationNVBuilder<'a> { + CoarseSampleLocationNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct CoarseSampleLocationNVBuilder<'a> { + inner: CoarseSampleLocationNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for CoarseSampleLocationNVBuilder<'a> { + type Target = CoarseSampleLocationNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for CoarseSampleLocationNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> CoarseSampleLocationNVBuilder<'a> { + #[inline] + pub fn pixel_x(mut self, pixel_x: u32) -> Self { + self.inner.pixel_x = pixel_x; + self + } + #[inline] + pub fn pixel_y(mut self, pixel_y: u32) -> Self { + self.inner.pixel_y = pixel_y; + self + } + #[inline] + pub fn sample(mut self, sample: u32) -> Self { + self.inner.sample = sample; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> CoarseSampleLocationNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct CoarseSampleOrderCustomNV { + pub shading_rate: ShadingRatePaletteEntryNV, + pub sample_count: u32, + pub sample_location_count: u32, + pub p_sample_locations: *const CoarseSampleLocationNV, +} +impl ::std::default::Default for CoarseSampleOrderCustomNV { + #[inline] + fn default() -> Self { + Self { + shading_rate: ShadingRatePaletteEntryNV::default(), + sample_count: u32::default(), + sample_location_count: u32::default(), + p_sample_locations: ::std::ptr::null(), + } + } +} +impl CoarseSampleOrderCustomNV { + pub fn builder<'a>() -> CoarseSampleOrderCustomNVBuilder<'a> { + CoarseSampleOrderCustomNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct CoarseSampleOrderCustomNVBuilder<'a> { + inner: CoarseSampleOrderCustomNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for CoarseSampleOrderCustomNVBuilder<'a> { + type Target = CoarseSampleOrderCustomNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for CoarseSampleOrderCustomNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> CoarseSampleOrderCustomNVBuilder<'a> { + #[inline] + pub fn shading_rate(mut self, shading_rate: ShadingRatePaletteEntryNV) -> Self { + self.inner.shading_rate = shading_rate; + self + } + #[inline] + pub fn sample_count(mut self, sample_count: u32) -> Self { + self.inner.sample_count = sample_count; + self + } + #[inline] + pub fn sample_locations(mut self, sample_locations: &'a [CoarseSampleLocationNV]) -> Self { + self.inner.sample_location_count = sample_locations.len() as _; + self.inner.p_sample_locations = sample_locations.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> CoarseSampleOrderCustomNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PipelineViewportCoarseSampleOrderStateCreateInfoNV { + pub s_type: StructureType, + pub p_next: *const c_void, + pub sample_order_type: CoarseSampleOrderTypeNV, + pub custom_sample_order_count: u32, + pub p_custom_sample_orders: *const CoarseSampleOrderCustomNV, +} +impl ::std::default::Default for PipelineViewportCoarseSampleOrderStateCreateInfoNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + sample_order_type: CoarseSampleOrderTypeNV::default(), + custom_sample_order_count: u32::default(), + p_custom_sample_orders: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for PipelineViewportCoarseSampleOrderStateCreateInfoNV { + const STRUCTURE_TYPE: StructureType = + StructureType::PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV; +} +impl PipelineViewportCoarseSampleOrderStateCreateInfoNV { + pub fn builder<'a>() -> PipelineViewportCoarseSampleOrderStateCreateInfoNVBuilder<'a> { + PipelineViewportCoarseSampleOrderStateCreateInfoNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PipelineViewportCoarseSampleOrderStateCreateInfoNVBuilder<'a> { + inner: PipelineViewportCoarseSampleOrderStateCreateInfoNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPipelineViewportStateCreateInfo + for PipelineViewportCoarseSampleOrderStateCreateInfoNVBuilder<'_> +{ +} +unsafe impl ExtendsPipelineViewportStateCreateInfo + for PipelineViewportCoarseSampleOrderStateCreateInfoNV +{ +} +impl<'a> ::std::ops::Deref for PipelineViewportCoarseSampleOrderStateCreateInfoNVBuilder<'a> { + type Target = PipelineViewportCoarseSampleOrderStateCreateInfoNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PipelineViewportCoarseSampleOrderStateCreateInfoNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PipelineViewportCoarseSampleOrderStateCreateInfoNVBuilder<'a> { + #[inline] + pub fn sample_order_type(mut self, sample_order_type: CoarseSampleOrderTypeNV) -> Self { + self.inner.sample_order_type = sample_order_type; + self + } + #[inline] + pub fn custom_sample_orders( + mut self, + custom_sample_orders: &'a [CoarseSampleOrderCustomNV], + ) -> Self { + self.inner.custom_sample_order_count = custom_sample_orders.len() as _; + self.inner.p_custom_sample_orders = custom_sample_orders.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PipelineViewportCoarseSampleOrderStateCreateInfoNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceMeshShaderFeaturesNV { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub task_shader: Bool32, + pub mesh_shader: Bool32, +} +impl ::std::default::Default for PhysicalDeviceMeshShaderFeaturesNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + task_shader: Bool32::default(), + mesh_shader: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceMeshShaderFeaturesNV { + const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV; +} +impl PhysicalDeviceMeshShaderFeaturesNV { + pub fn builder<'a>() -> PhysicalDeviceMeshShaderFeaturesNVBuilder<'a> { + PhysicalDeviceMeshShaderFeaturesNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceMeshShaderFeaturesNVBuilder<'a> { + inner: PhysicalDeviceMeshShaderFeaturesNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceMeshShaderFeaturesNVBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceMeshShaderFeaturesNV {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMeshShaderFeaturesNVBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMeshShaderFeaturesNV {} +impl<'a> ::std::ops::Deref for PhysicalDeviceMeshShaderFeaturesNVBuilder<'a> { + type Target = PhysicalDeviceMeshShaderFeaturesNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceMeshShaderFeaturesNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceMeshShaderFeaturesNVBuilder<'a> { + #[inline] + pub fn task_shader(mut self, task_shader: bool) -> Self { + self.inner.task_shader = task_shader.into(); + self + } + #[inline] + pub fn mesh_shader(mut self, mesh_shader: bool) -> Self { + self.inner.mesh_shader = mesh_shader.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceMeshShaderFeaturesNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceMeshShaderPropertiesNV { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub max_draw_mesh_tasks_count: u32, + pub max_task_work_group_invocations: u32, + pub max_task_work_group_size: [u32; 3], + pub max_task_total_memory_size: u32, + pub max_task_output_count: u32, + pub max_mesh_work_group_invocations: u32, + pub max_mesh_work_group_size: [u32; 3], + pub max_mesh_total_memory_size: u32, + pub max_mesh_output_vertices: u32, + pub max_mesh_output_primitives: u32, + pub max_mesh_multiview_view_count: u32, + pub mesh_output_per_vertex_granularity: u32, + pub mesh_output_per_primitive_granularity: u32, +} +impl ::std::default::Default for PhysicalDeviceMeshShaderPropertiesNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + max_draw_mesh_tasks_count: u32::default(), + max_task_work_group_invocations: u32::default(), + max_task_work_group_size: unsafe { ::std::mem::zeroed() }, + max_task_total_memory_size: u32::default(), + max_task_output_count: u32::default(), + max_mesh_work_group_invocations: u32::default(), + max_mesh_work_group_size: unsafe { ::std::mem::zeroed() }, + max_mesh_total_memory_size: u32::default(), + max_mesh_output_vertices: u32::default(), + max_mesh_output_primitives: u32::default(), + max_mesh_multiview_view_count: u32::default(), + mesh_output_per_vertex_granularity: u32::default(), + mesh_output_per_primitive_granularity: u32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceMeshShaderPropertiesNV { + const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV; +} +impl PhysicalDeviceMeshShaderPropertiesNV { + pub fn builder<'a>() -> PhysicalDeviceMeshShaderPropertiesNVBuilder<'a> { + PhysicalDeviceMeshShaderPropertiesNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceMeshShaderPropertiesNVBuilder<'a> { + inner: PhysicalDeviceMeshShaderPropertiesNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceMeshShaderPropertiesNVBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceMeshShaderPropertiesNV {} +impl<'a> ::std::ops::Deref for PhysicalDeviceMeshShaderPropertiesNVBuilder<'a> { + type Target = PhysicalDeviceMeshShaderPropertiesNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceMeshShaderPropertiesNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceMeshShaderPropertiesNVBuilder<'a> { + #[inline] + pub fn max_draw_mesh_tasks_count(mut self, max_draw_mesh_tasks_count: u32) -> Self { + self.inner.max_draw_mesh_tasks_count = max_draw_mesh_tasks_count; + self + } + #[inline] + pub fn max_task_work_group_invocations(mut self, max_task_work_group_invocations: u32) -> Self { + self.inner.max_task_work_group_invocations = max_task_work_group_invocations; + self + } + #[inline] + pub fn max_task_work_group_size(mut self, max_task_work_group_size: [u32; 3]) -> Self { + self.inner.max_task_work_group_size = max_task_work_group_size; + self + } + #[inline] + pub fn max_task_total_memory_size(mut self, max_task_total_memory_size: u32) -> Self { + self.inner.max_task_total_memory_size = max_task_total_memory_size; + self + } + #[inline] + pub fn max_task_output_count(mut self, max_task_output_count: u32) -> Self { + self.inner.max_task_output_count = max_task_output_count; + self + } + #[inline] + pub fn max_mesh_work_group_invocations(mut self, max_mesh_work_group_invocations: u32) -> Self { + self.inner.max_mesh_work_group_invocations = max_mesh_work_group_invocations; + self + } + #[inline] + pub fn max_mesh_work_group_size(mut self, max_mesh_work_group_size: [u32; 3]) -> Self { + self.inner.max_mesh_work_group_size = max_mesh_work_group_size; + self + } + #[inline] + pub fn max_mesh_total_memory_size(mut self, max_mesh_total_memory_size: u32) -> Self { + self.inner.max_mesh_total_memory_size = max_mesh_total_memory_size; + self + } + #[inline] + pub fn max_mesh_output_vertices(mut self, max_mesh_output_vertices: u32) -> Self { + self.inner.max_mesh_output_vertices = max_mesh_output_vertices; + self + } + #[inline] + pub fn max_mesh_output_primitives(mut self, max_mesh_output_primitives: u32) -> Self { + self.inner.max_mesh_output_primitives = max_mesh_output_primitives; + self + } + #[inline] + pub fn max_mesh_multiview_view_count(mut self, max_mesh_multiview_view_count: u32) -> Self { + self.inner.max_mesh_multiview_view_count = max_mesh_multiview_view_count; + self + } + #[inline] + pub fn mesh_output_per_vertex_granularity( + mut self, + mesh_output_per_vertex_granularity: u32, + ) -> Self { + self.inner.mesh_output_per_vertex_granularity = mesh_output_per_vertex_granularity; + self + } + #[inline] + pub fn mesh_output_per_primitive_granularity( + mut self, + mesh_output_per_primitive_granularity: u32, + ) -> Self { + self.inner.mesh_output_per_primitive_granularity = mesh_output_per_primitive_granularity; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceMeshShaderPropertiesNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct DrawMeshTasksIndirectCommandNV { + pub task_count: u32, + pub first_task: u32, +} +impl DrawMeshTasksIndirectCommandNV { + pub fn builder<'a>() -> DrawMeshTasksIndirectCommandNVBuilder<'a> { + DrawMeshTasksIndirectCommandNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DrawMeshTasksIndirectCommandNVBuilder<'a> { + inner: DrawMeshTasksIndirectCommandNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DrawMeshTasksIndirectCommandNVBuilder<'a> { + type Target = DrawMeshTasksIndirectCommandNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DrawMeshTasksIndirectCommandNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DrawMeshTasksIndirectCommandNVBuilder<'a> { + #[inline] + pub fn task_count(mut self, task_count: u32) -> Self { + self.inner.task_count = task_count; + self + } + #[inline] + pub fn first_task(mut self, first_task: u32) -> Self { + self.inner.first_task = first_task; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DrawMeshTasksIndirectCommandNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceMeshShaderFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub task_shader: Bool32, + pub mesh_shader: Bool32, + pub multiview_mesh_shader: Bool32, + pub primitive_fragment_shading_rate_mesh_shader: Bool32, + pub mesh_shader_queries: Bool32, +} +impl ::std::default::Default for PhysicalDeviceMeshShaderFeaturesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + task_shader: Bool32::default(), + mesh_shader: Bool32::default(), + multiview_mesh_shader: Bool32::default(), + primitive_fragment_shading_rate_mesh_shader: Bool32::default(), + mesh_shader_queries: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceMeshShaderFeaturesEXT { + const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT; +} +impl PhysicalDeviceMeshShaderFeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceMeshShaderFeaturesEXTBuilder<'a> { + PhysicalDeviceMeshShaderFeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceMeshShaderFeaturesEXTBuilder<'a> { + inner: PhysicalDeviceMeshShaderFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceMeshShaderFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceMeshShaderFeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMeshShaderFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMeshShaderFeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceMeshShaderFeaturesEXTBuilder<'a> { + type Target = PhysicalDeviceMeshShaderFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceMeshShaderFeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceMeshShaderFeaturesEXTBuilder<'a> { + #[inline] + pub fn task_shader(mut self, task_shader: bool) -> Self { + self.inner.task_shader = task_shader.into(); + self + } + #[inline] + pub fn mesh_shader(mut self, mesh_shader: bool) -> Self { + self.inner.mesh_shader = mesh_shader.into(); + self + } + #[inline] + pub fn multiview_mesh_shader(mut self, multiview_mesh_shader: bool) -> Self { + self.inner.multiview_mesh_shader = multiview_mesh_shader.into(); + self + } + #[inline] + pub fn primitive_fragment_shading_rate_mesh_shader( + mut self, + primitive_fragment_shading_rate_mesh_shader: bool, + ) -> Self { + self.inner.primitive_fragment_shading_rate_mesh_shader = + primitive_fragment_shading_rate_mesh_shader.into(); + self + } + #[inline] + pub fn mesh_shader_queries(mut self, mesh_shader_queries: bool) -> Self { + self.inner.mesh_shader_queries = mesh_shader_queries.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceMeshShaderFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceMeshShaderPropertiesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub max_task_work_group_total_count: u32, + pub max_task_work_group_count: [u32; 3], + pub max_task_work_group_invocations: u32, + pub max_task_work_group_size: [u32; 3], + pub max_task_payload_size: u32, + pub max_task_shared_memory_size: u32, + pub max_task_payload_and_shared_memory_size: u32, + pub max_mesh_work_group_total_count: u32, + pub max_mesh_work_group_count: [u32; 3], + pub max_mesh_work_group_invocations: u32, + pub max_mesh_work_group_size: [u32; 3], + pub max_mesh_shared_memory_size: u32, + pub max_mesh_payload_and_shared_memory_size: u32, + pub max_mesh_output_memory_size: u32, + pub max_mesh_payload_and_output_memory_size: u32, + pub max_mesh_output_components: u32, + pub max_mesh_output_vertices: u32, + pub max_mesh_output_primitives: u32, + pub max_mesh_output_layers: u32, + pub max_mesh_multiview_view_count: u32, + pub mesh_output_per_vertex_granularity: u32, + pub mesh_output_per_primitive_granularity: u32, + pub max_preferred_task_work_group_invocations: u32, + pub max_preferred_mesh_work_group_invocations: u32, + pub prefers_local_invocation_vertex_output: Bool32, + pub prefers_local_invocation_primitive_output: Bool32, + pub prefers_compact_vertex_output: Bool32, + pub prefers_compact_primitive_output: Bool32, +} +impl ::std::default::Default for PhysicalDeviceMeshShaderPropertiesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + max_task_work_group_total_count: u32::default(), + max_task_work_group_count: unsafe { ::std::mem::zeroed() }, + max_task_work_group_invocations: u32::default(), + max_task_work_group_size: unsafe { ::std::mem::zeroed() }, + max_task_payload_size: u32::default(), + max_task_shared_memory_size: u32::default(), + max_task_payload_and_shared_memory_size: u32::default(), + max_mesh_work_group_total_count: u32::default(), + max_mesh_work_group_count: unsafe { ::std::mem::zeroed() }, + max_mesh_work_group_invocations: u32::default(), + max_mesh_work_group_size: unsafe { ::std::mem::zeroed() }, + max_mesh_shared_memory_size: u32::default(), + max_mesh_payload_and_shared_memory_size: u32::default(), + max_mesh_output_memory_size: u32::default(), + max_mesh_payload_and_output_memory_size: u32::default(), + max_mesh_output_components: u32::default(), + max_mesh_output_vertices: u32::default(), + max_mesh_output_primitives: u32::default(), + max_mesh_output_layers: u32::default(), + max_mesh_multiview_view_count: u32::default(), + mesh_output_per_vertex_granularity: u32::default(), + mesh_output_per_primitive_granularity: u32::default(), + max_preferred_task_work_group_invocations: u32::default(), + max_preferred_mesh_work_group_invocations: u32::default(), + prefers_local_invocation_vertex_output: Bool32::default(), + prefers_local_invocation_primitive_output: Bool32::default(), + prefers_compact_vertex_output: Bool32::default(), + prefers_compact_primitive_output: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceMeshShaderPropertiesEXT { + const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT; +} +impl PhysicalDeviceMeshShaderPropertiesEXT { + pub fn builder<'a>() -> PhysicalDeviceMeshShaderPropertiesEXTBuilder<'a> { + PhysicalDeviceMeshShaderPropertiesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceMeshShaderPropertiesEXTBuilder<'a> { + inner: PhysicalDeviceMeshShaderPropertiesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceMeshShaderPropertiesEXTBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceMeshShaderPropertiesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceMeshShaderPropertiesEXTBuilder<'a> { + type Target = PhysicalDeviceMeshShaderPropertiesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceMeshShaderPropertiesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceMeshShaderPropertiesEXTBuilder<'a> { + #[inline] + pub fn max_task_work_group_total_count(mut self, max_task_work_group_total_count: u32) -> Self { + self.inner.max_task_work_group_total_count = max_task_work_group_total_count; + self + } + #[inline] + pub fn max_task_work_group_count(mut self, max_task_work_group_count: [u32; 3]) -> Self { + self.inner.max_task_work_group_count = max_task_work_group_count; + self + } + #[inline] + pub fn max_task_work_group_invocations(mut self, max_task_work_group_invocations: u32) -> Self { + self.inner.max_task_work_group_invocations = max_task_work_group_invocations; + self + } + #[inline] + pub fn max_task_work_group_size(mut self, max_task_work_group_size: [u32; 3]) -> Self { + self.inner.max_task_work_group_size = max_task_work_group_size; + self + } + #[inline] + pub fn max_task_payload_size(mut self, max_task_payload_size: u32) -> Self { + self.inner.max_task_payload_size = max_task_payload_size; + self + } + #[inline] + pub fn max_task_shared_memory_size(mut self, max_task_shared_memory_size: u32) -> Self { + self.inner.max_task_shared_memory_size = max_task_shared_memory_size; + self + } + #[inline] + pub fn max_task_payload_and_shared_memory_size( + mut self, + max_task_payload_and_shared_memory_size: u32, + ) -> Self { + self.inner.max_task_payload_and_shared_memory_size = + max_task_payload_and_shared_memory_size; + self + } + #[inline] + pub fn max_mesh_work_group_total_count(mut self, max_mesh_work_group_total_count: u32) -> Self { + self.inner.max_mesh_work_group_total_count = max_mesh_work_group_total_count; + self + } + #[inline] + pub fn max_mesh_work_group_count(mut self, max_mesh_work_group_count: [u32; 3]) -> Self { + self.inner.max_mesh_work_group_count = max_mesh_work_group_count; + self + } + #[inline] + pub fn max_mesh_work_group_invocations(mut self, max_mesh_work_group_invocations: u32) -> Self { + self.inner.max_mesh_work_group_invocations = max_mesh_work_group_invocations; + self + } + #[inline] + pub fn max_mesh_work_group_size(mut self, max_mesh_work_group_size: [u32; 3]) -> Self { + self.inner.max_mesh_work_group_size = max_mesh_work_group_size; + self + } + #[inline] + pub fn max_mesh_shared_memory_size(mut self, max_mesh_shared_memory_size: u32) -> Self { + self.inner.max_mesh_shared_memory_size = max_mesh_shared_memory_size; + self + } + #[inline] + pub fn max_mesh_payload_and_shared_memory_size( + mut self, + max_mesh_payload_and_shared_memory_size: u32, + ) -> Self { + self.inner.max_mesh_payload_and_shared_memory_size = + max_mesh_payload_and_shared_memory_size; + self + } + #[inline] + pub fn max_mesh_output_memory_size(mut self, max_mesh_output_memory_size: u32) -> Self { + self.inner.max_mesh_output_memory_size = max_mesh_output_memory_size; + self + } + #[inline] + pub fn max_mesh_payload_and_output_memory_size( + mut self, + max_mesh_payload_and_output_memory_size: u32, + ) -> Self { + self.inner.max_mesh_payload_and_output_memory_size = + max_mesh_payload_and_output_memory_size; + self + } + #[inline] + pub fn max_mesh_output_components(mut self, max_mesh_output_components: u32) -> Self { + self.inner.max_mesh_output_components = max_mesh_output_components; + self + } + #[inline] + pub fn max_mesh_output_vertices(mut self, max_mesh_output_vertices: u32) -> Self { + self.inner.max_mesh_output_vertices = max_mesh_output_vertices; + self + } + #[inline] + pub fn max_mesh_output_primitives(mut self, max_mesh_output_primitives: u32) -> Self { + self.inner.max_mesh_output_primitives = max_mesh_output_primitives; + self + } + #[inline] + pub fn max_mesh_output_layers(mut self, max_mesh_output_layers: u32) -> Self { + self.inner.max_mesh_output_layers = max_mesh_output_layers; + self + } + #[inline] + pub fn max_mesh_multiview_view_count(mut self, max_mesh_multiview_view_count: u32) -> Self { + self.inner.max_mesh_multiview_view_count = max_mesh_multiview_view_count; + self + } + #[inline] + pub fn mesh_output_per_vertex_granularity( + mut self, + mesh_output_per_vertex_granularity: u32, + ) -> Self { + self.inner.mesh_output_per_vertex_granularity = mesh_output_per_vertex_granularity; + self + } + #[inline] + pub fn mesh_output_per_primitive_granularity( + mut self, + mesh_output_per_primitive_granularity: u32, + ) -> Self { + self.inner.mesh_output_per_primitive_granularity = mesh_output_per_primitive_granularity; + self + } + #[inline] + pub fn max_preferred_task_work_group_invocations( + mut self, + max_preferred_task_work_group_invocations: u32, + ) -> Self { + self.inner.max_preferred_task_work_group_invocations = + max_preferred_task_work_group_invocations; + self + } + #[inline] + pub fn max_preferred_mesh_work_group_invocations( + mut self, + max_preferred_mesh_work_group_invocations: u32, + ) -> Self { + self.inner.max_preferred_mesh_work_group_invocations = + max_preferred_mesh_work_group_invocations; + self + } + #[inline] + pub fn prefers_local_invocation_vertex_output( + mut self, + prefers_local_invocation_vertex_output: bool, + ) -> Self { + self.inner.prefers_local_invocation_vertex_output = + prefers_local_invocation_vertex_output.into(); + self + } + #[inline] + pub fn prefers_local_invocation_primitive_output( + mut self, + prefers_local_invocation_primitive_output: bool, + ) -> Self { + self.inner.prefers_local_invocation_primitive_output = + prefers_local_invocation_primitive_output.into(); + self + } + #[inline] + pub fn prefers_compact_vertex_output(mut self, prefers_compact_vertex_output: bool) -> Self { + self.inner.prefers_compact_vertex_output = prefers_compact_vertex_output.into(); + self + } + #[inline] + pub fn prefers_compact_primitive_output( + mut self, + prefers_compact_primitive_output: bool, + ) -> Self { + self.inner.prefers_compact_primitive_output = prefers_compact_primitive_output.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceMeshShaderPropertiesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct DrawMeshTasksIndirectCommandEXT { + pub group_count_x: u32, + pub group_count_y: u32, + pub group_count_z: u32, +} +impl DrawMeshTasksIndirectCommandEXT { + pub fn builder<'a>() -> DrawMeshTasksIndirectCommandEXTBuilder<'a> { + DrawMeshTasksIndirectCommandEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DrawMeshTasksIndirectCommandEXTBuilder<'a> { + inner: DrawMeshTasksIndirectCommandEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DrawMeshTasksIndirectCommandEXTBuilder<'a> { + type Target = DrawMeshTasksIndirectCommandEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DrawMeshTasksIndirectCommandEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DrawMeshTasksIndirectCommandEXTBuilder<'a> { + #[inline] + pub fn group_count_x(mut self, group_count_x: u32) -> Self { + self.inner.group_count_x = group_count_x; + self + } + #[inline] + pub fn group_count_y(mut self, group_count_y: u32) -> Self { + self.inner.group_count_y = group_count_y; + self + } + #[inline] + pub fn group_count_z(mut self, group_count_z: u32) -> Self { + self.inner.group_count_z = group_count_z; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DrawMeshTasksIndirectCommandEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct RayTracingShaderGroupCreateInfoNV { + pub s_type: StructureType, + pub p_next: *const c_void, + pub ty: RayTracingShaderGroupTypeKHR, + pub general_shader: u32, + pub closest_hit_shader: u32, + pub any_hit_shader: u32, + pub intersection_shader: u32, +} +impl ::std::default::Default for RayTracingShaderGroupCreateInfoNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + ty: RayTracingShaderGroupTypeKHR::default(), + general_shader: u32::default(), + closest_hit_shader: u32::default(), + any_hit_shader: u32::default(), + intersection_shader: u32::default(), + } + } +} +unsafe impl TaggedStructure for RayTracingShaderGroupCreateInfoNV { + const STRUCTURE_TYPE: StructureType = StructureType::RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV; +} +impl RayTracingShaderGroupCreateInfoNV { + pub fn builder<'a>() -> RayTracingShaderGroupCreateInfoNVBuilder<'a> { + RayTracingShaderGroupCreateInfoNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct RayTracingShaderGroupCreateInfoNVBuilder<'a> { + inner: RayTracingShaderGroupCreateInfoNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for RayTracingShaderGroupCreateInfoNVBuilder<'a> { + type Target = RayTracingShaderGroupCreateInfoNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for RayTracingShaderGroupCreateInfoNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> RayTracingShaderGroupCreateInfoNVBuilder<'a> { + #[inline] + pub fn ty(mut self, ty: RayTracingShaderGroupTypeKHR) -> Self { + self.inner.ty = ty; + self + } + #[inline] + pub fn general_shader(mut self, general_shader: u32) -> Self { + self.inner.general_shader = general_shader; + self + } + #[inline] + pub fn closest_hit_shader(mut self, closest_hit_shader: u32) -> Self { + self.inner.closest_hit_shader = closest_hit_shader; + self + } + #[inline] + pub fn any_hit_shader(mut self, any_hit_shader: u32) -> Self { + self.inner.any_hit_shader = any_hit_shader; + self + } + #[inline] + pub fn intersection_shader(mut self, intersection_shader: u32) -> Self { + self.inner.intersection_shader = intersection_shader; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> RayTracingShaderGroupCreateInfoNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct RayTracingShaderGroupCreateInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub ty: RayTracingShaderGroupTypeKHR, + pub general_shader: u32, + pub closest_hit_shader: u32, + pub any_hit_shader: u32, + pub intersection_shader: u32, + pub p_shader_group_capture_replay_handle: *const c_void, +} +impl ::std::default::Default for RayTracingShaderGroupCreateInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + ty: RayTracingShaderGroupTypeKHR::default(), + general_shader: u32::default(), + closest_hit_shader: u32::default(), + any_hit_shader: u32::default(), + intersection_shader: u32::default(), + p_shader_group_capture_replay_handle: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for RayTracingShaderGroupCreateInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR; +} +impl RayTracingShaderGroupCreateInfoKHR { + pub fn builder<'a>() -> RayTracingShaderGroupCreateInfoKHRBuilder<'a> { + RayTracingShaderGroupCreateInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct RayTracingShaderGroupCreateInfoKHRBuilder<'a> { + inner: RayTracingShaderGroupCreateInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for RayTracingShaderGroupCreateInfoKHRBuilder<'a> { + type Target = RayTracingShaderGroupCreateInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for RayTracingShaderGroupCreateInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> RayTracingShaderGroupCreateInfoKHRBuilder<'a> { + #[inline] + pub fn ty(mut self, ty: RayTracingShaderGroupTypeKHR) -> Self { + self.inner.ty = ty; + self + } + #[inline] + pub fn general_shader(mut self, general_shader: u32) -> Self { + self.inner.general_shader = general_shader; + self + } + #[inline] + pub fn closest_hit_shader(mut self, closest_hit_shader: u32) -> Self { + self.inner.closest_hit_shader = closest_hit_shader; + self + } + #[inline] + pub fn any_hit_shader(mut self, any_hit_shader: u32) -> Self { + self.inner.any_hit_shader = any_hit_shader; + self + } + #[inline] + pub fn intersection_shader(mut self, intersection_shader: u32) -> Self { + self.inner.intersection_shader = intersection_shader; + self + } + #[inline] + pub fn shader_group_capture_replay_handle( + mut self, + shader_group_capture_replay_handle: *const c_void, + ) -> Self { + self.inner.p_shader_group_capture_replay_handle = shader_group_capture_replay_handle; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> RayTracingShaderGroupCreateInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct RayTracingPipelineCreateInfoNV { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: PipelineCreateFlags, + pub stage_count: u32, + pub p_stages: *const PipelineShaderStageCreateInfo, + pub group_count: u32, + pub p_groups: *const RayTracingShaderGroupCreateInfoNV, + pub max_recursion_depth: u32, + pub layout: PipelineLayout, + pub base_pipeline_handle: Pipeline, + pub base_pipeline_index: i32, +} +impl ::std::default::Default for RayTracingPipelineCreateInfoNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: PipelineCreateFlags::default(), + stage_count: u32::default(), + p_stages: ::std::ptr::null(), + group_count: u32::default(), + p_groups: ::std::ptr::null(), + max_recursion_depth: u32::default(), + layout: PipelineLayout::default(), + base_pipeline_handle: Pipeline::default(), + base_pipeline_index: i32::default(), + } + } +} +unsafe impl TaggedStructure for RayTracingPipelineCreateInfoNV { + const STRUCTURE_TYPE: StructureType = StructureType::RAY_TRACING_PIPELINE_CREATE_INFO_NV; +} +impl RayTracingPipelineCreateInfoNV { + pub fn builder<'a>() -> RayTracingPipelineCreateInfoNVBuilder<'a> { + RayTracingPipelineCreateInfoNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct RayTracingPipelineCreateInfoNVBuilder<'a> { + inner: RayTracingPipelineCreateInfoNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsRayTracingPipelineCreateInfoNV {} +impl<'a> ::std::ops::Deref for RayTracingPipelineCreateInfoNVBuilder<'a> { + type Target = RayTracingPipelineCreateInfoNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for RayTracingPipelineCreateInfoNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> RayTracingPipelineCreateInfoNVBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: PipelineCreateFlags) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn stages(mut self, stages: &'a [PipelineShaderStageCreateInfo]) -> Self { + self.inner.stage_count = stages.len() as _; + self.inner.p_stages = stages.as_ptr(); + self + } + #[inline] + pub fn groups(mut self, groups: &'a [RayTracingShaderGroupCreateInfoNV]) -> Self { + self.inner.group_count = groups.len() as _; + self.inner.p_groups = groups.as_ptr(); + self + } + #[inline] + pub fn max_recursion_depth(mut self, max_recursion_depth: u32) -> Self { + self.inner.max_recursion_depth = max_recursion_depth; + self + } + #[inline] + pub fn layout(mut self, layout: PipelineLayout) -> Self { + self.inner.layout = layout; + self + } + #[inline] + pub fn base_pipeline_handle(mut self, base_pipeline_handle: Pipeline) -> Self { + self.inner.base_pipeline_handle = base_pipeline_handle; + self + } + #[inline] + pub fn base_pipeline_index(mut self, base_pipeline_index: i32) -> Self { + self.inner.base_pipeline_index = base_pipeline_index; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> RayTracingPipelineCreateInfoNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct RayTracingPipelineCreateInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: PipelineCreateFlags, + pub stage_count: u32, + pub p_stages: *const PipelineShaderStageCreateInfo, + pub group_count: u32, + pub p_groups: *const RayTracingShaderGroupCreateInfoKHR, + pub max_pipeline_ray_recursion_depth: u32, + pub p_library_info: *const PipelineLibraryCreateInfoKHR, + pub p_library_interface: *const RayTracingPipelineInterfaceCreateInfoKHR, + pub p_dynamic_state: *const PipelineDynamicStateCreateInfo, + pub layout: PipelineLayout, + pub base_pipeline_handle: Pipeline, + pub base_pipeline_index: i32, +} +impl ::std::default::Default for RayTracingPipelineCreateInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: PipelineCreateFlags::default(), + stage_count: u32::default(), + p_stages: ::std::ptr::null(), + group_count: u32::default(), + p_groups: ::std::ptr::null(), + max_pipeline_ray_recursion_depth: u32::default(), + p_library_info: ::std::ptr::null(), + p_library_interface: ::std::ptr::null(), + p_dynamic_state: ::std::ptr::null(), + layout: PipelineLayout::default(), + base_pipeline_handle: Pipeline::default(), + base_pipeline_index: i32::default(), + } + } +} +unsafe impl TaggedStructure for RayTracingPipelineCreateInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::RAY_TRACING_PIPELINE_CREATE_INFO_KHR; +} +impl RayTracingPipelineCreateInfoKHR { + pub fn builder<'a>() -> RayTracingPipelineCreateInfoKHRBuilder<'a> { + RayTracingPipelineCreateInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct RayTracingPipelineCreateInfoKHRBuilder<'a> { + inner: RayTracingPipelineCreateInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsRayTracingPipelineCreateInfoKHR {} +impl<'a> ::std::ops::Deref for RayTracingPipelineCreateInfoKHRBuilder<'a> { + type Target = RayTracingPipelineCreateInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for RayTracingPipelineCreateInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> RayTracingPipelineCreateInfoKHRBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: PipelineCreateFlags) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn stages(mut self, stages: &'a [PipelineShaderStageCreateInfo]) -> Self { + self.inner.stage_count = stages.len() as _; + self.inner.p_stages = stages.as_ptr(); + self + } + #[inline] + pub fn groups(mut self, groups: &'a [RayTracingShaderGroupCreateInfoKHR]) -> Self { + self.inner.group_count = groups.len() as _; + self.inner.p_groups = groups.as_ptr(); + self + } + #[inline] + pub fn max_pipeline_ray_recursion_depth( + mut self, + max_pipeline_ray_recursion_depth: u32, + ) -> Self { + self.inner.max_pipeline_ray_recursion_depth = max_pipeline_ray_recursion_depth; + self + } + #[inline] + pub fn library_info(mut self, library_info: &'a PipelineLibraryCreateInfoKHR) -> Self { + self.inner.p_library_info = library_info; + self + } + #[inline] + pub fn library_interface( + mut self, + library_interface: &'a RayTracingPipelineInterfaceCreateInfoKHR, + ) -> Self { + self.inner.p_library_interface = library_interface; + self + } + #[inline] + pub fn dynamic_state(mut self, dynamic_state: &'a PipelineDynamicStateCreateInfo) -> Self { + self.inner.p_dynamic_state = dynamic_state; + self + } + #[inline] + pub fn layout(mut self, layout: PipelineLayout) -> Self { + self.inner.layout = layout; + self + } + #[inline] + pub fn base_pipeline_handle(mut self, base_pipeline_handle: Pipeline) -> Self { + self.inner.base_pipeline_handle = base_pipeline_handle; + self + } + #[inline] + pub fn base_pipeline_index(mut self, base_pipeline_index: i32) -> Self { + self.inner.base_pipeline_index = base_pipeline_index; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> RayTracingPipelineCreateInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct GeometryTrianglesNV { + pub s_type: StructureType, + pub p_next: *const c_void, + pub vertex_data: Buffer, + pub vertex_offset: DeviceSize, + pub vertex_count: u32, + pub vertex_stride: DeviceSize, + pub vertex_format: Format, + pub index_data: Buffer, + pub index_offset: DeviceSize, + pub index_count: u32, + pub index_type: IndexType, + pub transform_data: Buffer, + pub transform_offset: DeviceSize, +} +impl ::std::default::Default for GeometryTrianglesNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + vertex_data: Buffer::default(), + vertex_offset: DeviceSize::default(), + vertex_count: u32::default(), + vertex_stride: DeviceSize::default(), + vertex_format: Format::default(), + index_data: Buffer::default(), + index_offset: DeviceSize::default(), + index_count: u32::default(), + index_type: IndexType::default(), + transform_data: Buffer::default(), + transform_offset: DeviceSize::default(), + } + } +} +unsafe impl TaggedStructure for GeometryTrianglesNV { + const STRUCTURE_TYPE: StructureType = StructureType::GEOMETRY_TRIANGLES_NV; +} +impl GeometryTrianglesNV { + pub fn builder<'a>() -> GeometryTrianglesNVBuilder<'a> { + GeometryTrianglesNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct GeometryTrianglesNVBuilder<'a> { + inner: GeometryTrianglesNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for GeometryTrianglesNVBuilder<'a> { + type Target = GeometryTrianglesNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for GeometryTrianglesNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> GeometryTrianglesNVBuilder<'a> { + #[inline] + pub fn vertex_data(mut self, vertex_data: Buffer) -> Self { + self.inner.vertex_data = vertex_data; + self + } + #[inline] + pub fn vertex_offset(mut self, vertex_offset: DeviceSize) -> Self { + self.inner.vertex_offset = vertex_offset; + self + } + #[inline] + pub fn vertex_count(mut self, vertex_count: u32) -> Self { + self.inner.vertex_count = vertex_count; + self + } + #[inline] + pub fn vertex_stride(mut self, vertex_stride: DeviceSize) -> Self { + self.inner.vertex_stride = vertex_stride; + self + } + #[inline] + pub fn vertex_format(mut self, vertex_format: Format) -> Self { + self.inner.vertex_format = vertex_format; + self + } + #[inline] + pub fn index_data(mut self, index_data: Buffer) -> Self { + self.inner.index_data = index_data; + self + } + #[inline] + pub fn index_offset(mut self, index_offset: DeviceSize) -> Self { + self.inner.index_offset = index_offset; + self + } + #[inline] + pub fn index_count(mut self, index_count: u32) -> Self { + self.inner.index_count = index_count; + self + } + #[inline] + pub fn index_type(mut self, index_type: IndexType) -> Self { + self.inner.index_type = index_type; + self + } + #[inline] + pub fn transform_data(mut self, transform_data: Buffer) -> Self { + self.inner.transform_data = transform_data; + self + } + #[inline] + pub fn transform_offset(mut self, transform_offset: DeviceSize) -> Self { + self.inner.transform_offset = transform_offset; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> GeometryTrianglesNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct GeometryAABBNV { + pub s_type: StructureType, + pub p_next: *const c_void, + pub aabb_data: Buffer, + pub num_aab_bs: u32, + pub stride: u32, + pub offset: DeviceSize, +} +impl ::std::default::Default for GeometryAABBNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + aabb_data: Buffer::default(), + num_aab_bs: u32::default(), + stride: u32::default(), + offset: DeviceSize::default(), + } + } +} +unsafe impl TaggedStructure for GeometryAABBNV { + const STRUCTURE_TYPE: StructureType = StructureType::GEOMETRY_AABB_NV; +} +impl GeometryAABBNV { + pub fn builder<'a>() -> GeometryAABBNVBuilder<'a> { + GeometryAABBNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct GeometryAABBNVBuilder<'a> { + inner: GeometryAABBNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for GeometryAABBNVBuilder<'a> { + type Target = GeometryAABBNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for GeometryAABBNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> GeometryAABBNVBuilder<'a> { + #[inline] + pub fn aabb_data(mut self, aabb_data: Buffer) -> Self { + self.inner.aabb_data = aabb_data; + self + } + #[inline] + pub fn num_aab_bs(mut self, num_aab_bs: u32) -> Self { + self.inner.num_aab_bs = num_aab_bs; + self + } + #[inline] + pub fn stride(mut self, stride: u32) -> Self { + self.inner.stride = stride; + self + } + #[inline] + pub fn offset(mut self, offset: DeviceSize) -> Self { + self.inner.offset = offset; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> GeometryAABBNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct GeometryDataNV { + pub triangles: GeometryTrianglesNV, + pub aabbs: GeometryAABBNV, +} +impl GeometryDataNV { + pub fn builder<'a>() -> GeometryDataNVBuilder<'a> { + GeometryDataNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct GeometryDataNVBuilder<'a> { + inner: GeometryDataNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for GeometryDataNVBuilder<'a> { + type Target = GeometryDataNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for GeometryDataNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> GeometryDataNVBuilder<'a> { + #[inline] + pub fn triangles(mut self, triangles: GeometryTrianglesNV) -> Self { + self.inner.triangles = triangles; + self + } + #[inline] + pub fn aabbs(mut self, aabbs: GeometryAABBNV) -> Self { + self.inner.aabbs = aabbs; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> GeometryDataNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct GeometryNV { + pub s_type: StructureType, + pub p_next: *const c_void, + pub geometry_type: GeometryTypeKHR, + pub geometry: GeometryDataNV, + pub flags: GeometryFlagsKHR, +} +impl ::std::default::Default for GeometryNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + geometry_type: GeometryTypeKHR::default(), + geometry: GeometryDataNV::default(), + flags: GeometryFlagsKHR::default(), + } + } +} +unsafe impl TaggedStructure for GeometryNV { + const STRUCTURE_TYPE: StructureType = StructureType::GEOMETRY_NV; +} +impl GeometryNV { + pub fn builder<'a>() -> GeometryNVBuilder<'a> { + GeometryNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct GeometryNVBuilder<'a> { + inner: GeometryNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for GeometryNVBuilder<'a> { + type Target = GeometryNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for GeometryNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> GeometryNVBuilder<'a> { + #[inline] + pub fn geometry_type(mut self, geometry_type: GeometryTypeKHR) -> Self { + self.inner.geometry_type = geometry_type; + self + } + #[inline] + pub fn geometry(mut self, geometry: GeometryDataNV) -> Self { + self.inner.geometry = geometry; + self + } + #[inline] + pub fn flags(mut self, flags: GeometryFlagsKHR) -> Self { + self.inner.flags = flags; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> GeometryNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct AccelerationStructureInfoNV { + pub s_type: StructureType, + pub p_next: *const c_void, + pub ty: AccelerationStructureTypeNV, + pub flags: BuildAccelerationStructureFlagsNV, + pub instance_count: u32, + pub geometry_count: u32, + pub p_geometries: *const GeometryNV, +} +impl ::std::default::Default for AccelerationStructureInfoNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + ty: AccelerationStructureTypeNV::default(), + flags: BuildAccelerationStructureFlagsNV::default(), + instance_count: u32::default(), + geometry_count: u32::default(), + p_geometries: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for AccelerationStructureInfoNV { + const STRUCTURE_TYPE: StructureType = StructureType::ACCELERATION_STRUCTURE_INFO_NV; +} +impl AccelerationStructureInfoNV { + pub fn builder<'a>() -> AccelerationStructureInfoNVBuilder<'a> { + AccelerationStructureInfoNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct AccelerationStructureInfoNVBuilder<'a> { + inner: AccelerationStructureInfoNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for AccelerationStructureInfoNVBuilder<'a> { + type Target = AccelerationStructureInfoNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for AccelerationStructureInfoNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> AccelerationStructureInfoNVBuilder<'a> { + #[inline] + pub fn ty(mut self, ty: AccelerationStructureTypeNV) -> Self { + self.inner.ty = ty; + self + } + #[inline] + pub fn flags(mut self, flags: BuildAccelerationStructureFlagsNV) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn instance_count(mut self, instance_count: u32) -> Self { + self.inner.instance_count = instance_count; + self + } + #[inline] + pub fn geometries(mut self, geometries: &'a [GeometryNV]) -> Self { + self.inner.geometry_count = geometries.len() as _; + self.inner.p_geometries = geometries.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> AccelerationStructureInfoNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct AccelerationStructureCreateInfoNV { + pub s_type: StructureType, + pub p_next: *const c_void, + pub compacted_size: DeviceSize, + pub info: AccelerationStructureInfoNV, +} +impl ::std::default::Default for AccelerationStructureCreateInfoNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + compacted_size: DeviceSize::default(), + info: AccelerationStructureInfoNV::default(), + } + } +} +unsafe impl TaggedStructure for AccelerationStructureCreateInfoNV { + const STRUCTURE_TYPE: StructureType = StructureType::ACCELERATION_STRUCTURE_CREATE_INFO_NV; +} +impl AccelerationStructureCreateInfoNV { + pub fn builder<'a>() -> AccelerationStructureCreateInfoNVBuilder<'a> { + AccelerationStructureCreateInfoNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct AccelerationStructureCreateInfoNVBuilder<'a> { + inner: AccelerationStructureCreateInfoNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsAccelerationStructureCreateInfoNV {} +impl<'a> ::std::ops::Deref for AccelerationStructureCreateInfoNVBuilder<'a> { + type Target = AccelerationStructureCreateInfoNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for AccelerationStructureCreateInfoNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> AccelerationStructureCreateInfoNVBuilder<'a> { + #[inline] + pub fn compacted_size(mut self, compacted_size: DeviceSize) -> Self { + self.inner.compacted_size = compacted_size; + self + } + #[inline] + pub fn info(mut self, info: AccelerationStructureInfoNV) -> Self { + self.inner.info = info; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next( + mut self, + next: &'a mut T, + ) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> AccelerationStructureCreateInfoNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct BindAccelerationStructureMemoryInfoNV { + pub s_type: StructureType, + pub p_next: *const c_void, + pub acceleration_structure: AccelerationStructureNV, + pub memory: DeviceMemory, + pub memory_offset: DeviceSize, + pub device_index_count: u32, + pub p_device_indices: *const u32, +} +impl ::std::default::Default for BindAccelerationStructureMemoryInfoNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + acceleration_structure: AccelerationStructureNV::default(), + memory: DeviceMemory::default(), + memory_offset: DeviceSize::default(), + device_index_count: u32::default(), + p_device_indices: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for BindAccelerationStructureMemoryInfoNV { + const STRUCTURE_TYPE: StructureType = StructureType::BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NV; +} +impl BindAccelerationStructureMemoryInfoNV { + pub fn builder<'a>() -> BindAccelerationStructureMemoryInfoNVBuilder<'a> { + BindAccelerationStructureMemoryInfoNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct BindAccelerationStructureMemoryInfoNVBuilder<'a> { + inner: BindAccelerationStructureMemoryInfoNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for BindAccelerationStructureMemoryInfoNVBuilder<'a> { + type Target = BindAccelerationStructureMemoryInfoNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for BindAccelerationStructureMemoryInfoNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> BindAccelerationStructureMemoryInfoNVBuilder<'a> { + #[inline] + pub fn acceleration_structure( + mut self, + acceleration_structure: AccelerationStructureNV, + ) -> Self { + self.inner.acceleration_structure = acceleration_structure; + self + } + #[inline] + pub fn memory(mut self, memory: DeviceMemory) -> Self { + self.inner.memory = memory; + self + } + #[inline] + pub fn memory_offset(mut self, memory_offset: DeviceSize) -> Self { + self.inner.memory_offset = memory_offset; + self + } + #[inline] + pub fn device_indices(mut self, device_indices: &'a [u32]) -> Self { + self.inner.device_index_count = device_indices.len() as _; + self.inner.p_device_indices = device_indices.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> BindAccelerationStructureMemoryInfoNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct WriteDescriptorSetAccelerationStructureKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub acceleration_structure_count: u32, + pub p_acceleration_structures: *const AccelerationStructureKHR, +} +impl ::std::default::Default for WriteDescriptorSetAccelerationStructureKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + acceleration_structure_count: u32::default(), + p_acceleration_structures: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for WriteDescriptorSetAccelerationStructureKHR { + const STRUCTURE_TYPE: StructureType = + StructureType::WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR; +} +impl WriteDescriptorSetAccelerationStructureKHR { + pub fn builder<'a>() -> WriteDescriptorSetAccelerationStructureKHRBuilder<'a> { + WriteDescriptorSetAccelerationStructureKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct WriteDescriptorSetAccelerationStructureKHRBuilder<'a> { + inner: WriteDescriptorSetAccelerationStructureKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsWriteDescriptorSet for WriteDescriptorSetAccelerationStructureKHRBuilder<'_> {} +unsafe impl ExtendsWriteDescriptorSet for WriteDescriptorSetAccelerationStructureKHR {} +impl<'a> ::std::ops::Deref for WriteDescriptorSetAccelerationStructureKHRBuilder<'a> { + type Target = WriteDescriptorSetAccelerationStructureKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for WriteDescriptorSetAccelerationStructureKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> WriteDescriptorSetAccelerationStructureKHRBuilder<'a> { + #[inline] + pub fn acceleration_structures( + mut self, + acceleration_structures: &'a [AccelerationStructureKHR], + ) -> Self { + self.inner.acceleration_structure_count = acceleration_structures.len() as _; + self.inner.p_acceleration_structures = acceleration_structures.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> WriteDescriptorSetAccelerationStructureKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct WriteDescriptorSetAccelerationStructureNV { + pub s_type: StructureType, + pub p_next: *const c_void, + pub acceleration_structure_count: u32, + pub p_acceleration_structures: *const AccelerationStructureNV, +} +impl ::std::default::Default for WriteDescriptorSetAccelerationStructureNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + acceleration_structure_count: u32::default(), + p_acceleration_structures: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for WriteDescriptorSetAccelerationStructureNV { + const STRUCTURE_TYPE: StructureType = + StructureType::WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV; +} +impl WriteDescriptorSetAccelerationStructureNV { + pub fn builder<'a>() -> WriteDescriptorSetAccelerationStructureNVBuilder<'a> { + WriteDescriptorSetAccelerationStructureNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct WriteDescriptorSetAccelerationStructureNVBuilder<'a> { + inner: WriteDescriptorSetAccelerationStructureNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsWriteDescriptorSet for WriteDescriptorSetAccelerationStructureNVBuilder<'_> {} +unsafe impl ExtendsWriteDescriptorSet for WriteDescriptorSetAccelerationStructureNV {} +impl<'a> ::std::ops::Deref for WriteDescriptorSetAccelerationStructureNVBuilder<'a> { + type Target = WriteDescriptorSetAccelerationStructureNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for WriteDescriptorSetAccelerationStructureNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> WriteDescriptorSetAccelerationStructureNVBuilder<'a> { + #[inline] + pub fn acceleration_structures( + mut self, + acceleration_structures: &'a [AccelerationStructureNV], + ) -> Self { + self.inner.acceleration_structure_count = acceleration_structures.len() as _; + self.inner.p_acceleration_structures = acceleration_structures.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> WriteDescriptorSetAccelerationStructureNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct AccelerationStructureMemoryRequirementsInfoNV { + pub s_type: StructureType, + pub p_next: *const c_void, + pub ty: AccelerationStructureMemoryRequirementsTypeNV, + pub acceleration_structure: AccelerationStructureNV, +} +impl ::std::default::Default for AccelerationStructureMemoryRequirementsInfoNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + ty: AccelerationStructureMemoryRequirementsTypeNV::default(), + acceleration_structure: AccelerationStructureNV::default(), + } + } +} +unsafe impl TaggedStructure for AccelerationStructureMemoryRequirementsInfoNV { + const STRUCTURE_TYPE: StructureType = + StructureType::ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV; +} +impl AccelerationStructureMemoryRequirementsInfoNV { + pub fn builder<'a>() -> AccelerationStructureMemoryRequirementsInfoNVBuilder<'a> { + AccelerationStructureMemoryRequirementsInfoNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct AccelerationStructureMemoryRequirementsInfoNVBuilder<'a> { + inner: AccelerationStructureMemoryRequirementsInfoNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for AccelerationStructureMemoryRequirementsInfoNVBuilder<'a> { + type Target = AccelerationStructureMemoryRequirementsInfoNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for AccelerationStructureMemoryRequirementsInfoNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> AccelerationStructureMemoryRequirementsInfoNVBuilder<'a> { + #[inline] + pub fn ty(mut self, ty: AccelerationStructureMemoryRequirementsTypeNV) -> Self { + self.inner.ty = ty; + self + } + #[inline] + pub fn acceleration_structure( + mut self, + acceleration_structure: AccelerationStructureNV, + ) -> Self { + self.inner.acceleration_structure = acceleration_structure; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> AccelerationStructureMemoryRequirementsInfoNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceAccelerationStructureFeaturesKHR { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub acceleration_structure: Bool32, + pub acceleration_structure_capture_replay: Bool32, + pub acceleration_structure_indirect_build: Bool32, + pub acceleration_structure_host_commands: Bool32, + pub descriptor_binding_acceleration_structure_update_after_bind: Bool32, +} +impl ::std::default::Default for PhysicalDeviceAccelerationStructureFeaturesKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + acceleration_structure: Bool32::default(), + acceleration_structure_capture_replay: Bool32::default(), + acceleration_structure_indirect_build: Bool32::default(), + acceleration_structure_host_commands: Bool32::default(), + descriptor_binding_acceleration_structure_update_after_bind: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceAccelerationStructureFeaturesKHR { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR; +} +impl PhysicalDeviceAccelerationStructureFeaturesKHR { + pub fn builder<'a>() -> PhysicalDeviceAccelerationStructureFeaturesKHRBuilder<'a> { + PhysicalDeviceAccelerationStructureFeaturesKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceAccelerationStructureFeaturesKHRBuilder<'a> { + inner: PhysicalDeviceAccelerationStructureFeaturesKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceAccelerationStructureFeaturesKHRBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceAccelerationStructureFeaturesKHR {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceAccelerationStructureFeaturesKHRBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceAccelerationStructureFeaturesKHR {} +impl<'a> ::std::ops::Deref for PhysicalDeviceAccelerationStructureFeaturesKHRBuilder<'a> { + type Target = PhysicalDeviceAccelerationStructureFeaturesKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceAccelerationStructureFeaturesKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceAccelerationStructureFeaturesKHRBuilder<'a> { + #[inline] + pub fn acceleration_structure(mut self, acceleration_structure: bool) -> Self { + self.inner.acceleration_structure = acceleration_structure.into(); + self + } + #[inline] + pub fn acceleration_structure_capture_replay( + mut self, + acceleration_structure_capture_replay: bool, + ) -> Self { + self.inner.acceleration_structure_capture_replay = + acceleration_structure_capture_replay.into(); + self + } + #[inline] + pub fn acceleration_structure_indirect_build( + mut self, + acceleration_structure_indirect_build: bool, + ) -> Self { + self.inner.acceleration_structure_indirect_build = + acceleration_structure_indirect_build.into(); + self + } + #[inline] + pub fn acceleration_structure_host_commands( + mut self, + acceleration_structure_host_commands: bool, + ) -> Self { + self.inner.acceleration_structure_host_commands = + acceleration_structure_host_commands.into(); + self + } + #[inline] + pub fn descriptor_binding_acceleration_structure_update_after_bind( + mut self, + descriptor_binding_acceleration_structure_update_after_bind: bool, + ) -> Self { + self.inner + .descriptor_binding_acceleration_structure_update_after_bind = + descriptor_binding_acceleration_structure_update_after_bind.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceAccelerationStructureFeaturesKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceRayTracingPipelineFeaturesKHR { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub ray_tracing_pipeline: Bool32, + pub ray_tracing_pipeline_shader_group_handle_capture_replay: Bool32, + pub ray_tracing_pipeline_shader_group_handle_capture_replay_mixed: Bool32, + pub ray_tracing_pipeline_trace_rays_indirect: Bool32, + pub ray_traversal_primitive_culling: Bool32, +} +impl ::std::default::Default for PhysicalDeviceRayTracingPipelineFeaturesKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + ray_tracing_pipeline: Bool32::default(), + ray_tracing_pipeline_shader_group_handle_capture_replay: Bool32::default(), + ray_tracing_pipeline_shader_group_handle_capture_replay_mixed: Bool32::default(), + ray_tracing_pipeline_trace_rays_indirect: Bool32::default(), + ray_traversal_primitive_culling: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceRayTracingPipelineFeaturesKHR { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR; +} +impl PhysicalDeviceRayTracingPipelineFeaturesKHR { + pub fn builder<'a>() -> PhysicalDeviceRayTracingPipelineFeaturesKHRBuilder<'a> { + PhysicalDeviceRayTracingPipelineFeaturesKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceRayTracingPipelineFeaturesKHRBuilder<'a> { + inner: PhysicalDeviceRayTracingPipelineFeaturesKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceRayTracingPipelineFeaturesKHRBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceRayTracingPipelineFeaturesKHR {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceRayTracingPipelineFeaturesKHRBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceRayTracingPipelineFeaturesKHR {} +impl<'a> ::std::ops::Deref for PhysicalDeviceRayTracingPipelineFeaturesKHRBuilder<'a> { + type Target = PhysicalDeviceRayTracingPipelineFeaturesKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceRayTracingPipelineFeaturesKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceRayTracingPipelineFeaturesKHRBuilder<'a> { + #[inline] + pub fn ray_tracing_pipeline(mut self, ray_tracing_pipeline: bool) -> Self { + self.inner.ray_tracing_pipeline = ray_tracing_pipeline.into(); + self + } + #[inline] + pub fn ray_tracing_pipeline_shader_group_handle_capture_replay( + mut self, + ray_tracing_pipeline_shader_group_handle_capture_replay: bool, + ) -> Self { + self.inner + .ray_tracing_pipeline_shader_group_handle_capture_replay = + ray_tracing_pipeline_shader_group_handle_capture_replay.into(); + self + } + #[inline] + pub fn ray_tracing_pipeline_shader_group_handle_capture_replay_mixed( + mut self, + ray_tracing_pipeline_shader_group_handle_capture_replay_mixed: bool, + ) -> Self { + self.inner + .ray_tracing_pipeline_shader_group_handle_capture_replay_mixed = + ray_tracing_pipeline_shader_group_handle_capture_replay_mixed.into(); + self + } + #[inline] + pub fn ray_tracing_pipeline_trace_rays_indirect( + mut self, + ray_tracing_pipeline_trace_rays_indirect: bool, + ) -> Self { + self.inner.ray_tracing_pipeline_trace_rays_indirect = + ray_tracing_pipeline_trace_rays_indirect.into(); + self + } + #[inline] + pub fn ray_traversal_primitive_culling( + mut self, + ray_traversal_primitive_culling: bool, + ) -> Self { + self.inner.ray_traversal_primitive_culling = ray_traversal_primitive_culling.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceRayTracingPipelineFeaturesKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceRayQueryFeaturesKHR { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub ray_query: Bool32, +} +impl ::std::default::Default for PhysicalDeviceRayQueryFeaturesKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + ray_query: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceRayQueryFeaturesKHR { + const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR; +} +impl PhysicalDeviceRayQueryFeaturesKHR { + pub fn builder<'a>() -> PhysicalDeviceRayQueryFeaturesKHRBuilder<'a> { + PhysicalDeviceRayQueryFeaturesKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceRayQueryFeaturesKHRBuilder<'a> { + inner: PhysicalDeviceRayQueryFeaturesKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceRayQueryFeaturesKHRBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceRayQueryFeaturesKHR {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceRayQueryFeaturesKHRBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceRayQueryFeaturesKHR {} +impl<'a> ::std::ops::Deref for PhysicalDeviceRayQueryFeaturesKHRBuilder<'a> { + type Target = PhysicalDeviceRayQueryFeaturesKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceRayQueryFeaturesKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceRayQueryFeaturesKHRBuilder<'a> { + #[inline] + pub fn ray_query(mut self, ray_query: bool) -> Self { + self.inner.ray_query = ray_query.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceRayQueryFeaturesKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceAccelerationStructurePropertiesKHR { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub max_geometry_count: u64, + pub max_instance_count: u64, + pub max_primitive_count: u64, + pub max_per_stage_descriptor_acceleration_structures: u32, + pub max_per_stage_descriptor_update_after_bind_acceleration_structures: u32, + pub max_descriptor_set_acceleration_structures: u32, + pub max_descriptor_set_update_after_bind_acceleration_structures: u32, + pub min_acceleration_structure_scratch_offset_alignment: u32, +} +impl ::std::default::Default for PhysicalDeviceAccelerationStructurePropertiesKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + max_geometry_count: u64::default(), + max_instance_count: u64::default(), + max_primitive_count: u64::default(), + max_per_stage_descriptor_acceleration_structures: u32::default(), + max_per_stage_descriptor_update_after_bind_acceleration_structures: u32::default(), + max_descriptor_set_acceleration_structures: u32::default(), + max_descriptor_set_update_after_bind_acceleration_structures: u32::default(), + min_acceleration_structure_scratch_offset_alignment: u32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceAccelerationStructurePropertiesKHR { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR; +} +impl PhysicalDeviceAccelerationStructurePropertiesKHR { + pub fn builder<'a>() -> PhysicalDeviceAccelerationStructurePropertiesKHRBuilder<'a> { + PhysicalDeviceAccelerationStructurePropertiesKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceAccelerationStructurePropertiesKHRBuilder<'a> { + inner: PhysicalDeviceAccelerationStructurePropertiesKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceAccelerationStructurePropertiesKHRBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceAccelerationStructurePropertiesKHR {} +impl<'a> ::std::ops::Deref for PhysicalDeviceAccelerationStructurePropertiesKHRBuilder<'a> { + type Target = PhysicalDeviceAccelerationStructurePropertiesKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceAccelerationStructurePropertiesKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceAccelerationStructurePropertiesKHRBuilder<'a> { + #[inline] + pub fn max_geometry_count(mut self, max_geometry_count: u64) -> Self { + self.inner.max_geometry_count = max_geometry_count; + self + } + #[inline] + pub fn max_instance_count(mut self, max_instance_count: u64) -> Self { + self.inner.max_instance_count = max_instance_count; + self + } + #[inline] + pub fn max_primitive_count(mut self, max_primitive_count: u64) -> Self { + self.inner.max_primitive_count = max_primitive_count; + self + } + #[inline] + pub fn max_per_stage_descriptor_acceleration_structures( + mut self, + max_per_stage_descriptor_acceleration_structures: u32, + ) -> Self { + self.inner.max_per_stage_descriptor_acceleration_structures = + max_per_stage_descriptor_acceleration_structures; + self + } + #[inline] + pub fn max_per_stage_descriptor_update_after_bind_acceleration_structures( + mut self, + max_per_stage_descriptor_update_after_bind_acceleration_structures: u32, + ) -> Self { + self.inner + .max_per_stage_descriptor_update_after_bind_acceleration_structures = + max_per_stage_descriptor_update_after_bind_acceleration_structures; + self + } + #[inline] + pub fn max_descriptor_set_acceleration_structures( + mut self, + max_descriptor_set_acceleration_structures: u32, + ) -> Self { + self.inner.max_descriptor_set_acceleration_structures = + max_descriptor_set_acceleration_structures; + self + } + #[inline] + pub fn max_descriptor_set_update_after_bind_acceleration_structures( + mut self, + max_descriptor_set_update_after_bind_acceleration_structures: u32, + ) -> Self { + self.inner + .max_descriptor_set_update_after_bind_acceleration_structures = + max_descriptor_set_update_after_bind_acceleration_structures; + self + } + #[inline] + pub fn min_acceleration_structure_scratch_offset_alignment( + mut self, + min_acceleration_structure_scratch_offset_alignment: u32, + ) -> Self { + self.inner + .min_acceleration_structure_scratch_offset_alignment = + min_acceleration_structure_scratch_offset_alignment; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceAccelerationStructurePropertiesKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceRayTracingPipelinePropertiesKHR { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub shader_group_handle_size: u32, + pub max_ray_recursion_depth: u32, + pub max_shader_group_stride: u32, + pub shader_group_base_alignment: u32, + pub shader_group_handle_capture_replay_size: u32, + pub max_ray_dispatch_invocation_count: u32, + pub shader_group_handle_alignment: u32, + pub max_ray_hit_attribute_size: u32, +} +impl ::std::default::Default for PhysicalDeviceRayTracingPipelinePropertiesKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + shader_group_handle_size: u32::default(), + max_ray_recursion_depth: u32::default(), + max_shader_group_stride: u32::default(), + shader_group_base_alignment: u32::default(), + shader_group_handle_capture_replay_size: u32::default(), + max_ray_dispatch_invocation_count: u32::default(), + shader_group_handle_alignment: u32::default(), + max_ray_hit_attribute_size: u32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceRayTracingPipelinePropertiesKHR { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR; +} +impl PhysicalDeviceRayTracingPipelinePropertiesKHR { + pub fn builder<'a>() -> PhysicalDeviceRayTracingPipelinePropertiesKHRBuilder<'a> { + PhysicalDeviceRayTracingPipelinePropertiesKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceRayTracingPipelinePropertiesKHRBuilder<'a> { + inner: PhysicalDeviceRayTracingPipelinePropertiesKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceRayTracingPipelinePropertiesKHRBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceRayTracingPipelinePropertiesKHR {} +impl<'a> ::std::ops::Deref for PhysicalDeviceRayTracingPipelinePropertiesKHRBuilder<'a> { + type Target = PhysicalDeviceRayTracingPipelinePropertiesKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceRayTracingPipelinePropertiesKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceRayTracingPipelinePropertiesKHRBuilder<'a> { + #[inline] + pub fn shader_group_handle_size(mut self, shader_group_handle_size: u32) -> Self { + self.inner.shader_group_handle_size = shader_group_handle_size; + self + } + #[inline] + pub fn max_ray_recursion_depth(mut self, max_ray_recursion_depth: u32) -> Self { + self.inner.max_ray_recursion_depth = max_ray_recursion_depth; + self + } + #[inline] + pub fn max_shader_group_stride(mut self, max_shader_group_stride: u32) -> Self { + self.inner.max_shader_group_stride = max_shader_group_stride; + self + } + #[inline] + pub fn shader_group_base_alignment(mut self, shader_group_base_alignment: u32) -> Self { + self.inner.shader_group_base_alignment = shader_group_base_alignment; + self + } + #[inline] + pub fn shader_group_handle_capture_replay_size( + mut self, + shader_group_handle_capture_replay_size: u32, + ) -> Self { + self.inner.shader_group_handle_capture_replay_size = + shader_group_handle_capture_replay_size; + self + } + #[inline] + pub fn max_ray_dispatch_invocation_count( + mut self, + max_ray_dispatch_invocation_count: u32, + ) -> Self { + self.inner.max_ray_dispatch_invocation_count = max_ray_dispatch_invocation_count; + self + } + #[inline] + pub fn shader_group_handle_alignment(mut self, shader_group_handle_alignment: u32) -> Self { + self.inner.shader_group_handle_alignment = shader_group_handle_alignment; + self + } + #[inline] + pub fn max_ray_hit_attribute_size(mut self, max_ray_hit_attribute_size: u32) -> Self { + self.inner.max_ray_hit_attribute_size = max_ray_hit_attribute_size; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceRayTracingPipelinePropertiesKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceRayTracingPropertiesNV { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub shader_group_handle_size: u32, + pub max_recursion_depth: u32, + pub max_shader_group_stride: u32, + pub shader_group_base_alignment: u32, + pub max_geometry_count: u64, + pub max_instance_count: u64, + pub max_triangle_count: u64, + pub max_descriptor_set_acceleration_structures: u32, +} +impl ::std::default::Default for PhysicalDeviceRayTracingPropertiesNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + shader_group_handle_size: u32::default(), + max_recursion_depth: u32::default(), + max_shader_group_stride: u32::default(), + shader_group_base_alignment: u32::default(), + max_geometry_count: u64::default(), + max_instance_count: u64::default(), + max_triangle_count: u64::default(), + max_descriptor_set_acceleration_structures: u32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceRayTracingPropertiesNV { + const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV; +} +impl PhysicalDeviceRayTracingPropertiesNV { + pub fn builder<'a>() -> PhysicalDeviceRayTracingPropertiesNVBuilder<'a> { + PhysicalDeviceRayTracingPropertiesNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceRayTracingPropertiesNVBuilder<'a> { + inner: PhysicalDeviceRayTracingPropertiesNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceRayTracingPropertiesNVBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceRayTracingPropertiesNV {} +impl<'a> ::std::ops::Deref for PhysicalDeviceRayTracingPropertiesNVBuilder<'a> { + type Target = PhysicalDeviceRayTracingPropertiesNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceRayTracingPropertiesNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceRayTracingPropertiesNVBuilder<'a> { + #[inline] + pub fn shader_group_handle_size(mut self, shader_group_handle_size: u32) -> Self { + self.inner.shader_group_handle_size = shader_group_handle_size; + self + } + #[inline] + pub fn max_recursion_depth(mut self, max_recursion_depth: u32) -> Self { + self.inner.max_recursion_depth = max_recursion_depth; + self + } + #[inline] + pub fn max_shader_group_stride(mut self, max_shader_group_stride: u32) -> Self { + self.inner.max_shader_group_stride = max_shader_group_stride; + self + } + #[inline] + pub fn shader_group_base_alignment(mut self, shader_group_base_alignment: u32) -> Self { + self.inner.shader_group_base_alignment = shader_group_base_alignment; + self + } + #[inline] + pub fn max_geometry_count(mut self, max_geometry_count: u64) -> Self { + self.inner.max_geometry_count = max_geometry_count; + self + } + #[inline] + pub fn max_instance_count(mut self, max_instance_count: u64) -> Self { + self.inner.max_instance_count = max_instance_count; + self + } + #[inline] + pub fn max_triangle_count(mut self, max_triangle_count: u64) -> Self { + self.inner.max_triangle_count = max_triangle_count; + self + } + #[inline] + pub fn max_descriptor_set_acceleration_structures( + mut self, + max_descriptor_set_acceleration_structures: u32, + ) -> Self { + self.inner.max_descriptor_set_acceleration_structures = + max_descriptor_set_acceleration_structures; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceRayTracingPropertiesNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct StridedDeviceAddressRegionKHR { + pub device_address: DeviceAddress, + pub stride: DeviceSize, + pub size: DeviceSize, +} +impl StridedDeviceAddressRegionKHR { + pub fn builder<'a>() -> StridedDeviceAddressRegionKHRBuilder<'a> { + StridedDeviceAddressRegionKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct StridedDeviceAddressRegionKHRBuilder<'a> { + inner: StridedDeviceAddressRegionKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for StridedDeviceAddressRegionKHRBuilder<'a> { + type Target = StridedDeviceAddressRegionKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for StridedDeviceAddressRegionKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> StridedDeviceAddressRegionKHRBuilder<'a> { + #[inline] + pub fn device_address(mut self, device_address: DeviceAddress) -> Self { + self.inner.device_address = device_address; + self + } + #[inline] + pub fn stride(mut self, stride: DeviceSize) -> Self { + self.inner.stride = stride; + self + } + #[inline] + pub fn size(mut self, size: DeviceSize) -> Self { + self.inner.size = size; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> StridedDeviceAddressRegionKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct TraceRaysIndirectCommandKHR { + pub width: u32, + pub height: u32, + pub depth: u32, +} +impl TraceRaysIndirectCommandKHR { + pub fn builder<'a>() -> TraceRaysIndirectCommandKHRBuilder<'a> { + TraceRaysIndirectCommandKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct TraceRaysIndirectCommandKHRBuilder<'a> { + inner: TraceRaysIndirectCommandKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for TraceRaysIndirectCommandKHRBuilder<'a> { + type Target = TraceRaysIndirectCommandKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for TraceRaysIndirectCommandKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> TraceRaysIndirectCommandKHRBuilder<'a> { + #[inline] + pub fn width(mut self, width: u32) -> Self { + self.inner.width = width; + self + } + #[inline] + pub fn height(mut self, height: u32) -> Self { + self.inner.height = height; + self + } + #[inline] + pub fn depth(mut self, depth: u32) -> Self { + self.inner.depth = depth; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> TraceRaysIndirectCommandKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct TraceRaysIndirectCommand2KHR { + pub raygen_shader_record_address: DeviceAddress, + pub raygen_shader_record_size: DeviceSize, + pub miss_shader_binding_table_address: DeviceAddress, + pub miss_shader_binding_table_size: DeviceSize, + pub miss_shader_binding_table_stride: DeviceSize, + pub hit_shader_binding_table_address: DeviceAddress, + pub hit_shader_binding_table_size: DeviceSize, + pub hit_shader_binding_table_stride: DeviceSize, + pub callable_shader_binding_table_address: DeviceAddress, + pub callable_shader_binding_table_size: DeviceSize, + pub callable_shader_binding_table_stride: DeviceSize, + pub width: u32, + pub height: u32, + pub depth: u32, +} +impl TraceRaysIndirectCommand2KHR { + pub fn builder<'a>() -> TraceRaysIndirectCommand2KHRBuilder<'a> { + TraceRaysIndirectCommand2KHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct TraceRaysIndirectCommand2KHRBuilder<'a> { + inner: TraceRaysIndirectCommand2KHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for TraceRaysIndirectCommand2KHRBuilder<'a> { + type Target = TraceRaysIndirectCommand2KHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for TraceRaysIndirectCommand2KHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> TraceRaysIndirectCommand2KHRBuilder<'a> { + #[inline] + pub fn raygen_shader_record_address( + mut self, + raygen_shader_record_address: DeviceAddress, + ) -> Self { + self.inner.raygen_shader_record_address = raygen_shader_record_address; + self + } + #[inline] + pub fn raygen_shader_record_size(mut self, raygen_shader_record_size: DeviceSize) -> Self { + self.inner.raygen_shader_record_size = raygen_shader_record_size; + self + } + #[inline] + pub fn miss_shader_binding_table_address( + mut self, + miss_shader_binding_table_address: DeviceAddress, + ) -> Self { + self.inner.miss_shader_binding_table_address = miss_shader_binding_table_address; + self + } + #[inline] + pub fn miss_shader_binding_table_size( + mut self, + miss_shader_binding_table_size: DeviceSize, + ) -> Self { + self.inner.miss_shader_binding_table_size = miss_shader_binding_table_size; + self + } + #[inline] + pub fn miss_shader_binding_table_stride( + mut self, + miss_shader_binding_table_stride: DeviceSize, + ) -> Self { + self.inner.miss_shader_binding_table_stride = miss_shader_binding_table_stride; + self + } + #[inline] + pub fn hit_shader_binding_table_address( + mut self, + hit_shader_binding_table_address: DeviceAddress, + ) -> Self { + self.inner.hit_shader_binding_table_address = hit_shader_binding_table_address; + self + } + #[inline] + pub fn hit_shader_binding_table_size( + mut self, + hit_shader_binding_table_size: DeviceSize, + ) -> Self { + self.inner.hit_shader_binding_table_size = hit_shader_binding_table_size; + self + } + #[inline] + pub fn hit_shader_binding_table_stride( + mut self, + hit_shader_binding_table_stride: DeviceSize, + ) -> Self { + self.inner.hit_shader_binding_table_stride = hit_shader_binding_table_stride; + self + } + #[inline] + pub fn callable_shader_binding_table_address( + mut self, + callable_shader_binding_table_address: DeviceAddress, + ) -> Self { + self.inner.callable_shader_binding_table_address = callable_shader_binding_table_address; + self + } + #[inline] + pub fn callable_shader_binding_table_size( + mut self, + callable_shader_binding_table_size: DeviceSize, + ) -> Self { + self.inner.callable_shader_binding_table_size = callable_shader_binding_table_size; + self + } + #[inline] + pub fn callable_shader_binding_table_stride( + mut self, + callable_shader_binding_table_stride: DeviceSize, + ) -> Self { + self.inner.callable_shader_binding_table_stride = callable_shader_binding_table_stride; + self + } + #[inline] + pub fn width(mut self, width: u32) -> Self { + self.inner.width = width; + self + } + #[inline] + pub fn height(mut self, height: u32) -> Self { + self.inner.height = height; + self + } + #[inline] + pub fn depth(mut self, depth: u32) -> Self { + self.inner.depth = depth; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> TraceRaysIndirectCommand2KHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceRayTracingMaintenance1FeaturesKHR { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub ray_tracing_maintenance1: Bool32, + pub ray_tracing_pipeline_trace_rays_indirect2: Bool32, +} +impl ::std::default::Default for PhysicalDeviceRayTracingMaintenance1FeaturesKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + ray_tracing_maintenance1: Bool32::default(), + ray_tracing_pipeline_trace_rays_indirect2: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceRayTracingMaintenance1FeaturesKHR { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR; +} +impl PhysicalDeviceRayTracingMaintenance1FeaturesKHR { + pub fn builder<'a>() -> PhysicalDeviceRayTracingMaintenance1FeaturesKHRBuilder<'a> { + PhysicalDeviceRayTracingMaintenance1FeaturesKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceRayTracingMaintenance1FeaturesKHRBuilder<'a> { + inner: PhysicalDeviceRayTracingMaintenance1FeaturesKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceRayTracingMaintenance1FeaturesKHRBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceRayTracingMaintenance1FeaturesKHR {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceRayTracingMaintenance1FeaturesKHRBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceRayTracingMaintenance1FeaturesKHR {} +impl<'a> ::std::ops::Deref for PhysicalDeviceRayTracingMaintenance1FeaturesKHRBuilder<'a> { + type Target = PhysicalDeviceRayTracingMaintenance1FeaturesKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceRayTracingMaintenance1FeaturesKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceRayTracingMaintenance1FeaturesKHRBuilder<'a> { + #[inline] + pub fn ray_tracing_maintenance1(mut self, ray_tracing_maintenance1: bool) -> Self { + self.inner.ray_tracing_maintenance1 = ray_tracing_maintenance1.into(); + self + } + #[inline] + pub fn ray_tracing_pipeline_trace_rays_indirect2( + mut self, + ray_tracing_pipeline_trace_rays_indirect2: bool, + ) -> Self { + self.inner.ray_tracing_pipeline_trace_rays_indirect2 = + ray_tracing_pipeline_trace_rays_indirect2.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceRayTracingMaintenance1FeaturesKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DrmFormatModifierPropertiesListEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub drm_format_modifier_count: u32, + pub p_drm_format_modifier_properties: *mut DrmFormatModifierPropertiesEXT, +} +impl ::std::default::Default for DrmFormatModifierPropertiesListEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + drm_format_modifier_count: u32::default(), + p_drm_format_modifier_properties: ::std::ptr::null_mut(), + } + } +} +unsafe impl TaggedStructure for DrmFormatModifierPropertiesListEXT { + const STRUCTURE_TYPE: StructureType = StructureType::DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT; +} +impl DrmFormatModifierPropertiesListEXT { + pub fn builder<'a>() -> DrmFormatModifierPropertiesListEXTBuilder<'a> { + DrmFormatModifierPropertiesListEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DrmFormatModifierPropertiesListEXTBuilder<'a> { + inner: DrmFormatModifierPropertiesListEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsFormatProperties2 for DrmFormatModifierPropertiesListEXTBuilder<'_> {} +unsafe impl ExtendsFormatProperties2 for DrmFormatModifierPropertiesListEXT {} +impl<'a> ::std::ops::Deref for DrmFormatModifierPropertiesListEXTBuilder<'a> { + type Target = DrmFormatModifierPropertiesListEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DrmFormatModifierPropertiesListEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DrmFormatModifierPropertiesListEXTBuilder<'a> { + #[inline] + pub fn drm_format_modifier_properties( + mut self, + drm_format_modifier_properties: &'a mut [DrmFormatModifierPropertiesEXT], + ) -> Self { + self.inner.drm_format_modifier_count = drm_format_modifier_properties.len() as _; + self.inner.p_drm_format_modifier_properties = drm_format_modifier_properties.as_mut_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DrmFormatModifierPropertiesListEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct DrmFormatModifierPropertiesEXT { + pub drm_format_modifier: u64, + pub drm_format_modifier_plane_count: u32, + pub drm_format_modifier_tiling_features: FormatFeatureFlags, +} +impl DrmFormatModifierPropertiesEXT { + pub fn builder<'a>() -> DrmFormatModifierPropertiesEXTBuilder<'a> { + DrmFormatModifierPropertiesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DrmFormatModifierPropertiesEXTBuilder<'a> { + inner: DrmFormatModifierPropertiesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DrmFormatModifierPropertiesEXTBuilder<'a> { + type Target = DrmFormatModifierPropertiesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DrmFormatModifierPropertiesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DrmFormatModifierPropertiesEXTBuilder<'a> { + #[inline] + pub fn drm_format_modifier(mut self, drm_format_modifier: u64) -> Self { + self.inner.drm_format_modifier = drm_format_modifier; + self + } + #[inline] + pub fn drm_format_modifier_plane_count(mut self, drm_format_modifier_plane_count: u32) -> Self { + self.inner.drm_format_modifier_plane_count = drm_format_modifier_plane_count; + self + } + #[inline] + pub fn drm_format_modifier_tiling_features( + mut self, + drm_format_modifier_tiling_features: FormatFeatureFlags, + ) -> Self { + self.inner.drm_format_modifier_tiling_features = drm_format_modifier_tiling_features; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DrmFormatModifierPropertiesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceImageDrmFormatModifierInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub drm_format_modifier: u64, + pub sharing_mode: SharingMode, + pub queue_family_index_count: u32, + pub p_queue_family_indices: *const u32, +} +impl ::std::default::Default for PhysicalDeviceImageDrmFormatModifierInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + drm_format_modifier: u64::default(), + sharing_mode: SharingMode::default(), + queue_family_index_count: u32::default(), + p_queue_family_indices: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceImageDrmFormatModifierInfoEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT; +} +impl PhysicalDeviceImageDrmFormatModifierInfoEXT { + pub fn builder<'a>() -> PhysicalDeviceImageDrmFormatModifierInfoEXTBuilder<'a> { + PhysicalDeviceImageDrmFormatModifierInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceImageDrmFormatModifierInfoEXTBuilder<'a> { + inner: PhysicalDeviceImageDrmFormatModifierInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceImageFormatInfo2 + for PhysicalDeviceImageDrmFormatModifierInfoEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceImageFormatInfo2 for PhysicalDeviceImageDrmFormatModifierInfoEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceImageDrmFormatModifierInfoEXTBuilder<'a> { + type Target = PhysicalDeviceImageDrmFormatModifierInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceImageDrmFormatModifierInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceImageDrmFormatModifierInfoEXTBuilder<'a> { + #[inline] + pub fn drm_format_modifier(mut self, drm_format_modifier: u64) -> Self { + self.inner.drm_format_modifier = drm_format_modifier; + self + } + #[inline] + pub fn sharing_mode(mut self, sharing_mode: SharingMode) -> Self { + self.inner.sharing_mode = sharing_mode; + self + } + #[inline] + pub fn queue_family_indices(mut self, queue_family_indices: &'a [u32]) -> Self { + self.inner.queue_family_index_count = queue_family_indices.len() as _; + self.inner.p_queue_family_indices = queue_family_indices.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceImageDrmFormatModifierInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ImageDrmFormatModifierListCreateInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub drm_format_modifier_count: u32, + pub p_drm_format_modifiers: *const u64, +} +impl ::std::default::Default for ImageDrmFormatModifierListCreateInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + drm_format_modifier_count: u32::default(), + p_drm_format_modifiers: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for ImageDrmFormatModifierListCreateInfoEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT; +} +impl ImageDrmFormatModifierListCreateInfoEXT { + pub fn builder<'a>() -> ImageDrmFormatModifierListCreateInfoEXTBuilder<'a> { + ImageDrmFormatModifierListCreateInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ImageDrmFormatModifierListCreateInfoEXTBuilder<'a> { + inner: ImageDrmFormatModifierListCreateInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsImageCreateInfo for ImageDrmFormatModifierListCreateInfoEXTBuilder<'_> {} +unsafe impl ExtendsImageCreateInfo for ImageDrmFormatModifierListCreateInfoEXT {} +impl<'a> ::std::ops::Deref for ImageDrmFormatModifierListCreateInfoEXTBuilder<'a> { + type Target = ImageDrmFormatModifierListCreateInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ImageDrmFormatModifierListCreateInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ImageDrmFormatModifierListCreateInfoEXTBuilder<'a> { + #[inline] + pub fn drm_format_modifiers(mut self, drm_format_modifiers: &'a [u64]) -> Self { + self.inner.drm_format_modifier_count = drm_format_modifiers.len() as _; + self.inner.p_drm_format_modifiers = drm_format_modifiers.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ImageDrmFormatModifierListCreateInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ImageDrmFormatModifierExplicitCreateInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub drm_format_modifier: u64, + pub drm_format_modifier_plane_count: u32, + pub p_plane_layouts: *const SubresourceLayout, +} +impl ::std::default::Default for ImageDrmFormatModifierExplicitCreateInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + drm_format_modifier: u64::default(), + drm_format_modifier_plane_count: u32::default(), + p_plane_layouts: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for ImageDrmFormatModifierExplicitCreateInfoEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT; +} +impl ImageDrmFormatModifierExplicitCreateInfoEXT { + pub fn builder<'a>() -> ImageDrmFormatModifierExplicitCreateInfoEXTBuilder<'a> { + ImageDrmFormatModifierExplicitCreateInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ImageDrmFormatModifierExplicitCreateInfoEXTBuilder<'a> { + inner: ImageDrmFormatModifierExplicitCreateInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsImageCreateInfo for ImageDrmFormatModifierExplicitCreateInfoEXTBuilder<'_> {} +unsafe impl ExtendsImageCreateInfo for ImageDrmFormatModifierExplicitCreateInfoEXT {} +impl<'a> ::std::ops::Deref for ImageDrmFormatModifierExplicitCreateInfoEXTBuilder<'a> { + type Target = ImageDrmFormatModifierExplicitCreateInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ImageDrmFormatModifierExplicitCreateInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ImageDrmFormatModifierExplicitCreateInfoEXTBuilder<'a> { + #[inline] + pub fn drm_format_modifier(mut self, drm_format_modifier: u64) -> Self { + self.inner.drm_format_modifier = drm_format_modifier; + self + } + #[inline] + pub fn plane_layouts(mut self, plane_layouts: &'a [SubresourceLayout]) -> Self { + self.inner.drm_format_modifier_plane_count = plane_layouts.len() as _; + self.inner.p_plane_layouts = plane_layouts.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ImageDrmFormatModifierExplicitCreateInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ImageDrmFormatModifierPropertiesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub drm_format_modifier: u64, +} +impl ::std::default::Default for ImageDrmFormatModifierPropertiesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + drm_format_modifier: u64::default(), + } + } +} +unsafe impl TaggedStructure for ImageDrmFormatModifierPropertiesEXT { + const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT; +} +impl ImageDrmFormatModifierPropertiesEXT { + pub fn builder<'a>() -> ImageDrmFormatModifierPropertiesEXTBuilder<'a> { + ImageDrmFormatModifierPropertiesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ImageDrmFormatModifierPropertiesEXTBuilder<'a> { + inner: ImageDrmFormatModifierPropertiesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ImageDrmFormatModifierPropertiesEXTBuilder<'a> { + type Target = ImageDrmFormatModifierPropertiesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ImageDrmFormatModifierPropertiesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ImageDrmFormatModifierPropertiesEXTBuilder<'a> { + #[inline] + pub fn drm_format_modifier(mut self, drm_format_modifier: u64) -> Self { + self.inner.drm_format_modifier = drm_format_modifier; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ImageDrmFormatModifierPropertiesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ImageStencilUsageCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub stencil_usage: ImageUsageFlags, +} +impl ::std::default::Default for ImageStencilUsageCreateInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + stencil_usage: ImageUsageFlags::default(), + } + } +} +unsafe impl TaggedStructure for ImageStencilUsageCreateInfo { + const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_STENCIL_USAGE_CREATE_INFO; +} +impl ImageStencilUsageCreateInfo { + pub fn builder<'a>() -> ImageStencilUsageCreateInfoBuilder<'a> { + ImageStencilUsageCreateInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ImageStencilUsageCreateInfoBuilder<'a> { + inner: ImageStencilUsageCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsImageCreateInfo for ImageStencilUsageCreateInfoBuilder<'_> {} +unsafe impl ExtendsImageCreateInfo for ImageStencilUsageCreateInfo {} +unsafe impl ExtendsPhysicalDeviceImageFormatInfo2 for ImageStencilUsageCreateInfoBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceImageFormatInfo2 for ImageStencilUsageCreateInfo {} +impl<'a> ::std::ops::Deref for ImageStencilUsageCreateInfoBuilder<'a> { + type Target = ImageStencilUsageCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ImageStencilUsageCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ImageStencilUsageCreateInfoBuilder<'a> { + #[inline] + pub fn stencil_usage(mut self, stencil_usage: ImageUsageFlags) -> Self { + self.inner.stencil_usage = stencil_usage; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ImageStencilUsageCreateInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DeviceMemoryOverallocationCreateInfoAMD { + pub s_type: StructureType, + pub p_next: *const c_void, + pub overallocation_behavior: MemoryOverallocationBehaviorAMD, +} +impl ::std::default::Default for DeviceMemoryOverallocationCreateInfoAMD { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + overallocation_behavior: MemoryOverallocationBehaviorAMD::default(), + } + } +} +unsafe impl TaggedStructure for DeviceMemoryOverallocationCreateInfoAMD { + const STRUCTURE_TYPE: StructureType = + StructureType::DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD; +} +impl DeviceMemoryOverallocationCreateInfoAMD { + pub fn builder<'a>() -> DeviceMemoryOverallocationCreateInfoAMDBuilder<'a> { + DeviceMemoryOverallocationCreateInfoAMDBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DeviceMemoryOverallocationCreateInfoAMDBuilder<'a> { + inner: DeviceMemoryOverallocationCreateInfoAMD, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsDeviceCreateInfo for DeviceMemoryOverallocationCreateInfoAMDBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for DeviceMemoryOverallocationCreateInfoAMD {} +impl<'a> ::std::ops::Deref for DeviceMemoryOverallocationCreateInfoAMDBuilder<'a> { + type Target = DeviceMemoryOverallocationCreateInfoAMD; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DeviceMemoryOverallocationCreateInfoAMDBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DeviceMemoryOverallocationCreateInfoAMDBuilder<'a> { + #[inline] + pub fn overallocation_behavior( + mut self, + overallocation_behavior: MemoryOverallocationBehaviorAMD, + ) -> Self { + self.inner.overallocation_behavior = overallocation_behavior; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DeviceMemoryOverallocationCreateInfoAMD { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceFragmentDensityMapFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub fragment_density_map: Bool32, + pub fragment_density_map_dynamic: Bool32, + pub fragment_density_map_non_subsampled_images: Bool32, +} +impl ::std::default::Default for PhysicalDeviceFragmentDensityMapFeaturesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + fragment_density_map: Bool32::default(), + fragment_density_map_dynamic: Bool32::default(), + fragment_density_map_non_subsampled_images: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceFragmentDensityMapFeaturesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT; +} +impl PhysicalDeviceFragmentDensityMapFeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceFragmentDensityMapFeaturesEXTBuilder<'a> { + PhysicalDeviceFragmentDensityMapFeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceFragmentDensityMapFeaturesEXTBuilder<'a> { + inner: PhysicalDeviceFragmentDensityMapFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceFragmentDensityMapFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceFragmentDensityMapFeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFragmentDensityMapFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFragmentDensityMapFeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceFragmentDensityMapFeaturesEXTBuilder<'a> { + type Target = PhysicalDeviceFragmentDensityMapFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceFragmentDensityMapFeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceFragmentDensityMapFeaturesEXTBuilder<'a> { + #[inline] + pub fn fragment_density_map(mut self, fragment_density_map: bool) -> Self { + self.inner.fragment_density_map = fragment_density_map.into(); + self + } + #[inline] + pub fn fragment_density_map_dynamic(mut self, fragment_density_map_dynamic: bool) -> Self { + self.inner.fragment_density_map_dynamic = fragment_density_map_dynamic.into(); + self + } + #[inline] + pub fn fragment_density_map_non_subsampled_images( + mut self, + fragment_density_map_non_subsampled_images: bool, + ) -> Self { + self.inner.fragment_density_map_non_subsampled_images = + fragment_density_map_non_subsampled_images.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceFragmentDensityMapFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceFragmentDensityMap2FeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub fragment_density_map_deferred: Bool32, +} +impl ::std::default::Default for PhysicalDeviceFragmentDensityMap2FeaturesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + fragment_density_map_deferred: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceFragmentDensityMap2FeaturesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT; +} +impl PhysicalDeviceFragmentDensityMap2FeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceFragmentDensityMap2FeaturesEXTBuilder<'a> { + PhysicalDeviceFragmentDensityMap2FeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceFragmentDensityMap2FeaturesEXTBuilder<'a> { + inner: PhysicalDeviceFragmentDensityMap2FeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceFragmentDensityMap2FeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceFragmentDensityMap2FeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFragmentDensityMap2FeaturesEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFragmentDensityMap2FeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceFragmentDensityMap2FeaturesEXTBuilder<'a> { + type Target = PhysicalDeviceFragmentDensityMap2FeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceFragmentDensityMap2FeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceFragmentDensityMap2FeaturesEXTBuilder<'a> { + #[inline] + pub fn fragment_density_map_deferred(mut self, fragment_density_map_deferred: bool) -> Self { + self.inner.fragment_density_map_deferred = fragment_density_map_deferred.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceFragmentDensityMap2FeaturesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub fragment_density_map_offset: Bool32, +} +impl ::std::default::Default for PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + fragment_density_map_offset: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM; +} +impl PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM { + pub fn builder<'a>() -> PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOMBuilder<'a> { + PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOMBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOMBuilder<'a> { + inner: PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOMBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM {} +unsafe impl ExtendsDeviceCreateInfo + for PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOMBuilder<'_> +{ +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM {} +impl<'a> ::std::ops::Deref for PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOMBuilder<'a> { + type Target = PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOMBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOMBuilder<'a> { + #[inline] + pub fn fragment_density_map_offset(mut self, fragment_density_map_offset: bool) -> Self { + self.inner.fragment_density_map_offset = fragment_density_map_offset.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceFragmentDensityMapPropertiesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub min_fragment_density_texel_size: Extent2D, + pub max_fragment_density_texel_size: Extent2D, + pub fragment_density_invocations: Bool32, +} +impl ::std::default::Default for PhysicalDeviceFragmentDensityMapPropertiesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + min_fragment_density_texel_size: Extent2D::default(), + max_fragment_density_texel_size: Extent2D::default(), + fragment_density_invocations: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceFragmentDensityMapPropertiesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT; +} +impl PhysicalDeviceFragmentDensityMapPropertiesEXT { + pub fn builder<'a>() -> PhysicalDeviceFragmentDensityMapPropertiesEXTBuilder<'a> { + PhysicalDeviceFragmentDensityMapPropertiesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceFragmentDensityMapPropertiesEXTBuilder<'a> { + inner: PhysicalDeviceFragmentDensityMapPropertiesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceFragmentDensityMapPropertiesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceFragmentDensityMapPropertiesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceFragmentDensityMapPropertiesEXTBuilder<'a> { + type Target = PhysicalDeviceFragmentDensityMapPropertiesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceFragmentDensityMapPropertiesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceFragmentDensityMapPropertiesEXTBuilder<'a> { + #[inline] + pub fn min_fragment_density_texel_size( + mut self, + min_fragment_density_texel_size: Extent2D, + ) -> Self { + self.inner.min_fragment_density_texel_size = min_fragment_density_texel_size; + self + } + #[inline] + pub fn max_fragment_density_texel_size( + mut self, + max_fragment_density_texel_size: Extent2D, + ) -> Self { + self.inner.max_fragment_density_texel_size = max_fragment_density_texel_size; + self + } + #[inline] + pub fn fragment_density_invocations(mut self, fragment_density_invocations: bool) -> Self { + self.inner.fragment_density_invocations = fragment_density_invocations.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceFragmentDensityMapPropertiesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceFragmentDensityMap2PropertiesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub subsampled_loads: Bool32, + pub subsampled_coarse_reconstruction_early_access: Bool32, + pub max_subsampled_array_layers: u32, + pub max_descriptor_set_subsampled_samplers: u32, +} +impl ::std::default::Default for PhysicalDeviceFragmentDensityMap2PropertiesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + subsampled_loads: Bool32::default(), + subsampled_coarse_reconstruction_early_access: Bool32::default(), + max_subsampled_array_layers: u32::default(), + max_descriptor_set_subsampled_samplers: u32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceFragmentDensityMap2PropertiesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT; +} +impl PhysicalDeviceFragmentDensityMap2PropertiesEXT { + pub fn builder<'a>() -> PhysicalDeviceFragmentDensityMap2PropertiesEXTBuilder<'a> { + PhysicalDeviceFragmentDensityMap2PropertiesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceFragmentDensityMap2PropertiesEXTBuilder<'a> { + inner: PhysicalDeviceFragmentDensityMap2PropertiesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceFragmentDensityMap2PropertiesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceFragmentDensityMap2PropertiesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceFragmentDensityMap2PropertiesEXTBuilder<'a> { + type Target = PhysicalDeviceFragmentDensityMap2PropertiesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceFragmentDensityMap2PropertiesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceFragmentDensityMap2PropertiesEXTBuilder<'a> { + #[inline] + pub fn subsampled_loads(mut self, subsampled_loads: bool) -> Self { + self.inner.subsampled_loads = subsampled_loads.into(); + self + } + #[inline] + pub fn subsampled_coarse_reconstruction_early_access( + mut self, + subsampled_coarse_reconstruction_early_access: bool, + ) -> Self { + self.inner.subsampled_coarse_reconstruction_early_access = + subsampled_coarse_reconstruction_early_access.into(); + self + } + #[inline] + pub fn max_subsampled_array_layers(mut self, max_subsampled_array_layers: u32) -> Self { + self.inner.max_subsampled_array_layers = max_subsampled_array_layers; + self + } + #[inline] + pub fn max_descriptor_set_subsampled_samplers( + mut self, + max_descriptor_set_subsampled_samplers: u32, + ) -> Self { + self.inner.max_descriptor_set_subsampled_samplers = max_descriptor_set_subsampled_samplers; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceFragmentDensityMap2PropertiesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub fragment_density_offset_granularity: Extent2D, +} +impl ::std::default::Default for PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + fragment_density_offset_granularity: Extent2D::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM; +} +impl PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM { + pub fn builder<'a>() -> PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOMBuilder<'a> { + PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOMBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOMBuilder<'a> { + inner: PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOMBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM +{ +} +impl<'a> ::std::ops::Deref for PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOMBuilder<'a> { + type Target = PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOMBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOMBuilder<'a> { + #[inline] + pub fn fragment_density_offset_granularity( + mut self, + fragment_density_offset_granularity: Extent2D, + ) -> Self { + self.inner.fragment_density_offset_granularity = fragment_density_offset_granularity; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct RenderPassFragmentDensityMapCreateInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub fragment_density_map_attachment: AttachmentReference, +} +impl ::std::default::Default for RenderPassFragmentDensityMapCreateInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + fragment_density_map_attachment: AttachmentReference::default(), + } + } +} +unsafe impl TaggedStructure for RenderPassFragmentDensityMapCreateInfoEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT; +} +impl RenderPassFragmentDensityMapCreateInfoEXT { + pub fn builder<'a>() -> RenderPassFragmentDensityMapCreateInfoEXTBuilder<'a> { + RenderPassFragmentDensityMapCreateInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct RenderPassFragmentDensityMapCreateInfoEXTBuilder<'a> { + inner: RenderPassFragmentDensityMapCreateInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsRenderPassCreateInfo for RenderPassFragmentDensityMapCreateInfoEXTBuilder<'_> {} +unsafe impl ExtendsRenderPassCreateInfo for RenderPassFragmentDensityMapCreateInfoEXT {} +unsafe impl ExtendsRenderPassCreateInfo2 for RenderPassFragmentDensityMapCreateInfoEXTBuilder<'_> {} +unsafe impl ExtendsRenderPassCreateInfo2 for RenderPassFragmentDensityMapCreateInfoEXT {} +impl<'a> ::std::ops::Deref for RenderPassFragmentDensityMapCreateInfoEXTBuilder<'a> { + type Target = RenderPassFragmentDensityMapCreateInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for RenderPassFragmentDensityMapCreateInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> RenderPassFragmentDensityMapCreateInfoEXTBuilder<'a> { + #[inline] + pub fn fragment_density_map_attachment( + mut self, + fragment_density_map_attachment: AttachmentReference, + ) -> Self { + self.inner.fragment_density_map_attachment = fragment_density_map_attachment; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> RenderPassFragmentDensityMapCreateInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SubpassFragmentDensityMapOffsetEndInfoQCOM { + pub s_type: StructureType, + pub p_next: *const c_void, + pub fragment_density_offset_count: u32, + pub p_fragment_density_offsets: *const Offset2D, +} +impl ::std::default::Default for SubpassFragmentDensityMapOffsetEndInfoQCOM { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + fragment_density_offset_count: u32::default(), + p_fragment_density_offsets: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for SubpassFragmentDensityMapOffsetEndInfoQCOM { + const STRUCTURE_TYPE: StructureType = + StructureType::SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM; +} +impl SubpassFragmentDensityMapOffsetEndInfoQCOM { + pub fn builder<'a>() -> SubpassFragmentDensityMapOffsetEndInfoQCOMBuilder<'a> { + SubpassFragmentDensityMapOffsetEndInfoQCOMBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SubpassFragmentDensityMapOffsetEndInfoQCOMBuilder<'a> { + inner: SubpassFragmentDensityMapOffsetEndInfoQCOM, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsSubpassEndInfo for SubpassFragmentDensityMapOffsetEndInfoQCOMBuilder<'_> {} +unsafe impl ExtendsSubpassEndInfo for SubpassFragmentDensityMapOffsetEndInfoQCOM {} +impl<'a> ::std::ops::Deref for SubpassFragmentDensityMapOffsetEndInfoQCOMBuilder<'a> { + type Target = SubpassFragmentDensityMapOffsetEndInfoQCOM; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SubpassFragmentDensityMapOffsetEndInfoQCOMBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SubpassFragmentDensityMapOffsetEndInfoQCOMBuilder<'a> { + #[inline] + pub fn fragment_density_offsets(mut self, fragment_density_offsets: &'a [Offset2D]) -> Self { + self.inner.fragment_density_offset_count = fragment_density_offsets.len() as _; + self.inner.p_fragment_density_offsets = fragment_density_offsets.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SubpassFragmentDensityMapOffsetEndInfoQCOM { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceScalarBlockLayoutFeatures { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub scalar_block_layout: Bool32, +} +impl ::std::default::Default for PhysicalDeviceScalarBlockLayoutFeatures { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + scalar_block_layout: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceScalarBlockLayoutFeatures { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES; +} +impl PhysicalDeviceScalarBlockLayoutFeatures { + pub fn builder<'a>() -> PhysicalDeviceScalarBlockLayoutFeaturesBuilder<'a> { + PhysicalDeviceScalarBlockLayoutFeaturesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceScalarBlockLayoutFeaturesBuilder<'a> { + inner: PhysicalDeviceScalarBlockLayoutFeatures, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceScalarBlockLayoutFeaturesBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceScalarBlockLayoutFeatures {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceScalarBlockLayoutFeaturesBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceScalarBlockLayoutFeatures {} +impl<'a> ::std::ops::Deref for PhysicalDeviceScalarBlockLayoutFeaturesBuilder<'a> { + type Target = PhysicalDeviceScalarBlockLayoutFeatures; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceScalarBlockLayoutFeaturesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceScalarBlockLayoutFeaturesBuilder<'a> { + #[inline] + pub fn scalar_block_layout(mut self, scalar_block_layout: bool) -> Self { + self.inner.scalar_block_layout = scalar_block_layout.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceScalarBlockLayoutFeatures { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SurfaceProtectedCapabilitiesKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub supports_protected: Bool32, +} +impl ::std::default::Default for SurfaceProtectedCapabilitiesKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + supports_protected: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for SurfaceProtectedCapabilitiesKHR { + const STRUCTURE_TYPE: StructureType = StructureType::SURFACE_PROTECTED_CAPABILITIES_KHR; +} +impl SurfaceProtectedCapabilitiesKHR { + pub fn builder<'a>() -> SurfaceProtectedCapabilitiesKHRBuilder<'a> { + SurfaceProtectedCapabilitiesKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SurfaceProtectedCapabilitiesKHRBuilder<'a> { + inner: SurfaceProtectedCapabilitiesKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsSurfaceCapabilities2KHR for SurfaceProtectedCapabilitiesKHRBuilder<'_> {} +unsafe impl ExtendsSurfaceCapabilities2KHR for SurfaceProtectedCapabilitiesKHR {} +impl<'a> ::std::ops::Deref for SurfaceProtectedCapabilitiesKHRBuilder<'a> { + type Target = SurfaceProtectedCapabilitiesKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SurfaceProtectedCapabilitiesKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SurfaceProtectedCapabilitiesKHRBuilder<'a> { + #[inline] + pub fn supports_protected(mut self, supports_protected: bool) -> Self { + self.inner.supports_protected = supports_protected.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SurfaceProtectedCapabilitiesKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceUniformBufferStandardLayoutFeatures { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub uniform_buffer_standard_layout: Bool32, +} +impl ::std::default::Default for PhysicalDeviceUniformBufferStandardLayoutFeatures { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + uniform_buffer_standard_layout: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceUniformBufferStandardLayoutFeatures { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES; +} +impl PhysicalDeviceUniformBufferStandardLayoutFeatures { + pub fn builder<'a>() -> PhysicalDeviceUniformBufferStandardLayoutFeaturesBuilder<'a> { + PhysicalDeviceUniformBufferStandardLayoutFeaturesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceUniformBufferStandardLayoutFeaturesBuilder<'a> { + inner: PhysicalDeviceUniformBufferStandardLayoutFeatures, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceUniformBufferStandardLayoutFeaturesBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceUniformBufferStandardLayoutFeatures {} +unsafe impl ExtendsDeviceCreateInfo + for PhysicalDeviceUniformBufferStandardLayoutFeaturesBuilder<'_> +{ +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceUniformBufferStandardLayoutFeatures {} +impl<'a> ::std::ops::Deref for PhysicalDeviceUniformBufferStandardLayoutFeaturesBuilder<'a> { + type Target = PhysicalDeviceUniformBufferStandardLayoutFeatures; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceUniformBufferStandardLayoutFeaturesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceUniformBufferStandardLayoutFeaturesBuilder<'a> { + #[inline] + pub fn uniform_buffer_standard_layout(mut self, uniform_buffer_standard_layout: bool) -> Self { + self.inner.uniform_buffer_standard_layout = uniform_buffer_standard_layout.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceUniformBufferStandardLayoutFeatures { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceDepthClipEnableFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub depth_clip_enable: Bool32, +} +impl ::std::default::Default for PhysicalDeviceDepthClipEnableFeaturesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + depth_clip_enable: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceDepthClipEnableFeaturesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT; +} +impl PhysicalDeviceDepthClipEnableFeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceDepthClipEnableFeaturesEXTBuilder<'a> { + PhysicalDeviceDepthClipEnableFeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceDepthClipEnableFeaturesEXTBuilder<'a> { + inner: PhysicalDeviceDepthClipEnableFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceDepthClipEnableFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceDepthClipEnableFeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDepthClipEnableFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDepthClipEnableFeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceDepthClipEnableFeaturesEXTBuilder<'a> { + type Target = PhysicalDeviceDepthClipEnableFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceDepthClipEnableFeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceDepthClipEnableFeaturesEXTBuilder<'a> { + #[inline] + pub fn depth_clip_enable(mut self, depth_clip_enable: bool) -> Self { + self.inner.depth_clip_enable = depth_clip_enable.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceDepthClipEnableFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PipelineRasterizationDepthClipStateCreateInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: PipelineRasterizationDepthClipStateCreateFlagsEXT, + pub depth_clip_enable: Bool32, +} +impl ::std::default::Default for PipelineRasterizationDepthClipStateCreateInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: PipelineRasterizationDepthClipStateCreateFlagsEXT::default(), + depth_clip_enable: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PipelineRasterizationDepthClipStateCreateInfoEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT; +} +impl PipelineRasterizationDepthClipStateCreateInfoEXT { + pub fn builder<'a>() -> PipelineRasterizationDepthClipStateCreateInfoEXTBuilder<'a> { + PipelineRasterizationDepthClipStateCreateInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PipelineRasterizationDepthClipStateCreateInfoEXTBuilder<'a> { + inner: PipelineRasterizationDepthClipStateCreateInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPipelineRasterizationStateCreateInfo + for PipelineRasterizationDepthClipStateCreateInfoEXTBuilder<'_> +{ +} +unsafe impl ExtendsPipelineRasterizationStateCreateInfo + for PipelineRasterizationDepthClipStateCreateInfoEXT +{ +} +impl<'a> ::std::ops::Deref for PipelineRasterizationDepthClipStateCreateInfoEXTBuilder<'a> { + type Target = PipelineRasterizationDepthClipStateCreateInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PipelineRasterizationDepthClipStateCreateInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PipelineRasterizationDepthClipStateCreateInfoEXTBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: PipelineRasterizationDepthClipStateCreateFlagsEXT) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn depth_clip_enable(mut self, depth_clip_enable: bool) -> Self { + self.inner.depth_clip_enable = depth_clip_enable.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PipelineRasterizationDepthClipStateCreateInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceMemoryBudgetPropertiesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub heap_budget: [DeviceSize; MAX_MEMORY_HEAPS], + pub heap_usage: [DeviceSize; MAX_MEMORY_HEAPS], +} +impl ::std::default::Default for PhysicalDeviceMemoryBudgetPropertiesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + heap_budget: unsafe { ::std::mem::zeroed() }, + heap_usage: unsafe { ::std::mem::zeroed() }, + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceMemoryBudgetPropertiesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT; +} +impl PhysicalDeviceMemoryBudgetPropertiesEXT { + pub fn builder<'a>() -> PhysicalDeviceMemoryBudgetPropertiesEXTBuilder<'a> { + PhysicalDeviceMemoryBudgetPropertiesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceMemoryBudgetPropertiesEXTBuilder<'a> { + inner: PhysicalDeviceMemoryBudgetPropertiesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceMemoryProperties2 + for PhysicalDeviceMemoryBudgetPropertiesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceMemoryProperties2 for PhysicalDeviceMemoryBudgetPropertiesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceMemoryBudgetPropertiesEXTBuilder<'a> { + type Target = PhysicalDeviceMemoryBudgetPropertiesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceMemoryBudgetPropertiesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceMemoryBudgetPropertiesEXTBuilder<'a> { + #[inline] + pub fn heap_budget(mut self, heap_budget: [DeviceSize; MAX_MEMORY_HEAPS]) -> Self { + self.inner.heap_budget = heap_budget; + self + } + #[inline] + pub fn heap_usage(mut self, heap_usage: [DeviceSize; MAX_MEMORY_HEAPS]) -> Self { + self.inner.heap_usage = heap_usage; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceMemoryBudgetPropertiesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceMemoryPriorityFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub memory_priority: Bool32, +} +impl ::std::default::Default for PhysicalDeviceMemoryPriorityFeaturesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + memory_priority: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceMemoryPriorityFeaturesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT; +} +impl PhysicalDeviceMemoryPriorityFeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceMemoryPriorityFeaturesEXTBuilder<'a> { + PhysicalDeviceMemoryPriorityFeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceMemoryPriorityFeaturesEXTBuilder<'a> { + inner: PhysicalDeviceMemoryPriorityFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceMemoryPriorityFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceMemoryPriorityFeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMemoryPriorityFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMemoryPriorityFeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceMemoryPriorityFeaturesEXTBuilder<'a> { + type Target = PhysicalDeviceMemoryPriorityFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceMemoryPriorityFeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceMemoryPriorityFeaturesEXTBuilder<'a> { + #[inline] + pub fn memory_priority(mut self, memory_priority: bool) -> Self { + self.inner.memory_priority = memory_priority.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceMemoryPriorityFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct MemoryPriorityAllocateInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub priority: f32, +} +impl ::std::default::Default for MemoryPriorityAllocateInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + priority: f32::default(), + } + } +} +unsafe impl TaggedStructure for MemoryPriorityAllocateInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::MEMORY_PRIORITY_ALLOCATE_INFO_EXT; +} +impl MemoryPriorityAllocateInfoEXT { + pub fn builder<'a>() -> MemoryPriorityAllocateInfoEXTBuilder<'a> { + MemoryPriorityAllocateInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct MemoryPriorityAllocateInfoEXTBuilder<'a> { + inner: MemoryPriorityAllocateInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsMemoryAllocateInfo for MemoryPriorityAllocateInfoEXTBuilder<'_> {} +unsafe impl ExtendsMemoryAllocateInfo for MemoryPriorityAllocateInfoEXT {} +impl<'a> ::std::ops::Deref for MemoryPriorityAllocateInfoEXTBuilder<'a> { + type Target = MemoryPriorityAllocateInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for MemoryPriorityAllocateInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> MemoryPriorityAllocateInfoEXTBuilder<'a> { + #[inline] + pub fn priority(mut self, priority: f32) -> Self { + self.inner.priority = priority; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> MemoryPriorityAllocateInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub pageable_device_local_memory: Bool32, +} +impl ::std::default::Default for PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + pageable_device_local_memory: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT; +} +impl PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT { + pub fn builder<'a>() -> PhysicalDevicePageableDeviceLocalMemoryFeaturesEXTBuilder<'a> { + PhysicalDevicePageableDeviceLocalMemoryFeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDevicePageableDeviceLocalMemoryFeaturesEXTBuilder<'a> { + inner: PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDevicePageableDeviceLocalMemoryFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo + for PhysicalDevicePageableDeviceLocalMemoryFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDevicePageableDeviceLocalMemoryFeaturesEXTBuilder<'a> { + type Target = PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDevicePageableDeviceLocalMemoryFeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDevicePageableDeviceLocalMemoryFeaturesEXTBuilder<'a> { + #[inline] + pub fn pageable_device_local_memory(mut self, pageable_device_local_memory: bool) -> Self { + self.inner.pageable_device_local_memory = pageable_device_local_memory.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceBufferDeviceAddressFeatures { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub buffer_device_address: Bool32, + pub buffer_device_address_capture_replay: Bool32, + pub buffer_device_address_multi_device: Bool32, +} +impl ::std::default::Default for PhysicalDeviceBufferDeviceAddressFeatures { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + buffer_device_address: Bool32::default(), + buffer_device_address_capture_replay: Bool32::default(), + buffer_device_address_multi_device: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceBufferDeviceAddressFeatures { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES; +} +impl PhysicalDeviceBufferDeviceAddressFeatures { + pub fn builder<'a>() -> PhysicalDeviceBufferDeviceAddressFeaturesBuilder<'a> { + PhysicalDeviceBufferDeviceAddressFeaturesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceBufferDeviceAddressFeaturesBuilder<'a> { + inner: PhysicalDeviceBufferDeviceAddressFeatures, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceBufferDeviceAddressFeaturesBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceBufferDeviceAddressFeatures {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceBufferDeviceAddressFeaturesBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceBufferDeviceAddressFeatures {} +impl<'a> ::std::ops::Deref for PhysicalDeviceBufferDeviceAddressFeaturesBuilder<'a> { + type Target = PhysicalDeviceBufferDeviceAddressFeatures; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceBufferDeviceAddressFeaturesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceBufferDeviceAddressFeaturesBuilder<'a> { + #[inline] + pub fn buffer_device_address(mut self, buffer_device_address: bool) -> Self { + self.inner.buffer_device_address = buffer_device_address.into(); + self + } + #[inline] + pub fn buffer_device_address_capture_replay( + mut self, + buffer_device_address_capture_replay: bool, + ) -> Self { + self.inner.buffer_device_address_capture_replay = + buffer_device_address_capture_replay.into(); + self + } + #[inline] + pub fn buffer_device_address_multi_device( + mut self, + buffer_device_address_multi_device: bool, + ) -> Self { + self.inner.buffer_device_address_multi_device = buffer_device_address_multi_device.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceBufferDeviceAddressFeatures { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceBufferDeviceAddressFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub buffer_device_address: Bool32, + pub buffer_device_address_capture_replay: Bool32, + pub buffer_device_address_multi_device: Bool32, +} +impl ::std::default::Default for PhysicalDeviceBufferDeviceAddressFeaturesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + buffer_device_address: Bool32::default(), + buffer_device_address_capture_replay: Bool32::default(), + buffer_device_address_multi_device: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceBufferDeviceAddressFeaturesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT; +} +impl PhysicalDeviceBufferDeviceAddressFeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceBufferDeviceAddressFeaturesEXTBuilder<'a> { + PhysicalDeviceBufferDeviceAddressFeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceBufferDeviceAddressFeaturesEXTBuilder<'a> { + inner: PhysicalDeviceBufferDeviceAddressFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceBufferDeviceAddressFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceBufferDeviceAddressFeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceBufferDeviceAddressFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceBufferDeviceAddressFeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceBufferDeviceAddressFeaturesEXTBuilder<'a> { + type Target = PhysicalDeviceBufferDeviceAddressFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceBufferDeviceAddressFeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceBufferDeviceAddressFeaturesEXTBuilder<'a> { + #[inline] + pub fn buffer_device_address(mut self, buffer_device_address: bool) -> Self { + self.inner.buffer_device_address = buffer_device_address.into(); + self + } + #[inline] + pub fn buffer_device_address_capture_replay( + mut self, + buffer_device_address_capture_replay: bool, + ) -> Self { + self.inner.buffer_device_address_capture_replay = + buffer_device_address_capture_replay.into(); + self + } + #[inline] + pub fn buffer_device_address_multi_device( + mut self, + buffer_device_address_multi_device: bool, + ) -> Self { + self.inner.buffer_device_address_multi_device = buffer_device_address_multi_device.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceBufferDeviceAddressFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct BufferDeviceAddressInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub buffer: Buffer, +} +impl ::std::default::Default for BufferDeviceAddressInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + buffer: Buffer::default(), + } + } +} +unsafe impl TaggedStructure for BufferDeviceAddressInfo { + const STRUCTURE_TYPE: StructureType = StructureType::BUFFER_DEVICE_ADDRESS_INFO; +} +impl BufferDeviceAddressInfo { + pub fn builder<'a>() -> BufferDeviceAddressInfoBuilder<'a> { + BufferDeviceAddressInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct BufferDeviceAddressInfoBuilder<'a> { + inner: BufferDeviceAddressInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for BufferDeviceAddressInfoBuilder<'a> { + type Target = BufferDeviceAddressInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for BufferDeviceAddressInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> BufferDeviceAddressInfoBuilder<'a> { + #[inline] + pub fn buffer(mut self, buffer: Buffer) -> Self { + self.inner.buffer = buffer; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> BufferDeviceAddressInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct BufferOpaqueCaptureAddressCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub opaque_capture_address: u64, +} +impl ::std::default::Default for BufferOpaqueCaptureAddressCreateInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + opaque_capture_address: u64::default(), + } + } +} +unsafe impl TaggedStructure for BufferOpaqueCaptureAddressCreateInfo { + const STRUCTURE_TYPE: StructureType = StructureType::BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO; +} +impl BufferOpaqueCaptureAddressCreateInfo { + pub fn builder<'a>() -> BufferOpaqueCaptureAddressCreateInfoBuilder<'a> { + BufferOpaqueCaptureAddressCreateInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct BufferOpaqueCaptureAddressCreateInfoBuilder<'a> { + inner: BufferOpaqueCaptureAddressCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsBufferCreateInfo for BufferOpaqueCaptureAddressCreateInfoBuilder<'_> {} +unsafe impl ExtendsBufferCreateInfo for BufferOpaqueCaptureAddressCreateInfo {} +impl<'a> ::std::ops::Deref for BufferOpaqueCaptureAddressCreateInfoBuilder<'a> { + type Target = BufferOpaqueCaptureAddressCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for BufferOpaqueCaptureAddressCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> BufferOpaqueCaptureAddressCreateInfoBuilder<'a> { + #[inline] + pub fn opaque_capture_address(mut self, opaque_capture_address: u64) -> Self { + self.inner.opaque_capture_address = opaque_capture_address; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> BufferOpaqueCaptureAddressCreateInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct BufferDeviceAddressCreateInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub device_address: DeviceAddress, +} +impl ::std::default::Default for BufferDeviceAddressCreateInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + device_address: DeviceAddress::default(), + } + } +} +unsafe impl TaggedStructure for BufferDeviceAddressCreateInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT; +} +impl BufferDeviceAddressCreateInfoEXT { + pub fn builder<'a>() -> BufferDeviceAddressCreateInfoEXTBuilder<'a> { + BufferDeviceAddressCreateInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct BufferDeviceAddressCreateInfoEXTBuilder<'a> { + inner: BufferDeviceAddressCreateInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsBufferCreateInfo for BufferDeviceAddressCreateInfoEXTBuilder<'_> {} +unsafe impl ExtendsBufferCreateInfo for BufferDeviceAddressCreateInfoEXT {} +impl<'a> ::std::ops::Deref for BufferDeviceAddressCreateInfoEXTBuilder<'a> { + type Target = BufferDeviceAddressCreateInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for BufferDeviceAddressCreateInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> BufferDeviceAddressCreateInfoEXTBuilder<'a> { + #[inline] + pub fn device_address(mut self, device_address: DeviceAddress) -> Self { + self.inner.device_address = device_address; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> BufferDeviceAddressCreateInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceImageViewImageFormatInfoEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub image_view_type: ImageViewType, +} +impl ::std::default::Default for PhysicalDeviceImageViewImageFormatInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + image_view_type: ImageViewType::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceImageViewImageFormatInfoEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT; +} +impl PhysicalDeviceImageViewImageFormatInfoEXT { + pub fn builder<'a>() -> PhysicalDeviceImageViewImageFormatInfoEXTBuilder<'a> { + PhysicalDeviceImageViewImageFormatInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceImageViewImageFormatInfoEXTBuilder<'a> { + inner: PhysicalDeviceImageViewImageFormatInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceImageFormatInfo2 + for PhysicalDeviceImageViewImageFormatInfoEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceImageFormatInfo2 for PhysicalDeviceImageViewImageFormatInfoEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceImageViewImageFormatInfoEXTBuilder<'a> { + type Target = PhysicalDeviceImageViewImageFormatInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceImageViewImageFormatInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceImageViewImageFormatInfoEXTBuilder<'a> { + #[inline] + pub fn image_view_type(mut self, image_view_type: ImageViewType) -> Self { + self.inner.image_view_type = image_view_type; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceImageViewImageFormatInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct FilterCubicImageViewImageFormatPropertiesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub filter_cubic: Bool32, + pub filter_cubic_minmax: Bool32, +} +impl ::std::default::Default for FilterCubicImageViewImageFormatPropertiesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + filter_cubic: Bool32::default(), + filter_cubic_minmax: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for FilterCubicImageViewImageFormatPropertiesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT; +} +impl FilterCubicImageViewImageFormatPropertiesEXT { + pub fn builder<'a>() -> FilterCubicImageViewImageFormatPropertiesEXTBuilder<'a> { + FilterCubicImageViewImageFormatPropertiesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct FilterCubicImageViewImageFormatPropertiesEXTBuilder<'a> { + inner: FilterCubicImageViewImageFormatPropertiesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsImageFormatProperties2 + for FilterCubicImageViewImageFormatPropertiesEXTBuilder<'_> +{ +} +unsafe impl ExtendsImageFormatProperties2 for FilterCubicImageViewImageFormatPropertiesEXT {} +impl<'a> ::std::ops::Deref for FilterCubicImageViewImageFormatPropertiesEXTBuilder<'a> { + type Target = FilterCubicImageViewImageFormatPropertiesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for FilterCubicImageViewImageFormatPropertiesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> FilterCubicImageViewImageFormatPropertiesEXTBuilder<'a> { + #[inline] + pub fn filter_cubic(mut self, filter_cubic: bool) -> Self { + self.inner.filter_cubic = filter_cubic.into(); + self + } + #[inline] + pub fn filter_cubic_minmax(mut self, filter_cubic_minmax: bool) -> Self { + self.inner.filter_cubic_minmax = filter_cubic_minmax.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> FilterCubicImageViewImageFormatPropertiesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceImagelessFramebufferFeatures { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub imageless_framebuffer: Bool32, +} +impl ::std::default::Default for PhysicalDeviceImagelessFramebufferFeatures { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + imageless_framebuffer: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceImagelessFramebufferFeatures { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES; +} +impl PhysicalDeviceImagelessFramebufferFeatures { + pub fn builder<'a>() -> PhysicalDeviceImagelessFramebufferFeaturesBuilder<'a> { + PhysicalDeviceImagelessFramebufferFeaturesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceImagelessFramebufferFeaturesBuilder<'a> { + inner: PhysicalDeviceImagelessFramebufferFeatures, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceImagelessFramebufferFeaturesBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceImagelessFramebufferFeatures {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceImagelessFramebufferFeaturesBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceImagelessFramebufferFeatures {} +impl<'a> ::std::ops::Deref for PhysicalDeviceImagelessFramebufferFeaturesBuilder<'a> { + type Target = PhysicalDeviceImagelessFramebufferFeatures; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceImagelessFramebufferFeaturesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceImagelessFramebufferFeaturesBuilder<'a> { + #[inline] + pub fn imageless_framebuffer(mut self, imageless_framebuffer: bool) -> Self { + self.inner.imageless_framebuffer = imageless_framebuffer.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceImagelessFramebufferFeatures { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct FramebufferAttachmentsCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub attachment_image_info_count: u32, + pub p_attachment_image_infos: *const FramebufferAttachmentImageInfo, +} +impl ::std::default::Default for FramebufferAttachmentsCreateInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + attachment_image_info_count: u32::default(), + p_attachment_image_infos: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for FramebufferAttachmentsCreateInfo { + const STRUCTURE_TYPE: StructureType = StructureType::FRAMEBUFFER_ATTACHMENTS_CREATE_INFO; +} +impl FramebufferAttachmentsCreateInfo { + pub fn builder<'a>() -> FramebufferAttachmentsCreateInfoBuilder<'a> { + FramebufferAttachmentsCreateInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct FramebufferAttachmentsCreateInfoBuilder<'a> { + inner: FramebufferAttachmentsCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsFramebufferCreateInfo for FramebufferAttachmentsCreateInfoBuilder<'_> {} +unsafe impl ExtendsFramebufferCreateInfo for FramebufferAttachmentsCreateInfo {} +impl<'a> ::std::ops::Deref for FramebufferAttachmentsCreateInfoBuilder<'a> { + type Target = FramebufferAttachmentsCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for FramebufferAttachmentsCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> FramebufferAttachmentsCreateInfoBuilder<'a> { + #[inline] + pub fn attachment_image_infos( + mut self, + attachment_image_infos: &'a [FramebufferAttachmentImageInfo], + ) -> Self { + self.inner.attachment_image_info_count = attachment_image_infos.len() as _; + self.inner.p_attachment_image_infos = attachment_image_infos.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> FramebufferAttachmentsCreateInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct FramebufferAttachmentImageInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: ImageCreateFlags, + pub usage: ImageUsageFlags, + pub width: u32, + pub height: u32, + pub layer_count: u32, + pub view_format_count: u32, + pub p_view_formats: *const Format, +} +impl ::std::default::Default for FramebufferAttachmentImageInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: ImageCreateFlags::default(), + usage: ImageUsageFlags::default(), + width: u32::default(), + height: u32::default(), + layer_count: u32::default(), + view_format_count: u32::default(), + p_view_formats: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for FramebufferAttachmentImageInfo { + const STRUCTURE_TYPE: StructureType = StructureType::FRAMEBUFFER_ATTACHMENT_IMAGE_INFO; +} +impl FramebufferAttachmentImageInfo { + pub fn builder<'a>() -> FramebufferAttachmentImageInfoBuilder<'a> { + FramebufferAttachmentImageInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct FramebufferAttachmentImageInfoBuilder<'a> { + inner: FramebufferAttachmentImageInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for FramebufferAttachmentImageInfoBuilder<'a> { + type Target = FramebufferAttachmentImageInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for FramebufferAttachmentImageInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> FramebufferAttachmentImageInfoBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: ImageCreateFlags) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn usage(mut self, usage: ImageUsageFlags) -> Self { + self.inner.usage = usage; + self + } + #[inline] + pub fn width(mut self, width: u32) -> Self { + self.inner.width = width; + self + } + #[inline] + pub fn height(mut self, height: u32) -> Self { + self.inner.height = height; + self + } + #[inline] + pub fn layer_count(mut self, layer_count: u32) -> Self { + self.inner.layer_count = layer_count; + self + } + #[inline] + pub fn view_formats(mut self, view_formats: &'a [Format]) -> Self { + self.inner.view_format_count = view_formats.len() as _; + self.inner.p_view_formats = view_formats.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> FramebufferAttachmentImageInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct RenderPassAttachmentBeginInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub attachment_count: u32, + pub p_attachments: *const ImageView, +} +impl ::std::default::Default for RenderPassAttachmentBeginInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + attachment_count: u32::default(), + p_attachments: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for RenderPassAttachmentBeginInfo { + const STRUCTURE_TYPE: StructureType = StructureType::RENDER_PASS_ATTACHMENT_BEGIN_INFO; +} +impl RenderPassAttachmentBeginInfo { + pub fn builder<'a>() -> RenderPassAttachmentBeginInfoBuilder<'a> { + RenderPassAttachmentBeginInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct RenderPassAttachmentBeginInfoBuilder<'a> { + inner: RenderPassAttachmentBeginInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsRenderPassBeginInfo for RenderPassAttachmentBeginInfoBuilder<'_> {} +unsafe impl ExtendsRenderPassBeginInfo for RenderPassAttachmentBeginInfo {} +impl<'a> ::std::ops::Deref for RenderPassAttachmentBeginInfoBuilder<'a> { + type Target = RenderPassAttachmentBeginInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for RenderPassAttachmentBeginInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> RenderPassAttachmentBeginInfoBuilder<'a> { + #[inline] + pub fn attachments(mut self, attachments: &'a [ImageView]) -> Self { + self.inner.attachment_count = attachments.len() as _; + self.inner.p_attachments = attachments.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> RenderPassAttachmentBeginInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceTextureCompressionASTCHDRFeatures { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub texture_compression_astc_hdr: Bool32, +} +impl ::std::default::Default for PhysicalDeviceTextureCompressionASTCHDRFeatures { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + texture_compression_astc_hdr: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceTextureCompressionASTCHDRFeatures { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES; +} +impl PhysicalDeviceTextureCompressionASTCHDRFeatures { + pub fn builder<'a>() -> PhysicalDeviceTextureCompressionASTCHDRFeaturesBuilder<'a> { + PhysicalDeviceTextureCompressionASTCHDRFeaturesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceTextureCompressionASTCHDRFeaturesBuilder<'a> { + inner: PhysicalDeviceTextureCompressionASTCHDRFeatures, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceTextureCompressionASTCHDRFeaturesBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceTextureCompressionASTCHDRFeatures {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceTextureCompressionASTCHDRFeaturesBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceTextureCompressionASTCHDRFeatures {} +impl<'a> ::std::ops::Deref for PhysicalDeviceTextureCompressionASTCHDRFeaturesBuilder<'a> { + type Target = PhysicalDeviceTextureCompressionASTCHDRFeatures; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceTextureCompressionASTCHDRFeaturesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceTextureCompressionASTCHDRFeaturesBuilder<'a> { + #[inline] + pub fn texture_compression_astc_hdr(mut self, texture_compression_astc_hdr: bool) -> Self { + self.inner.texture_compression_astc_hdr = texture_compression_astc_hdr.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceTextureCompressionASTCHDRFeatures { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceCooperativeMatrixFeaturesNV { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub cooperative_matrix: Bool32, + pub cooperative_matrix_robust_buffer_access: Bool32, +} +impl ::std::default::Default for PhysicalDeviceCooperativeMatrixFeaturesNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + cooperative_matrix: Bool32::default(), + cooperative_matrix_robust_buffer_access: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceCooperativeMatrixFeaturesNV { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV; +} +impl PhysicalDeviceCooperativeMatrixFeaturesNV { + pub fn builder<'a>() -> PhysicalDeviceCooperativeMatrixFeaturesNVBuilder<'a> { + PhysicalDeviceCooperativeMatrixFeaturesNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceCooperativeMatrixFeaturesNVBuilder<'a> { + inner: PhysicalDeviceCooperativeMatrixFeaturesNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceCooperativeMatrixFeaturesNVBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceCooperativeMatrixFeaturesNV {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceCooperativeMatrixFeaturesNVBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceCooperativeMatrixFeaturesNV {} +impl<'a> ::std::ops::Deref for PhysicalDeviceCooperativeMatrixFeaturesNVBuilder<'a> { + type Target = PhysicalDeviceCooperativeMatrixFeaturesNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceCooperativeMatrixFeaturesNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceCooperativeMatrixFeaturesNVBuilder<'a> { + #[inline] + pub fn cooperative_matrix(mut self, cooperative_matrix: bool) -> Self { + self.inner.cooperative_matrix = cooperative_matrix.into(); + self + } + #[inline] + pub fn cooperative_matrix_robust_buffer_access( + mut self, + cooperative_matrix_robust_buffer_access: bool, + ) -> Self { + self.inner.cooperative_matrix_robust_buffer_access = + cooperative_matrix_robust_buffer_access.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceCooperativeMatrixFeaturesNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceCooperativeMatrixPropertiesNV { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub cooperative_matrix_supported_stages: ShaderStageFlags, +} +impl ::std::default::Default for PhysicalDeviceCooperativeMatrixPropertiesNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + cooperative_matrix_supported_stages: ShaderStageFlags::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceCooperativeMatrixPropertiesNV { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV; +} +impl PhysicalDeviceCooperativeMatrixPropertiesNV { + pub fn builder<'a>() -> PhysicalDeviceCooperativeMatrixPropertiesNVBuilder<'a> { + PhysicalDeviceCooperativeMatrixPropertiesNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceCooperativeMatrixPropertiesNVBuilder<'a> { + inner: PhysicalDeviceCooperativeMatrixPropertiesNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceCooperativeMatrixPropertiesNVBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceCooperativeMatrixPropertiesNV {} +impl<'a> ::std::ops::Deref for PhysicalDeviceCooperativeMatrixPropertiesNVBuilder<'a> { + type Target = PhysicalDeviceCooperativeMatrixPropertiesNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceCooperativeMatrixPropertiesNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceCooperativeMatrixPropertiesNVBuilder<'a> { + #[inline] + pub fn cooperative_matrix_supported_stages( + mut self, + cooperative_matrix_supported_stages: ShaderStageFlags, + ) -> Self { + self.inner.cooperative_matrix_supported_stages = cooperative_matrix_supported_stages; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceCooperativeMatrixPropertiesNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct CooperativeMatrixPropertiesNV { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub m_size: u32, + pub n_size: u32, + pub k_size: u32, + pub a_type: ComponentTypeNV, + pub b_type: ComponentTypeNV, + pub c_type: ComponentTypeNV, + pub d_type: ComponentTypeNV, + pub scope: ScopeNV, +} +impl ::std::default::Default for CooperativeMatrixPropertiesNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + m_size: u32::default(), + n_size: u32::default(), + k_size: u32::default(), + a_type: ComponentTypeNV::default(), + b_type: ComponentTypeNV::default(), + c_type: ComponentTypeNV::default(), + d_type: ComponentTypeNV::default(), + scope: ScopeNV::default(), + } + } +} +unsafe impl TaggedStructure for CooperativeMatrixPropertiesNV { + const STRUCTURE_TYPE: StructureType = StructureType::COOPERATIVE_MATRIX_PROPERTIES_NV; +} +impl CooperativeMatrixPropertiesNV { + pub fn builder<'a>() -> CooperativeMatrixPropertiesNVBuilder<'a> { + CooperativeMatrixPropertiesNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct CooperativeMatrixPropertiesNVBuilder<'a> { + inner: CooperativeMatrixPropertiesNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for CooperativeMatrixPropertiesNVBuilder<'a> { + type Target = CooperativeMatrixPropertiesNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for CooperativeMatrixPropertiesNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> CooperativeMatrixPropertiesNVBuilder<'a> { + #[inline] + pub fn m_size(mut self, m_size: u32) -> Self { + self.inner.m_size = m_size; + self + } + #[inline] + pub fn n_size(mut self, n_size: u32) -> Self { + self.inner.n_size = n_size; + self + } + #[inline] + pub fn k_size(mut self, k_size: u32) -> Self { + self.inner.k_size = k_size; + self + } + #[inline] + pub fn a_type(mut self, a_type: ComponentTypeNV) -> Self { + self.inner.a_type = a_type; + self + } + #[inline] + pub fn b_type(mut self, b_type: ComponentTypeNV) -> Self { + self.inner.b_type = b_type; + self + } + #[inline] + pub fn c_type(mut self, c_type: ComponentTypeNV) -> Self { + self.inner.c_type = c_type; + self + } + #[inline] + pub fn d_type(mut self, d_type: ComponentTypeNV) -> Self { + self.inner.d_type = d_type; + self + } + #[inline] + pub fn scope(mut self, scope: ScopeNV) -> Self { + self.inner.scope = scope; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> CooperativeMatrixPropertiesNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceYcbcrImageArraysFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub ycbcr_image_arrays: Bool32, +} +impl ::std::default::Default for PhysicalDeviceYcbcrImageArraysFeaturesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + ycbcr_image_arrays: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceYcbcrImageArraysFeaturesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT; +} +impl PhysicalDeviceYcbcrImageArraysFeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceYcbcrImageArraysFeaturesEXTBuilder<'a> { + PhysicalDeviceYcbcrImageArraysFeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceYcbcrImageArraysFeaturesEXTBuilder<'a> { + inner: PhysicalDeviceYcbcrImageArraysFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceYcbcrImageArraysFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceYcbcrImageArraysFeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceYcbcrImageArraysFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceYcbcrImageArraysFeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceYcbcrImageArraysFeaturesEXTBuilder<'a> { + type Target = PhysicalDeviceYcbcrImageArraysFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceYcbcrImageArraysFeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceYcbcrImageArraysFeaturesEXTBuilder<'a> { + #[inline] + pub fn ycbcr_image_arrays(mut self, ycbcr_image_arrays: bool) -> Self { + self.inner.ycbcr_image_arrays = ycbcr_image_arrays.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceYcbcrImageArraysFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ImageViewHandleInfoNVX { + pub s_type: StructureType, + pub p_next: *const c_void, + pub image_view: ImageView, + pub descriptor_type: DescriptorType, + pub sampler: Sampler, +} +impl ::std::default::Default for ImageViewHandleInfoNVX { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + image_view: ImageView::default(), + descriptor_type: DescriptorType::default(), + sampler: Sampler::default(), + } + } +} +unsafe impl TaggedStructure for ImageViewHandleInfoNVX { + const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_VIEW_HANDLE_INFO_NVX; +} +impl ImageViewHandleInfoNVX { + pub fn builder<'a>() -> ImageViewHandleInfoNVXBuilder<'a> { + ImageViewHandleInfoNVXBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ImageViewHandleInfoNVXBuilder<'a> { + inner: ImageViewHandleInfoNVX, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ImageViewHandleInfoNVXBuilder<'a> { + type Target = ImageViewHandleInfoNVX; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ImageViewHandleInfoNVXBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ImageViewHandleInfoNVXBuilder<'a> { + #[inline] + pub fn image_view(mut self, image_view: ImageView) -> Self { + self.inner.image_view = image_view; + self + } + #[inline] + pub fn descriptor_type(mut self, descriptor_type: DescriptorType) -> Self { + self.inner.descriptor_type = descriptor_type; + self + } + #[inline] + pub fn sampler(mut self, sampler: Sampler) -> Self { + self.inner.sampler = sampler; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ImageViewHandleInfoNVX { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ImageViewAddressPropertiesNVX { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub device_address: DeviceAddress, + pub size: DeviceSize, +} +impl ::std::default::Default for ImageViewAddressPropertiesNVX { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + device_address: DeviceAddress::default(), + size: DeviceSize::default(), + } + } +} +unsafe impl TaggedStructure for ImageViewAddressPropertiesNVX { + const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_VIEW_ADDRESS_PROPERTIES_NVX; +} +impl ImageViewAddressPropertiesNVX { + pub fn builder<'a>() -> ImageViewAddressPropertiesNVXBuilder<'a> { + ImageViewAddressPropertiesNVXBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ImageViewAddressPropertiesNVXBuilder<'a> { + inner: ImageViewAddressPropertiesNVX, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ImageViewAddressPropertiesNVXBuilder<'a> { + type Target = ImageViewAddressPropertiesNVX; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ImageViewAddressPropertiesNVXBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ImageViewAddressPropertiesNVXBuilder<'a> { + #[inline] + pub fn device_address(mut self, device_address: DeviceAddress) -> Self { + self.inner.device_address = device_address; + self + } + #[inline] + pub fn size(mut self, size: DeviceSize) -> Self { + self.inner.size = size; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ImageViewAddressPropertiesNVX { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PresentFrameTokenGGP { + pub s_type: StructureType, + pub p_next: *const c_void, + pub frame_token: GgpFrameToken, +} +impl ::std::default::Default for PresentFrameTokenGGP { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + frame_token: GgpFrameToken::default(), + } + } +} +unsafe impl TaggedStructure for PresentFrameTokenGGP { + const STRUCTURE_TYPE: StructureType = StructureType::PRESENT_FRAME_TOKEN_GGP; +} +impl PresentFrameTokenGGP { + pub fn builder<'a>() -> PresentFrameTokenGGPBuilder<'a> { + PresentFrameTokenGGPBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PresentFrameTokenGGPBuilder<'a> { + inner: PresentFrameTokenGGP, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPresentInfoKHR for PresentFrameTokenGGPBuilder<'_> {} +unsafe impl ExtendsPresentInfoKHR for PresentFrameTokenGGP {} +impl<'a> ::std::ops::Deref for PresentFrameTokenGGPBuilder<'a> { + type Target = PresentFrameTokenGGP; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PresentFrameTokenGGPBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PresentFrameTokenGGPBuilder<'a> { + #[inline] + pub fn frame_token(mut self, frame_token: GgpFrameToken) -> Self { + self.inner.frame_token = frame_token; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PresentFrameTokenGGP { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct PipelineCreationFeedback { + pub flags: PipelineCreationFeedbackFlags, + pub duration: u64, +} +impl PipelineCreationFeedback { + pub fn builder<'a>() -> PipelineCreationFeedbackBuilder<'a> { + PipelineCreationFeedbackBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PipelineCreationFeedbackBuilder<'a> { + inner: PipelineCreationFeedback, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PipelineCreationFeedbackBuilder<'a> { + type Target = PipelineCreationFeedback; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PipelineCreationFeedbackBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PipelineCreationFeedbackBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: PipelineCreationFeedbackFlags) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn duration(mut self, duration: u64) -> Self { + self.inner.duration = duration; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PipelineCreationFeedback { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PipelineCreationFeedbackCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub p_pipeline_creation_feedback: *mut PipelineCreationFeedback, + pub pipeline_stage_creation_feedback_count: u32, + pub p_pipeline_stage_creation_feedbacks: *mut PipelineCreationFeedback, +} +impl ::std::default::Default for PipelineCreationFeedbackCreateInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + p_pipeline_creation_feedback: ::std::ptr::null_mut(), + pipeline_stage_creation_feedback_count: u32::default(), + p_pipeline_stage_creation_feedbacks: ::std::ptr::null_mut(), + } + } +} +unsafe impl TaggedStructure for PipelineCreationFeedbackCreateInfo { + const STRUCTURE_TYPE: StructureType = StructureType::PIPELINE_CREATION_FEEDBACK_CREATE_INFO; +} +impl PipelineCreationFeedbackCreateInfo { + pub fn builder<'a>() -> PipelineCreationFeedbackCreateInfoBuilder<'a> { + PipelineCreationFeedbackCreateInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PipelineCreationFeedbackCreateInfoBuilder<'a> { + inner: PipelineCreationFeedbackCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsGraphicsPipelineCreateInfo for PipelineCreationFeedbackCreateInfoBuilder<'_> {} +unsafe impl ExtendsGraphicsPipelineCreateInfo for PipelineCreationFeedbackCreateInfo {} +unsafe impl ExtendsComputePipelineCreateInfo for PipelineCreationFeedbackCreateInfoBuilder<'_> {} +unsafe impl ExtendsComputePipelineCreateInfo for PipelineCreationFeedbackCreateInfo {} +unsafe impl ExtendsRayTracingPipelineCreateInfoNV + for PipelineCreationFeedbackCreateInfoBuilder<'_> +{ +} +unsafe impl ExtendsRayTracingPipelineCreateInfoNV for PipelineCreationFeedbackCreateInfo {} +unsafe impl ExtendsRayTracingPipelineCreateInfoKHR + for PipelineCreationFeedbackCreateInfoBuilder<'_> +{ +} +unsafe impl ExtendsRayTracingPipelineCreateInfoKHR for PipelineCreationFeedbackCreateInfo {} +impl<'a> ::std::ops::Deref for PipelineCreationFeedbackCreateInfoBuilder<'a> { + type Target = PipelineCreationFeedbackCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PipelineCreationFeedbackCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PipelineCreationFeedbackCreateInfoBuilder<'a> { + #[inline] + pub fn pipeline_creation_feedback( + mut self, + pipeline_creation_feedback: &'a mut PipelineCreationFeedback, + ) -> Self { + self.inner.p_pipeline_creation_feedback = pipeline_creation_feedback; + self + } + #[inline] + pub fn pipeline_stage_creation_feedbacks( + mut self, + pipeline_stage_creation_feedbacks: &'a mut [PipelineCreationFeedback], + ) -> Self { + self.inner.pipeline_stage_creation_feedback_count = + pipeline_stage_creation_feedbacks.len() as _; + self.inner.p_pipeline_stage_creation_feedbacks = + pipeline_stage_creation_feedbacks.as_mut_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PipelineCreationFeedbackCreateInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SurfaceFullScreenExclusiveInfoEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub full_screen_exclusive: FullScreenExclusiveEXT, +} +impl ::std::default::Default for SurfaceFullScreenExclusiveInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + full_screen_exclusive: FullScreenExclusiveEXT::default(), + } + } +} +unsafe impl TaggedStructure for SurfaceFullScreenExclusiveInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT; +} +impl SurfaceFullScreenExclusiveInfoEXT { + pub fn builder<'a>() -> SurfaceFullScreenExclusiveInfoEXTBuilder<'a> { + SurfaceFullScreenExclusiveInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SurfaceFullScreenExclusiveInfoEXTBuilder<'a> { + inner: SurfaceFullScreenExclusiveInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceSurfaceInfo2KHR for SurfaceFullScreenExclusiveInfoEXTBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceSurfaceInfo2KHR for SurfaceFullScreenExclusiveInfoEXT {} +unsafe impl ExtendsSwapchainCreateInfoKHR for SurfaceFullScreenExclusiveInfoEXTBuilder<'_> {} +unsafe impl ExtendsSwapchainCreateInfoKHR for SurfaceFullScreenExclusiveInfoEXT {} +impl<'a> ::std::ops::Deref for SurfaceFullScreenExclusiveInfoEXTBuilder<'a> { + type Target = SurfaceFullScreenExclusiveInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SurfaceFullScreenExclusiveInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SurfaceFullScreenExclusiveInfoEXTBuilder<'a> { + #[inline] + pub fn full_screen_exclusive(mut self, full_screen_exclusive: FullScreenExclusiveEXT) -> Self { + self.inner.full_screen_exclusive = full_screen_exclusive; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SurfaceFullScreenExclusiveInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SurfaceFullScreenExclusiveWin32InfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub hmonitor: HMONITOR, +} +impl ::std::default::Default for SurfaceFullScreenExclusiveWin32InfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + hmonitor: unsafe { ::std::mem::zeroed() }, + } + } +} +unsafe impl TaggedStructure for SurfaceFullScreenExclusiveWin32InfoEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT; +} +impl SurfaceFullScreenExclusiveWin32InfoEXT { + pub fn builder<'a>() -> SurfaceFullScreenExclusiveWin32InfoEXTBuilder<'a> { + SurfaceFullScreenExclusiveWin32InfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SurfaceFullScreenExclusiveWin32InfoEXTBuilder<'a> { + inner: SurfaceFullScreenExclusiveWin32InfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceSurfaceInfo2KHR + for SurfaceFullScreenExclusiveWin32InfoEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceSurfaceInfo2KHR for SurfaceFullScreenExclusiveWin32InfoEXT {} +unsafe impl ExtendsSwapchainCreateInfoKHR for SurfaceFullScreenExclusiveWin32InfoEXTBuilder<'_> {} +unsafe impl ExtendsSwapchainCreateInfoKHR for SurfaceFullScreenExclusiveWin32InfoEXT {} +impl<'a> ::std::ops::Deref for SurfaceFullScreenExclusiveWin32InfoEXTBuilder<'a> { + type Target = SurfaceFullScreenExclusiveWin32InfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SurfaceFullScreenExclusiveWin32InfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SurfaceFullScreenExclusiveWin32InfoEXTBuilder<'a> { + #[inline] + pub fn hmonitor(mut self, hmonitor: HMONITOR) -> Self { + self.inner.hmonitor = hmonitor; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SurfaceFullScreenExclusiveWin32InfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SurfaceCapabilitiesFullScreenExclusiveEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub full_screen_exclusive_supported: Bool32, +} +impl ::std::default::Default for SurfaceCapabilitiesFullScreenExclusiveEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + full_screen_exclusive_supported: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for SurfaceCapabilitiesFullScreenExclusiveEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT; +} +impl SurfaceCapabilitiesFullScreenExclusiveEXT { + pub fn builder<'a>() -> SurfaceCapabilitiesFullScreenExclusiveEXTBuilder<'a> { + SurfaceCapabilitiesFullScreenExclusiveEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SurfaceCapabilitiesFullScreenExclusiveEXTBuilder<'a> { + inner: SurfaceCapabilitiesFullScreenExclusiveEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsSurfaceCapabilities2KHR + for SurfaceCapabilitiesFullScreenExclusiveEXTBuilder<'_> +{ +} +unsafe impl ExtendsSurfaceCapabilities2KHR for SurfaceCapabilitiesFullScreenExclusiveEXT {} +impl<'a> ::std::ops::Deref for SurfaceCapabilitiesFullScreenExclusiveEXTBuilder<'a> { + type Target = SurfaceCapabilitiesFullScreenExclusiveEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SurfaceCapabilitiesFullScreenExclusiveEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SurfaceCapabilitiesFullScreenExclusiveEXTBuilder<'a> { + #[inline] + pub fn full_screen_exclusive_supported( + mut self, + full_screen_exclusive_supported: bool, + ) -> Self { + self.inner.full_screen_exclusive_supported = full_screen_exclusive_supported.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SurfaceCapabilitiesFullScreenExclusiveEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDevicePresentBarrierFeaturesNV { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub present_barrier: Bool32, +} +impl ::std::default::Default for PhysicalDevicePresentBarrierFeaturesNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + present_barrier: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDevicePresentBarrierFeaturesNV { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV; +} +impl PhysicalDevicePresentBarrierFeaturesNV { + pub fn builder<'a>() -> PhysicalDevicePresentBarrierFeaturesNVBuilder<'a> { + PhysicalDevicePresentBarrierFeaturesNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDevicePresentBarrierFeaturesNVBuilder<'a> { + inner: PhysicalDevicePresentBarrierFeaturesNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePresentBarrierFeaturesNVBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePresentBarrierFeaturesNV {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePresentBarrierFeaturesNVBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePresentBarrierFeaturesNV {} +impl<'a> ::std::ops::Deref for PhysicalDevicePresentBarrierFeaturesNVBuilder<'a> { + type Target = PhysicalDevicePresentBarrierFeaturesNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDevicePresentBarrierFeaturesNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDevicePresentBarrierFeaturesNVBuilder<'a> { + #[inline] + pub fn present_barrier(mut self, present_barrier: bool) -> Self { + self.inner.present_barrier = present_barrier.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDevicePresentBarrierFeaturesNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SurfaceCapabilitiesPresentBarrierNV { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub present_barrier_supported: Bool32, +} +impl ::std::default::Default for SurfaceCapabilitiesPresentBarrierNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + present_barrier_supported: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for SurfaceCapabilitiesPresentBarrierNV { + const STRUCTURE_TYPE: StructureType = StructureType::SURFACE_CAPABILITIES_PRESENT_BARRIER_NV; +} +impl SurfaceCapabilitiesPresentBarrierNV { + pub fn builder<'a>() -> SurfaceCapabilitiesPresentBarrierNVBuilder<'a> { + SurfaceCapabilitiesPresentBarrierNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SurfaceCapabilitiesPresentBarrierNVBuilder<'a> { + inner: SurfaceCapabilitiesPresentBarrierNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsSurfaceCapabilities2KHR for SurfaceCapabilitiesPresentBarrierNVBuilder<'_> {} +unsafe impl ExtendsSurfaceCapabilities2KHR for SurfaceCapabilitiesPresentBarrierNV {} +impl<'a> ::std::ops::Deref for SurfaceCapabilitiesPresentBarrierNVBuilder<'a> { + type Target = SurfaceCapabilitiesPresentBarrierNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SurfaceCapabilitiesPresentBarrierNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SurfaceCapabilitiesPresentBarrierNVBuilder<'a> { + #[inline] + pub fn present_barrier_supported(mut self, present_barrier_supported: bool) -> Self { + self.inner.present_barrier_supported = present_barrier_supported.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SurfaceCapabilitiesPresentBarrierNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SwapchainPresentBarrierCreateInfoNV { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub present_barrier_enable: Bool32, +} +impl ::std::default::Default for SwapchainPresentBarrierCreateInfoNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + present_barrier_enable: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for SwapchainPresentBarrierCreateInfoNV { + const STRUCTURE_TYPE: StructureType = StructureType::SWAPCHAIN_PRESENT_BARRIER_CREATE_INFO_NV; +} +impl SwapchainPresentBarrierCreateInfoNV { + pub fn builder<'a>() -> SwapchainPresentBarrierCreateInfoNVBuilder<'a> { + SwapchainPresentBarrierCreateInfoNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SwapchainPresentBarrierCreateInfoNVBuilder<'a> { + inner: SwapchainPresentBarrierCreateInfoNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsSwapchainCreateInfoKHR for SwapchainPresentBarrierCreateInfoNVBuilder<'_> {} +unsafe impl ExtendsSwapchainCreateInfoKHR for SwapchainPresentBarrierCreateInfoNV {} +impl<'a> ::std::ops::Deref for SwapchainPresentBarrierCreateInfoNVBuilder<'a> { + type Target = SwapchainPresentBarrierCreateInfoNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SwapchainPresentBarrierCreateInfoNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SwapchainPresentBarrierCreateInfoNVBuilder<'a> { + #[inline] + pub fn present_barrier_enable(mut self, present_barrier_enable: bool) -> Self { + self.inner.present_barrier_enable = present_barrier_enable.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SwapchainPresentBarrierCreateInfoNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDevicePerformanceQueryFeaturesKHR { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub performance_counter_query_pools: Bool32, + pub performance_counter_multiple_query_pools: Bool32, +} +impl ::std::default::Default for PhysicalDevicePerformanceQueryFeaturesKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + performance_counter_query_pools: Bool32::default(), + performance_counter_multiple_query_pools: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDevicePerformanceQueryFeaturesKHR { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR; +} +impl PhysicalDevicePerformanceQueryFeaturesKHR { + pub fn builder<'a>() -> PhysicalDevicePerformanceQueryFeaturesKHRBuilder<'a> { + PhysicalDevicePerformanceQueryFeaturesKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDevicePerformanceQueryFeaturesKHRBuilder<'a> { + inner: PhysicalDevicePerformanceQueryFeaturesKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDevicePerformanceQueryFeaturesKHRBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePerformanceQueryFeaturesKHR {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePerformanceQueryFeaturesKHRBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePerformanceQueryFeaturesKHR {} +impl<'a> ::std::ops::Deref for PhysicalDevicePerformanceQueryFeaturesKHRBuilder<'a> { + type Target = PhysicalDevicePerformanceQueryFeaturesKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDevicePerformanceQueryFeaturesKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDevicePerformanceQueryFeaturesKHRBuilder<'a> { + #[inline] + pub fn performance_counter_query_pools( + mut self, + performance_counter_query_pools: bool, + ) -> Self { + self.inner.performance_counter_query_pools = performance_counter_query_pools.into(); + self + } + #[inline] + pub fn performance_counter_multiple_query_pools( + mut self, + performance_counter_multiple_query_pools: bool, + ) -> Self { + self.inner.performance_counter_multiple_query_pools = + performance_counter_multiple_query_pools.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDevicePerformanceQueryFeaturesKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDevicePerformanceQueryPropertiesKHR { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub allow_command_buffer_query_copies: Bool32, +} +impl ::std::default::Default for PhysicalDevicePerformanceQueryPropertiesKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + allow_command_buffer_query_copies: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDevicePerformanceQueryPropertiesKHR { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR; +} +impl PhysicalDevicePerformanceQueryPropertiesKHR { + pub fn builder<'a>() -> PhysicalDevicePerformanceQueryPropertiesKHRBuilder<'a> { + PhysicalDevicePerformanceQueryPropertiesKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDevicePerformanceQueryPropertiesKHRBuilder<'a> { + inner: PhysicalDevicePerformanceQueryPropertiesKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDevicePerformanceQueryPropertiesKHRBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDevicePerformanceQueryPropertiesKHR {} +impl<'a> ::std::ops::Deref for PhysicalDevicePerformanceQueryPropertiesKHRBuilder<'a> { + type Target = PhysicalDevicePerformanceQueryPropertiesKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDevicePerformanceQueryPropertiesKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDevicePerformanceQueryPropertiesKHRBuilder<'a> { + #[inline] + pub fn allow_command_buffer_query_copies( + mut self, + allow_command_buffer_query_copies: bool, + ) -> Self { + self.inner.allow_command_buffer_query_copies = allow_command_buffer_query_copies.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDevicePerformanceQueryPropertiesKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PerformanceCounterKHR { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub unit: PerformanceCounterUnitKHR, + pub scope: PerformanceCounterScopeKHR, + pub storage: PerformanceCounterStorageKHR, + pub uuid: [u8; UUID_SIZE], +} +impl ::std::default::Default for PerformanceCounterKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + unit: PerformanceCounterUnitKHR::default(), + scope: PerformanceCounterScopeKHR::default(), + storage: PerformanceCounterStorageKHR::default(), + uuid: unsafe { ::std::mem::zeroed() }, + } + } +} +unsafe impl TaggedStructure for PerformanceCounterKHR { + const STRUCTURE_TYPE: StructureType = StructureType::PERFORMANCE_COUNTER_KHR; +} +impl PerformanceCounterKHR { + pub fn builder<'a>() -> PerformanceCounterKHRBuilder<'a> { + PerformanceCounterKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PerformanceCounterKHRBuilder<'a> { + inner: PerformanceCounterKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PerformanceCounterKHRBuilder<'a> { + type Target = PerformanceCounterKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PerformanceCounterKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PerformanceCounterKHRBuilder<'a> { + #[inline] + pub fn unit(mut self, unit: PerformanceCounterUnitKHR) -> Self { + self.inner.unit = unit; + self + } + #[inline] + pub fn scope(mut self, scope: PerformanceCounterScopeKHR) -> Self { + self.inner.scope = scope; + self + } + #[inline] + pub fn storage(mut self, storage: PerformanceCounterStorageKHR) -> Self { + self.inner.storage = storage; + self + } + #[inline] + pub fn uuid(mut self, uuid: [u8; UUID_SIZE]) -> Self { + self.inner.uuid = uuid; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PerformanceCounterKHR { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PerformanceCounterDescriptionKHR { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub flags: PerformanceCounterDescriptionFlagsKHR, + pub name: [c_char; MAX_DESCRIPTION_SIZE], + pub category: [c_char; MAX_DESCRIPTION_SIZE], + pub description: [c_char; MAX_DESCRIPTION_SIZE], +} +#[cfg(feature = "debug")] +impl fmt::Debug for PerformanceCounterDescriptionKHR { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fmt.debug_struct("PerformanceCounterDescriptionKHR") + .field("s_type", &self.s_type) + .field("p_next", &self.p_next) + .field("flags", &self.flags) + .field("name", &unsafe { + ::std::ffi::CStr::from_ptr(self.name.as_ptr()) + }) + .field("category", &unsafe { + ::std::ffi::CStr::from_ptr(self.category.as_ptr()) + }) + .field("description", &unsafe { + ::std::ffi::CStr::from_ptr(self.description.as_ptr()) + }) + .finish() + } +} +impl ::std::default::Default for PerformanceCounterDescriptionKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + flags: PerformanceCounterDescriptionFlagsKHR::default(), + name: unsafe { ::std::mem::zeroed() }, + category: unsafe { ::std::mem::zeroed() }, + description: unsafe { ::std::mem::zeroed() }, + } + } +} +unsafe impl TaggedStructure for PerformanceCounterDescriptionKHR { + const STRUCTURE_TYPE: StructureType = StructureType::PERFORMANCE_COUNTER_DESCRIPTION_KHR; +} +impl PerformanceCounterDescriptionKHR { + pub fn builder<'a>() -> PerformanceCounterDescriptionKHRBuilder<'a> { + PerformanceCounterDescriptionKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PerformanceCounterDescriptionKHRBuilder<'a> { + inner: PerformanceCounterDescriptionKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PerformanceCounterDescriptionKHRBuilder<'a> { + type Target = PerformanceCounterDescriptionKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PerformanceCounterDescriptionKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PerformanceCounterDescriptionKHRBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: PerformanceCounterDescriptionFlagsKHR) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn name(mut self, name: [c_char; MAX_DESCRIPTION_SIZE]) -> Self { + self.inner.name = name; + self + } + #[inline] + pub fn category(mut self, category: [c_char; MAX_DESCRIPTION_SIZE]) -> Self { + self.inner.category = category; + self + } + #[inline] + pub fn description(mut self, description: [c_char; MAX_DESCRIPTION_SIZE]) -> Self { + self.inner.description = description; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PerformanceCounterDescriptionKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct QueryPoolPerformanceCreateInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub queue_family_index: u32, + pub counter_index_count: u32, + pub p_counter_indices: *const u32, +} +impl ::std::default::Default for QueryPoolPerformanceCreateInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + queue_family_index: u32::default(), + counter_index_count: u32::default(), + p_counter_indices: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for QueryPoolPerformanceCreateInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR; +} +impl QueryPoolPerformanceCreateInfoKHR { + pub fn builder<'a>() -> QueryPoolPerformanceCreateInfoKHRBuilder<'a> { + QueryPoolPerformanceCreateInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct QueryPoolPerformanceCreateInfoKHRBuilder<'a> { + inner: QueryPoolPerformanceCreateInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsQueryPoolCreateInfo for QueryPoolPerformanceCreateInfoKHRBuilder<'_> {} +unsafe impl ExtendsQueryPoolCreateInfo for QueryPoolPerformanceCreateInfoKHR {} +impl<'a> ::std::ops::Deref for QueryPoolPerformanceCreateInfoKHRBuilder<'a> { + type Target = QueryPoolPerformanceCreateInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for QueryPoolPerformanceCreateInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> QueryPoolPerformanceCreateInfoKHRBuilder<'a> { + #[inline] + pub fn queue_family_index(mut self, queue_family_index: u32) -> Self { + self.inner.queue_family_index = queue_family_index; + self + } + #[inline] + pub fn counter_indices(mut self, counter_indices: &'a [u32]) -> Self { + self.inner.counter_index_count = counter_indices.len() as _; + self.inner.p_counter_indices = counter_indices.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> QueryPoolPerformanceCreateInfoKHR { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[doc = ""] +pub union PerformanceCounterResultKHR { + pub int32: i32, + pub int64: i64, + pub uint32: u32, + pub uint64: u64, + pub float32: f32, + pub float64: f64, +} +impl ::std::default::Default for PerformanceCounterResultKHR { + #[inline] + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct AcquireProfilingLockInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: AcquireProfilingLockFlagsKHR, + pub timeout: u64, +} +impl ::std::default::Default for AcquireProfilingLockInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: AcquireProfilingLockFlagsKHR::default(), + timeout: u64::default(), + } + } +} +unsafe impl TaggedStructure for AcquireProfilingLockInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::ACQUIRE_PROFILING_LOCK_INFO_KHR; +} +impl AcquireProfilingLockInfoKHR { + pub fn builder<'a>() -> AcquireProfilingLockInfoKHRBuilder<'a> { + AcquireProfilingLockInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct AcquireProfilingLockInfoKHRBuilder<'a> { + inner: AcquireProfilingLockInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for AcquireProfilingLockInfoKHRBuilder<'a> { + type Target = AcquireProfilingLockInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for AcquireProfilingLockInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> AcquireProfilingLockInfoKHRBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: AcquireProfilingLockFlagsKHR) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn timeout(mut self, timeout: u64) -> Self { + self.inner.timeout = timeout; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> AcquireProfilingLockInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PerformanceQuerySubmitInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub counter_pass_index: u32, +} +impl ::std::default::Default for PerformanceQuerySubmitInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + counter_pass_index: u32::default(), + } + } +} +unsafe impl TaggedStructure for PerformanceQuerySubmitInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::PERFORMANCE_QUERY_SUBMIT_INFO_KHR; +} +impl PerformanceQuerySubmitInfoKHR { + pub fn builder<'a>() -> PerformanceQuerySubmitInfoKHRBuilder<'a> { + PerformanceQuerySubmitInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PerformanceQuerySubmitInfoKHRBuilder<'a> { + inner: PerformanceQuerySubmitInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsSubmitInfo for PerformanceQuerySubmitInfoKHRBuilder<'_> {} +unsafe impl ExtendsSubmitInfo for PerformanceQuerySubmitInfoKHR {} +unsafe impl ExtendsSubmitInfo2 for PerformanceQuerySubmitInfoKHRBuilder<'_> {} +unsafe impl ExtendsSubmitInfo2 for PerformanceQuerySubmitInfoKHR {} +impl<'a> ::std::ops::Deref for PerformanceQuerySubmitInfoKHRBuilder<'a> { + type Target = PerformanceQuerySubmitInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PerformanceQuerySubmitInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PerformanceQuerySubmitInfoKHRBuilder<'a> { + #[inline] + pub fn counter_pass_index(mut self, counter_pass_index: u32) -> Self { + self.inner.counter_pass_index = counter_pass_index; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PerformanceQuerySubmitInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct HeadlessSurfaceCreateInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: HeadlessSurfaceCreateFlagsEXT, +} +impl ::std::default::Default for HeadlessSurfaceCreateInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: HeadlessSurfaceCreateFlagsEXT::default(), + } + } +} +unsafe impl TaggedStructure for HeadlessSurfaceCreateInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::HEADLESS_SURFACE_CREATE_INFO_EXT; +} +impl HeadlessSurfaceCreateInfoEXT { + pub fn builder<'a>() -> HeadlessSurfaceCreateInfoEXTBuilder<'a> { + HeadlessSurfaceCreateInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct HeadlessSurfaceCreateInfoEXTBuilder<'a> { + inner: HeadlessSurfaceCreateInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for HeadlessSurfaceCreateInfoEXTBuilder<'a> { + type Target = HeadlessSurfaceCreateInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for HeadlessSurfaceCreateInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> HeadlessSurfaceCreateInfoEXTBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: HeadlessSurfaceCreateFlagsEXT) -> Self { + self.inner.flags = flags; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> HeadlessSurfaceCreateInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceCoverageReductionModeFeaturesNV { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub coverage_reduction_mode: Bool32, +} +impl ::std::default::Default for PhysicalDeviceCoverageReductionModeFeaturesNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + coverage_reduction_mode: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceCoverageReductionModeFeaturesNV { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV; +} +impl PhysicalDeviceCoverageReductionModeFeaturesNV { + pub fn builder<'a>() -> PhysicalDeviceCoverageReductionModeFeaturesNVBuilder<'a> { + PhysicalDeviceCoverageReductionModeFeaturesNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceCoverageReductionModeFeaturesNVBuilder<'a> { + inner: PhysicalDeviceCoverageReductionModeFeaturesNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceCoverageReductionModeFeaturesNVBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceCoverageReductionModeFeaturesNV {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceCoverageReductionModeFeaturesNVBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceCoverageReductionModeFeaturesNV {} +impl<'a> ::std::ops::Deref for PhysicalDeviceCoverageReductionModeFeaturesNVBuilder<'a> { + type Target = PhysicalDeviceCoverageReductionModeFeaturesNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceCoverageReductionModeFeaturesNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceCoverageReductionModeFeaturesNVBuilder<'a> { + #[inline] + pub fn coverage_reduction_mode(mut self, coverage_reduction_mode: bool) -> Self { + self.inner.coverage_reduction_mode = coverage_reduction_mode.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceCoverageReductionModeFeaturesNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PipelineCoverageReductionStateCreateInfoNV { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: PipelineCoverageReductionStateCreateFlagsNV, + pub coverage_reduction_mode: CoverageReductionModeNV, +} +impl ::std::default::Default for PipelineCoverageReductionStateCreateInfoNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: PipelineCoverageReductionStateCreateFlagsNV::default(), + coverage_reduction_mode: CoverageReductionModeNV::default(), + } + } +} +unsafe impl TaggedStructure for PipelineCoverageReductionStateCreateInfoNV { + const STRUCTURE_TYPE: StructureType = + StructureType::PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV; +} +impl PipelineCoverageReductionStateCreateInfoNV { + pub fn builder<'a>() -> PipelineCoverageReductionStateCreateInfoNVBuilder<'a> { + PipelineCoverageReductionStateCreateInfoNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PipelineCoverageReductionStateCreateInfoNVBuilder<'a> { + inner: PipelineCoverageReductionStateCreateInfoNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPipelineMultisampleStateCreateInfo + for PipelineCoverageReductionStateCreateInfoNVBuilder<'_> +{ +} +unsafe impl ExtendsPipelineMultisampleStateCreateInfo + for PipelineCoverageReductionStateCreateInfoNV +{ +} +impl<'a> ::std::ops::Deref for PipelineCoverageReductionStateCreateInfoNVBuilder<'a> { + type Target = PipelineCoverageReductionStateCreateInfoNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PipelineCoverageReductionStateCreateInfoNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PipelineCoverageReductionStateCreateInfoNVBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: PipelineCoverageReductionStateCreateFlagsNV) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn coverage_reduction_mode( + mut self, + coverage_reduction_mode: CoverageReductionModeNV, + ) -> Self { + self.inner.coverage_reduction_mode = coverage_reduction_mode; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PipelineCoverageReductionStateCreateInfoNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct FramebufferMixedSamplesCombinationNV { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub coverage_reduction_mode: CoverageReductionModeNV, + pub rasterization_samples: SampleCountFlags, + pub depth_stencil_samples: SampleCountFlags, + pub color_samples: SampleCountFlags, +} +impl ::std::default::Default for FramebufferMixedSamplesCombinationNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + coverage_reduction_mode: CoverageReductionModeNV::default(), + rasterization_samples: SampleCountFlags::default(), + depth_stencil_samples: SampleCountFlags::default(), + color_samples: SampleCountFlags::default(), + } + } +} +unsafe impl TaggedStructure for FramebufferMixedSamplesCombinationNV { + const STRUCTURE_TYPE: StructureType = StructureType::FRAMEBUFFER_MIXED_SAMPLES_COMBINATION_NV; +} +impl FramebufferMixedSamplesCombinationNV { + pub fn builder<'a>() -> FramebufferMixedSamplesCombinationNVBuilder<'a> { + FramebufferMixedSamplesCombinationNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct FramebufferMixedSamplesCombinationNVBuilder<'a> { + inner: FramebufferMixedSamplesCombinationNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for FramebufferMixedSamplesCombinationNVBuilder<'a> { + type Target = FramebufferMixedSamplesCombinationNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for FramebufferMixedSamplesCombinationNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> FramebufferMixedSamplesCombinationNVBuilder<'a> { + #[inline] + pub fn coverage_reduction_mode( + mut self, + coverage_reduction_mode: CoverageReductionModeNV, + ) -> Self { + self.inner.coverage_reduction_mode = coverage_reduction_mode; + self + } + #[inline] + pub fn rasterization_samples(mut self, rasterization_samples: SampleCountFlags) -> Self { + self.inner.rasterization_samples = rasterization_samples; + self + } + #[inline] + pub fn depth_stencil_samples(mut self, depth_stencil_samples: SampleCountFlags) -> Self { + self.inner.depth_stencil_samples = depth_stencil_samples; + self + } + #[inline] + pub fn color_samples(mut self, color_samples: SampleCountFlags) -> Self { + self.inner.color_samples = color_samples; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> FramebufferMixedSamplesCombinationNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub shader_integer_functions2: Bool32, +} +impl ::std::default::Default for PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + shader_integer_functions2: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL; +} +impl PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL { + pub fn builder<'a>() -> PhysicalDeviceShaderIntegerFunctions2FeaturesINTELBuilder<'a> { + PhysicalDeviceShaderIntegerFunctions2FeaturesINTELBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceShaderIntegerFunctions2FeaturesINTELBuilder<'a> { + inner: PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceShaderIntegerFunctions2FeaturesINTELBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL {} +unsafe impl ExtendsDeviceCreateInfo + for PhysicalDeviceShaderIntegerFunctions2FeaturesINTELBuilder<'_> +{ +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL {} +impl<'a> ::std::ops::Deref for PhysicalDeviceShaderIntegerFunctions2FeaturesINTELBuilder<'a> { + type Target = PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderIntegerFunctions2FeaturesINTELBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceShaderIntegerFunctions2FeaturesINTELBuilder<'a> { + #[inline] + pub fn shader_integer_functions2(mut self, shader_integer_functions2: bool) -> Self { + self.inner.shader_integer_functions2 = shader_integer_functions2.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[doc = ""] +pub union PerformanceValueDataINTEL { + pub value32: u32, + pub value64: u64, + pub value_float: f32, + pub value_bool: Bool32, + pub value_string: *const c_char, +} +impl ::std::default::Default for PerformanceValueDataINTEL { + #[inline] + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } +} +#[repr(C)] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct PerformanceValueINTEL { + pub ty: PerformanceValueTypeINTEL, + pub data: PerformanceValueDataINTEL, +} +#[cfg(feature = "debug")] +impl fmt::Debug for PerformanceValueINTEL { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fmt.debug_struct("PerformanceValueINTEL") + .field("ty", &self.ty) + .field("data", &"union") + .finish() + } +} +impl PerformanceValueINTEL { + pub fn builder<'a>() -> PerformanceValueINTELBuilder<'a> { + PerformanceValueINTELBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PerformanceValueINTELBuilder<'a> { + inner: PerformanceValueINTEL, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PerformanceValueINTELBuilder<'a> { + type Target = PerformanceValueINTEL; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PerformanceValueINTELBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PerformanceValueINTELBuilder<'a> { + #[inline] + pub fn ty(mut self, ty: PerformanceValueTypeINTEL) -> Self { + self.inner.ty = ty; + self + } + #[inline] + pub fn data(mut self, data: PerformanceValueDataINTEL) -> Self { + self.inner.data = data; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PerformanceValueINTEL { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct InitializePerformanceApiInfoINTEL { + pub s_type: StructureType, + pub p_next: *const c_void, + pub p_user_data: *mut c_void, +} +impl ::std::default::Default for InitializePerformanceApiInfoINTEL { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + p_user_data: ::std::ptr::null_mut(), + } + } +} +unsafe impl TaggedStructure for InitializePerformanceApiInfoINTEL { + const STRUCTURE_TYPE: StructureType = StructureType::INITIALIZE_PERFORMANCE_API_INFO_INTEL; +} +impl InitializePerformanceApiInfoINTEL { + pub fn builder<'a>() -> InitializePerformanceApiInfoINTELBuilder<'a> { + InitializePerformanceApiInfoINTELBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct InitializePerformanceApiInfoINTELBuilder<'a> { + inner: InitializePerformanceApiInfoINTEL, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for InitializePerformanceApiInfoINTELBuilder<'a> { + type Target = InitializePerformanceApiInfoINTEL; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for InitializePerformanceApiInfoINTELBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> InitializePerformanceApiInfoINTELBuilder<'a> { + #[inline] + pub fn user_data(mut self, user_data: *mut c_void) -> Self { + self.inner.p_user_data = user_data; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> InitializePerformanceApiInfoINTEL { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct QueryPoolPerformanceQueryCreateInfoINTEL { + pub s_type: StructureType, + pub p_next: *const c_void, + pub performance_counters_sampling: QueryPoolSamplingModeINTEL, +} +impl ::std::default::Default for QueryPoolPerformanceQueryCreateInfoINTEL { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + performance_counters_sampling: QueryPoolSamplingModeINTEL::default(), + } + } +} +unsafe impl TaggedStructure for QueryPoolPerformanceQueryCreateInfoINTEL { + const STRUCTURE_TYPE: StructureType = + StructureType::QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL; +} +impl QueryPoolPerformanceQueryCreateInfoINTEL { + pub fn builder<'a>() -> QueryPoolPerformanceQueryCreateInfoINTELBuilder<'a> { + QueryPoolPerformanceQueryCreateInfoINTELBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct QueryPoolPerformanceQueryCreateInfoINTELBuilder<'a> { + inner: QueryPoolPerformanceQueryCreateInfoINTEL, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsQueryPoolCreateInfo for QueryPoolPerformanceQueryCreateInfoINTELBuilder<'_> {} +unsafe impl ExtendsQueryPoolCreateInfo for QueryPoolPerformanceQueryCreateInfoINTEL {} +impl<'a> ::std::ops::Deref for QueryPoolPerformanceQueryCreateInfoINTELBuilder<'a> { + type Target = QueryPoolPerformanceQueryCreateInfoINTEL; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for QueryPoolPerformanceQueryCreateInfoINTELBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> QueryPoolPerformanceQueryCreateInfoINTELBuilder<'a> { + #[inline] + pub fn performance_counters_sampling( + mut self, + performance_counters_sampling: QueryPoolSamplingModeINTEL, + ) -> Self { + self.inner.performance_counters_sampling = performance_counters_sampling; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> QueryPoolPerformanceQueryCreateInfoINTEL { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PerformanceMarkerInfoINTEL { + pub s_type: StructureType, + pub p_next: *const c_void, + pub marker: u64, +} +impl ::std::default::Default for PerformanceMarkerInfoINTEL { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + marker: u64::default(), + } + } +} +unsafe impl TaggedStructure for PerformanceMarkerInfoINTEL { + const STRUCTURE_TYPE: StructureType = StructureType::PERFORMANCE_MARKER_INFO_INTEL; +} +impl PerformanceMarkerInfoINTEL { + pub fn builder<'a>() -> PerformanceMarkerInfoINTELBuilder<'a> { + PerformanceMarkerInfoINTELBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PerformanceMarkerInfoINTELBuilder<'a> { + inner: PerformanceMarkerInfoINTEL, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PerformanceMarkerInfoINTELBuilder<'a> { + type Target = PerformanceMarkerInfoINTEL; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PerformanceMarkerInfoINTELBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PerformanceMarkerInfoINTELBuilder<'a> { + #[inline] + pub fn marker(mut self, marker: u64) -> Self { + self.inner.marker = marker; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PerformanceMarkerInfoINTEL { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PerformanceStreamMarkerInfoINTEL { + pub s_type: StructureType, + pub p_next: *const c_void, + pub marker: u32, +} +impl ::std::default::Default for PerformanceStreamMarkerInfoINTEL { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + marker: u32::default(), + } + } +} +unsafe impl TaggedStructure for PerformanceStreamMarkerInfoINTEL { + const STRUCTURE_TYPE: StructureType = StructureType::PERFORMANCE_STREAM_MARKER_INFO_INTEL; +} +impl PerformanceStreamMarkerInfoINTEL { + pub fn builder<'a>() -> PerformanceStreamMarkerInfoINTELBuilder<'a> { + PerformanceStreamMarkerInfoINTELBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PerformanceStreamMarkerInfoINTELBuilder<'a> { + inner: PerformanceStreamMarkerInfoINTEL, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PerformanceStreamMarkerInfoINTELBuilder<'a> { + type Target = PerformanceStreamMarkerInfoINTEL; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PerformanceStreamMarkerInfoINTELBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PerformanceStreamMarkerInfoINTELBuilder<'a> { + #[inline] + pub fn marker(mut self, marker: u32) -> Self { + self.inner.marker = marker; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PerformanceStreamMarkerInfoINTEL { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PerformanceOverrideInfoINTEL { + pub s_type: StructureType, + pub p_next: *const c_void, + pub ty: PerformanceOverrideTypeINTEL, + pub enable: Bool32, + pub parameter: u64, +} +impl ::std::default::Default for PerformanceOverrideInfoINTEL { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + ty: PerformanceOverrideTypeINTEL::default(), + enable: Bool32::default(), + parameter: u64::default(), + } + } +} +unsafe impl TaggedStructure for PerformanceOverrideInfoINTEL { + const STRUCTURE_TYPE: StructureType = StructureType::PERFORMANCE_OVERRIDE_INFO_INTEL; +} +impl PerformanceOverrideInfoINTEL { + pub fn builder<'a>() -> PerformanceOverrideInfoINTELBuilder<'a> { + PerformanceOverrideInfoINTELBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PerformanceOverrideInfoINTELBuilder<'a> { + inner: PerformanceOverrideInfoINTEL, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PerformanceOverrideInfoINTELBuilder<'a> { + type Target = PerformanceOverrideInfoINTEL; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PerformanceOverrideInfoINTELBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PerformanceOverrideInfoINTELBuilder<'a> { + #[inline] + pub fn ty(mut self, ty: PerformanceOverrideTypeINTEL) -> Self { + self.inner.ty = ty; + self + } + #[inline] + pub fn enable(mut self, enable: bool) -> Self { + self.inner.enable = enable.into(); + self + } + #[inline] + pub fn parameter(mut self, parameter: u64) -> Self { + self.inner.parameter = parameter; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PerformanceOverrideInfoINTEL { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PerformanceConfigurationAcquireInfoINTEL { + pub s_type: StructureType, + pub p_next: *const c_void, + pub ty: PerformanceConfigurationTypeINTEL, +} +impl ::std::default::Default for PerformanceConfigurationAcquireInfoINTEL { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + ty: PerformanceConfigurationTypeINTEL::default(), + } + } +} +unsafe impl TaggedStructure for PerformanceConfigurationAcquireInfoINTEL { + const STRUCTURE_TYPE: StructureType = + StructureType::PERFORMANCE_CONFIGURATION_ACQUIRE_INFO_INTEL; +} +impl PerformanceConfigurationAcquireInfoINTEL { + pub fn builder<'a>() -> PerformanceConfigurationAcquireInfoINTELBuilder<'a> { + PerformanceConfigurationAcquireInfoINTELBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PerformanceConfigurationAcquireInfoINTELBuilder<'a> { + inner: PerformanceConfigurationAcquireInfoINTEL, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PerformanceConfigurationAcquireInfoINTELBuilder<'a> { + type Target = PerformanceConfigurationAcquireInfoINTEL; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PerformanceConfigurationAcquireInfoINTELBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PerformanceConfigurationAcquireInfoINTELBuilder<'a> { + #[inline] + pub fn ty(mut self, ty: PerformanceConfigurationTypeINTEL) -> Self { + self.inner.ty = ty; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PerformanceConfigurationAcquireInfoINTEL { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceShaderClockFeaturesKHR { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub shader_subgroup_clock: Bool32, + pub shader_device_clock: Bool32, +} +impl ::std::default::Default for PhysicalDeviceShaderClockFeaturesKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + shader_subgroup_clock: Bool32::default(), + shader_device_clock: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceShaderClockFeaturesKHR { + const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR; +} +impl PhysicalDeviceShaderClockFeaturesKHR { + pub fn builder<'a>() -> PhysicalDeviceShaderClockFeaturesKHRBuilder<'a> { + PhysicalDeviceShaderClockFeaturesKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceShaderClockFeaturesKHRBuilder<'a> { + inner: PhysicalDeviceShaderClockFeaturesKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderClockFeaturesKHRBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderClockFeaturesKHR {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderClockFeaturesKHRBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderClockFeaturesKHR {} +impl<'a> ::std::ops::Deref for PhysicalDeviceShaderClockFeaturesKHRBuilder<'a> { + type Target = PhysicalDeviceShaderClockFeaturesKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderClockFeaturesKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceShaderClockFeaturesKHRBuilder<'a> { + #[inline] + pub fn shader_subgroup_clock(mut self, shader_subgroup_clock: bool) -> Self { + self.inner.shader_subgroup_clock = shader_subgroup_clock.into(); + self + } + #[inline] + pub fn shader_device_clock(mut self, shader_device_clock: bool) -> Self { + self.inner.shader_device_clock = shader_device_clock.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceShaderClockFeaturesKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceIndexTypeUint8FeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub index_type_uint8: Bool32, +} +impl ::std::default::Default for PhysicalDeviceIndexTypeUint8FeaturesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + index_type_uint8: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceIndexTypeUint8FeaturesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT; +} +impl PhysicalDeviceIndexTypeUint8FeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceIndexTypeUint8FeaturesEXTBuilder<'a> { + PhysicalDeviceIndexTypeUint8FeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceIndexTypeUint8FeaturesEXTBuilder<'a> { + inner: PhysicalDeviceIndexTypeUint8FeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceIndexTypeUint8FeaturesEXTBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceIndexTypeUint8FeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceIndexTypeUint8FeaturesEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceIndexTypeUint8FeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceIndexTypeUint8FeaturesEXTBuilder<'a> { + type Target = PhysicalDeviceIndexTypeUint8FeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceIndexTypeUint8FeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceIndexTypeUint8FeaturesEXTBuilder<'a> { + #[inline] + pub fn index_type_uint8(mut self, index_type_uint8: bool) -> Self { + self.inner.index_type_uint8 = index_type_uint8.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceIndexTypeUint8FeaturesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceShaderSMBuiltinsPropertiesNV { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub shader_sm_count: u32, + pub shader_warps_per_sm: u32, +} +impl ::std::default::Default for PhysicalDeviceShaderSMBuiltinsPropertiesNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + shader_sm_count: u32::default(), + shader_warps_per_sm: u32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceShaderSMBuiltinsPropertiesNV { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV; +} +impl PhysicalDeviceShaderSMBuiltinsPropertiesNV { + pub fn builder<'a>() -> PhysicalDeviceShaderSMBuiltinsPropertiesNVBuilder<'a> { + PhysicalDeviceShaderSMBuiltinsPropertiesNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceShaderSMBuiltinsPropertiesNVBuilder<'a> { + inner: PhysicalDeviceShaderSMBuiltinsPropertiesNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceShaderSMBuiltinsPropertiesNVBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceShaderSMBuiltinsPropertiesNV {} +impl<'a> ::std::ops::Deref for PhysicalDeviceShaderSMBuiltinsPropertiesNVBuilder<'a> { + type Target = PhysicalDeviceShaderSMBuiltinsPropertiesNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderSMBuiltinsPropertiesNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceShaderSMBuiltinsPropertiesNVBuilder<'a> { + #[inline] + pub fn shader_sm_count(mut self, shader_sm_count: u32) -> Self { + self.inner.shader_sm_count = shader_sm_count; + self + } + #[inline] + pub fn shader_warps_per_sm(mut self, shader_warps_per_sm: u32) -> Self { + self.inner.shader_warps_per_sm = shader_warps_per_sm; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceShaderSMBuiltinsPropertiesNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceShaderSMBuiltinsFeaturesNV { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub shader_sm_builtins: Bool32, +} +impl ::std::default::Default for PhysicalDeviceShaderSMBuiltinsFeaturesNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + shader_sm_builtins: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceShaderSMBuiltinsFeaturesNV { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV; +} +impl PhysicalDeviceShaderSMBuiltinsFeaturesNV { + pub fn builder<'a>() -> PhysicalDeviceShaderSMBuiltinsFeaturesNVBuilder<'a> { + PhysicalDeviceShaderSMBuiltinsFeaturesNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceShaderSMBuiltinsFeaturesNVBuilder<'a> { + inner: PhysicalDeviceShaderSMBuiltinsFeaturesNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderSMBuiltinsFeaturesNVBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderSMBuiltinsFeaturesNV {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderSMBuiltinsFeaturesNVBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderSMBuiltinsFeaturesNV {} +impl<'a> ::std::ops::Deref for PhysicalDeviceShaderSMBuiltinsFeaturesNVBuilder<'a> { + type Target = PhysicalDeviceShaderSMBuiltinsFeaturesNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderSMBuiltinsFeaturesNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceShaderSMBuiltinsFeaturesNVBuilder<'a> { + #[inline] + pub fn shader_sm_builtins(mut self, shader_sm_builtins: bool) -> Self { + self.inner.shader_sm_builtins = shader_sm_builtins.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceShaderSMBuiltinsFeaturesNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceFragmentShaderInterlockFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub fragment_shader_sample_interlock: Bool32, + pub fragment_shader_pixel_interlock: Bool32, + pub fragment_shader_shading_rate_interlock: Bool32, +} +impl ::std::default::Default for PhysicalDeviceFragmentShaderInterlockFeaturesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + fragment_shader_sample_interlock: Bool32::default(), + fragment_shader_pixel_interlock: Bool32::default(), + fragment_shader_shading_rate_interlock: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceFragmentShaderInterlockFeaturesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT; +} +impl PhysicalDeviceFragmentShaderInterlockFeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceFragmentShaderInterlockFeaturesEXTBuilder<'a> { + PhysicalDeviceFragmentShaderInterlockFeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceFragmentShaderInterlockFeaturesEXTBuilder<'a> { + inner: PhysicalDeviceFragmentShaderInterlockFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceFragmentShaderInterlockFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceFragmentShaderInterlockFeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo + for PhysicalDeviceFragmentShaderInterlockFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFragmentShaderInterlockFeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceFragmentShaderInterlockFeaturesEXTBuilder<'a> { + type Target = PhysicalDeviceFragmentShaderInterlockFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceFragmentShaderInterlockFeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceFragmentShaderInterlockFeaturesEXTBuilder<'a> { + #[inline] + pub fn fragment_shader_sample_interlock( + mut self, + fragment_shader_sample_interlock: bool, + ) -> Self { + self.inner.fragment_shader_sample_interlock = fragment_shader_sample_interlock.into(); + self + } + #[inline] + pub fn fragment_shader_pixel_interlock( + mut self, + fragment_shader_pixel_interlock: bool, + ) -> Self { + self.inner.fragment_shader_pixel_interlock = fragment_shader_pixel_interlock.into(); + self + } + #[inline] + pub fn fragment_shader_shading_rate_interlock( + mut self, + fragment_shader_shading_rate_interlock: bool, + ) -> Self { + self.inner.fragment_shader_shading_rate_interlock = + fragment_shader_shading_rate_interlock.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceFragmentShaderInterlockFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceSeparateDepthStencilLayoutsFeatures { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub separate_depth_stencil_layouts: Bool32, +} +impl ::std::default::Default for PhysicalDeviceSeparateDepthStencilLayoutsFeatures { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + separate_depth_stencil_layouts: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceSeparateDepthStencilLayoutsFeatures { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES; +} +impl PhysicalDeviceSeparateDepthStencilLayoutsFeatures { + pub fn builder<'a>() -> PhysicalDeviceSeparateDepthStencilLayoutsFeaturesBuilder<'a> { + PhysicalDeviceSeparateDepthStencilLayoutsFeaturesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceSeparateDepthStencilLayoutsFeaturesBuilder<'a> { + inner: PhysicalDeviceSeparateDepthStencilLayoutsFeatures, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceSeparateDepthStencilLayoutsFeaturesBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceSeparateDepthStencilLayoutsFeatures {} +unsafe impl ExtendsDeviceCreateInfo + for PhysicalDeviceSeparateDepthStencilLayoutsFeaturesBuilder<'_> +{ +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceSeparateDepthStencilLayoutsFeatures {} +impl<'a> ::std::ops::Deref for PhysicalDeviceSeparateDepthStencilLayoutsFeaturesBuilder<'a> { + type Target = PhysicalDeviceSeparateDepthStencilLayoutsFeatures; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceSeparateDepthStencilLayoutsFeaturesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceSeparateDepthStencilLayoutsFeaturesBuilder<'a> { + #[inline] + pub fn separate_depth_stencil_layouts(mut self, separate_depth_stencil_layouts: bool) -> Self { + self.inner.separate_depth_stencil_layouts = separate_depth_stencil_layouts.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceSeparateDepthStencilLayoutsFeatures { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct AttachmentReferenceStencilLayout { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub stencil_layout: ImageLayout, +} +impl ::std::default::Default for AttachmentReferenceStencilLayout { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + stencil_layout: ImageLayout::default(), + } + } +} +unsafe impl TaggedStructure for AttachmentReferenceStencilLayout { + const STRUCTURE_TYPE: StructureType = StructureType::ATTACHMENT_REFERENCE_STENCIL_LAYOUT; +} +impl AttachmentReferenceStencilLayout { + pub fn builder<'a>() -> AttachmentReferenceStencilLayoutBuilder<'a> { + AttachmentReferenceStencilLayoutBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct AttachmentReferenceStencilLayoutBuilder<'a> { + inner: AttachmentReferenceStencilLayout, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsAttachmentReference2 for AttachmentReferenceStencilLayoutBuilder<'_> {} +unsafe impl ExtendsAttachmentReference2 for AttachmentReferenceStencilLayout {} +impl<'a> ::std::ops::Deref for AttachmentReferenceStencilLayoutBuilder<'a> { + type Target = AttachmentReferenceStencilLayout; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for AttachmentReferenceStencilLayoutBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> AttachmentReferenceStencilLayoutBuilder<'a> { + #[inline] + pub fn stencil_layout(mut self, stencil_layout: ImageLayout) -> Self { + self.inner.stencil_layout = stencil_layout; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> AttachmentReferenceStencilLayout { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub primitive_topology_list_restart: Bool32, + pub primitive_topology_patch_list_restart: Bool32, +} +impl ::std::default::Default for PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + primitive_topology_list_restart: Bool32::default(), + primitive_topology_patch_list_restart: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT; +} +impl PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT { + pub fn builder<'a>() -> PhysicalDevicePrimitiveTopologyListRestartFeaturesEXTBuilder<'a> { + PhysicalDevicePrimitiveTopologyListRestartFeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDevicePrimitiveTopologyListRestartFeaturesEXTBuilder<'a> { + inner: PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDevicePrimitiveTopologyListRestartFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT +{ +} +unsafe impl ExtendsDeviceCreateInfo + for PhysicalDevicePrimitiveTopologyListRestartFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDevicePrimitiveTopologyListRestartFeaturesEXTBuilder<'a> { + type Target = PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDevicePrimitiveTopologyListRestartFeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDevicePrimitiveTopologyListRestartFeaturesEXTBuilder<'a> { + #[inline] + pub fn primitive_topology_list_restart( + mut self, + primitive_topology_list_restart: bool, + ) -> Self { + self.inner.primitive_topology_list_restart = primitive_topology_list_restart.into(); + self + } + #[inline] + pub fn primitive_topology_patch_list_restart( + mut self, + primitive_topology_patch_list_restart: bool, + ) -> Self { + self.inner.primitive_topology_patch_list_restart = + primitive_topology_patch_list_restart.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct AttachmentDescriptionStencilLayout { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub stencil_initial_layout: ImageLayout, + pub stencil_final_layout: ImageLayout, +} +impl ::std::default::Default for AttachmentDescriptionStencilLayout { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + stencil_initial_layout: ImageLayout::default(), + stencil_final_layout: ImageLayout::default(), + } + } +} +unsafe impl TaggedStructure for AttachmentDescriptionStencilLayout { + const STRUCTURE_TYPE: StructureType = StructureType::ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT; +} +impl AttachmentDescriptionStencilLayout { + pub fn builder<'a>() -> AttachmentDescriptionStencilLayoutBuilder<'a> { + AttachmentDescriptionStencilLayoutBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct AttachmentDescriptionStencilLayoutBuilder<'a> { + inner: AttachmentDescriptionStencilLayout, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsAttachmentDescription2 for AttachmentDescriptionStencilLayoutBuilder<'_> {} +unsafe impl ExtendsAttachmentDescription2 for AttachmentDescriptionStencilLayout {} +impl<'a> ::std::ops::Deref for AttachmentDescriptionStencilLayoutBuilder<'a> { + type Target = AttachmentDescriptionStencilLayout; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for AttachmentDescriptionStencilLayoutBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> AttachmentDescriptionStencilLayoutBuilder<'a> { + #[inline] + pub fn stencil_initial_layout(mut self, stencil_initial_layout: ImageLayout) -> Self { + self.inner.stencil_initial_layout = stencil_initial_layout; + self + } + #[inline] + pub fn stencil_final_layout(mut self, stencil_final_layout: ImageLayout) -> Self { + self.inner.stencil_final_layout = stencil_final_layout; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> AttachmentDescriptionStencilLayout { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDevicePipelineExecutablePropertiesFeaturesKHR { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub pipeline_executable_info: Bool32, +} +impl ::std::default::Default for PhysicalDevicePipelineExecutablePropertiesFeaturesKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + pipeline_executable_info: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDevicePipelineExecutablePropertiesFeaturesKHR { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR; +} +impl PhysicalDevicePipelineExecutablePropertiesFeaturesKHR { + pub fn builder<'a>() -> PhysicalDevicePipelineExecutablePropertiesFeaturesKHRBuilder<'a> { + PhysicalDevicePipelineExecutablePropertiesFeaturesKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDevicePipelineExecutablePropertiesFeaturesKHRBuilder<'a> { + inner: PhysicalDevicePipelineExecutablePropertiesFeaturesKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDevicePipelineExecutablePropertiesFeaturesKHRBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDevicePipelineExecutablePropertiesFeaturesKHR +{ +} +unsafe impl ExtendsDeviceCreateInfo + for PhysicalDevicePipelineExecutablePropertiesFeaturesKHRBuilder<'_> +{ +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePipelineExecutablePropertiesFeaturesKHR {} +impl<'a> ::std::ops::Deref for PhysicalDevicePipelineExecutablePropertiesFeaturesKHRBuilder<'a> { + type Target = PhysicalDevicePipelineExecutablePropertiesFeaturesKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDevicePipelineExecutablePropertiesFeaturesKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDevicePipelineExecutablePropertiesFeaturesKHRBuilder<'a> { + #[inline] + pub fn pipeline_executable_info(mut self, pipeline_executable_info: bool) -> Self { + self.inner.pipeline_executable_info = pipeline_executable_info.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDevicePipelineExecutablePropertiesFeaturesKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PipelineInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub pipeline: Pipeline, +} +impl ::std::default::Default for PipelineInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + pipeline: Pipeline::default(), + } + } +} +unsafe impl TaggedStructure for PipelineInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::PIPELINE_INFO_KHR; +} +impl PipelineInfoKHR { + pub fn builder<'a>() -> PipelineInfoKHRBuilder<'a> { + PipelineInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PipelineInfoKHRBuilder<'a> { + inner: PipelineInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PipelineInfoKHRBuilder<'a> { + type Target = PipelineInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PipelineInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PipelineInfoKHRBuilder<'a> { + #[inline] + pub fn pipeline(mut self, pipeline: Pipeline) -> Self { + self.inner.pipeline = pipeline; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PipelineInfoKHR { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PipelineExecutablePropertiesKHR { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub stages: ShaderStageFlags, + pub name: [c_char; MAX_DESCRIPTION_SIZE], + pub description: [c_char; MAX_DESCRIPTION_SIZE], + pub subgroup_size: u32, +} +#[cfg(feature = "debug")] +impl fmt::Debug for PipelineExecutablePropertiesKHR { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fmt.debug_struct("PipelineExecutablePropertiesKHR") + .field("s_type", &self.s_type) + .field("p_next", &self.p_next) + .field("stages", &self.stages) + .field("name", &unsafe { + ::std::ffi::CStr::from_ptr(self.name.as_ptr()) + }) + .field("description", &unsafe { + ::std::ffi::CStr::from_ptr(self.description.as_ptr()) + }) + .field("subgroup_size", &self.subgroup_size) + .finish() + } +} +impl ::std::default::Default for PipelineExecutablePropertiesKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + stages: ShaderStageFlags::default(), + name: unsafe { ::std::mem::zeroed() }, + description: unsafe { ::std::mem::zeroed() }, + subgroup_size: u32::default(), + } + } +} +unsafe impl TaggedStructure for PipelineExecutablePropertiesKHR { + const STRUCTURE_TYPE: StructureType = StructureType::PIPELINE_EXECUTABLE_PROPERTIES_KHR; +} +impl PipelineExecutablePropertiesKHR { + pub fn builder<'a>() -> PipelineExecutablePropertiesKHRBuilder<'a> { + PipelineExecutablePropertiesKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PipelineExecutablePropertiesKHRBuilder<'a> { + inner: PipelineExecutablePropertiesKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PipelineExecutablePropertiesKHRBuilder<'a> { + type Target = PipelineExecutablePropertiesKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PipelineExecutablePropertiesKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PipelineExecutablePropertiesKHRBuilder<'a> { + #[inline] + pub fn stages(mut self, stages: ShaderStageFlags) -> Self { + self.inner.stages = stages; + self + } + #[inline] + pub fn name(mut self, name: [c_char; MAX_DESCRIPTION_SIZE]) -> Self { + self.inner.name = name; + self + } + #[inline] + pub fn description(mut self, description: [c_char; MAX_DESCRIPTION_SIZE]) -> Self { + self.inner.description = description; + self + } + #[inline] + pub fn subgroup_size(mut self, subgroup_size: u32) -> Self { + self.inner.subgroup_size = subgroup_size; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PipelineExecutablePropertiesKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PipelineExecutableInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub pipeline: Pipeline, + pub executable_index: u32, +} +impl ::std::default::Default for PipelineExecutableInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + pipeline: Pipeline::default(), + executable_index: u32::default(), + } + } +} +unsafe impl TaggedStructure for PipelineExecutableInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::PIPELINE_EXECUTABLE_INFO_KHR; +} +impl PipelineExecutableInfoKHR { + pub fn builder<'a>() -> PipelineExecutableInfoKHRBuilder<'a> { + PipelineExecutableInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PipelineExecutableInfoKHRBuilder<'a> { + inner: PipelineExecutableInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PipelineExecutableInfoKHRBuilder<'a> { + type Target = PipelineExecutableInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PipelineExecutableInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PipelineExecutableInfoKHRBuilder<'a> { + #[inline] + pub fn pipeline(mut self, pipeline: Pipeline) -> Self { + self.inner.pipeline = pipeline; + self + } + #[inline] + pub fn executable_index(mut self, executable_index: u32) -> Self { + self.inner.executable_index = executable_index; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PipelineExecutableInfoKHR { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[doc = ""] +pub union PipelineExecutableStatisticValueKHR { + pub b32: Bool32, + pub i64: i64, + pub u64: u64, + pub f64: f64, +} +impl ::std::default::Default for PipelineExecutableStatisticValueKHR { + #[inline] + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PipelineExecutableStatisticKHR { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub name: [c_char; MAX_DESCRIPTION_SIZE], + pub description: [c_char; MAX_DESCRIPTION_SIZE], + pub format: PipelineExecutableStatisticFormatKHR, + pub value: PipelineExecutableStatisticValueKHR, +} +#[cfg(feature = "debug")] +impl fmt::Debug for PipelineExecutableStatisticKHR { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fmt.debug_struct("PipelineExecutableStatisticKHR") + .field("s_type", &self.s_type) + .field("p_next", &self.p_next) + .field("name", &unsafe { + ::std::ffi::CStr::from_ptr(self.name.as_ptr()) + }) + .field("description", &unsafe { + ::std::ffi::CStr::from_ptr(self.description.as_ptr()) + }) + .field("format", &self.format) + .field("value", &"union") + .finish() + } +} +impl ::std::default::Default for PipelineExecutableStatisticKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + name: unsafe { ::std::mem::zeroed() }, + description: unsafe { ::std::mem::zeroed() }, + format: PipelineExecutableStatisticFormatKHR::default(), + value: PipelineExecutableStatisticValueKHR::default(), + } + } +} +unsafe impl TaggedStructure for PipelineExecutableStatisticKHR { + const STRUCTURE_TYPE: StructureType = StructureType::PIPELINE_EXECUTABLE_STATISTIC_KHR; +} +impl PipelineExecutableStatisticKHR { + pub fn builder<'a>() -> PipelineExecutableStatisticKHRBuilder<'a> { + PipelineExecutableStatisticKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PipelineExecutableStatisticKHRBuilder<'a> { + inner: PipelineExecutableStatisticKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PipelineExecutableStatisticKHRBuilder<'a> { + type Target = PipelineExecutableStatisticKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PipelineExecutableStatisticKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PipelineExecutableStatisticKHRBuilder<'a> { + #[inline] + pub fn name(mut self, name: [c_char; MAX_DESCRIPTION_SIZE]) -> Self { + self.inner.name = name; + self + } + #[inline] + pub fn description(mut self, description: [c_char; MAX_DESCRIPTION_SIZE]) -> Self { + self.inner.description = description; + self + } + #[inline] + pub fn format(mut self, format: PipelineExecutableStatisticFormatKHR) -> Self { + self.inner.format = format; + self + } + #[inline] + pub fn value(mut self, value: PipelineExecutableStatisticValueKHR) -> Self { + self.inner.value = value; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PipelineExecutableStatisticKHR { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PipelineExecutableInternalRepresentationKHR { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub name: [c_char; MAX_DESCRIPTION_SIZE], + pub description: [c_char; MAX_DESCRIPTION_SIZE], + pub is_text: Bool32, + pub data_size: usize, + pub p_data: *mut c_void, +} +#[cfg(feature = "debug")] +impl fmt::Debug for PipelineExecutableInternalRepresentationKHR { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fmt.debug_struct("PipelineExecutableInternalRepresentationKHR") + .field("s_type", &self.s_type) + .field("p_next", &self.p_next) + .field("name", &unsafe { + ::std::ffi::CStr::from_ptr(self.name.as_ptr()) + }) + .field("description", &unsafe { + ::std::ffi::CStr::from_ptr(self.description.as_ptr()) + }) + .field("is_text", &self.is_text) + .field("data_size", &self.data_size) + .field("p_data", &self.p_data) + .finish() + } +} +impl ::std::default::Default for PipelineExecutableInternalRepresentationKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + name: unsafe { ::std::mem::zeroed() }, + description: unsafe { ::std::mem::zeroed() }, + is_text: Bool32::default(), + data_size: usize::default(), + p_data: ::std::ptr::null_mut(), + } + } +} +unsafe impl TaggedStructure for PipelineExecutableInternalRepresentationKHR { + const STRUCTURE_TYPE: StructureType = + StructureType::PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR; +} +impl PipelineExecutableInternalRepresentationKHR { + pub fn builder<'a>() -> PipelineExecutableInternalRepresentationKHRBuilder<'a> { + PipelineExecutableInternalRepresentationKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PipelineExecutableInternalRepresentationKHRBuilder<'a> { + inner: PipelineExecutableInternalRepresentationKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PipelineExecutableInternalRepresentationKHRBuilder<'a> { + type Target = PipelineExecutableInternalRepresentationKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PipelineExecutableInternalRepresentationKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PipelineExecutableInternalRepresentationKHRBuilder<'a> { + #[inline] + pub fn name(mut self, name: [c_char; MAX_DESCRIPTION_SIZE]) -> Self { + self.inner.name = name; + self + } + #[inline] + pub fn description(mut self, description: [c_char; MAX_DESCRIPTION_SIZE]) -> Self { + self.inner.description = description; + self + } + #[inline] + pub fn is_text(mut self, is_text: bool) -> Self { + self.inner.is_text = is_text.into(); + self + } + #[inline] + pub fn data(mut self, data: &'a mut [u8]) -> Self { + self.inner.data_size = data.len(); + self.inner.p_data = data.as_mut_ptr().cast(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PipelineExecutableInternalRepresentationKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceShaderDemoteToHelperInvocationFeatures { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub shader_demote_to_helper_invocation: Bool32, +} +impl ::std::default::Default for PhysicalDeviceShaderDemoteToHelperInvocationFeatures { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + shader_demote_to_helper_invocation: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceShaderDemoteToHelperInvocationFeatures { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES; +} +impl PhysicalDeviceShaderDemoteToHelperInvocationFeatures { + pub fn builder<'a>() -> PhysicalDeviceShaderDemoteToHelperInvocationFeaturesBuilder<'a> { + PhysicalDeviceShaderDemoteToHelperInvocationFeaturesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceShaderDemoteToHelperInvocationFeaturesBuilder<'a> { + inner: PhysicalDeviceShaderDemoteToHelperInvocationFeatures, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceShaderDemoteToHelperInvocationFeaturesBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceShaderDemoteToHelperInvocationFeatures +{ +} +unsafe impl ExtendsDeviceCreateInfo + for PhysicalDeviceShaderDemoteToHelperInvocationFeaturesBuilder<'_> +{ +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderDemoteToHelperInvocationFeatures {} +impl<'a> ::std::ops::Deref for PhysicalDeviceShaderDemoteToHelperInvocationFeaturesBuilder<'a> { + type Target = PhysicalDeviceShaderDemoteToHelperInvocationFeatures; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderDemoteToHelperInvocationFeaturesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceShaderDemoteToHelperInvocationFeaturesBuilder<'a> { + #[inline] + pub fn shader_demote_to_helper_invocation( + mut self, + shader_demote_to_helper_invocation: bool, + ) -> Self { + self.inner.shader_demote_to_helper_invocation = shader_demote_to_helper_invocation.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceShaderDemoteToHelperInvocationFeatures { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceTexelBufferAlignmentFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub texel_buffer_alignment: Bool32, +} +impl ::std::default::Default for PhysicalDeviceTexelBufferAlignmentFeaturesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + texel_buffer_alignment: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceTexelBufferAlignmentFeaturesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT; +} +impl PhysicalDeviceTexelBufferAlignmentFeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceTexelBufferAlignmentFeaturesEXTBuilder<'a> { + PhysicalDeviceTexelBufferAlignmentFeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceTexelBufferAlignmentFeaturesEXTBuilder<'a> { + inner: PhysicalDeviceTexelBufferAlignmentFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceTexelBufferAlignmentFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceTexelBufferAlignmentFeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceTexelBufferAlignmentFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceTexelBufferAlignmentFeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceTexelBufferAlignmentFeaturesEXTBuilder<'a> { + type Target = PhysicalDeviceTexelBufferAlignmentFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceTexelBufferAlignmentFeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceTexelBufferAlignmentFeaturesEXTBuilder<'a> { + #[inline] + pub fn texel_buffer_alignment(mut self, texel_buffer_alignment: bool) -> Self { + self.inner.texel_buffer_alignment = texel_buffer_alignment.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceTexelBufferAlignmentFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceTexelBufferAlignmentProperties { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub storage_texel_buffer_offset_alignment_bytes: DeviceSize, + pub storage_texel_buffer_offset_single_texel_alignment: Bool32, + pub uniform_texel_buffer_offset_alignment_bytes: DeviceSize, + pub uniform_texel_buffer_offset_single_texel_alignment: Bool32, +} +impl ::std::default::Default for PhysicalDeviceTexelBufferAlignmentProperties { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + storage_texel_buffer_offset_alignment_bytes: DeviceSize::default(), + storage_texel_buffer_offset_single_texel_alignment: Bool32::default(), + uniform_texel_buffer_offset_alignment_bytes: DeviceSize::default(), + uniform_texel_buffer_offset_single_texel_alignment: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceTexelBufferAlignmentProperties { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES; +} +impl PhysicalDeviceTexelBufferAlignmentProperties { + pub fn builder<'a>() -> PhysicalDeviceTexelBufferAlignmentPropertiesBuilder<'a> { + PhysicalDeviceTexelBufferAlignmentPropertiesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceTexelBufferAlignmentPropertiesBuilder<'a> { + inner: PhysicalDeviceTexelBufferAlignmentProperties, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceTexelBufferAlignmentPropertiesBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceTexelBufferAlignmentProperties {} +impl<'a> ::std::ops::Deref for PhysicalDeviceTexelBufferAlignmentPropertiesBuilder<'a> { + type Target = PhysicalDeviceTexelBufferAlignmentProperties; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceTexelBufferAlignmentPropertiesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceTexelBufferAlignmentPropertiesBuilder<'a> { + #[inline] + pub fn storage_texel_buffer_offset_alignment_bytes( + mut self, + storage_texel_buffer_offset_alignment_bytes: DeviceSize, + ) -> Self { + self.inner.storage_texel_buffer_offset_alignment_bytes = + storage_texel_buffer_offset_alignment_bytes; + self + } + #[inline] + pub fn storage_texel_buffer_offset_single_texel_alignment( + mut self, + storage_texel_buffer_offset_single_texel_alignment: bool, + ) -> Self { + self.inner + .storage_texel_buffer_offset_single_texel_alignment = + storage_texel_buffer_offset_single_texel_alignment.into(); + self + } + #[inline] + pub fn uniform_texel_buffer_offset_alignment_bytes( + mut self, + uniform_texel_buffer_offset_alignment_bytes: DeviceSize, + ) -> Self { + self.inner.uniform_texel_buffer_offset_alignment_bytes = + uniform_texel_buffer_offset_alignment_bytes; + self + } + #[inline] + pub fn uniform_texel_buffer_offset_single_texel_alignment( + mut self, + uniform_texel_buffer_offset_single_texel_alignment: bool, + ) -> Self { + self.inner + .uniform_texel_buffer_offset_single_texel_alignment = + uniform_texel_buffer_offset_single_texel_alignment.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceTexelBufferAlignmentProperties { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceSubgroupSizeControlFeatures { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub subgroup_size_control: Bool32, + pub compute_full_subgroups: Bool32, +} +impl ::std::default::Default for PhysicalDeviceSubgroupSizeControlFeatures { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + subgroup_size_control: Bool32::default(), + compute_full_subgroups: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceSubgroupSizeControlFeatures { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES; +} +impl PhysicalDeviceSubgroupSizeControlFeatures { + pub fn builder<'a>() -> PhysicalDeviceSubgroupSizeControlFeaturesBuilder<'a> { + PhysicalDeviceSubgroupSizeControlFeaturesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceSubgroupSizeControlFeaturesBuilder<'a> { + inner: PhysicalDeviceSubgroupSizeControlFeatures, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceSubgroupSizeControlFeaturesBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceSubgroupSizeControlFeatures {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceSubgroupSizeControlFeaturesBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceSubgroupSizeControlFeatures {} +impl<'a> ::std::ops::Deref for PhysicalDeviceSubgroupSizeControlFeaturesBuilder<'a> { + type Target = PhysicalDeviceSubgroupSizeControlFeatures; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceSubgroupSizeControlFeaturesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceSubgroupSizeControlFeaturesBuilder<'a> { + #[inline] + pub fn subgroup_size_control(mut self, subgroup_size_control: bool) -> Self { + self.inner.subgroup_size_control = subgroup_size_control.into(); + self + } + #[inline] + pub fn compute_full_subgroups(mut self, compute_full_subgroups: bool) -> Self { + self.inner.compute_full_subgroups = compute_full_subgroups.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceSubgroupSizeControlFeatures { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceSubgroupSizeControlProperties { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub min_subgroup_size: u32, + pub max_subgroup_size: u32, + pub max_compute_workgroup_subgroups: u32, + pub required_subgroup_size_stages: ShaderStageFlags, +} +impl ::std::default::Default for PhysicalDeviceSubgroupSizeControlProperties { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + min_subgroup_size: u32::default(), + max_subgroup_size: u32::default(), + max_compute_workgroup_subgroups: u32::default(), + required_subgroup_size_stages: ShaderStageFlags::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceSubgroupSizeControlProperties { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES; +} +impl PhysicalDeviceSubgroupSizeControlProperties { + pub fn builder<'a>() -> PhysicalDeviceSubgroupSizeControlPropertiesBuilder<'a> { + PhysicalDeviceSubgroupSizeControlPropertiesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceSubgroupSizeControlPropertiesBuilder<'a> { + inner: PhysicalDeviceSubgroupSizeControlProperties, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceSubgroupSizeControlPropertiesBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceSubgroupSizeControlProperties {} +impl<'a> ::std::ops::Deref for PhysicalDeviceSubgroupSizeControlPropertiesBuilder<'a> { + type Target = PhysicalDeviceSubgroupSizeControlProperties; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceSubgroupSizeControlPropertiesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceSubgroupSizeControlPropertiesBuilder<'a> { + #[inline] + pub fn min_subgroup_size(mut self, min_subgroup_size: u32) -> Self { + self.inner.min_subgroup_size = min_subgroup_size; + self + } + #[inline] + pub fn max_subgroup_size(mut self, max_subgroup_size: u32) -> Self { + self.inner.max_subgroup_size = max_subgroup_size; + self + } + #[inline] + pub fn max_compute_workgroup_subgroups(mut self, max_compute_workgroup_subgroups: u32) -> Self { + self.inner.max_compute_workgroup_subgroups = max_compute_workgroup_subgroups; + self + } + #[inline] + pub fn required_subgroup_size_stages( + mut self, + required_subgroup_size_stages: ShaderStageFlags, + ) -> Self { + self.inner.required_subgroup_size_stages = required_subgroup_size_stages; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceSubgroupSizeControlProperties { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PipelineShaderStageRequiredSubgroupSizeCreateInfo { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub required_subgroup_size: u32, +} +impl ::std::default::Default for PipelineShaderStageRequiredSubgroupSizeCreateInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + required_subgroup_size: u32::default(), + } + } +} +unsafe impl TaggedStructure for PipelineShaderStageRequiredSubgroupSizeCreateInfo { + const STRUCTURE_TYPE: StructureType = + StructureType::PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO; +} +impl PipelineShaderStageRequiredSubgroupSizeCreateInfo { + pub fn builder<'a>() -> PipelineShaderStageRequiredSubgroupSizeCreateInfoBuilder<'a> { + PipelineShaderStageRequiredSubgroupSizeCreateInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PipelineShaderStageRequiredSubgroupSizeCreateInfoBuilder<'a> { + inner: PipelineShaderStageRequiredSubgroupSizeCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPipelineShaderStageCreateInfo + for PipelineShaderStageRequiredSubgroupSizeCreateInfoBuilder<'_> +{ +} +unsafe impl ExtendsPipelineShaderStageCreateInfo + for PipelineShaderStageRequiredSubgroupSizeCreateInfo +{ +} +impl<'a> ::std::ops::Deref for PipelineShaderStageRequiredSubgroupSizeCreateInfoBuilder<'a> { + type Target = PipelineShaderStageRequiredSubgroupSizeCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PipelineShaderStageRequiredSubgroupSizeCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PipelineShaderStageRequiredSubgroupSizeCreateInfoBuilder<'a> { + #[inline] + pub fn required_subgroup_size(mut self, required_subgroup_size: u32) -> Self { + self.inner.required_subgroup_size = required_subgroup_size; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PipelineShaderStageRequiredSubgroupSizeCreateInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SubpassShadingPipelineCreateInfoHUAWEI { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub render_pass: RenderPass, + pub subpass: u32, +} +impl ::std::default::Default for SubpassShadingPipelineCreateInfoHUAWEI { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + render_pass: RenderPass::default(), + subpass: u32::default(), + } + } +} +unsafe impl TaggedStructure for SubpassShadingPipelineCreateInfoHUAWEI { + const STRUCTURE_TYPE: StructureType = + StructureType::SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI; +} +impl SubpassShadingPipelineCreateInfoHUAWEI { + pub fn builder<'a>() -> SubpassShadingPipelineCreateInfoHUAWEIBuilder<'a> { + SubpassShadingPipelineCreateInfoHUAWEIBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SubpassShadingPipelineCreateInfoHUAWEIBuilder<'a> { + inner: SubpassShadingPipelineCreateInfoHUAWEI, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsComputePipelineCreateInfo for SubpassShadingPipelineCreateInfoHUAWEIBuilder<'_> {} +unsafe impl ExtendsComputePipelineCreateInfo for SubpassShadingPipelineCreateInfoHUAWEI {} +impl<'a> ::std::ops::Deref for SubpassShadingPipelineCreateInfoHUAWEIBuilder<'a> { + type Target = SubpassShadingPipelineCreateInfoHUAWEI; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SubpassShadingPipelineCreateInfoHUAWEIBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SubpassShadingPipelineCreateInfoHUAWEIBuilder<'a> { + #[inline] + pub fn render_pass(mut self, render_pass: RenderPass) -> Self { + self.inner.render_pass = render_pass; + self + } + #[inline] + pub fn subpass(mut self, subpass: u32) -> Self { + self.inner.subpass = subpass; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SubpassShadingPipelineCreateInfoHUAWEI { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceSubpassShadingPropertiesHUAWEI { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub max_subpass_shading_workgroup_size_aspect_ratio: u32, +} +impl ::std::default::Default for PhysicalDeviceSubpassShadingPropertiesHUAWEI { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + max_subpass_shading_workgroup_size_aspect_ratio: u32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceSubpassShadingPropertiesHUAWEI { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI; +} +impl PhysicalDeviceSubpassShadingPropertiesHUAWEI { + pub fn builder<'a>() -> PhysicalDeviceSubpassShadingPropertiesHUAWEIBuilder<'a> { + PhysicalDeviceSubpassShadingPropertiesHUAWEIBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceSubpassShadingPropertiesHUAWEIBuilder<'a> { + inner: PhysicalDeviceSubpassShadingPropertiesHUAWEI, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceSubpassShadingPropertiesHUAWEIBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceSubpassShadingPropertiesHUAWEI {} +impl<'a> ::std::ops::Deref for PhysicalDeviceSubpassShadingPropertiesHUAWEIBuilder<'a> { + type Target = PhysicalDeviceSubpassShadingPropertiesHUAWEI; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceSubpassShadingPropertiesHUAWEIBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceSubpassShadingPropertiesHUAWEIBuilder<'a> { + #[inline] + pub fn max_subpass_shading_workgroup_size_aspect_ratio( + mut self, + max_subpass_shading_workgroup_size_aspect_ratio: u32, + ) -> Self { + self.inner.max_subpass_shading_workgroup_size_aspect_ratio = + max_subpass_shading_workgroup_size_aspect_ratio; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceSubpassShadingPropertiesHUAWEI { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct MemoryOpaqueCaptureAddressAllocateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub opaque_capture_address: u64, +} +impl ::std::default::Default for MemoryOpaqueCaptureAddressAllocateInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + opaque_capture_address: u64::default(), + } + } +} +unsafe impl TaggedStructure for MemoryOpaqueCaptureAddressAllocateInfo { + const STRUCTURE_TYPE: StructureType = + StructureType::MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO; +} +impl MemoryOpaqueCaptureAddressAllocateInfo { + pub fn builder<'a>() -> MemoryOpaqueCaptureAddressAllocateInfoBuilder<'a> { + MemoryOpaqueCaptureAddressAllocateInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct MemoryOpaqueCaptureAddressAllocateInfoBuilder<'a> { + inner: MemoryOpaqueCaptureAddressAllocateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsMemoryAllocateInfo for MemoryOpaqueCaptureAddressAllocateInfoBuilder<'_> {} +unsafe impl ExtendsMemoryAllocateInfo for MemoryOpaqueCaptureAddressAllocateInfo {} +impl<'a> ::std::ops::Deref for MemoryOpaqueCaptureAddressAllocateInfoBuilder<'a> { + type Target = MemoryOpaqueCaptureAddressAllocateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for MemoryOpaqueCaptureAddressAllocateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> MemoryOpaqueCaptureAddressAllocateInfoBuilder<'a> { + #[inline] + pub fn opaque_capture_address(mut self, opaque_capture_address: u64) -> Self { + self.inner.opaque_capture_address = opaque_capture_address; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> MemoryOpaqueCaptureAddressAllocateInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DeviceMemoryOpaqueCaptureAddressInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub memory: DeviceMemory, +} +impl ::std::default::Default for DeviceMemoryOpaqueCaptureAddressInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + memory: DeviceMemory::default(), + } + } +} +unsafe impl TaggedStructure for DeviceMemoryOpaqueCaptureAddressInfo { + const STRUCTURE_TYPE: StructureType = StructureType::DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO; +} +impl DeviceMemoryOpaqueCaptureAddressInfo { + pub fn builder<'a>() -> DeviceMemoryOpaqueCaptureAddressInfoBuilder<'a> { + DeviceMemoryOpaqueCaptureAddressInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DeviceMemoryOpaqueCaptureAddressInfoBuilder<'a> { + inner: DeviceMemoryOpaqueCaptureAddressInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DeviceMemoryOpaqueCaptureAddressInfoBuilder<'a> { + type Target = DeviceMemoryOpaqueCaptureAddressInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DeviceMemoryOpaqueCaptureAddressInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DeviceMemoryOpaqueCaptureAddressInfoBuilder<'a> { + #[inline] + pub fn memory(mut self, memory: DeviceMemory) -> Self { + self.inner.memory = memory; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DeviceMemoryOpaqueCaptureAddressInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceLineRasterizationFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub rectangular_lines: Bool32, + pub bresenham_lines: Bool32, + pub smooth_lines: Bool32, + pub stippled_rectangular_lines: Bool32, + pub stippled_bresenham_lines: Bool32, + pub stippled_smooth_lines: Bool32, +} +impl ::std::default::Default for PhysicalDeviceLineRasterizationFeaturesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + rectangular_lines: Bool32::default(), + bresenham_lines: Bool32::default(), + smooth_lines: Bool32::default(), + stippled_rectangular_lines: Bool32::default(), + stippled_bresenham_lines: Bool32::default(), + stippled_smooth_lines: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceLineRasterizationFeaturesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT; +} +impl PhysicalDeviceLineRasterizationFeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceLineRasterizationFeaturesEXTBuilder<'a> { + PhysicalDeviceLineRasterizationFeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceLineRasterizationFeaturesEXTBuilder<'a> { + inner: PhysicalDeviceLineRasterizationFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceLineRasterizationFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceLineRasterizationFeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceLineRasterizationFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceLineRasterizationFeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceLineRasterizationFeaturesEXTBuilder<'a> { + type Target = PhysicalDeviceLineRasterizationFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceLineRasterizationFeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceLineRasterizationFeaturesEXTBuilder<'a> { + #[inline] + pub fn rectangular_lines(mut self, rectangular_lines: bool) -> Self { + self.inner.rectangular_lines = rectangular_lines.into(); + self + } + #[inline] + pub fn bresenham_lines(mut self, bresenham_lines: bool) -> Self { + self.inner.bresenham_lines = bresenham_lines.into(); + self + } + #[inline] + pub fn smooth_lines(mut self, smooth_lines: bool) -> Self { + self.inner.smooth_lines = smooth_lines.into(); + self + } + #[inline] + pub fn stippled_rectangular_lines(mut self, stippled_rectangular_lines: bool) -> Self { + self.inner.stippled_rectangular_lines = stippled_rectangular_lines.into(); + self + } + #[inline] + pub fn stippled_bresenham_lines(mut self, stippled_bresenham_lines: bool) -> Self { + self.inner.stippled_bresenham_lines = stippled_bresenham_lines.into(); + self + } + #[inline] + pub fn stippled_smooth_lines(mut self, stippled_smooth_lines: bool) -> Self { + self.inner.stippled_smooth_lines = stippled_smooth_lines.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceLineRasterizationFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceLineRasterizationPropertiesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub line_sub_pixel_precision_bits: u32, +} +impl ::std::default::Default for PhysicalDeviceLineRasterizationPropertiesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + line_sub_pixel_precision_bits: u32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceLineRasterizationPropertiesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT; +} +impl PhysicalDeviceLineRasterizationPropertiesEXT { + pub fn builder<'a>() -> PhysicalDeviceLineRasterizationPropertiesEXTBuilder<'a> { + PhysicalDeviceLineRasterizationPropertiesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceLineRasterizationPropertiesEXTBuilder<'a> { + inner: PhysicalDeviceLineRasterizationPropertiesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceLineRasterizationPropertiesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceLineRasterizationPropertiesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceLineRasterizationPropertiesEXTBuilder<'a> { + type Target = PhysicalDeviceLineRasterizationPropertiesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceLineRasterizationPropertiesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceLineRasterizationPropertiesEXTBuilder<'a> { + #[inline] + pub fn line_sub_pixel_precision_bits(mut self, line_sub_pixel_precision_bits: u32) -> Self { + self.inner.line_sub_pixel_precision_bits = line_sub_pixel_precision_bits; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceLineRasterizationPropertiesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PipelineRasterizationLineStateCreateInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub line_rasterization_mode: LineRasterizationModeEXT, + pub stippled_line_enable: Bool32, + pub line_stipple_factor: u32, + pub line_stipple_pattern: u16, +} +impl ::std::default::Default for PipelineRasterizationLineStateCreateInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + line_rasterization_mode: LineRasterizationModeEXT::default(), + stippled_line_enable: Bool32::default(), + line_stipple_factor: u32::default(), + line_stipple_pattern: u16::default(), + } + } +} +unsafe impl TaggedStructure for PipelineRasterizationLineStateCreateInfoEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT; +} +impl PipelineRasterizationLineStateCreateInfoEXT { + pub fn builder<'a>() -> PipelineRasterizationLineStateCreateInfoEXTBuilder<'a> { + PipelineRasterizationLineStateCreateInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PipelineRasterizationLineStateCreateInfoEXTBuilder<'a> { + inner: PipelineRasterizationLineStateCreateInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPipelineRasterizationStateCreateInfo + for PipelineRasterizationLineStateCreateInfoEXTBuilder<'_> +{ +} +unsafe impl ExtendsPipelineRasterizationStateCreateInfo + for PipelineRasterizationLineStateCreateInfoEXT +{ +} +impl<'a> ::std::ops::Deref for PipelineRasterizationLineStateCreateInfoEXTBuilder<'a> { + type Target = PipelineRasterizationLineStateCreateInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PipelineRasterizationLineStateCreateInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PipelineRasterizationLineStateCreateInfoEXTBuilder<'a> { + #[inline] + pub fn line_rasterization_mode( + mut self, + line_rasterization_mode: LineRasterizationModeEXT, + ) -> Self { + self.inner.line_rasterization_mode = line_rasterization_mode; + self + } + #[inline] + pub fn stippled_line_enable(mut self, stippled_line_enable: bool) -> Self { + self.inner.stippled_line_enable = stippled_line_enable.into(); + self + } + #[inline] + pub fn line_stipple_factor(mut self, line_stipple_factor: u32) -> Self { + self.inner.line_stipple_factor = line_stipple_factor; + self + } + #[inline] + pub fn line_stipple_pattern(mut self, line_stipple_pattern: u16) -> Self { + self.inner.line_stipple_pattern = line_stipple_pattern; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PipelineRasterizationLineStateCreateInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDevicePipelineCreationCacheControlFeatures { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub pipeline_creation_cache_control: Bool32, +} +impl ::std::default::Default for PhysicalDevicePipelineCreationCacheControlFeatures { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + pipeline_creation_cache_control: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDevicePipelineCreationCacheControlFeatures { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES; +} +impl PhysicalDevicePipelineCreationCacheControlFeatures { + pub fn builder<'a>() -> PhysicalDevicePipelineCreationCacheControlFeaturesBuilder<'a> { + PhysicalDevicePipelineCreationCacheControlFeaturesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDevicePipelineCreationCacheControlFeaturesBuilder<'a> { + inner: PhysicalDevicePipelineCreationCacheControlFeatures, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDevicePipelineCreationCacheControlFeaturesBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePipelineCreationCacheControlFeatures {} +unsafe impl ExtendsDeviceCreateInfo + for PhysicalDevicePipelineCreationCacheControlFeaturesBuilder<'_> +{ +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePipelineCreationCacheControlFeatures {} +impl<'a> ::std::ops::Deref for PhysicalDevicePipelineCreationCacheControlFeaturesBuilder<'a> { + type Target = PhysicalDevicePipelineCreationCacheControlFeatures; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDevicePipelineCreationCacheControlFeaturesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDevicePipelineCreationCacheControlFeaturesBuilder<'a> { + #[inline] + pub fn pipeline_creation_cache_control( + mut self, + pipeline_creation_cache_control: bool, + ) -> Self { + self.inner.pipeline_creation_cache_control = pipeline_creation_cache_control.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDevicePipelineCreationCacheControlFeatures { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceVulkan11Features { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub storage_buffer16_bit_access: Bool32, + pub uniform_and_storage_buffer16_bit_access: Bool32, + pub storage_push_constant16: Bool32, + pub storage_input_output16: Bool32, + pub multiview: Bool32, + pub multiview_geometry_shader: Bool32, + pub multiview_tessellation_shader: Bool32, + pub variable_pointers_storage_buffer: Bool32, + pub variable_pointers: Bool32, + pub protected_memory: Bool32, + pub sampler_ycbcr_conversion: Bool32, + pub shader_draw_parameters: Bool32, +} +impl ::std::default::Default for PhysicalDeviceVulkan11Features { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + storage_buffer16_bit_access: Bool32::default(), + uniform_and_storage_buffer16_bit_access: Bool32::default(), + storage_push_constant16: Bool32::default(), + storage_input_output16: Bool32::default(), + multiview: Bool32::default(), + multiview_geometry_shader: Bool32::default(), + multiview_tessellation_shader: Bool32::default(), + variable_pointers_storage_buffer: Bool32::default(), + variable_pointers: Bool32::default(), + protected_memory: Bool32::default(), + sampler_ycbcr_conversion: Bool32::default(), + shader_draw_parameters: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceVulkan11Features { + const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_VULKAN_1_1_FEATURES; +} +impl PhysicalDeviceVulkan11Features { + pub fn builder<'a>() -> PhysicalDeviceVulkan11FeaturesBuilder<'a> { + PhysicalDeviceVulkan11FeaturesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceVulkan11FeaturesBuilder<'a> { + inner: PhysicalDeviceVulkan11Features, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceVulkan11FeaturesBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceVulkan11Features {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVulkan11FeaturesBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVulkan11Features {} +impl<'a> ::std::ops::Deref for PhysicalDeviceVulkan11FeaturesBuilder<'a> { + type Target = PhysicalDeviceVulkan11Features; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceVulkan11FeaturesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceVulkan11FeaturesBuilder<'a> { + #[inline] + pub fn storage_buffer16_bit_access(mut self, storage_buffer16_bit_access: bool) -> Self { + self.inner.storage_buffer16_bit_access = storage_buffer16_bit_access.into(); + self + } + #[inline] + pub fn uniform_and_storage_buffer16_bit_access( + mut self, + uniform_and_storage_buffer16_bit_access: bool, + ) -> Self { + self.inner.uniform_and_storage_buffer16_bit_access = + uniform_and_storage_buffer16_bit_access.into(); + self + } + #[inline] + pub fn storage_push_constant16(mut self, storage_push_constant16: bool) -> Self { + self.inner.storage_push_constant16 = storage_push_constant16.into(); + self + } + #[inline] + pub fn storage_input_output16(mut self, storage_input_output16: bool) -> Self { + self.inner.storage_input_output16 = storage_input_output16.into(); + self + } + #[inline] + pub fn multiview(mut self, multiview: bool) -> Self { + self.inner.multiview = multiview.into(); + self + } + #[inline] + pub fn multiview_geometry_shader(mut self, multiview_geometry_shader: bool) -> Self { + self.inner.multiview_geometry_shader = multiview_geometry_shader.into(); + self + } + #[inline] + pub fn multiview_tessellation_shader(mut self, multiview_tessellation_shader: bool) -> Self { + self.inner.multiview_tessellation_shader = multiview_tessellation_shader.into(); + self + } + #[inline] + pub fn variable_pointers_storage_buffer( + mut self, + variable_pointers_storage_buffer: bool, + ) -> Self { + self.inner.variable_pointers_storage_buffer = variable_pointers_storage_buffer.into(); + self + } + #[inline] + pub fn variable_pointers(mut self, variable_pointers: bool) -> Self { + self.inner.variable_pointers = variable_pointers.into(); + self + } + #[inline] + pub fn protected_memory(mut self, protected_memory: bool) -> Self { + self.inner.protected_memory = protected_memory.into(); + self + } + #[inline] + pub fn sampler_ycbcr_conversion(mut self, sampler_ycbcr_conversion: bool) -> Self { + self.inner.sampler_ycbcr_conversion = sampler_ycbcr_conversion.into(); + self + } + #[inline] + pub fn shader_draw_parameters(mut self, shader_draw_parameters: bool) -> Self { + self.inner.shader_draw_parameters = shader_draw_parameters.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceVulkan11Features { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceVulkan11Properties { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub device_uuid: [u8; UUID_SIZE], + pub driver_uuid: [u8; UUID_SIZE], + pub device_luid: [u8; LUID_SIZE], + pub device_node_mask: u32, + pub device_luid_valid: Bool32, + pub subgroup_size: u32, + pub subgroup_supported_stages: ShaderStageFlags, + pub subgroup_supported_operations: SubgroupFeatureFlags, + pub subgroup_quad_operations_in_all_stages: Bool32, + pub point_clipping_behavior: PointClippingBehavior, + pub max_multiview_view_count: u32, + pub max_multiview_instance_index: u32, + pub protected_no_fault: Bool32, + pub max_per_set_descriptors: u32, + pub max_memory_allocation_size: DeviceSize, +} +impl ::std::default::Default for PhysicalDeviceVulkan11Properties { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + device_uuid: unsafe { ::std::mem::zeroed() }, + driver_uuid: unsafe { ::std::mem::zeroed() }, + device_luid: unsafe { ::std::mem::zeroed() }, + device_node_mask: u32::default(), + device_luid_valid: Bool32::default(), + subgroup_size: u32::default(), + subgroup_supported_stages: ShaderStageFlags::default(), + subgroup_supported_operations: SubgroupFeatureFlags::default(), + subgroup_quad_operations_in_all_stages: Bool32::default(), + point_clipping_behavior: PointClippingBehavior::default(), + max_multiview_view_count: u32::default(), + max_multiview_instance_index: u32::default(), + protected_no_fault: Bool32::default(), + max_per_set_descriptors: u32::default(), + max_memory_allocation_size: DeviceSize::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceVulkan11Properties { + const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES; +} +impl PhysicalDeviceVulkan11Properties { + pub fn builder<'a>() -> PhysicalDeviceVulkan11PropertiesBuilder<'a> { + PhysicalDeviceVulkan11PropertiesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceVulkan11PropertiesBuilder<'a> { + inner: PhysicalDeviceVulkan11Properties, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceVulkan11PropertiesBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceVulkan11Properties {} +impl<'a> ::std::ops::Deref for PhysicalDeviceVulkan11PropertiesBuilder<'a> { + type Target = PhysicalDeviceVulkan11Properties; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceVulkan11PropertiesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceVulkan11PropertiesBuilder<'a> { + #[inline] + pub fn device_uuid(mut self, device_uuid: [u8; UUID_SIZE]) -> Self { + self.inner.device_uuid = device_uuid; + self + } + #[inline] + pub fn driver_uuid(mut self, driver_uuid: [u8; UUID_SIZE]) -> Self { + self.inner.driver_uuid = driver_uuid; + self + } + #[inline] + pub fn device_luid(mut self, device_luid: [u8; LUID_SIZE]) -> Self { + self.inner.device_luid = device_luid; + self + } + #[inline] + pub fn device_node_mask(mut self, device_node_mask: u32) -> Self { + self.inner.device_node_mask = device_node_mask; + self + } + #[inline] + pub fn device_luid_valid(mut self, device_luid_valid: bool) -> Self { + self.inner.device_luid_valid = device_luid_valid.into(); + self + } + #[inline] + pub fn subgroup_size(mut self, subgroup_size: u32) -> Self { + self.inner.subgroup_size = subgroup_size; + self + } + #[inline] + pub fn subgroup_supported_stages( + mut self, + subgroup_supported_stages: ShaderStageFlags, + ) -> Self { + self.inner.subgroup_supported_stages = subgroup_supported_stages; + self + } + #[inline] + pub fn subgroup_supported_operations( + mut self, + subgroup_supported_operations: SubgroupFeatureFlags, + ) -> Self { + self.inner.subgroup_supported_operations = subgroup_supported_operations; + self + } + #[inline] + pub fn subgroup_quad_operations_in_all_stages( + mut self, + subgroup_quad_operations_in_all_stages: bool, + ) -> Self { + self.inner.subgroup_quad_operations_in_all_stages = + subgroup_quad_operations_in_all_stages.into(); + self + } + #[inline] + pub fn point_clipping_behavior( + mut self, + point_clipping_behavior: PointClippingBehavior, + ) -> Self { + self.inner.point_clipping_behavior = point_clipping_behavior; + self + } + #[inline] + pub fn max_multiview_view_count(mut self, max_multiview_view_count: u32) -> Self { + self.inner.max_multiview_view_count = max_multiview_view_count; + self + } + #[inline] + pub fn max_multiview_instance_index(mut self, max_multiview_instance_index: u32) -> Self { + self.inner.max_multiview_instance_index = max_multiview_instance_index; + self + } + #[inline] + pub fn protected_no_fault(mut self, protected_no_fault: bool) -> Self { + self.inner.protected_no_fault = protected_no_fault.into(); + self + } + #[inline] + pub fn max_per_set_descriptors(mut self, max_per_set_descriptors: u32) -> Self { + self.inner.max_per_set_descriptors = max_per_set_descriptors; + self + } + #[inline] + pub fn max_memory_allocation_size(mut self, max_memory_allocation_size: DeviceSize) -> Self { + self.inner.max_memory_allocation_size = max_memory_allocation_size; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceVulkan11Properties { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceVulkan12Features { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub sampler_mirror_clamp_to_edge: Bool32, + pub draw_indirect_count: Bool32, + pub storage_buffer8_bit_access: Bool32, + pub uniform_and_storage_buffer8_bit_access: Bool32, + pub storage_push_constant8: Bool32, + pub shader_buffer_int64_atomics: Bool32, + pub shader_shared_int64_atomics: Bool32, + pub shader_float16: Bool32, + pub shader_int8: Bool32, + pub descriptor_indexing: Bool32, + pub shader_input_attachment_array_dynamic_indexing: Bool32, + pub shader_uniform_texel_buffer_array_dynamic_indexing: Bool32, + pub shader_storage_texel_buffer_array_dynamic_indexing: Bool32, + pub shader_uniform_buffer_array_non_uniform_indexing: Bool32, + pub shader_sampled_image_array_non_uniform_indexing: Bool32, + pub shader_storage_buffer_array_non_uniform_indexing: Bool32, + pub shader_storage_image_array_non_uniform_indexing: Bool32, + pub shader_input_attachment_array_non_uniform_indexing: Bool32, + pub shader_uniform_texel_buffer_array_non_uniform_indexing: Bool32, + pub shader_storage_texel_buffer_array_non_uniform_indexing: Bool32, + pub descriptor_binding_uniform_buffer_update_after_bind: Bool32, + pub descriptor_binding_sampled_image_update_after_bind: Bool32, + pub descriptor_binding_storage_image_update_after_bind: Bool32, + pub descriptor_binding_storage_buffer_update_after_bind: Bool32, + pub descriptor_binding_uniform_texel_buffer_update_after_bind: Bool32, + pub descriptor_binding_storage_texel_buffer_update_after_bind: Bool32, + pub descriptor_binding_update_unused_while_pending: Bool32, + pub descriptor_binding_partially_bound: Bool32, + pub descriptor_binding_variable_descriptor_count: Bool32, + pub runtime_descriptor_array: Bool32, + pub sampler_filter_minmax: Bool32, + pub scalar_block_layout: Bool32, + pub imageless_framebuffer: Bool32, + pub uniform_buffer_standard_layout: Bool32, + pub shader_subgroup_extended_types: Bool32, + pub separate_depth_stencil_layouts: Bool32, + pub host_query_reset: Bool32, + pub timeline_semaphore: Bool32, + pub buffer_device_address: Bool32, + pub buffer_device_address_capture_replay: Bool32, + pub buffer_device_address_multi_device: Bool32, + pub vulkan_memory_model: Bool32, + pub vulkan_memory_model_device_scope: Bool32, + pub vulkan_memory_model_availability_visibility_chains: Bool32, + pub shader_output_viewport_index: Bool32, + pub shader_output_layer: Bool32, + pub subgroup_broadcast_dynamic_id: Bool32, +} +impl ::std::default::Default for PhysicalDeviceVulkan12Features { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + sampler_mirror_clamp_to_edge: Bool32::default(), + draw_indirect_count: Bool32::default(), + storage_buffer8_bit_access: Bool32::default(), + uniform_and_storage_buffer8_bit_access: Bool32::default(), + storage_push_constant8: Bool32::default(), + shader_buffer_int64_atomics: Bool32::default(), + shader_shared_int64_atomics: Bool32::default(), + shader_float16: Bool32::default(), + shader_int8: Bool32::default(), + descriptor_indexing: Bool32::default(), + shader_input_attachment_array_dynamic_indexing: Bool32::default(), + shader_uniform_texel_buffer_array_dynamic_indexing: Bool32::default(), + shader_storage_texel_buffer_array_dynamic_indexing: Bool32::default(), + shader_uniform_buffer_array_non_uniform_indexing: Bool32::default(), + shader_sampled_image_array_non_uniform_indexing: Bool32::default(), + shader_storage_buffer_array_non_uniform_indexing: Bool32::default(), + shader_storage_image_array_non_uniform_indexing: Bool32::default(), + shader_input_attachment_array_non_uniform_indexing: Bool32::default(), + shader_uniform_texel_buffer_array_non_uniform_indexing: Bool32::default(), + shader_storage_texel_buffer_array_non_uniform_indexing: Bool32::default(), + descriptor_binding_uniform_buffer_update_after_bind: Bool32::default(), + descriptor_binding_sampled_image_update_after_bind: Bool32::default(), + descriptor_binding_storage_image_update_after_bind: Bool32::default(), + descriptor_binding_storage_buffer_update_after_bind: Bool32::default(), + descriptor_binding_uniform_texel_buffer_update_after_bind: Bool32::default(), + descriptor_binding_storage_texel_buffer_update_after_bind: Bool32::default(), + descriptor_binding_update_unused_while_pending: Bool32::default(), + descriptor_binding_partially_bound: Bool32::default(), + descriptor_binding_variable_descriptor_count: Bool32::default(), + runtime_descriptor_array: Bool32::default(), + sampler_filter_minmax: Bool32::default(), + scalar_block_layout: Bool32::default(), + imageless_framebuffer: Bool32::default(), + uniform_buffer_standard_layout: Bool32::default(), + shader_subgroup_extended_types: Bool32::default(), + separate_depth_stencil_layouts: Bool32::default(), + host_query_reset: Bool32::default(), + timeline_semaphore: Bool32::default(), + buffer_device_address: Bool32::default(), + buffer_device_address_capture_replay: Bool32::default(), + buffer_device_address_multi_device: Bool32::default(), + vulkan_memory_model: Bool32::default(), + vulkan_memory_model_device_scope: Bool32::default(), + vulkan_memory_model_availability_visibility_chains: Bool32::default(), + shader_output_viewport_index: Bool32::default(), + shader_output_layer: Bool32::default(), + subgroup_broadcast_dynamic_id: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceVulkan12Features { + const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_VULKAN_1_2_FEATURES; +} +impl PhysicalDeviceVulkan12Features { + pub fn builder<'a>() -> PhysicalDeviceVulkan12FeaturesBuilder<'a> { + PhysicalDeviceVulkan12FeaturesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceVulkan12FeaturesBuilder<'a> { + inner: PhysicalDeviceVulkan12Features, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceVulkan12FeaturesBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceVulkan12Features {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVulkan12FeaturesBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVulkan12Features {} +impl<'a> ::std::ops::Deref for PhysicalDeviceVulkan12FeaturesBuilder<'a> { + type Target = PhysicalDeviceVulkan12Features; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceVulkan12FeaturesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceVulkan12FeaturesBuilder<'a> { + #[inline] + pub fn sampler_mirror_clamp_to_edge(mut self, sampler_mirror_clamp_to_edge: bool) -> Self { + self.inner.sampler_mirror_clamp_to_edge = sampler_mirror_clamp_to_edge.into(); + self + } + #[inline] + pub fn draw_indirect_count(mut self, draw_indirect_count: bool) -> Self { + self.inner.draw_indirect_count = draw_indirect_count.into(); + self + } + #[inline] + pub fn storage_buffer8_bit_access(mut self, storage_buffer8_bit_access: bool) -> Self { + self.inner.storage_buffer8_bit_access = storage_buffer8_bit_access.into(); + self + } + #[inline] + pub fn uniform_and_storage_buffer8_bit_access( + mut self, + uniform_and_storage_buffer8_bit_access: bool, + ) -> Self { + self.inner.uniform_and_storage_buffer8_bit_access = + uniform_and_storage_buffer8_bit_access.into(); + self + } + #[inline] + pub fn storage_push_constant8(mut self, storage_push_constant8: bool) -> Self { + self.inner.storage_push_constant8 = storage_push_constant8.into(); + self + } + #[inline] + pub fn shader_buffer_int64_atomics(mut self, shader_buffer_int64_atomics: bool) -> Self { + self.inner.shader_buffer_int64_atomics = shader_buffer_int64_atomics.into(); + self + } + #[inline] + pub fn shader_shared_int64_atomics(mut self, shader_shared_int64_atomics: bool) -> Self { + self.inner.shader_shared_int64_atomics = shader_shared_int64_atomics.into(); + self + } + #[inline] + pub fn shader_float16(mut self, shader_float16: bool) -> Self { + self.inner.shader_float16 = shader_float16.into(); + self + } + #[inline] + pub fn shader_int8(mut self, shader_int8: bool) -> Self { + self.inner.shader_int8 = shader_int8.into(); + self + } + #[inline] + pub fn descriptor_indexing(mut self, descriptor_indexing: bool) -> Self { + self.inner.descriptor_indexing = descriptor_indexing.into(); + self + } + #[inline] + pub fn shader_input_attachment_array_dynamic_indexing( + mut self, + shader_input_attachment_array_dynamic_indexing: bool, + ) -> Self { + self.inner.shader_input_attachment_array_dynamic_indexing = + shader_input_attachment_array_dynamic_indexing.into(); + self + } + #[inline] + pub fn shader_uniform_texel_buffer_array_dynamic_indexing( + mut self, + shader_uniform_texel_buffer_array_dynamic_indexing: bool, + ) -> Self { + self.inner + .shader_uniform_texel_buffer_array_dynamic_indexing = + shader_uniform_texel_buffer_array_dynamic_indexing.into(); + self + } + #[inline] + pub fn shader_storage_texel_buffer_array_dynamic_indexing( + mut self, + shader_storage_texel_buffer_array_dynamic_indexing: bool, + ) -> Self { + self.inner + .shader_storage_texel_buffer_array_dynamic_indexing = + shader_storage_texel_buffer_array_dynamic_indexing.into(); + self + } + #[inline] + pub fn shader_uniform_buffer_array_non_uniform_indexing( + mut self, + shader_uniform_buffer_array_non_uniform_indexing: bool, + ) -> Self { + self.inner.shader_uniform_buffer_array_non_uniform_indexing = + shader_uniform_buffer_array_non_uniform_indexing.into(); + self + } + #[inline] + pub fn shader_sampled_image_array_non_uniform_indexing( + mut self, + shader_sampled_image_array_non_uniform_indexing: bool, + ) -> Self { + self.inner.shader_sampled_image_array_non_uniform_indexing = + shader_sampled_image_array_non_uniform_indexing.into(); + self + } + #[inline] + pub fn shader_storage_buffer_array_non_uniform_indexing( + mut self, + shader_storage_buffer_array_non_uniform_indexing: bool, + ) -> Self { + self.inner.shader_storage_buffer_array_non_uniform_indexing = + shader_storage_buffer_array_non_uniform_indexing.into(); + self + } + #[inline] + pub fn shader_storage_image_array_non_uniform_indexing( + mut self, + shader_storage_image_array_non_uniform_indexing: bool, + ) -> Self { + self.inner.shader_storage_image_array_non_uniform_indexing = + shader_storage_image_array_non_uniform_indexing.into(); + self + } + #[inline] + pub fn shader_input_attachment_array_non_uniform_indexing( + mut self, + shader_input_attachment_array_non_uniform_indexing: bool, + ) -> Self { + self.inner + .shader_input_attachment_array_non_uniform_indexing = + shader_input_attachment_array_non_uniform_indexing.into(); + self + } + #[inline] + pub fn shader_uniform_texel_buffer_array_non_uniform_indexing( + mut self, + shader_uniform_texel_buffer_array_non_uniform_indexing: bool, + ) -> Self { + self.inner + .shader_uniform_texel_buffer_array_non_uniform_indexing = + shader_uniform_texel_buffer_array_non_uniform_indexing.into(); + self + } + #[inline] + pub fn shader_storage_texel_buffer_array_non_uniform_indexing( + mut self, + shader_storage_texel_buffer_array_non_uniform_indexing: bool, + ) -> Self { + self.inner + .shader_storage_texel_buffer_array_non_uniform_indexing = + shader_storage_texel_buffer_array_non_uniform_indexing.into(); + self + } + #[inline] + pub fn descriptor_binding_uniform_buffer_update_after_bind( + mut self, + descriptor_binding_uniform_buffer_update_after_bind: bool, + ) -> Self { + self.inner + .descriptor_binding_uniform_buffer_update_after_bind = + descriptor_binding_uniform_buffer_update_after_bind.into(); + self + } + #[inline] + pub fn descriptor_binding_sampled_image_update_after_bind( + mut self, + descriptor_binding_sampled_image_update_after_bind: bool, + ) -> Self { + self.inner + .descriptor_binding_sampled_image_update_after_bind = + descriptor_binding_sampled_image_update_after_bind.into(); + self + } + #[inline] + pub fn descriptor_binding_storage_image_update_after_bind( + mut self, + descriptor_binding_storage_image_update_after_bind: bool, + ) -> Self { + self.inner + .descriptor_binding_storage_image_update_after_bind = + descriptor_binding_storage_image_update_after_bind.into(); + self + } + #[inline] + pub fn descriptor_binding_storage_buffer_update_after_bind( + mut self, + descriptor_binding_storage_buffer_update_after_bind: bool, + ) -> Self { + self.inner + .descriptor_binding_storage_buffer_update_after_bind = + descriptor_binding_storage_buffer_update_after_bind.into(); + self + } + #[inline] + pub fn descriptor_binding_uniform_texel_buffer_update_after_bind( + mut self, + descriptor_binding_uniform_texel_buffer_update_after_bind: bool, + ) -> Self { + self.inner + .descriptor_binding_uniform_texel_buffer_update_after_bind = + descriptor_binding_uniform_texel_buffer_update_after_bind.into(); + self + } + #[inline] + pub fn descriptor_binding_storage_texel_buffer_update_after_bind( + mut self, + descriptor_binding_storage_texel_buffer_update_after_bind: bool, + ) -> Self { + self.inner + .descriptor_binding_storage_texel_buffer_update_after_bind = + descriptor_binding_storage_texel_buffer_update_after_bind.into(); + self + } + #[inline] + pub fn descriptor_binding_update_unused_while_pending( + mut self, + descriptor_binding_update_unused_while_pending: bool, + ) -> Self { + self.inner.descriptor_binding_update_unused_while_pending = + descriptor_binding_update_unused_while_pending.into(); + self + } + #[inline] + pub fn descriptor_binding_partially_bound( + mut self, + descriptor_binding_partially_bound: bool, + ) -> Self { + self.inner.descriptor_binding_partially_bound = descriptor_binding_partially_bound.into(); + self + } + #[inline] + pub fn descriptor_binding_variable_descriptor_count( + mut self, + descriptor_binding_variable_descriptor_count: bool, + ) -> Self { + self.inner.descriptor_binding_variable_descriptor_count = + descriptor_binding_variable_descriptor_count.into(); + self + } + #[inline] + pub fn runtime_descriptor_array(mut self, runtime_descriptor_array: bool) -> Self { + self.inner.runtime_descriptor_array = runtime_descriptor_array.into(); + self + } + #[inline] + pub fn sampler_filter_minmax(mut self, sampler_filter_minmax: bool) -> Self { + self.inner.sampler_filter_minmax = sampler_filter_minmax.into(); + self + } + #[inline] + pub fn scalar_block_layout(mut self, scalar_block_layout: bool) -> Self { + self.inner.scalar_block_layout = scalar_block_layout.into(); + self + } + #[inline] + pub fn imageless_framebuffer(mut self, imageless_framebuffer: bool) -> Self { + self.inner.imageless_framebuffer = imageless_framebuffer.into(); + self + } + #[inline] + pub fn uniform_buffer_standard_layout(mut self, uniform_buffer_standard_layout: bool) -> Self { + self.inner.uniform_buffer_standard_layout = uniform_buffer_standard_layout.into(); + self + } + #[inline] + pub fn shader_subgroup_extended_types(mut self, shader_subgroup_extended_types: bool) -> Self { + self.inner.shader_subgroup_extended_types = shader_subgroup_extended_types.into(); + self + } + #[inline] + pub fn separate_depth_stencil_layouts(mut self, separate_depth_stencil_layouts: bool) -> Self { + self.inner.separate_depth_stencil_layouts = separate_depth_stencil_layouts.into(); + self + } + #[inline] + pub fn host_query_reset(mut self, host_query_reset: bool) -> Self { + self.inner.host_query_reset = host_query_reset.into(); + self + } + #[inline] + pub fn timeline_semaphore(mut self, timeline_semaphore: bool) -> Self { + self.inner.timeline_semaphore = timeline_semaphore.into(); + self + } + #[inline] + pub fn buffer_device_address(mut self, buffer_device_address: bool) -> Self { + self.inner.buffer_device_address = buffer_device_address.into(); + self + } + #[inline] + pub fn buffer_device_address_capture_replay( + mut self, + buffer_device_address_capture_replay: bool, + ) -> Self { + self.inner.buffer_device_address_capture_replay = + buffer_device_address_capture_replay.into(); + self + } + #[inline] + pub fn buffer_device_address_multi_device( + mut self, + buffer_device_address_multi_device: bool, + ) -> Self { + self.inner.buffer_device_address_multi_device = buffer_device_address_multi_device.into(); + self + } + #[inline] + pub fn vulkan_memory_model(mut self, vulkan_memory_model: bool) -> Self { + self.inner.vulkan_memory_model = vulkan_memory_model.into(); + self + } + #[inline] + pub fn vulkan_memory_model_device_scope( + mut self, + vulkan_memory_model_device_scope: bool, + ) -> Self { + self.inner.vulkan_memory_model_device_scope = vulkan_memory_model_device_scope.into(); + self + } + #[inline] + pub fn vulkan_memory_model_availability_visibility_chains( + mut self, + vulkan_memory_model_availability_visibility_chains: bool, + ) -> Self { + self.inner + .vulkan_memory_model_availability_visibility_chains = + vulkan_memory_model_availability_visibility_chains.into(); + self + } + #[inline] + pub fn shader_output_viewport_index(mut self, shader_output_viewport_index: bool) -> Self { + self.inner.shader_output_viewport_index = shader_output_viewport_index.into(); + self + } + #[inline] + pub fn shader_output_layer(mut self, shader_output_layer: bool) -> Self { + self.inner.shader_output_layer = shader_output_layer.into(); + self + } + #[inline] + pub fn subgroup_broadcast_dynamic_id(mut self, subgroup_broadcast_dynamic_id: bool) -> Self { + self.inner.subgroup_broadcast_dynamic_id = subgroup_broadcast_dynamic_id.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceVulkan12Features { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceVulkan12Properties { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub driver_id: DriverId, + pub driver_name: [c_char; MAX_DRIVER_NAME_SIZE], + pub driver_info: [c_char; MAX_DRIVER_INFO_SIZE], + pub conformance_version: ConformanceVersion, + pub denorm_behavior_independence: ShaderFloatControlsIndependence, + pub rounding_mode_independence: ShaderFloatControlsIndependence, + pub shader_signed_zero_inf_nan_preserve_float16: Bool32, + pub shader_signed_zero_inf_nan_preserve_float32: Bool32, + pub shader_signed_zero_inf_nan_preserve_float64: Bool32, + pub shader_denorm_preserve_float16: Bool32, + pub shader_denorm_preserve_float32: Bool32, + pub shader_denorm_preserve_float64: Bool32, + pub shader_denorm_flush_to_zero_float16: Bool32, + pub shader_denorm_flush_to_zero_float32: Bool32, + pub shader_denorm_flush_to_zero_float64: Bool32, + pub shader_rounding_mode_rte_float16: Bool32, + pub shader_rounding_mode_rte_float32: Bool32, + pub shader_rounding_mode_rte_float64: Bool32, + pub shader_rounding_mode_rtz_float16: Bool32, + pub shader_rounding_mode_rtz_float32: Bool32, + pub shader_rounding_mode_rtz_float64: Bool32, + pub max_update_after_bind_descriptors_in_all_pools: u32, + pub shader_uniform_buffer_array_non_uniform_indexing_native: Bool32, + pub shader_sampled_image_array_non_uniform_indexing_native: Bool32, + pub shader_storage_buffer_array_non_uniform_indexing_native: Bool32, + pub shader_storage_image_array_non_uniform_indexing_native: Bool32, + pub shader_input_attachment_array_non_uniform_indexing_native: Bool32, + pub robust_buffer_access_update_after_bind: Bool32, + pub quad_divergent_implicit_lod: Bool32, + pub max_per_stage_descriptor_update_after_bind_samplers: u32, + pub max_per_stage_descriptor_update_after_bind_uniform_buffers: u32, + pub max_per_stage_descriptor_update_after_bind_storage_buffers: u32, + pub max_per_stage_descriptor_update_after_bind_sampled_images: u32, + pub max_per_stage_descriptor_update_after_bind_storage_images: u32, + pub max_per_stage_descriptor_update_after_bind_input_attachments: u32, + pub max_per_stage_update_after_bind_resources: u32, + pub max_descriptor_set_update_after_bind_samplers: u32, + pub max_descriptor_set_update_after_bind_uniform_buffers: u32, + pub max_descriptor_set_update_after_bind_uniform_buffers_dynamic: u32, + pub max_descriptor_set_update_after_bind_storage_buffers: u32, + pub max_descriptor_set_update_after_bind_storage_buffers_dynamic: u32, + pub max_descriptor_set_update_after_bind_sampled_images: u32, + pub max_descriptor_set_update_after_bind_storage_images: u32, + pub max_descriptor_set_update_after_bind_input_attachments: u32, + pub supported_depth_resolve_modes: ResolveModeFlags, + pub supported_stencil_resolve_modes: ResolveModeFlags, + pub independent_resolve_none: Bool32, + pub independent_resolve: Bool32, + pub filter_minmax_single_component_formats: Bool32, + pub filter_minmax_image_component_mapping: Bool32, + pub max_timeline_semaphore_value_difference: u64, + pub framebuffer_integer_color_sample_counts: SampleCountFlags, +} +#[cfg(feature = "debug")] +impl fmt::Debug for PhysicalDeviceVulkan12Properties { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fmt.debug_struct("PhysicalDeviceVulkan12Properties") + .field("s_type", &self.s_type) + .field("p_next", &self.p_next) + .field("driver_id", &self.driver_id) + .field("driver_name", &unsafe { + ::std::ffi::CStr::from_ptr(self.driver_name.as_ptr()) + }) + .field("driver_info", &unsafe { + ::std::ffi::CStr::from_ptr(self.driver_info.as_ptr()) + }) + .field("conformance_version", &self.conformance_version) + .field( + "denorm_behavior_independence", + &self.denorm_behavior_independence, + ) + .field( + "rounding_mode_independence", + &self.rounding_mode_independence, + ) + .field( + "shader_signed_zero_inf_nan_preserve_float16", + &self.shader_signed_zero_inf_nan_preserve_float16, + ) + .field( + "shader_signed_zero_inf_nan_preserve_float32", + &self.shader_signed_zero_inf_nan_preserve_float32, + ) + .field( + "shader_signed_zero_inf_nan_preserve_float64", + &self.shader_signed_zero_inf_nan_preserve_float64, + ) + .field( + "shader_denorm_preserve_float16", + &self.shader_denorm_preserve_float16, + ) + .field( + "shader_denorm_preserve_float32", + &self.shader_denorm_preserve_float32, + ) + .field( + "shader_denorm_preserve_float64", + &self.shader_denorm_preserve_float64, + ) + .field( + "shader_denorm_flush_to_zero_float16", + &self.shader_denorm_flush_to_zero_float16, + ) + .field( + "shader_denorm_flush_to_zero_float32", + &self.shader_denorm_flush_to_zero_float32, + ) + .field( + "shader_denorm_flush_to_zero_float64", + &self.shader_denorm_flush_to_zero_float64, + ) + .field( + "shader_rounding_mode_rte_float16", + &self.shader_rounding_mode_rte_float16, + ) + .field( + "shader_rounding_mode_rte_float32", + &self.shader_rounding_mode_rte_float32, + ) + .field( + "shader_rounding_mode_rte_float64", + &self.shader_rounding_mode_rte_float64, + ) + .field( + "shader_rounding_mode_rtz_float16", + &self.shader_rounding_mode_rtz_float16, + ) + .field( + "shader_rounding_mode_rtz_float32", + &self.shader_rounding_mode_rtz_float32, + ) + .field( + "shader_rounding_mode_rtz_float64", + &self.shader_rounding_mode_rtz_float64, + ) + .field( + "max_update_after_bind_descriptors_in_all_pools", + &self.max_update_after_bind_descriptors_in_all_pools, + ) + .field( + "shader_uniform_buffer_array_non_uniform_indexing_native", + &self.shader_uniform_buffer_array_non_uniform_indexing_native, + ) + .field( + "shader_sampled_image_array_non_uniform_indexing_native", + &self.shader_sampled_image_array_non_uniform_indexing_native, + ) + .field( + "shader_storage_buffer_array_non_uniform_indexing_native", + &self.shader_storage_buffer_array_non_uniform_indexing_native, + ) + .field( + "shader_storage_image_array_non_uniform_indexing_native", + &self.shader_storage_image_array_non_uniform_indexing_native, + ) + .field( + "shader_input_attachment_array_non_uniform_indexing_native", + &self.shader_input_attachment_array_non_uniform_indexing_native, + ) + .field( + "robust_buffer_access_update_after_bind", + &self.robust_buffer_access_update_after_bind, + ) + .field( + "quad_divergent_implicit_lod", + &self.quad_divergent_implicit_lod, + ) + .field( + "max_per_stage_descriptor_update_after_bind_samplers", + &self.max_per_stage_descriptor_update_after_bind_samplers, + ) + .field( + "max_per_stage_descriptor_update_after_bind_uniform_buffers", + &self.max_per_stage_descriptor_update_after_bind_uniform_buffers, + ) + .field( + "max_per_stage_descriptor_update_after_bind_storage_buffers", + &self.max_per_stage_descriptor_update_after_bind_storage_buffers, + ) + .field( + "max_per_stage_descriptor_update_after_bind_sampled_images", + &self.max_per_stage_descriptor_update_after_bind_sampled_images, + ) + .field( + "max_per_stage_descriptor_update_after_bind_storage_images", + &self.max_per_stage_descriptor_update_after_bind_storage_images, + ) + .field( + "max_per_stage_descriptor_update_after_bind_input_attachments", + &self.max_per_stage_descriptor_update_after_bind_input_attachments, + ) + .field( + "max_per_stage_update_after_bind_resources", + &self.max_per_stage_update_after_bind_resources, + ) + .field( + "max_descriptor_set_update_after_bind_samplers", + &self.max_descriptor_set_update_after_bind_samplers, + ) + .field( + "max_descriptor_set_update_after_bind_uniform_buffers", + &self.max_descriptor_set_update_after_bind_uniform_buffers, + ) + .field( + "max_descriptor_set_update_after_bind_uniform_buffers_dynamic", + &self.max_descriptor_set_update_after_bind_uniform_buffers_dynamic, + ) + .field( + "max_descriptor_set_update_after_bind_storage_buffers", + &self.max_descriptor_set_update_after_bind_storage_buffers, + ) + .field( + "max_descriptor_set_update_after_bind_storage_buffers_dynamic", + &self.max_descriptor_set_update_after_bind_storage_buffers_dynamic, + ) + .field( + "max_descriptor_set_update_after_bind_sampled_images", + &self.max_descriptor_set_update_after_bind_sampled_images, + ) + .field( + "max_descriptor_set_update_after_bind_storage_images", + &self.max_descriptor_set_update_after_bind_storage_images, + ) + .field( + "max_descriptor_set_update_after_bind_input_attachments", + &self.max_descriptor_set_update_after_bind_input_attachments, + ) + .field( + "supported_depth_resolve_modes", + &self.supported_depth_resolve_modes, + ) + .field( + "supported_stencil_resolve_modes", + &self.supported_stencil_resolve_modes, + ) + .field("independent_resolve_none", &self.independent_resolve_none) + .field("independent_resolve", &self.independent_resolve) + .field( + "filter_minmax_single_component_formats", + &self.filter_minmax_single_component_formats, + ) + .field( + "filter_minmax_image_component_mapping", + &self.filter_minmax_image_component_mapping, + ) + .field( + "max_timeline_semaphore_value_difference", + &self.max_timeline_semaphore_value_difference, + ) + .field( + "framebuffer_integer_color_sample_counts", + &self.framebuffer_integer_color_sample_counts, + ) + .finish() + } +} +impl ::std::default::Default for PhysicalDeviceVulkan12Properties { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + driver_id: DriverId::default(), + driver_name: unsafe { ::std::mem::zeroed() }, + driver_info: unsafe { ::std::mem::zeroed() }, + conformance_version: ConformanceVersion::default(), + denorm_behavior_independence: ShaderFloatControlsIndependence::default(), + rounding_mode_independence: ShaderFloatControlsIndependence::default(), + shader_signed_zero_inf_nan_preserve_float16: Bool32::default(), + shader_signed_zero_inf_nan_preserve_float32: Bool32::default(), + shader_signed_zero_inf_nan_preserve_float64: Bool32::default(), + shader_denorm_preserve_float16: Bool32::default(), + shader_denorm_preserve_float32: Bool32::default(), + shader_denorm_preserve_float64: Bool32::default(), + shader_denorm_flush_to_zero_float16: Bool32::default(), + shader_denorm_flush_to_zero_float32: Bool32::default(), + shader_denorm_flush_to_zero_float64: Bool32::default(), + shader_rounding_mode_rte_float16: Bool32::default(), + shader_rounding_mode_rte_float32: Bool32::default(), + shader_rounding_mode_rte_float64: Bool32::default(), + shader_rounding_mode_rtz_float16: Bool32::default(), + shader_rounding_mode_rtz_float32: Bool32::default(), + shader_rounding_mode_rtz_float64: Bool32::default(), + max_update_after_bind_descriptors_in_all_pools: u32::default(), + shader_uniform_buffer_array_non_uniform_indexing_native: Bool32::default(), + shader_sampled_image_array_non_uniform_indexing_native: Bool32::default(), + shader_storage_buffer_array_non_uniform_indexing_native: Bool32::default(), + shader_storage_image_array_non_uniform_indexing_native: Bool32::default(), + shader_input_attachment_array_non_uniform_indexing_native: Bool32::default(), + robust_buffer_access_update_after_bind: Bool32::default(), + quad_divergent_implicit_lod: Bool32::default(), + max_per_stage_descriptor_update_after_bind_samplers: u32::default(), + max_per_stage_descriptor_update_after_bind_uniform_buffers: u32::default(), + max_per_stage_descriptor_update_after_bind_storage_buffers: u32::default(), + max_per_stage_descriptor_update_after_bind_sampled_images: u32::default(), + max_per_stage_descriptor_update_after_bind_storage_images: u32::default(), + max_per_stage_descriptor_update_after_bind_input_attachments: u32::default(), + max_per_stage_update_after_bind_resources: u32::default(), + max_descriptor_set_update_after_bind_samplers: u32::default(), + max_descriptor_set_update_after_bind_uniform_buffers: u32::default(), + max_descriptor_set_update_after_bind_uniform_buffers_dynamic: u32::default(), + max_descriptor_set_update_after_bind_storage_buffers: u32::default(), + max_descriptor_set_update_after_bind_storage_buffers_dynamic: u32::default(), + max_descriptor_set_update_after_bind_sampled_images: u32::default(), + max_descriptor_set_update_after_bind_storage_images: u32::default(), + max_descriptor_set_update_after_bind_input_attachments: u32::default(), + supported_depth_resolve_modes: ResolveModeFlags::default(), + supported_stencil_resolve_modes: ResolveModeFlags::default(), + independent_resolve_none: Bool32::default(), + independent_resolve: Bool32::default(), + filter_minmax_single_component_formats: Bool32::default(), + filter_minmax_image_component_mapping: Bool32::default(), + max_timeline_semaphore_value_difference: u64::default(), + framebuffer_integer_color_sample_counts: SampleCountFlags::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceVulkan12Properties { + const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES; +} +impl PhysicalDeviceVulkan12Properties { + pub fn builder<'a>() -> PhysicalDeviceVulkan12PropertiesBuilder<'a> { + PhysicalDeviceVulkan12PropertiesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceVulkan12PropertiesBuilder<'a> { + inner: PhysicalDeviceVulkan12Properties, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceVulkan12PropertiesBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceVulkan12Properties {} +impl<'a> ::std::ops::Deref for PhysicalDeviceVulkan12PropertiesBuilder<'a> { + type Target = PhysicalDeviceVulkan12Properties; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceVulkan12PropertiesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceVulkan12PropertiesBuilder<'a> { + #[inline] + pub fn driver_id(mut self, driver_id: DriverId) -> Self { + self.inner.driver_id = driver_id; + self + } + #[inline] + pub fn driver_name(mut self, driver_name: [c_char; MAX_DRIVER_NAME_SIZE]) -> Self { + self.inner.driver_name = driver_name; + self + } + #[inline] + pub fn driver_info(mut self, driver_info: [c_char; MAX_DRIVER_INFO_SIZE]) -> Self { + self.inner.driver_info = driver_info; + self + } + #[inline] + pub fn conformance_version(mut self, conformance_version: ConformanceVersion) -> Self { + self.inner.conformance_version = conformance_version; + self + } + #[inline] + pub fn denorm_behavior_independence( + mut self, + denorm_behavior_independence: ShaderFloatControlsIndependence, + ) -> Self { + self.inner.denorm_behavior_independence = denorm_behavior_independence; + self + } + #[inline] + pub fn rounding_mode_independence( + mut self, + rounding_mode_independence: ShaderFloatControlsIndependence, + ) -> Self { + self.inner.rounding_mode_independence = rounding_mode_independence; + self + } + #[inline] + pub fn shader_signed_zero_inf_nan_preserve_float16( + mut self, + shader_signed_zero_inf_nan_preserve_float16: bool, + ) -> Self { + self.inner.shader_signed_zero_inf_nan_preserve_float16 = + shader_signed_zero_inf_nan_preserve_float16.into(); + self + } + #[inline] + pub fn shader_signed_zero_inf_nan_preserve_float32( + mut self, + shader_signed_zero_inf_nan_preserve_float32: bool, + ) -> Self { + self.inner.shader_signed_zero_inf_nan_preserve_float32 = + shader_signed_zero_inf_nan_preserve_float32.into(); + self + } + #[inline] + pub fn shader_signed_zero_inf_nan_preserve_float64( + mut self, + shader_signed_zero_inf_nan_preserve_float64: bool, + ) -> Self { + self.inner.shader_signed_zero_inf_nan_preserve_float64 = + shader_signed_zero_inf_nan_preserve_float64.into(); + self + } + #[inline] + pub fn shader_denorm_preserve_float16(mut self, shader_denorm_preserve_float16: bool) -> Self { + self.inner.shader_denorm_preserve_float16 = shader_denorm_preserve_float16.into(); + self + } + #[inline] + pub fn shader_denorm_preserve_float32(mut self, shader_denorm_preserve_float32: bool) -> Self { + self.inner.shader_denorm_preserve_float32 = shader_denorm_preserve_float32.into(); + self + } + #[inline] + pub fn shader_denorm_preserve_float64(mut self, shader_denorm_preserve_float64: bool) -> Self { + self.inner.shader_denorm_preserve_float64 = shader_denorm_preserve_float64.into(); + self + } + #[inline] + pub fn shader_denorm_flush_to_zero_float16( + mut self, + shader_denorm_flush_to_zero_float16: bool, + ) -> Self { + self.inner.shader_denorm_flush_to_zero_float16 = shader_denorm_flush_to_zero_float16.into(); + self + } + #[inline] + pub fn shader_denorm_flush_to_zero_float32( + mut self, + shader_denorm_flush_to_zero_float32: bool, + ) -> Self { + self.inner.shader_denorm_flush_to_zero_float32 = shader_denorm_flush_to_zero_float32.into(); + self + } + #[inline] + pub fn shader_denorm_flush_to_zero_float64( + mut self, + shader_denorm_flush_to_zero_float64: bool, + ) -> Self { + self.inner.shader_denorm_flush_to_zero_float64 = shader_denorm_flush_to_zero_float64.into(); + self + } + #[inline] + pub fn shader_rounding_mode_rte_float16( + mut self, + shader_rounding_mode_rte_float16: bool, + ) -> Self { + self.inner.shader_rounding_mode_rte_float16 = shader_rounding_mode_rte_float16.into(); + self + } + #[inline] + pub fn shader_rounding_mode_rte_float32( + mut self, + shader_rounding_mode_rte_float32: bool, + ) -> Self { + self.inner.shader_rounding_mode_rte_float32 = shader_rounding_mode_rte_float32.into(); + self + } + #[inline] + pub fn shader_rounding_mode_rte_float64( + mut self, + shader_rounding_mode_rte_float64: bool, + ) -> Self { + self.inner.shader_rounding_mode_rte_float64 = shader_rounding_mode_rte_float64.into(); + self + } + #[inline] + pub fn shader_rounding_mode_rtz_float16( + mut self, + shader_rounding_mode_rtz_float16: bool, + ) -> Self { + self.inner.shader_rounding_mode_rtz_float16 = shader_rounding_mode_rtz_float16.into(); + self + } + #[inline] + pub fn shader_rounding_mode_rtz_float32( + mut self, + shader_rounding_mode_rtz_float32: bool, + ) -> Self { + self.inner.shader_rounding_mode_rtz_float32 = shader_rounding_mode_rtz_float32.into(); + self + } + #[inline] + pub fn shader_rounding_mode_rtz_float64( + mut self, + shader_rounding_mode_rtz_float64: bool, + ) -> Self { + self.inner.shader_rounding_mode_rtz_float64 = shader_rounding_mode_rtz_float64.into(); + self + } + #[inline] + pub fn max_update_after_bind_descriptors_in_all_pools( + mut self, + max_update_after_bind_descriptors_in_all_pools: u32, + ) -> Self { + self.inner.max_update_after_bind_descriptors_in_all_pools = + max_update_after_bind_descriptors_in_all_pools; + self + } + #[inline] + pub fn shader_uniform_buffer_array_non_uniform_indexing_native( + mut self, + shader_uniform_buffer_array_non_uniform_indexing_native: bool, + ) -> Self { + self.inner + .shader_uniform_buffer_array_non_uniform_indexing_native = + shader_uniform_buffer_array_non_uniform_indexing_native.into(); + self + } + #[inline] + pub fn shader_sampled_image_array_non_uniform_indexing_native( + mut self, + shader_sampled_image_array_non_uniform_indexing_native: bool, + ) -> Self { + self.inner + .shader_sampled_image_array_non_uniform_indexing_native = + shader_sampled_image_array_non_uniform_indexing_native.into(); + self + } + #[inline] + pub fn shader_storage_buffer_array_non_uniform_indexing_native( + mut self, + shader_storage_buffer_array_non_uniform_indexing_native: bool, + ) -> Self { + self.inner + .shader_storage_buffer_array_non_uniform_indexing_native = + shader_storage_buffer_array_non_uniform_indexing_native.into(); + self + } + #[inline] + pub fn shader_storage_image_array_non_uniform_indexing_native( + mut self, + shader_storage_image_array_non_uniform_indexing_native: bool, + ) -> Self { + self.inner + .shader_storage_image_array_non_uniform_indexing_native = + shader_storage_image_array_non_uniform_indexing_native.into(); + self + } + #[inline] + pub fn shader_input_attachment_array_non_uniform_indexing_native( + mut self, + shader_input_attachment_array_non_uniform_indexing_native: bool, + ) -> Self { + self.inner + .shader_input_attachment_array_non_uniform_indexing_native = + shader_input_attachment_array_non_uniform_indexing_native.into(); + self + } + #[inline] + pub fn robust_buffer_access_update_after_bind( + mut self, + robust_buffer_access_update_after_bind: bool, + ) -> Self { + self.inner.robust_buffer_access_update_after_bind = + robust_buffer_access_update_after_bind.into(); + self + } + #[inline] + pub fn quad_divergent_implicit_lod(mut self, quad_divergent_implicit_lod: bool) -> Self { + self.inner.quad_divergent_implicit_lod = quad_divergent_implicit_lod.into(); + self + } + #[inline] + pub fn max_per_stage_descriptor_update_after_bind_samplers( + mut self, + max_per_stage_descriptor_update_after_bind_samplers: u32, + ) -> Self { + self.inner + .max_per_stage_descriptor_update_after_bind_samplers = + max_per_stage_descriptor_update_after_bind_samplers; + self + } + #[inline] + pub fn max_per_stage_descriptor_update_after_bind_uniform_buffers( + mut self, + max_per_stage_descriptor_update_after_bind_uniform_buffers: u32, + ) -> Self { + self.inner + .max_per_stage_descriptor_update_after_bind_uniform_buffers = + max_per_stage_descriptor_update_after_bind_uniform_buffers; + self + } + #[inline] + pub fn max_per_stage_descriptor_update_after_bind_storage_buffers( + mut self, + max_per_stage_descriptor_update_after_bind_storage_buffers: u32, + ) -> Self { + self.inner + .max_per_stage_descriptor_update_after_bind_storage_buffers = + max_per_stage_descriptor_update_after_bind_storage_buffers; + self + } + #[inline] + pub fn max_per_stage_descriptor_update_after_bind_sampled_images( + mut self, + max_per_stage_descriptor_update_after_bind_sampled_images: u32, + ) -> Self { + self.inner + .max_per_stage_descriptor_update_after_bind_sampled_images = + max_per_stage_descriptor_update_after_bind_sampled_images; + self + } + #[inline] + pub fn max_per_stage_descriptor_update_after_bind_storage_images( + mut self, + max_per_stage_descriptor_update_after_bind_storage_images: u32, + ) -> Self { + self.inner + .max_per_stage_descriptor_update_after_bind_storage_images = + max_per_stage_descriptor_update_after_bind_storage_images; + self + } + #[inline] + pub fn max_per_stage_descriptor_update_after_bind_input_attachments( + mut self, + max_per_stage_descriptor_update_after_bind_input_attachments: u32, + ) -> Self { + self.inner + .max_per_stage_descriptor_update_after_bind_input_attachments = + max_per_stage_descriptor_update_after_bind_input_attachments; + self + } + #[inline] + pub fn max_per_stage_update_after_bind_resources( + mut self, + max_per_stage_update_after_bind_resources: u32, + ) -> Self { + self.inner.max_per_stage_update_after_bind_resources = + max_per_stage_update_after_bind_resources; + self + } + #[inline] + pub fn max_descriptor_set_update_after_bind_samplers( + mut self, + max_descriptor_set_update_after_bind_samplers: u32, + ) -> Self { + self.inner.max_descriptor_set_update_after_bind_samplers = + max_descriptor_set_update_after_bind_samplers; + self + } + #[inline] + pub fn max_descriptor_set_update_after_bind_uniform_buffers( + mut self, + max_descriptor_set_update_after_bind_uniform_buffers: u32, + ) -> Self { + self.inner + .max_descriptor_set_update_after_bind_uniform_buffers = + max_descriptor_set_update_after_bind_uniform_buffers; + self + } + #[inline] + pub fn max_descriptor_set_update_after_bind_uniform_buffers_dynamic( + mut self, + max_descriptor_set_update_after_bind_uniform_buffers_dynamic: u32, + ) -> Self { + self.inner + .max_descriptor_set_update_after_bind_uniform_buffers_dynamic = + max_descriptor_set_update_after_bind_uniform_buffers_dynamic; + self + } + #[inline] + pub fn max_descriptor_set_update_after_bind_storage_buffers( + mut self, + max_descriptor_set_update_after_bind_storage_buffers: u32, + ) -> Self { + self.inner + .max_descriptor_set_update_after_bind_storage_buffers = + max_descriptor_set_update_after_bind_storage_buffers; + self + } + #[inline] + pub fn max_descriptor_set_update_after_bind_storage_buffers_dynamic( + mut self, + max_descriptor_set_update_after_bind_storage_buffers_dynamic: u32, + ) -> Self { + self.inner + .max_descriptor_set_update_after_bind_storage_buffers_dynamic = + max_descriptor_set_update_after_bind_storage_buffers_dynamic; + self + } + #[inline] + pub fn max_descriptor_set_update_after_bind_sampled_images( + mut self, + max_descriptor_set_update_after_bind_sampled_images: u32, + ) -> Self { + self.inner + .max_descriptor_set_update_after_bind_sampled_images = + max_descriptor_set_update_after_bind_sampled_images; + self + } + #[inline] + pub fn max_descriptor_set_update_after_bind_storage_images( + mut self, + max_descriptor_set_update_after_bind_storage_images: u32, + ) -> Self { + self.inner + .max_descriptor_set_update_after_bind_storage_images = + max_descriptor_set_update_after_bind_storage_images; + self + } + #[inline] + pub fn max_descriptor_set_update_after_bind_input_attachments( + mut self, + max_descriptor_set_update_after_bind_input_attachments: u32, + ) -> Self { + self.inner + .max_descriptor_set_update_after_bind_input_attachments = + max_descriptor_set_update_after_bind_input_attachments; + self + } + #[inline] + pub fn supported_depth_resolve_modes( + mut self, + supported_depth_resolve_modes: ResolveModeFlags, + ) -> Self { + self.inner.supported_depth_resolve_modes = supported_depth_resolve_modes; + self + } + #[inline] + pub fn supported_stencil_resolve_modes( + mut self, + supported_stencil_resolve_modes: ResolveModeFlags, + ) -> Self { + self.inner.supported_stencil_resolve_modes = supported_stencil_resolve_modes; + self + } + #[inline] + pub fn independent_resolve_none(mut self, independent_resolve_none: bool) -> Self { + self.inner.independent_resolve_none = independent_resolve_none.into(); + self + } + #[inline] + pub fn independent_resolve(mut self, independent_resolve: bool) -> Self { + self.inner.independent_resolve = independent_resolve.into(); + self + } + #[inline] + pub fn filter_minmax_single_component_formats( + mut self, + filter_minmax_single_component_formats: bool, + ) -> Self { + self.inner.filter_minmax_single_component_formats = + filter_minmax_single_component_formats.into(); + self + } + #[inline] + pub fn filter_minmax_image_component_mapping( + mut self, + filter_minmax_image_component_mapping: bool, + ) -> Self { + self.inner.filter_minmax_image_component_mapping = + filter_minmax_image_component_mapping.into(); + self + } + #[inline] + pub fn max_timeline_semaphore_value_difference( + mut self, + max_timeline_semaphore_value_difference: u64, + ) -> Self { + self.inner.max_timeline_semaphore_value_difference = + max_timeline_semaphore_value_difference; + self + } + #[inline] + pub fn framebuffer_integer_color_sample_counts( + mut self, + framebuffer_integer_color_sample_counts: SampleCountFlags, + ) -> Self { + self.inner.framebuffer_integer_color_sample_counts = + framebuffer_integer_color_sample_counts; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceVulkan12Properties { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceVulkan13Features { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub robust_image_access: Bool32, + pub inline_uniform_block: Bool32, + pub descriptor_binding_inline_uniform_block_update_after_bind: Bool32, + pub pipeline_creation_cache_control: Bool32, + pub private_data: Bool32, + pub shader_demote_to_helper_invocation: Bool32, + pub shader_terminate_invocation: Bool32, + pub subgroup_size_control: Bool32, + pub compute_full_subgroups: Bool32, + pub synchronization2: Bool32, + pub texture_compression_astc_hdr: Bool32, + pub shader_zero_initialize_workgroup_memory: Bool32, + pub dynamic_rendering: Bool32, + pub shader_integer_dot_product: Bool32, + pub maintenance4: Bool32, +} +impl ::std::default::Default for PhysicalDeviceVulkan13Features { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + robust_image_access: Bool32::default(), + inline_uniform_block: Bool32::default(), + descriptor_binding_inline_uniform_block_update_after_bind: Bool32::default(), + pipeline_creation_cache_control: Bool32::default(), + private_data: Bool32::default(), + shader_demote_to_helper_invocation: Bool32::default(), + shader_terminate_invocation: Bool32::default(), + subgroup_size_control: Bool32::default(), + compute_full_subgroups: Bool32::default(), + synchronization2: Bool32::default(), + texture_compression_astc_hdr: Bool32::default(), + shader_zero_initialize_workgroup_memory: Bool32::default(), + dynamic_rendering: Bool32::default(), + shader_integer_dot_product: Bool32::default(), + maintenance4: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceVulkan13Features { + const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_VULKAN_1_3_FEATURES; +} +impl PhysicalDeviceVulkan13Features { + pub fn builder<'a>() -> PhysicalDeviceVulkan13FeaturesBuilder<'a> { + PhysicalDeviceVulkan13FeaturesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceVulkan13FeaturesBuilder<'a> { + inner: PhysicalDeviceVulkan13Features, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceVulkan13FeaturesBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceVulkan13Features {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVulkan13FeaturesBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVulkan13Features {} +impl<'a> ::std::ops::Deref for PhysicalDeviceVulkan13FeaturesBuilder<'a> { + type Target = PhysicalDeviceVulkan13Features; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceVulkan13FeaturesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceVulkan13FeaturesBuilder<'a> { + #[inline] + pub fn robust_image_access(mut self, robust_image_access: bool) -> Self { + self.inner.robust_image_access = robust_image_access.into(); + self + } + #[inline] + pub fn inline_uniform_block(mut self, inline_uniform_block: bool) -> Self { + self.inner.inline_uniform_block = inline_uniform_block.into(); + self + } + #[inline] + pub fn descriptor_binding_inline_uniform_block_update_after_bind( + mut self, + descriptor_binding_inline_uniform_block_update_after_bind: bool, + ) -> Self { + self.inner + .descriptor_binding_inline_uniform_block_update_after_bind = + descriptor_binding_inline_uniform_block_update_after_bind.into(); + self + } + #[inline] + pub fn pipeline_creation_cache_control( + mut self, + pipeline_creation_cache_control: bool, + ) -> Self { + self.inner.pipeline_creation_cache_control = pipeline_creation_cache_control.into(); + self + } + #[inline] + pub fn private_data(mut self, private_data: bool) -> Self { + self.inner.private_data = private_data.into(); + self + } + #[inline] + pub fn shader_demote_to_helper_invocation( + mut self, + shader_demote_to_helper_invocation: bool, + ) -> Self { + self.inner.shader_demote_to_helper_invocation = shader_demote_to_helper_invocation.into(); + self + } + #[inline] + pub fn shader_terminate_invocation(mut self, shader_terminate_invocation: bool) -> Self { + self.inner.shader_terminate_invocation = shader_terminate_invocation.into(); + self + } + #[inline] + pub fn subgroup_size_control(mut self, subgroup_size_control: bool) -> Self { + self.inner.subgroup_size_control = subgroup_size_control.into(); + self + } + #[inline] + pub fn compute_full_subgroups(mut self, compute_full_subgroups: bool) -> Self { + self.inner.compute_full_subgroups = compute_full_subgroups.into(); + self + } + #[inline] + pub fn synchronization2(mut self, synchronization2: bool) -> Self { + self.inner.synchronization2 = synchronization2.into(); + self + } + #[inline] + pub fn texture_compression_astc_hdr(mut self, texture_compression_astc_hdr: bool) -> Self { + self.inner.texture_compression_astc_hdr = texture_compression_astc_hdr.into(); + self + } + #[inline] + pub fn shader_zero_initialize_workgroup_memory( + mut self, + shader_zero_initialize_workgroup_memory: bool, + ) -> Self { + self.inner.shader_zero_initialize_workgroup_memory = + shader_zero_initialize_workgroup_memory.into(); + self + } + #[inline] + pub fn dynamic_rendering(mut self, dynamic_rendering: bool) -> Self { + self.inner.dynamic_rendering = dynamic_rendering.into(); + self + } + #[inline] + pub fn shader_integer_dot_product(mut self, shader_integer_dot_product: bool) -> Self { + self.inner.shader_integer_dot_product = shader_integer_dot_product.into(); + self + } + #[inline] + pub fn maintenance4(mut self, maintenance4: bool) -> Self { + self.inner.maintenance4 = maintenance4.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceVulkan13Features { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceVulkan13Properties { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub min_subgroup_size: u32, + pub max_subgroup_size: u32, + pub max_compute_workgroup_subgroups: u32, + pub required_subgroup_size_stages: ShaderStageFlags, + pub max_inline_uniform_block_size: u32, + pub max_per_stage_descriptor_inline_uniform_blocks: u32, + pub max_per_stage_descriptor_update_after_bind_inline_uniform_blocks: u32, + pub max_descriptor_set_inline_uniform_blocks: u32, + pub max_descriptor_set_update_after_bind_inline_uniform_blocks: u32, + pub max_inline_uniform_total_size: u32, + pub integer_dot_product8_bit_unsigned_accelerated: Bool32, + pub integer_dot_product8_bit_signed_accelerated: Bool32, + pub integer_dot_product8_bit_mixed_signedness_accelerated: Bool32, + pub integer_dot_product4x8_bit_packed_unsigned_accelerated: Bool32, + pub integer_dot_product4x8_bit_packed_signed_accelerated: Bool32, + pub integer_dot_product4x8_bit_packed_mixed_signedness_accelerated: Bool32, + pub integer_dot_product16_bit_unsigned_accelerated: Bool32, + pub integer_dot_product16_bit_signed_accelerated: Bool32, + pub integer_dot_product16_bit_mixed_signedness_accelerated: Bool32, + pub integer_dot_product32_bit_unsigned_accelerated: Bool32, + pub integer_dot_product32_bit_signed_accelerated: Bool32, + pub integer_dot_product32_bit_mixed_signedness_accelerated: Bool32, + pub integer_dot_product64_bit_unsigned_accelerated: Bool32, + pub integer_dot_product64_bit_signed_accelerated: Bool32, + pub integer_dot_product64_bit_mixed_signedness_accelerated: Bool32, + pub integer_dot_product_accumulating_saturating8_bit_unsigned_accelerated: Bool32, + pub integer_dot_product_accumulating_saturating8_bit_signed_accelerated: Bool32, + pub integer_dot_product_accumulating_saturating8_bit_mixed_signedness_accelerated: Bool32, + pub integer_dot_product_accumulating_saturating4x8_bit_packed_unsigned_accelerated: Bool32, + pub integer_dot_product_accumulating_saturating4x8_bit_packed_signed_accelerated: Bool32, + pub integer_dot_product_accumulating_saturating4x8_bit_packed_mixed_signedness_accelerated: + Bool32, + pub integer_dot_product_accumulating_saturating16_bit_unsigned_accelerated: Bool32, + pub integer_dot_product_accumulating_saturating16_bit_signed_accelerated: Bool32, + pub integer_dot_product_accumulating_saturating16_bit_mixed_signedness_accelerated: Bool32, + pub integer_dot_product_accumulating_saturating32_bit_unsigned_accelerated: Bool32, + pub integer_dot_product_accumulating_saturating32_bit_signed_accelerated: Bool32, + pub integer_dot_product_accumulating_saturating32_bit_mixed_signedness_accelerated: Bool32, + pub integer_dot_product_accumulating_saturating64_bit_unsigned_accelerated: Bool32, + pub integer_dot_product_accumulating_saturating64_bit_signed_accelerated: Bool32, + pub integer_dot_product_accumulating_saturating64_bit_mixed_signedness_accelerated: Bool32, + pub storage_texel_buffer_offset_alignment_bytes: DeviceSize, + pub storage_texel_buffer_offset_single_texel_alignment: Bool32, + pub uniform_texel_buffer_offset_alignment_bytes: DeviceSize, + pub uniform_texel_buffer_offset_single_texel_alignment: Bool32, + pub max_buffer_size: DeviceSize, +} +impl ::std::default::Default for PhysicalDeviceVulkan13Properties { + #[inline] + fn default() -> Self { + Self { s_type : Self :: STRUCTURE_TYPE , p_next : :: std :: ptr :: null_mut () , min_subgroup_size : u32 :: default () , max_subgroup_size : u32 :: default () , max_compute_workgroup_subgroups : u32 :: default () , required_subgroup_size_stages : ShaderStageFlags :: default () , max_inline_uniform_block_size : u32 :: default () , max_per_stage_descriptor_inline_uniform_blocks : u32 :: default () , max_per_stage_descriptor_update_after_bind_inline_uniform_blocks : u32 :: default () , max_descriptor_set_inline_uniform_blocks : u32 :: default () , max_descriptor_set_update_after_bind_inline_uniform_blocks : u32 :: default () , max_inline_uniform_total_size : u32 :: default () , integer_dot_product8_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product8_bit_signed_accelerated : Bool32 :: default () , integer_dot_product8_bit_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product4x8_bit_packed_unsigned_accelerated : Bool32 :: default () , integer_dot_product4x8_bit_packed_signed_accelerated : Bool32 :: default () , integer_dot_product4x8_bit_packed_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product16_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product16_bit_signed_accelerated : Bool32 :: default () , integer_dot_product16_bit_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product32_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product32_bit_signed_accelerated : Bool32 :: default () , integer_dot_product32_bit_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product64_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product64_bit_signed_accelerated : Bool32 :: default () , integer_dot_product64_bit_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating8_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating8_bit_signed_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating8_bit_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating4x8_bit_packed_unsigned_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating4x8_bit_packed_signed_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating4x8_bit_packed_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating16_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating16_bit_signed_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating16_bit_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating32_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating32_bit_signed_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating32_bit_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating64_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating64_bit_signed_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating64_bit_mixed_signedness_accelerated : Bool32 :: default () , storage_texel_buffer_offset_alignment_bytes : DeviceSize :: default () , storage_texel_buffer_offset_single_texel_alignment : Bool32 :: default () , uniform_texel_buffer_offset_alignment_bytes : DeviceSize :: default () , uniform_texel_buffer_offset_single_texel_alignment : Bool32 :: default () , max_buffer_size : DeviceSize :: default () } + } +} +unsafe impl TaggedStructure for PhysicalDeviceVulkan13Properties { + const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES; +} +impl PhysicalDeviceVulkan13Properties { + pub fn builder<'a>() -> PhysicalDeviceVulkan13PropertiesBuilder<'a> { + PhysicalDeviceVulkan13PropertiesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceVulkan13PropertiesBuilder<'a> { + inner: PhysicalDeviceVulkan13Properties, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceVulkan13PropertiesBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceVulkan13Properties {} +impl<'a> ::std::ops::Deref for PhysicalDeviceVulkan13PropertiesBuilder<'a> { + type Target = PhysicalDeviceVulkan13Properties; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceVulkan13PropertiesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceVulkan13PropertiesBuilder<'a> { + #[inline] + pub fn min_subgroup_size(mut self, min_subgroup_size: u32) -> Self { + self.inner.min_subgroup_size = min_subgroup_size; + self + } + #[inline] + pub fn max_subgroup_size(mut self, max_subgroup_size: u32) -> Self { + self.inner.max_subgroup_size = max_subgroup_size; + self + } + #[inline] + pub fn max_compute_workgroup_subgroups(mut self, max_compute_workgroup_subgroups: u32) -> Self { + self.inner.max_compute_workgroup_subgroups = max_compute_workgroup_subgroups; + self + } + #[inline] + pub fn required_subgroup_size_stages( + mut self, + required_subgroup_size_stages: ShaderStageFlags, + ) -> Self { + self.inner.required_subgroup_size_stages = required_subgroup_size_stages; + self + } + #[inline] + pub fn max_inline_uniform_block_size(mut self, max_inline_uniform_block_size: u32) -> Self { + self.inner.max_inline_uniform_block_size = max_inline_uniform_block_size; + self + } + #[inline] + pub fn max_per_stage_descriptor_inline_uniform_blocks( + mut self, + max_per_stage_descriptor_inline_uniform_blocks: u32, + ) -> Self { + self.inner.max_per_stage_descriptor_inline_uniform_blocks = + max_per_stage_descriptor_inline_uniform_blocks; + self + } + #[inline] + pub fn max_per_stage_descriptor_update_after_bind_inline_uniform_blocks( + mut self, + max_per_stage_descriptor_update_after_bind_inline_uniform_blocks: u32, + ) -> Self { + self.inner + .max_per_stage_descriptor_update_after_bind_inline_uniform_blocks = + max_per_stage_descriptor_update_after_bind_inline_uniform_blocks; + self + } + #[inline] + pub fn max_descriptor_set_inline_uniform_blocks( + mut self, + max_descriptor_set_inline_uniform_blocks: u32, + ) -> Self { + self.inner.max_descriptor_set_inline_uniform_blocks = + max_descriptor_set_inline_uniform_blocks; + self + } + #[inline] + pub fn max_descriptor_set_update_after_bind_inline_uniform_blocks( + mut self, + max_descriptor_set_update_after_bind_inline_uniform_blocks: u32, + ) -> Self { + self.inner + .max_descriptor_set_update_after_bind_inline_uniform_blocks = + max_descriptor_set_update_after_bind_inline_uniform_blocks; + self + } + #[inline] + pub fn max_inline_uniform_total_size(mut self, max_inline_uniform_total_size: u32) -> Self { + self.inner.max_inline_uniform_total_size = max_inline_uniform_total_size; + self + } + #[inline] + pub fn integer_dot_product8_bit_unsigned_accelerated( + mut self, + integer_dot_product8_bit_unsigned_accelerated: bool, + ) -> Self { + self.inner.integer_dot_product8_bit_unsigned_accelerated = + integer_dot_product8_bit_unsigned_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product8_bit_signed_accelerated( + mut self, + integer_dot_product8_bit_signed_accelerated: bool, + ) -> Self { + self.inner.integer_dot_product8_bit_signed_accelerated = + integer_dot_product8_bit_signed_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product8_bit_mixed_signedness_accelerated( + mut self, + integer_dot_product8_bit_mixed_signedness_accelerated: bool, + ) -> Self { + self.inner + .integer_dot_product8_bit_mixed_signedness_accelerated = + integer_dot_product8_bit_mixed_signedness_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product4x8_bit_packed_unsigned_accelerated( + mut self, + integer_dot_product4x8_bit_packed_unsigned_accelerated: bool, + ) -> Self { + self.inner + .integer_dot_product4x8_bit_packed_unsigned_accelerated = + integer_dot_product4x8_bit_packed_unsigned_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product4x8_bit_packed_signed_accelerated( + mut self, + integer_dot_product4x8_bit_packed_signed_accelerated: bool, + ) -> Self { + self.inner + .integer_dot_product4x8_bit_packed_signed_accelerated = + integer_dot_product4x8_bit_packed_signed_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product4x8_bit_packed_mixed_signedness_accelerated( + mut self, + integer_dot_product4x8_bit_packed_mixed_signedness_accelerated: bool, + ) -> Self { + self.inner + .integer_dot_product4x8_bit_packed_mixed_signedness_accelerated = + integer_dot_product4x8_bit_packed_mixed_signedness_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product16_bit_unsigned_accelerated( + mut self, + integer_dot_product16_bit_unsigned_accelerated: bool, + ) -> Self { + self.inner.integer_dot_product16_bit_unsigned_accelerated = + integer_dot_product16_bit_unsigned_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product16_bit_signed_accelerated( + mut self, + integer_dot_product16_bit_signed_accelerated: bool, + ) -> Self { + self.inner.integer_dot_product16_bit_signed_accelerated = + integer_dot_product16_bit_signed_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product16_bit_mixed_signedness_accelerated( + mut self, + integer_dot_product16_bit_mixed_signedness_accelerated: bool, + ) -> Self { + self.inner + .integer_dot_product16_bit_mixed_signedness_accelerated = + integer_dot_product16_bit_mixed_signedness_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product32_bit_unsigned_accelerated( + mut self, + integer_dot_product32_bit_unsigned_accelerated: bool, + ) -> Self { + self.inner.integer_dot_product32_bit_unsigned_accelerated = + integer_dot_product32_bit_unsigned_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product32_bit_signed_accelerated( + mut self, + integer_dot_product32_bit_signed_accelerated: bool, + ) -> Self { + self.inner.integer_dot_product32_bit_signed_accelerated = + integer_dot_product32_bit_signed_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product32_bit_mixed_signedness_accelerated( + mut self, + integer_dot_product32_bit_mixed_signedness_accelerated: bool, + ) -> Self { + self.inner + .integer_dot_product32_bit_mixed_signedness_accelerated = + integer_dot_product32_bit_mixed_signedness_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product64_bit_unsigned_accelerated( + mut self, + integer_dot_product64_bit_unsigned_accelerated: bool, + ) -> Self { + self.inner.integer_dot_product64_bit_unsigned_accelerated = + integer_dot_product64_bit_unsigned_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product64_bit_signed_accelerated( + mut self, + integer_dot_product64_bit_signed_accelerated: bool, + ) -> Self { + self.inner.integer_dot_product64_bit_signed_accelerated = + integer_dot_product64_bit_signed_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product64_bit_mixed_signedness_accelerated( + mut self, + integer_dot_product64_bit_mixed_signedness_accelerated: bool, + ) -> Self { + self.inner + .integer_dot_product64_bit_mixed_signedness_accelerated = + integer_dot_product64_bit_mixed_signedness_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product_accumulating_saturating8_bit_unsigned_accelerated( + mut self, + integer_dot_product_accumulating_saturating8_bit_unsigned_accelerated: bool, + ) -> Self { + self.inner + .integer_dot_product_accumulating_saturating8_bit_unsigned_accelerated = + integer_dot_product_accumulating_saturating8_bit_unsigned_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product_accumulating_saturating8_bit_signed_accelerated( + mut self, + integer_dot_product_accumulating_saturating8_bit_signed_accelerated: bool, + ) -> Self { + self.inner + .integer_dot_product_accumulating_saturating8_bit_signed_accelerated = + integer_dot_product_accumulating_saturating8_bit_signed_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product_accumulating_saturating8_bit_mixed_signedness_accelerated( + mut self, + integer_dot_product_accumulating_saturating8_bit_mixed_signedness_accelerated: bool, + ) -> Self { + self.inner + .integer_dot_product_accumulating_saturating8_bit_mixed_signedness_accelerated = + integer_dot_product_accumulating_saturating8_bit_mixed_signedness_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product_accumulating_saturating4x8_bit_packed_unsigned_accelerated( + mut self, + integer_dot_product_accumulating_saturating4x8_bit_packed_unsigned_accelerated: bool, + ) -> Self { + self.inner + .integer_dot_product_accumulating_saturating4x8_bit_packed_unsigned_accelerated = + integer_dot_product_accumulating_saturating4x8_bit_packed_unsigned_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product_accumulating_saturating4x8_bit_packed_signed_accelerated( + mut self, + integer_dot_product_accumulating_saturating4x8_bit_packed_signed_accelerated: bool, + ) -> Self { + self.inner + .integer_dot_product_accumulating_saturating4x8_bit_packed_signed_accelerated = + integer_dot_product_accumulating_saturating4x8_bit_packed_signed_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product_accumulating_saturating4x8_bit_packed_mixed_signedness_accelerated( + mut self, + integer_dot_product_accumulating_saturating4x8_bit_packed_mixed_signedness_accelerated : bool, + ) -> Self { + self . inner . integer_dot_product_accumulating_saturating4x8_bit_packed_mixed_signedness_accelerated = integer_dot_product_accumulating_saturating4x8_bit_packed_mixed_signedness_accelerated . into () ; + self + } + #[inline] + pub fn integer_dot_product_accumulating_saturating16_bit_unsigned_accelerated( + mut self, + integer_dot_product_accumulating_saturating16_bit_unsigned_accelerated: bool, + ) -> Self { + self.inner + .integer_dot_product_accumulating_saturating16_bit_unsigned_accelerated = + integer_dot_product_accumulating_saturating16_bit_unsigned_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product_accumulating_saturating16_bit_signed_accelerated( + mut self, + integer_dot_product_accumulating_saturating16_bit_signed_accelerated: bool, + ) -> Self { + self.inner + .integer_dot_product_accumulating_saturating16_bit_signed_accelerated = + integer_dot_product_accumulating_saturating16_bit_signed_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product_accumulating_saturating16_bit_mixed_signedness_accelerated( + mut self, + integer_dot_product_accumulating_saturating16_bit_mixed_signedness_accelerated: bool, + ) -> Self { + self.inner + .integer_dot_product_accumulating_saturating16_bit_mixed_signedness_accelerated = + integer_dot_product_accumulating_saturating16_bit_mixed_signedness_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product_accumulating_saturating32_bit_unsigned_accelerated( + mut self, + integer_dot_product_accumulating_saturating32_bit_unsigned_accelerated: bool, + ) -> Self { + self.inner + .integer_dot_product_accumulating_saturating32_bit_unsigned_accelerated = + integer_dot_product_accumulating_saturating32_bit_unsigned_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product_accumulating_saturating32_bit_signed_accelerated( + mut self, + integer_dot_product_accumulating_saturating32_bit_signed_accelerated: bool, + ) -> Self { + self.inner + .integer_dot_product_accumulating_saturating32_bit_signed_accelerated = + integer_dot_product_accumulating_saturating32_bit_signed_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product_accumulating_saturating32_bit_mixed_signedness_accelerated( + mut self, + integer_dot_product_accumulating_saturating32_bit_mixed_signedness_accelerated: bool, + ) -> Self { + self.inner + .integer_dot_product_accumulating_saturating32_bit_mixed_signedness_accelerated = + integer_dot_product_accumulating_saturating32_bit_mixed_signedness_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product_accumulating_saturating64_bit_unsigned_accelerated( + mut self, + integer_dot_product_accumulating_saturating64_bit_unsigned_accelerated: bool, + ) -> Self { + self.inner + .integer_dot_product_accumulating_saturating64_bit_unsigned_accelerated = + integer_dot_product_accumulating_saturating64_bit_unsigned_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product_accumulating_saturating64_bit_signed_accelerated( + mut self, + integer_dot_product_accumulating_saturating64_bit_signed_accelerated: bool, + ) -> Self { + self.inner + .integer_dot_product_accumulating_saturating64_bit_signed_accelerated = + integer_dot_product_accumulating_saturating64_bit_signed_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product_accumulating_saturating64_bit_mixed_signedness_accelerated( + mut self, + integer_dot_product_accumulating_saturating64_bit_mixed_signedness_accelerated: bool, + ) -> Self { + self.inner + .integer_dot_product_accumulating_saturating64_bit_mixed_signedness_accelerated = + integer_dot_product_accumulating_saturating64_bit_mixed_signedness_accelerated.into(); + self + } + #[inline] + pub fn storage_texel_buffer_offset_alignment_bytes( + mut self, + storage_texel_buffer_offset_alignment_bytes: DeviceSize, + ) -> Self { + self.inner.storage_texel_buffer_offset_alignment_bytes = + storage_texel_buffer_offset_alignment_bytes; + self + } + #[inline] + pub fn storage_texel_buffer_offset_single_texel_alignment( + mut self, + storage_texel_buffer_offset_single_texel_alignment: bool, + ) -> Self { + self.inner + .storage_texel_buffer_offset_single_texel_alignment = + storage_texel_buffer_offset_single_texel_alignment.into(); + self + } + #[inline] + pub fn uniform_texel_buffer_offset_alignment_bytes( + mut self, + uniform_texel_buffer_offset_alignment_bytes: DeviceSize, + ) -> Self { + self.inner.uniform_texel_buffer_offset_alignment_bytes = + uniform_texel_buffer_offset_alignment_bytes; + self + } + #[inline] + pub fn uniform_texel_buffer_offset_single_texel_alignment( + mut self, + uniform_texel_buffer_offset_single_texel_alignment: bool, + ) -> Self { + self.inner + .uniform_texel_buffer_offset_single_texel_alignment = + uniform_texel_buffer_offset_single_texel_alignment.into(); + self + } + #[inline] + pub fn max_buffer_size(mut self, max_buffer_size: DeviceSize) -> Self { + self.inner.max_buffer_size = max_buffer_size; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceVulkan13Properties { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PipelineCompilerControlCreateInfoAMD { + pub s_type: StructureType, + pub p_next: *const c_void, + pub compiler_control_flags: PipelineCompilerControlFlagsAMD, +} +impl ::std::default::Default for PipelineCompilerControlCreateInfoAMD { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + compiler_control_flags: PipelineCompilerControlFlagsAMD::default(), + } + } +} +unsafe impl TaggedStructure for PipelineCompilerControlCreateInfoAMD { + const STRUCTURE_TYPE: StructureType = StructureType::PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD; +} +impl PipelineCompilerControlCreateInfoAMD { + pub fn builder<'a>() -> PipelineCompilerControlCreateInfoAMDBuilder<'a> { + PipelineCompilerControlCreateInfoAMDBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PipelineCompilerControlCreateInfoAMDBuilder<'a> { + inner: PipelineCompilerControlCreateInfoAMD, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsGraphicsPipelineCreateInfo for PipelineCompilerControlCreateInfoAMDBuilder<'_> {} +unsafe impl ExtendsGraphicsPipelineCreateInfo for PipelineCompilerControlCreateInfoAMD {} +unsafe impl ExtendsComputePipelineCreateInfo for PipelineCompilerControlCreateInfoAMDBuilder<'_> {} +unsafe impl ExtendsComputePipelineCreateInfo for PipelineCompilerControlCreateInfoAMD {} +impl<'a> ::std::ops::Deref for PipelineCompilerControlCreateInfoAMDBuilder<'a> { + type Target = PipelineCompilerControlCreateInfoAMD; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PipelineCompilerControlCreateInfoAMDBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PipelineCompilerControlCreateInfoAMDBuilder<'a> { + #[inline] + pub fn compiler_control_flags( + mut self, + compiler_control_flags: PipelineCompilerControlFlagsAMD, + ) -> Self { + self.inner.compiler_control_flags = compiler_control_flags; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PipelineCompilerControlCreateInfoAMD { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceCoherentMemoryFeaturesAMD { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub device_coherent_memory: Bool32, +} +impl ::std::default::Default for PhysicalDeviceCoherentMemoryFeaturesAMD { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + device_coherent_memory: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceCoherentMemoryFeaturesAMD { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD; +} +impl PhysicalDeviceCoherentMemoryFeaturesAMD { + pub fn builder<'a>() -> PhysicalDeviceCoherentMemoryFeaturesAMDBuilder<'a> { + PhysicalDeviceCoherentMemoryFeaturesAMDBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceCoherentMemoryFeaturesAMDBuilder<'a> { + inner: PhysicalDeviceCoherentMemoryFeaturesAMD, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceCoherentMemoryFeaturesAMDBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceCoherentMemoryFeaturesAMD {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceCoherentMemoryFeaturesAMDBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceCoherentMemoryFeaturesAMD {} +impl<'a> ::std::ops::Deref for PhysicalDeviceCoherentMemoryFeaturesAMDBuilder<'a> { + type Target = PhysicalDeviceCoherentMemoryFeaturesAMD; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceCoherentMemoryFeaturesAMDBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceCoherentMemoryFeaturesAMDBuilder<'a> { + #[inline] + pub fn device_coherent_memory(mut self, device_coherent_memory: bool) -> Self { + self.inner.device_coherent_memory = device_coherent_memory.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceCoherentMemoryFeaturesAMD { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceToolProperties { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub name: [c_char; MAX_EXTENSION_NAME_SIZE], + pub version: [c_char; MAX_EXTENSION_NAME_SIZE], + pub purposes: ToolPurposeFlags, + pub description: [c_char; MAX_DESCRIPTION_SIZE], + pub layer: [c_char; MAX_EXTENSION_NAME_SIZE], +} +#[cfg(feature = "debug")] +impl fmt::Debug for PhysicalDeviceToolProperties { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fmt.debug_struct("PhysicalDeviceToolProperties") + .field("s_type", &self.s_type) + .field("p_next", &self.p_next) + .field("name", &unsafe { + ::std::ffi::CStr::from_ptr(self.name.as_ptr()) + }) + .field("version", &unsafe { + ::std::ffi::CStr::from_ptr(self.version.as_ptr()) + }) + .field("purposes", &self.purposes) + .field("description", &unsafe { + ::std::ffi::CStr::from_ptr(self.description.as_ptr()) + }) + .field("layer", &unsafe { + ::std::ffi::CStr::from_ptr(self.layer.as_ptr()) + }) + .finish() + } +} +impl ::std::default::Default for PhysicalDeviceToolProperties { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + name: unsafe { ::std::mem::zeroed() }, + version: unsafe { ::std::mem::zeroed() }, + purposes: ToolPurposeFlags::default(), + description: unsafe { ::std::mem::zeroed() }, + layer: unsafe { ::std::mem::zeroed() }, + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceToolProperties { + const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_TOOL_PROPERTIES; +} +impl PhysicalDeviceToolProperties { + pub fn builder<'a>() -> PhysicalDeviceToolPropertiesBuilder<'a> { + PhysicalDeviceToolPropertiesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceToolPropertiesBuilder<'a> { + inner: PhysicalDeviceToolProperties, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PhysicalDeviceToolPropertiesBuilder<'a> { + type Target = PhysicalDeviceToolProperties; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceToolPropertiesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceToolPropertiesBuilder<'a> { + #[inline] + pub fn name(mut self, name: [c_char; MAX_EXTENSION_NAME_SIZE]) -> Self { + self.inner.name = name; + self + } + #[inline] + pub fn version(mut self, version: [c_char; MAX_EXTENSION_NAME_SIZE]) -> Self { + self.inner.version = version; + self + } + #[inline] + pub fn purposes(mut self, purposes: ToolPurposeFlags) -> Self { + self.inner.purposes = purposes; + self + } + #[inline] + pub fn description(mut self, description: [c_char; MAX_DESCRIPTION_SIZE]) -> Self { + self.inner.description = description; + self + } + #[inline] + pub fn layer(mut self, layer: [c_char; MAX_EXTENSION_NAME_SIZE]) -> Self { + self.inner.layer = layer; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceToolProperties { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SamplerCustomBorderColorCreateInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub custom_border_color: ClearColorValue, + pub format: Format, +} +#[cfg(feature = "debug")] +impl fmt::Debug for SamplerCustomBorderColorCreateInfoEXT { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fmt.debug_struct("SamplerCustomBorderColorCreateInfoEXT") + .field("s_type", &self.s_type) + .field("p_next", &self.p_next) + .field("custom_border_color", &"union") + .field("format", &self.format) + .finish() + } +} +impl ::std::default::Default for SamplerCustomBorderColorCreateInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + custom_border_color: ClearColorValue::default(), + format: Format::default(), + } + } +} +unsafe impl TaggedStructure for SamplerCustomBorderColorCreateInfoEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT; +} +impl SamplerCustomBorderColorCreateInfoEXT { + pub fn builder<'a>() -> SamplerCustomBorderColorCreateInfoEXTBuilder<'a> { + SamplerCustomBorderColorCreateInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SamplerCustomBorderColorCreateInfoEXTBuilder<'a> { + inner: SamplerCustomBorderColorCreateInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsSamplerCreateInfo for SamplerCustomBorderColorCreateInfoEXTBuilder<'_> {} +unsafe impl ExtendsSamplerCreateInfo for SamplerCustomBorderColorCreateInfoEXT {} +impl<'a> ::std::ops::Deref for SamplerCustomBorderColorCreateInfoEXTBuilder<'a> { + type Target = SamplerCustomBorderColorCreateInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SamplerCustomBorderColorCreateInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SamplerCustomBorderColorCreateInfoEXTBuilder<'a> { + #[inline] + pub fn custom_border_color(mut self, custom_border_color: ClearColorValue) -> Self { + self.inner.custom_border_color = custom_border_color; + self + } + #[inline] + pub fn format(mut self, format: Format) -> Self { + self.inner.format = format; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SamplerCustomBorderColorCreateInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceCustomBorderColorPropertiesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub max_custom_border_color_samplers: u32, +} +impl ::std::default::Default for PhysicalDeviceCustomBorderColorPropertiesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + max_custom_border_color_samplers: u32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceCustomBorderColorPropertiesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT; +} +impl PhysicalDeviceCustomBorderColorPropertiesEXT { + pub fn builder<'a>() -> PhysicalDeviceCustomBorderColorPropertiesEXTBuilder<'a> { + PhysicalDeviceCustomBorderColorPropertiesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceCustomBorderColorPropertiesEXTBuilder<'a> { + inner: PhysicalDeviceCustomBorderColorPropertiesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceCustomBorderColorPropertiesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceCustomBorderColorPropertiesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceCustomBorderColorPropertiesEXTBuilder<'a> { + type Target = PhysicalDeviceCustomBorderColorPropertiesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceCustomBorderColorPropertiesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceCustomBorderColorPropertiesEXTBuilder<'a> { + #[inline] + pub fn max_custom_border_color_samplers( + mut self, + max_custom_border_color_samplers: u32, + ) -> Self { + self.inner.max_custom_border_color_samplers = max_custom_border_color_samplers; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceCustomBorderColorPropertiesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceCustomBorderColorFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub custom_border_colors: Bool32, + pub custom_border_color_without_format: Bool32, +} +impl ::std::default::Default for PhysicalDeviceCustomBorderColorFeaturesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + custom_border_colors: Bool32::default(), + custom_border_color_without_format: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceCustomBorderColorFeaturesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT; +} +impl PhysicalDeviceCustomBorderColorFeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceCustomBorderColorFeaturesEXTBuilder<'a> { + PhysicalDeviceCustomBorderColorFeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceCustomBorderColorFeaturesEXTBuilder<'a> { + inner: PhysicalDeviceCustomBorderColorFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceCustomBorderColorFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceCustomBorderColorFeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceCustomBorderColorFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceCustomBorderColorFeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceCustomBorderColorFeaturesEXTBuilder<'a> { + type Target = PhysicalDeviceCustomBorderColorFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceCustomBorderColorFeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceCustomBorderColorFeaturesEXTBuilder<'a> { + #[inline] + pub fn custom_border_colors(mut self, custom_border_colors: bool) -> Self { + self.inner.custom_border_colors = custom_border_colors.into(); + self + } + #[inline] + pub fn custom_border_color_without_format( + mut self, + custom_border_color_without_format: bool, + ) -> Self { + self.inner.custom_border_color_without_format = custom_border_color_without_format.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceCustomBorderColorFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SamplerBorderColorComponentMappingCreateInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub components: ComponentMapping, + pub srgb: Bool32, +} +impl ::std::default::Default for SamplerBorderColorComponentMappingCreateInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + components: ComponentMapping::default(), + srgb: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for SamplerBorderColorComponentMappingCreateInfoEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT; +} +impl SamplerBorderColorComponentMappingCreateInfoEXT { + pub fn builder<'a>() -> SamplerBorderColorComponentMappingCreateInfoEXTBuilder<'a> { + SamplerBorderColorComponentMappingCreateInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SamplerBorderColorComponentMappingCreateInfoEXTBuilder<'a> { + inner: SamplerBorderColorComponentMappingCreateInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsSamplerCreateInfo + for SamplerBorderColorComponentMappingCreateInfoEXTBuilder<'_> +{ +} +unsafe impl ExtendsSamplerCreateInfo for SamplerBorderColorComponentMappingCreateInfoEXT {} +impl<'a> ::std::ops::Deref for SamplerBorderColorComponentMappingCreateInfoEXTBuilder<'a> { + type Target = SamplerBorderColorComponentMappingCreateInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SamplerBorderColorComponentMappingCreateInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SamplerBorderColorComponentMappingCreateInfoEXTBuilder<'a> { + #[inline] + pub fn components(mut self, components: ComponentMapping) -> Self { + self.inner.components = components; + self + } + #[inline] + pub fn srgb(mut self, srgb: bool) -> Self { + self.inner.srgb = srgb.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SamplerBorderColorComponentMappingCreateInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceBorderColorSwizzleFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub border_color_swizzle: Bool32, + pub border_color_swizzle_from_image: Bool32, +} +impl ::std::default::Default for PhysicalDeviceBorderColorSwizzleFeaturesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + border_color_swizzle: Bool32::default(), + border_color_swizzle_from_image: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceBorderColorSwizzleFeaturesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT; +} +impl PhysicalDeviceBorderColorSwizzleFeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceBorderColorSwizzleFeaturesEXTBuilder<'a> { + PhysicalDeviceBorderColorSwizzleFeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceBorderColorSwizzleFeaturesEXTBuilder<'a> { + inner: PhysicalDeviceBorderColorSwizzleFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceBorderColorSwizzleFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceBorderColorSwizzleFeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceBorderColorSwizzleFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceBorderColorSwizzleFeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceBorderColorSwizzleFeaturesEXTBuilder<'a> { + type Target = PhysicalDeviceBorderColorSwizzleFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceBorderColorSwizzleFeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceBorderColorSwizzleFeaturesEXTBuilder<'a> { + #[inline] + pub fn border_color_swizzle(mut self, border_color_swizzle: bool) -> Self { + self.inner.border_color_swizzle = border_color_swizzle.into(); + self + } + #[inline] + pub fn border_color_swizzle_from_image( + mut self, + border_color_swizzle_from_image: bool, + ) -> Self { + self.inner.border_color_swizzle_from_image = border_color_swizzle_from_image.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceBorderColorSwizzleFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[doc = ""] +pub union DeviceOrHostAddressKHR { + pub device_address: DeviceAddress, + pub host_address: *mut c_void, +} +impl ::std::default::Default for DeviceOrHostAddressKHR { + #[inline] + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[doc = ""] +pub union DeviceOrHostAddressConstKHR { + pub device_address: DeviceAddress, + pub host_address: *const c_void, +} +impl ::std::default::Default for DeviceOrHostAddressConstKHR { + #[inline] + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct AccelerationStructureGeometryTrianglesDataKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub vertex_format: Format, + pub vertex_data: DeviceOrHostAddressConstKHR, + pub vertex_stride: DeviceSize, + pub max_vertex: u32, + pub index_type: IndexType, + pub index_data: DeviceOrHostAddressConstKHR, + pub transform_data: DeviceOrHostAddressConstKHR, +} +#[cfg(feature = "debug")] +impl fmt::Debug for AccelerationStructureGeometryTrianglesDataKHR { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fmt.debug_struct("AccelerationStructureGeometryTrianglesDataKHR") + .field("s_type", &self.s_type) + .field("p_next", &self.p_next) + .field("vertex_format", &self.vertex_format) + .field("vertex_data", &"union") + .field("vertex_stride", &self.vertex_stride) + .field("max_vertex", &self.max_vertex) + .field("index_type", &self.index_type) + .field("index_data", &"union") + .field("transform_data", &"union") + .finish() + } +} +impl ::std::default::Default for AccelerationStructureGeometryTrianglesDataKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + vertex_format: Format::default(), + vertex_data: DeviceOrHostAddressConstKHR::default(), + vertex_stride: DeviceSize::default(), + max_vertex: u32::default(), + index_type: IndexType::default(), + index_data: DeviceOrHostAddressConstKHR::default(), + transform_data: DeviceOrHostAddressConstKHR::default(), + } + } +} +unsafe impl TaggedStructure for AccelerationStructureGeometryTrianglesDataKHR { + const STRUCTURE_TYPE: StructureType = + StructureType::ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR; +} +impl AccelerationStructureGeometryTrianglesDataKHR { + pub fn builder<'a>() -> AccelerationStructureGeometryTrianglesDataKHRBuilder<'a> { + AccelerationStructureGeometryTrianglesDataKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct AccelerationStructureGeometryTrianglesDataKHRBuilder<'a> { + inner: AccelerationStructureGeometryTrianglesDataKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsAccelerationStructureGeometryTrianglesDataKHR {} +impl<'a> ::std::ops::Deref for AccelerationStructureGeometryTrianglesDataKHRBuilder<'a> { + type Target = AccelerationStructureGeometryTrianglesDataKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for AccelerationStructureGeometryTrianglesDataKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> AccelerationStructureGeometryTrianglesDataKHRBuilder<'a> { + #[inline] + pub fn vertex_format(mut self, vertex_format: Format) -> Self { + self.inner.vertex_format = vertex_format; + self + } + #[inline] + pub fn vertex_data(mut self, vertex_data: DeviceOrHostAddressConstKHR) -> Self { + self.inner.vertex_data = vertex_data; + self + } + #[inline] + pub fn vertex_stride(mut self, vertex_stride: DeviceSize) -> Self { + self.inner.vertex_stride = vertex_stride; + self + } + #[inline] + pub fn max_vertex(mut self, max_vertex: u32) -> Self { + self.inner.max_vertex = max_vertex; + self + } + #[inline] + pub fn index_type(mut self, index_type: IndexType) -> Self { + self.inner.index_type = index_type; + self + } + #[inline] + pub fn index_data(mut self, index_data: DeviceOrHostAddressConstKHR) -> Self { + self.inner.index_data = index_data; + self + } + #[inline] + pub fn transform_data(mut self, transform_data: DeviceOrHostAddressConstKHR) -> Self { + self.inner.transform_data = transform_data; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next( + mut self, + next: &'a mut T, + ) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> AccelerationStructureGeometryTrianglesDataKHR { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct AccelerationStructureGeometryAabbsDataKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub data: DeviceOrHostAddressConstKHR, + pub stride: DeviceSize, +} +#[cfg(feature = "debug")] +impl fmt::Debug for AccelerationStructureGeometryAabbsDataKHR { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fmt.debug_struct("AccelerationStructureGeometryAabbsDataKHR") + .field("s_type", &self.s_type) + .field("p_next", &self.p_next) + .field("data", &"union") + .field("stride", &self.stride) + .finish() + } +} +impl ::std::default::Default for AccelerationStructureGeometryAabbsDataKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + data: DeviceOrHostAddressConstKHR::default(), + stride: DeviceSize::default(), + } + } +} +unsafe impl TaggedStructure for AccelerationStructureGeometryAabbsDataKHR { + const STRUCTURE_TYPE: StructureType = + StructureType::ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA_KHR; +} +impl AccelerationStructureGeometryAabbsDataKHR { + pub fn builder<'a>() -> AccelerationStructureGeometryAabbsDataKHRBuilder<'a> { + AccelerationStructureGeometryAabbsDataKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct AccelerationStructureGeometryAabbsDataKHRBuilder<'a> { + inner: AccelerationStructureGeometryAabbsDataKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for AccelerationStructureGeometryAabbsDataKHRBuilder<'a> { + type Target = AccelerationStructureGeometryAabbsDataKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for AccelerationStructureGeometryAabbsDataKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> AccelerationStructureGeometryAabbsDataKHRBuilder<'a> { + #[inline] + pub fn data(mut self, data: DeviceOrHostAddressConstKHR) -> Self { + self.inner.data = data; + self + } + #[inline] + pub fn stride(mut self, stride: DeviceSize) -> Self { + self.inner.stride = stride; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> AccelerationStructureGeometryAabbsDataKHR { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct AccelerationStructureGeometryInstancesDataKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub array_of_pointers: Bool32, + pub data: DeviceOrHostAddressConstKHR, +} +#[cfg(feature = "debug")] +impl fmt::Debug for AccelerationStructureGeometryInstancesDataKHR { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fmt.debug_struct("AccelerationStructureGeometryInstancesDataKHR") + .field("s_type", &self.s_type) + .field("p_next", &self.p_next) + .field("array_of_pointers", &self.array_of_pointers) + .field("data", &"union") + .finish() + } +} +impl ::std::default::Default for AccelerationStructureGeometryInstancesDataKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + array_of_pointers: Bool32::default(), + data: DeviceOrHostAddressConstKHR::default(), + } + } +} +unsafe impl TaggedStructure for AccelerationStructureGeometryInstancesDataKHR { + const STRUCTURE_TYPE: StructureType = + StructureType::ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR; +} +impl AccelerationStructureGeometryInstancesDataKHR { + pub fn builder<'a>() -> AccelerationStructureGeometryInstancesDataKHRBuilder<'a> { + AccelerationStructureGeometryInstancesDataKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct AccelerationStructureGeometryInstancesDataKHRBuilder<'a> { + inner: AccelerationStructureGeometryInstancesDataKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for AccelerationStructureGeometryInstancesDataKHRBuilder<'a> { + type Target = AccelerationStructureGeometryInstancesDataKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for AccelerationStructureGeometryInstancesDataKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> AccelerationStructureGeometryInstancesDataKHRBuilder<'a> { + #[inline] + pub fn array_of_pointers(mut self, array_of_pointers: bool) -> Self { + self.inner.array_of_pointers = array_of_pointers.into(); + self + } + #[inline] + pub fn data(mut self, data: DeviceOrHostAddressConstKHR) -> Self { + self.inner.data = data; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> AccelerationStructureGeometryInstancesDataKHR { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[doc = ""] +pub union AccelerationStructureGeometryDataKHR { + pub triangles: AccelerationStructureGeometryTrianglesDataKHR, + pub aabbs: AccelerationStructureGeometryAabbsDataKHR, + pub instances: AccelerationStructureGeometryInstancesDataKHR, +} +impl ::std::default::Default for AccelerationStructureGeometryDataKHR { + #[inline] + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct AccelerationStructureGeometryKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub geometry_type: GeometryTypeKHR, + pub geometry: AccelerationStructureGeometryDataKHR, + pub flags: GeometryFlagsKHR, +} +#[cfg(feature = "debug")] +impl fmt::Debug for AccelerationStructureGeometryKHR { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fmt.debug_struct("AccelerationStructureGeometryKHR") + .field("s_type", &self.s_type) + .field("p_next", &self.p_next) + .field("geometry_type", &self.geometry_type) + .field("geometry", &"union") + .field("flags", &self.flags) + .finish() + } +} +impl ::std::default::Default for AccelerationStructureGeometryKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + geometry_type: GeometryTypeKHR::default(), + geometry: AccelerationStructureGeometryDataKHR::default(), + flags: GeometryFlagsKHR::default(), + } + } +} +unsafe impl TaggedStructure for AccelerationStructureGeometryKHR { + const STRUCTURE_TYPE: StructureType = StructureType::ACCELERATION_STRUCTURE_GEOMETRY_KHR; +} +impl AccelerationStructureGeometryKHR { + pub fn builder<'a>() -> AccelerationStructureGeometryKHRBuilder<'a> { + AccelerationStructureGeometryKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct AccelerationStructureGeometryKHRBuilder<'a> { + inner: AccelerationStructureGeometryKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for AccelerationStructureGeometryKHRBuilder<'a> { + type Target = AccelerationStructureGeometryKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for AccelerationStructureGeometryKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> AccelerationStructureGeometryKHRBuilder<'a> { + #[inline] + pub fn geometry_type(mut self, geometry_type: GeometryTypeKHR) -> Self { + self.inner.geometry_type = geometry_type; + self + } + #[inline] + pub fn geometry(mut self, geometry: AccelerationStructureGeometryDataKHR) -> Self { + self.inner.geometry = geometry; + self + } + #[inline] + pub fn flags(mut self, flags: GeometryFlagsKHR) -> Self { + self.inner.flags = flags; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> AccelerationStructureGeometryKHR { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct AccelerationStructureBuildGeometryInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub ty: AccelerationStructureTypeKHR, + pub flags: BuildAccelerationStructureFlagsKHR, + pub mode: BuildAccelerationStructureModeKHR, + pub src_acceleration_structure: AccelerationStructureKHR, + pub dst_acceleration_structure: AccelerationStructureKHR, + pub geometry_count: u32, + pub p_geometries: *const AccelerationStructureGeometryKHR, + pub pp_geometries: *const *const AccelerationStructureGeometryKHR, + pub scratch_data: DeviceOrHostAddressKHR, +} +#[cfg(feature = "debug")] +impl fmt::Debug for AccelerationStructureBuildGeometryInfoKHR { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fmt.debug_struct("AccelerationStructureBuildGeometryInfoKHR") + .field("s_type", &self.s_type) + .field("p_next", &self.p_next) + .field("ty", &self.ty) + .field("flags", &self.flags) + .field("mode", &self.mode) + .field( + "src_acceleration_structure", + &self.src_acceleration_structure, + ) + .field( + "dst_acceleration_structure", + &self.dst_acceleration_structure, + ) + .field("geometry_count", &self.geometry_count) + .field("p_geometries", &self.p_geometries) + .field("pp_geometries", &self.pp_geometries) + .field("scratch_data", &"union") + .finish() + } +} +impl ::std::default::Default for AccelerationStructureBuildGeometryInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + ty: AccelerationStructureTypeKHR::default(), + flags: BuildAccelerationStructureFlagsKHR::default(), + mode: BuildAccelerationStructureModeKHR::default(), + src_acceleration_structure: AccelerationStructureKHR::default(), + dst_acceleration_structure: AccelerationStructureKHR::default(), + geometry_count: u32::default(), + p_geometries: ::std::ptr::null(), + pp_geometries: ::std::ptr::null(), + scratch_data: DeviceOrHostAddressKHR::default(), + } + } +} +unsafe impl TaggedStructure for AccelerationStructureBuildGeometryInfoKHR { + const STRUCTURE_TYPE: StructureType = + StructureType::ACCELERATION_STRUCTURE_BUILD_GEOMETRY_INFO_KHR; +} +impl AccelerationStructureBuildGeometryInfoKHR { + pub fn builder<'a>() -> AccelerationStructureBuildGeometryInfoKHRBuilder<'a> { + AccelerationStructureBuildGeometryInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct AccelerationStructureBuildGeometryInfoKHRBuilder<'a> { + inner: AccelerationStructureBuildGeometryInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for AccelerationStructureBuildGeometryInfoKHRBuilder<'a> { + type Target = AccelerationStructureBuildGeometryInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for AccelerationStructureBuildGeometryInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> AccelerationStructureBuildGeometryInfoKHRBuilder<'a> { + #[inline] + pub fn ty(mut self, ty: AccelerationStructureTypeKHR) -> Self { + self.inner.ty = ty; + self + } + #[inline] + pub fn flags(mut self, flags: BuildAccelerationStructureFlagsKHR) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn mode(mut self, mode: BuildAccelerationStructureModeKHR) -> Self { + self.inner.mode = mode; + self + } + #[inline] + pub fn src_acceleration_structure( + mut self, + src_acceleration_structure: AccelerationStructureKHR, + ) -> Self { + self.inner.src_acceleration_structure = src_acceleration_structure; + self + } + #[inline] + pub fn dst_acceleration_structure( + mut self, + dst_acceleration_structure: AccelerationStructureKHR, + ) -> Self { + self.inner.dst_acceleration_structure = dst_acceleration_structure; + self + } + #[inline] + pub fn geometries(mut self, geometries: &'a [AccelerationStructureGeometryKHR]) -> Self { + self.inner.geometry_count = geometries.len() as _; + self.inner.p_geometries = geometries.as_ptr(); + self + } + #[inline] + pub fn geometries_ptrs( + mut self, + geometries_ptrs: &'a [&'a AccelerationStructureGeometryKHR], + ) -> Self { + self.inner.geometry_count = geometries_ptrs.len() as _; + self.inner.pp_geometries = geometries_ptrs.as_ptr().cast(); + self + } + #[inline] + pub fn scratch_data(mut self, scratch_data: DeviceOrHostAddressKHR) -> Self { + self.inner.scratch_data = scratch_data; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> AccelerationStructureBuildGeometryInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct AccelerationStructureBuildRangeInfoKHR { + pub primitive_count: u32, + pub primitive_offset: u32, + pub first_vertex: u32, + pub transform_offset: u32, +} +impl AccelerationStructureBuildRangeInfoKHR { + pub fn builder<'a>() -> AccelerationStructureBuildRangeInfoKHRBuilder<'a> { + AccelerationStructureBuildRangeInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct AccelerationStructureBuildRangeInfoKHRBuilder<'a> { + inner: AccelerationStructureBuildRangeInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for AccelerationStructureBuildRangeInfoKHRBuilder<'a> { + type Target = AccelerationStructureBuildRangeInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for AccelerationStructureBuildRangeInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> AccelerationStructureBuildRangeInfoKHRBuilder<'a> { + #[inline] + pub fn primitive_count(mut self, primitive_count: u32) -> Self { + self.inner.primitive_count = primitive_count; + self + } + #[inline] + pub fn primitive_offset(mut self, primitive_offset: u32) -> Self { + self.inner.primitive_offset = primitive_offset; + self + } + #[inline] + pub fn first_vertex(mut self, first_vertex: u32) -> Self { + self.inner.first_vertex = first_vertex; + self + } + #[inline] + pub fn transform_offset(mut self, transform_offset: u32) -> Self { + self.inner.transform_offset = transform_offset; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> AccelerationStructureBuildRangeInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct AccelerationStructureCreateInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub create_flags: AccelerationStructureCreateFlagsKHR, + pub buffer: Buffer, + pub offset: DeviceSize, + pub size: DeviceSize, + pub ty: AccelerationStructureTypeKHR, + pub device_address: DeviceAddress, +} +impl ::std::default::Default for AccelerationStructureCreateInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + create_flags: AccelerationStructureCreateFlagsKHR::default(), + buffer: Buffer::default(), + offset: DeviceSize::default(), + size: DeviceSize::default(), + ty: AccelerationStructureTypeKHR::default(), + device_address: DeviceAddress::default(), + } + } +} +unsafe impl TaggedStructure for AccelerationStructureCreateInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::ACCELERATION_STRUCTURE_CREATE_INFO_KHR; +} +impl AccelerationStructureCreateInfoKHR { + pub fn builder<'a>() -> AccelerationStructureCreateInfoKHRBuilder<'a> { + AccelerationStructureCreateInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct AccelerationStructureCreateInfoKHRBuilder<'a> { + inner: AccelerationStructureCreateInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsAccelerationStructureCreateInfoKHR {} +impl<'a> ::std::ops::Deref for AccelerationStructureCreateInfoKHRBuilder<'a> { + type Target = AccelerationStructureCreateInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for AccelerationStructureCreateInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> AccelerationStructureCreateInfoKHRBuilder<'a> { + #[inline] + pub fn create_flags(mut self, create_flags: AccelerationStructureCreateFlagsKHR) -> Self { + self.inner.create_flags = create_flags; + self + } + #[inline] + pub fn buffer(mut self, buffer: Buffer) -> Self { + self.inner.buffer = buffer; + self + } + #[inline] + pub fn offset(mut self, offset: DeviceSize) -> Self { + self.inner.offset = offset; + self + } + #[inline] + pub fn size(mut self, size: DeviceSize) -> Self { + self.inner.size = size; + self + } + #[inline] + pub fn ty(mut self, ty: AccelerationStructureTypeKHR) -> Self { + self.inner.ty = ty; + self + } + #[inline] + pub fn device_address(mut self, device_address: DeviceAddress) -> Self { + self.inner.device_address = device_address; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next( + mut self, + next: &'a mut T, + ) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> AccelerationStructureCreateInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct AabbPositionsKHR { + pub min_x: f32, + pub min_y: f32, + pub min_z: f32, + pub max_x: f32, + pub max_y: f32, + pub max_z: f32, +} +impl AabbPositionsKHR { + pub fn builder<'a>() -> AabbPositionsKHRBuilder<'a> { + AabbPositionsKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct AabbPositionsKHRBuilder<'a> { + inner: AabbPositionsKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for AabbPositionsKHRBuilder<'a> { + type Target = AabbPositionsKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for AabbPositionsKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> AabbPositionsKHRBuilder<'a> { + #[inline] + pub fn min_x(mut self, min_x: f32) -> Self { + self.inner.min_x = min_x; + self + } + #[inline] + pub fn min_y(mut self, min_y: f32) -> Self { + self.inner.min_y = min_y; + self + } + #[inline] + pub fn min_z(mut self, min_z: f32) -> Self { + self.inner.min_z = min_z; + self + } + #[inline] + pub fn max_x(mut self, max_x: f32) -> Self { + self.inner.max_x = max_x; + self + } + #[inline] + pub fn max_y(mut self, max_y: f32) -> Self { + self.inner.max_y = max_y; + self + } + #[inline] + pub fn max_z(mut self, max_z: f32) -> Self { + self.inner.max_z = max_z; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> AabbPositionsKHR { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct TransformMatrixKHR { + pub matrix: [f32; 12], +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union AccelerationStructureReferenceKHR { + pub device_handle: DeviceAddress, + pub host_handle: AccelerationStructureKHR, +} +#[repr(C)] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct AccelerationStructureInstanceKHR { + pub transform: TransformMatrixKHR, + #[doc = r" Use [`Packed24_8::new(instance_custom_index, mask)`][Packed24_8::new()] to construct this field"] + pub instance_custom_index_and_mask: Packed24_8, + #[doc = r" Use [`Packed24_8::new(instance_shader_binding_table_record_offset, flags)`][Packed24_8::new()] to construct this field"] + pub instance_shader_binding_table_record_offset_and_flags: Packed24_8, + pub acceleration_structure_reference: AccelerationStructureReferenceKHR, +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct AccelerationStructureDeviceAddressInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub acceleration_structure: AccelerationStructureKHR, +} +impl ::std::default::Default for AccelerationStructureDeviceAddressInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + acceleration_structure: AccelerationStructureKHR::default(), + } + } +} +unsafe impl TaggedStructure for AccelerationStructureDeviceAddressInfoKHR { + const STRUCTURE_TYPE: StructureType = + StructureType::ACCELERATION_STRUCTURE_DEVICE_ADDRESS_INFO_KHR; +} +impl AccelerationStructureDeviceAddressInfoKHR { + pub fn builder<'a>() -> AccelerationStructureDeviceAddressInfoKHRBuilder<'a> { + AccelerationStructureDeviceAddressInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct AccelerationStructureDeviceAddressInfoKHRBuilder<'a> { + inner: AccelerationStructureDeviceAddressInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for AccelerationStructureDeviceAddressInfoKHRBuilder<'a> { + type Target = AccelerationStructureDeviceAddressInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for AccelerationStructureDeviceAddressInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> AccelerationStructureDeviceAddressInfoKHRBuilder<'a> { + #[inline] + pub fn acceleration_structure( + mut self, + acceleration_structure: AccelerationStructureKHR, + ) -> Self { + self.inner.acceleration_structure = acceleration_structure; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> AccelerationStructureDeviceAddressInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct AccelerationStructureVersionInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub p_version_data: *const [u8; 2 * UUID_SIZE], +} +impl ::std::default::Default for AccelerationStructureVersionInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + p_version_data: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for AccelerationStructureVersionInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::ACCELERATION_STRUCTURE_VERSION_INFO_KHR; +} +impl AccelerationStructureVersionInfoKHR { + pub fn builder<'a>() -> AccelerationStructureVersionInfoKHRBuilder<'a> { + AccelerationStructureVersionInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct AccelerationStructureVersionInfoKHRBuilder<'a> { + inner: AccelerationStructureVersionInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for AccelerationStructureVersionInfoKHRBuilder<'a> { + type Target = AccelerationStructureVersionInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for AccelerationStructureVersionInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> AccelerationStructureVersionInfoKHRBuilder<'a> { + #[inline] + pub fn version_data(mut self, version_data: &'a [u8; 2 * UUID_SIZE]) -> Self { + self.inner.p_version_data = version_data; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> AccelerationStructureVersionInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct CopyAccelerationStructureInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub src: AccelerationStructureKHR, + pub dst: AccelerationStructureKHR, + pub mode: CopyAccelerationStructureModeKHR, +} +impl ::std::default::Default for CopyAccelerationStructureInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + src: AccelerationStructureKHR::default(), + dst: AccelerationStructureKHR::default(), + mode: CopyAccelerationStructureModeKHR::default(), + } + } +} +unsafe impl TaggedStructure for CopyAccelerationStructureInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::COPY_ACCELERATION_STRUCTURE_INFO_KHR; +} +impl CopyAccelerationStructureInfoKHR { + pub fn builder<'a>() -> CopyAccelerationStructureInfoKHRBuilder<'a> { + CopyAccelerationStructureInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct CopyAccelerationStructureInfoKHRBuilder<'a> { + inner: CopyAccelerationStructureInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for CopyAccelerationStructureInfoKHRBuilder<'a> { + type Target = CopyAccelerationStructureInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for CopyAccelerationStructureInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> CopyAccelerationStructureInfoKHRBuilder<'a> { + #[inline] + pub fn src(mut self, src: AccelerationStructureKHR) -> Self { + self.inner.src = src; + self + } + #[inline] + pub fn dst(mut self, dst: AccelerationStructureKHR) -> Self { + self.inner.dst = dst; + self + } + #[inline] + pub fn mode(mut self, mode: CopyAccelerationStructureModeKHR) -> Self { + self.inner.mode = mode; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> CopyAccelerationStructureInfoKHR { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct CopyAccelerationStructureToMemoryInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub src: AccelerationStructureKHR, + pub dst: DeviceOrHostAddressKHR, + pub mode: CopyAccelerationStructureModeKHR, +} +#[cfg(feature = "debug")] +impl fmt::Debug for CopyAccelerationStructureToMemoryInfoKHR { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fmt.debug_struct("CopyAccelerationStructureToMemoryInfoKHR") + .field("s_type", &self.s_type) + .field("p_next", &self.p_next) + .field("src", &self.src) + .field("dst", &"union") + .field("mode", &self.mode) + .finish() + } +} +impl ::std::default::Default for CopyAccelerationStructureToMemoryInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + src: AccelerationStructureKHR::default(), + dst: DeviceOrHostAddressKHR::default(), + mode: CopyAccelerationStructureModeKHR::default(), + } + } +} +unsafe impl TaggedStructure for CopyAccelerationStructureToMemoryInfoKHR { + const STRUCTURE_TYPE: StructureType = + StructureType::COPY_ACCELERATION_STRUCTURE_TO_MEMORY_INFO_KHR; +} +impl CopyAccelerationStructureToMemoryInfoKHR { + pub fn builder<'a>() -> CopyAccelerationStructureToMemoryInfoKHRBuilder<'a> { + CopyAccelerationStructureToMemoryInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct CopyAccelerationStructureToMemoryInfoKHRBuilder<'a> { + inner: CopyAccelerationStructureToMemoryInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for CopyAccelerationStructureToMemoryInfoKHRBuilder<'a> { + type Target = CopyAccelerationStructureToMemoryInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for CopyAccelerationStructureToMemoryInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> CopyAccelerationStructureToMemoryInfoKHRBuilder<'a> { + #[inline] + pub fn src(mut self, src: AccelerationStructureKHR) -> Self { + self.inner.src = src; + self + } + #[inline] + pub fn dst(mut self, dst: DeviceOrHostAddressKHR) -> Self { + self.inner.dst = dst; + self + } + #[inline] + pub fn mode(mut self, mode: CopyAccelerationStructureModeKHR) -> Self { + self.inner.mode = mode; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> CopyAccelerationStructureToMemoryInfoKHR { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct CopyMemoryToAccelerationStructureInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub src: DeviceOrHostAddressConstKHR, + pub dst: AccelerationStructureKHR, + pub mode: CopyAccelerationStructureModeKHR, +} +#[cfg(feature = "debug")] +impl fmt::Debug for CopyMemoryToAccelerationStructureInfoKHR { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fmt.debug_struct("CopyMemoryToAccelerationStructureInfoKHR") + .field("s_type", &self.s_type) + .field("p_next", &self.p_next) + .field("src", &"union") + .field("dst", &self.dst) + .field("mode", &self.mode) + .finish() + } +} +impl ::std::default::Default for CopyMemoryToAccelerationStructureInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + src: DeviceOrHostAddressConstKHR::default(), + dst: AccelerationStructureKHR::default(), + mode: CopyAccelerationStructureModeKHR::default(), + } + } +} +unsafe impl TaggedStructure for CopyMemoryToAccelerationStructureInfoKHR { + const STRUCTURE_TYPE: StructureType = + StructureType::COPY_MEMORY_TO_ACCELERATION_STRUCTURE_INFO_KHR; +} +impl CopyMemoryToAccelerationStructureInfoKHR { + pub fn builder<'a>() -> CopyMemoryToAccelerationStructureInfoKHRBuilder<'a> { + CopyMemoryToAccelerationStructureInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct CopyMemoryToAccelerationStructureInfoKHRBuilder<'a> { + inner: CopyMemoryToAccelerationStructureInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for CopyMemoryToAccelerationStructureInfoKHRBuilder<'a> { + type Target = CopyMemoryToAccelerationStructureInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for CopyMemoryToAccelerationStructureInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> CopyMemoryToAccelerationStructureInfoKHRBuilder<'a> { + #[inline] + pub fn src(mut self, src: DeviceOrHostAddressConstKHR) -> Self { + self.inner.src = src; + self + } + #[inline] + pub fn dst(mut self, dst: AccelerationStructureKHR) -> Self { + self.inner.dst = dst; + self + } + #[inline] + pub fn mode(mut self, mode: CopyAccelerationStructureModeKHR) -> Self { + self.inner.mode = mode; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> CopyMemoryToAccelerationStructureInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct RayTracingPipelineInterfaceCreateInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub max_pipeline_ray_payload_size: u32, + pub max_pipeline_ray_hit_attribute_size: u32, +} +impl ::std::default::Default for RayTracingPipelineInterfaceCreateInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + max_pipeline_ray_payload_size: u32::default(), + max_pipeline_ray_hit_attribute_size: u32::default(), + } + } +} +unsafe impl TaggedStructure for RayTracingPipelineInterfaceCreateInfoKHR { + const STRUCTURE_TYPE: StructureType = + StructureType::RAY_TRACING_PIPELINE_INTERFACE_CREATE_INFO_KHR; +} +impl RayTracingPipelineInterfaceCreateInfoKHR { + pub fn builder<'a>() -> RayTracingPipelineInterfaceCreateInfoKHRBuilder<'a> { + RayTracingPipelineInterfaceCreateInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct RayTracingPipelineInterfaceCreateInfoKHRBuilder<'a> { + inner: RayTracingPipelineInterfaceCreateInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for RayTracingPipelineInterfaceCreateInfoKHRBuilder<'a> { + type Target = RayTracingPipelineInterfaceCreateInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for RayTracingPipelineInterfaceCreateInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> RayTracingPipelineInterfaceCreateInfoKHRBuilder<'a> { + #[inline] + pub fn max_pipeline_ray_payload_size(mut self, max_pipeline_ray_payload_size: u32) -> Self { + self.inner.max_pipeline_ray_payload_size = max_pipeline_ray_payload_size; + self + } + #[inline] + pub fn max_pipeline_ray_hit_attribute_size( + mut self, + max_pipeline_ray_hit_attribute_size: u32, + ) -> Self { + self.inner.max_pipeline_ray_hit_attribute_size = max_pipeline_ray_hit_attribute_size; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> RayTracingPipelineInterfaceCreateInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PipelineLibraryCreateInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub library_count: u32, + pub p_libraries: *const Pipeline, +} +impl ::std::default::Default for PipelineLibraryCreateInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + library_count: u32::default(), + p_libraries: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for PipelineLibraryCreateInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::PIPELINE_LIBRARY_CREATE_INFO_KHR; +} +impl PipelineLibraryCreateInfoKHR { + pub fn builder<'a>() -> PipelineLibraryCreateInfoKHRBuilder<'a> { + PipelineLibraryCreateInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PipelineLibraryCreateInfoKHRBuilder<'a> { + inner: PipelineLibraryCreateInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsGraphicsPipelineCreateInfo for PipelineLibraryCreateInfoKHRBuilder<'_> {} +unsafe impl ExtendsGraphicsPipelineCreateInfo for PipelineLibraryCreateInfoKHR {} +impl<'a> ::std::ops::Deref for PipelineLibraryCreateInfoKHRBuilder<'a> { + type Target = PipelineLibraryCreateInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PipelineLibraryCreateInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PipelineLibraryCreateInfoKHRBuilder<'a> { + #[inline] + pub fn libraries(mut self, libraries: &'a [Pipeline]) -> Self { + self.inner.library_count = libraries.len() as _; + self.inner.p_libraries = libraries.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PipelineLibraryCreateInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceExtendedDynamicStateFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub extended_dynamic_state: Bool32, +} +impl ::std::default::Default for PhysicalDeviceExtendedDynamicStateFeaturesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + extended_dynamic_state: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceExtendedDynamicStateFeaturesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT; +} +impl PhysicalDeviceExtendedDynamicStateFeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceExtendedDynamicStateFeaturesEXTBuilder<'a> { + PhysicalDeviceExtendedDynamicStateFeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceExtendedDynamicStateFeaturesEXTBuilder<'a> { + inner: PhysicalDeviceExtendedDynamicStateFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceExtendedDynamicStateFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceExtendedDynamicStateFeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceExtendedDynamicStateFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceExtendedDynamicStateFeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceExtendedDynamicStateFeaturesEXTBuilder<'a> { + type Target = PhysicalDeviceExtendedDynamicStateFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceExtendedDynamicStateFeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceExtendedDynamicStateFeaturesEXTBuilder<'a> { + #[inline] + pub fn extended_dynamic_state(mut self, extended_dynamic_state: bool) -> Self { + self.inner.extended_dynamic_state = extended_dynamic_state.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceExtendedDynamicStateFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceExtendedDynamicState2FeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub extended_dynamic_state2: Bool32, + pub extended_dynamic_state2_logic_op: Bool32, + pub extended_dynamic_state2_patch_control_points: Bool32, +} +impl ::std::default::Default for PhysicalDeviceExtendedDynamicState2FeaturesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + extended_dynamic_state2: Bool32::default(), + extended_dynamic_state2_logic_op: Bool32::default(), + extended_dynamic_state2_patch_control_points: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceExtendedDynamicState2FeaturesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT; +} +impl PhysicalDeviceExtendedDynamicState2FeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceExtendedDynamicState2FeaturesEXTBuilder<'a> { + PhysicalDeviceExtendedDynamicState2FeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceExtendedDynamicState2FeaturesEXTBuilder<'a> { + inner: PhysicalDeviceExtendedDynamicState2FeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceExtendedDynamicState2FeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceExtendedDynamicState2FeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceExtendedDynamicState2FeaturesEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceExtendedDynamicState2FeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceExtendedDynamicState2FeaturesEXTBuilder<'a> { + type Target = PhysicalDeviceExtendedDynamicState2FeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceExtendedDynamicState2FeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceExtendedDynamicState2FeaturesEXTBuilder<'a> { + #[inline] + pub fn extended_dynamic_state2(mut self, extended_dynamic_state2: bool) -> Self { + self.inner.extended_dynamic_state2 = extended_dynamic_state2.into(); + self + } + #[inline] + pub fn extended_dynamic_state2_logic_op( + mut self, + extended_dynamic_state2_logic_op: bool, + ) -> Self { + self.inner.extended_dynamic_state2_logic_op = extended_dynamic_state2_logic_op.into(); + self + } + #[inline] + pub fn extended_dynamic_state2_patch_control_points( + mut self, + extended_dynamic_state2_patch_control_points: bool, + ) -> Self { + self.inner.extended_dynamic_state2_patch_control_points = + extended_dynamic_state2_patch_control_points.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceExtendedDynamicState2FeaturesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceExtendedDynamicState3FeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub extended_dynamic_state3_tessellation_domain_origin: Bool32, + pub extended_dynamic_state3_depth_clamp_enable: Bool32, + pub extended_dynamic_state3_polygon_mode: Bool32, + pub extended_dynamic_state3_rasterization_samples: Bool32, + pub extended_dynamic_state3_sample_mask: Bool32, + pub extended_dynamic_state3_alpha_to_coverage_enable: Bool32, + pub extended_dynamic_state3_alpha_to_one_enable: Bool32, + pub extended_dynamic_state3_logic_op_enable: Bool32, + pub extended_dynamic_state3_color_blend_enable: Bool32, + pub extended_dynamic_state3_color_blend_equation: Bool32, + pub extended_dynamic_state3_color_write_mask: Bool32, + pub extended_dynamic_state3_rasterization_stream: Bool32, + pub extended_dynamic_state3_conservative_rasterization_mode: Bool32, + pub extended_dynamic_state3_extra_primitive_overestimation_size: Bool32, + pub extended_dynamic_state3_depth_clip_enable: Bool32, + pub extended_dynamic_state3_sample_locations_enable: Bool32, + pub extended_dynamic_state3_color_blend_advanced: Bool32, + pub extended_dynamic_state3_provoking_vertex_mode: Bool32, + pub extended_dynamic_state3_line_rasterization_mode: Bool32, + pub extended_dynamic_state3_line_stipple_enable: Bool32, + pub extended_dynamic_state3_depth_clip_negative_one_to_one: Bool32, + pub extended_dynamic_state3_viewport_w_scaling_enable: Bool32, + pub extended_dynamic_state3_viewport_swizzle: Bool32, + pub extended_dynamic_state3_coverage_to_color_enable: Bool32, + pub extended_dynamic_state3_coverage_to_color_location: Bool32, + pub extended_dynamic_state3_coverage_modulation_mode: Bool32, + pub extended_dynamic_state3_coverage_modulation_table_enable: Bool32, + pub extended_dynamic_state3_coverage_modulation_table: Bool32, + pub extended_dynamic_state3_coverage_reduction_mode: Bool32, + pub extended_dynamic_state3_representative_fragment_test_enable: Bool32, + pub extended_dynamic_state3_shading_rate_image_enable: Bool32, +} +impl ::std::default::Default for PhysicalDeviceExtendedDynamicState3FeaturesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + extended_dynamic_state3_tessellation_domain_origin: Bool32::default(), + extended_dynamic_state3_depth_clamp_enable: Bool32::default(), + extended_dynamic_state3_polygon_mode: Bool32::default(), + extended_dynamic_state3_rasterization_samples: Bool32::default(), + extended_dynamic_state3_sample_mask: Bool32::default(), + extended_dynamic_state3_alpha_to_coverage_enable: Bool32::default(), + extended_dynamic_state3_alpha_to_one_enable: Bool32::default(), + extended_dynamic_state3_logic_op_enable: Bool32::default(), + extended_dynamic_state3_color_blend_enable: Bool32::default(), + extended_dynamic_state3_color_blend_equation: Bool32::default(), + extended_dynamic_state3_color_write_mask: Bool32::default(), + extended_dynamic_state3_rasterization_stream: Bool32::default(), + extended_dynamic_state3_conservative_rasterization_mode: Bool32::default(), + extended_dynamic_state3_extra_primitive_overestimation_size: Bool32::default(), + extended_dynamic_state3_depth_clip_enable: Bool32::default(), + extended_dynamic_state3_sample_locations_enable: Bool32::default(), + extended_dynamic_state3_color_blend_advanced: Bool32::default(), + extended_dynamic_state3_provoking_vertex_mode: Bool32::default(), + extended_dynamic_state3_line_rasterization_mode: Bool32::default(), + extended_dynamic_state3_line_stipple_enable: Bool32::default(), + extended_dynamic_state3_depth_clip_negative_one_to_one: Bool32::default(), + extended_dynamic_state3_viewport_w_scaling_enable: Bool32::default(), + extended_dynamic_state3_viewport_swizzle: Bool32::default(), + extended_dynamic_state3_coverage_to_color_enable: Bool32::default(), + extended_dynamic_state3_coverage_to_color_location: Bool32::default(), + extended_dynamic_state3_coverage_modulation_mode: Bool32::default(), + extended_dynamic_state3_coverage_modulation_table_enable: Bool32::default(), + extended_dynamic_state3_coverage_modulation_table: Bool32::default(), + extended_dynamic_state3_coverage_reduction_mode: Bool32::default(), + extended_dynamic_state3_representative_fragment_test_enable: Bool32::default(), + extended_dynamic_state3_shading_rate_image_enable: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceExtendedDynamicState3FeaturesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT; +} +impl PhysicalDeviceExtendedDynamicState3FeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceExtendedDynamicState3FeaturesEXTBuilder<'a> { + PhysicalDeviceExtendedDynamicState3FeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceExtendedDynamicState3FeaturesEXTBuilder<'a> { + inner: PhysicalDeviceExtendedDynamicState3FeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceExtendedDynamicState3FeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceExtendedDynamicState3FeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceExtendedDynamicState3FeaturesEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceExtendedDynamicState3FeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceExtendedDynamicState3FeaturesEXTBuilder<'a> { + type Target = PhysicalDeviceExtendedDynamicState3FeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceExtendedDynamicState3FeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceExtendedDynamicState3FeaturesEXTBuilder<'a> { + #[inline] + pub fn extended_dynamic_state3_tessellation_domain_origin( + mut self, + extended_dynamic_state3_tessellation_domain_origin: bool, + ) -> Self { + self.inner + .extended_dynamic_state3_tessellation_domain_origin = + extended_dynamic_state3_tessellation_domain_origin.into(); + self + } + #[inline] + pub fn extended_dynamic_state3_depth_clamp_enable( + mut self, + extended_dynamic_state3_depth_clamp_enable: bool, + ) -> Self { + self.inner.extended_dynamic_state3_depth_clamp_enable = + extended_dynamic_state3_depth_clamp_enable.into(); + self + } + #[inline] + pub fn extended_dynamic_state3_polygon_mode( + mut self, + extended_dynamic_state3_polygon_mode: bool, + ) -> Self { + self.inner.extended_dynamic_state3_polygon_mode = + extended_dynamic_state3_polygon_mode.into(); + self + } + #[inline] + pub fn extended_dynamic_state3_rasterization_samples( + mut self, + extended_dynamic_state3_rasterization_samples: bool, + ) -> Self { + self.inner.extended_dynamic_state3_rasterization_samples = + extended_dynamic_state3_rasterization_samples.into(); + self + } + #[inline] + pub fn extended_dynamic_state3_sample_mask( + mut self, + extended_dynamic_state3_sample_mask: bool, + ) -> Self { + self.inner.extended_dynamic_state3_sample_mask = extended_dynamic_state3_sample_mask.into(); + self + } + #[inline] + pub fn extended_dynamic_state3_alpha_to_coverage_enable( + mut self, + extended_dynamic_state3_alpha_to_coverage_enable: bool, + ) -> Self { + self.inner.extended_dynamic_state3_alpha_to_coverage_enable = + extended_dynamic_state3_alpha_to_coverage_enable.into(); + self + } + #[inline] + pub fn extended_dynamic_state3_alpha_to_one_enable( + mut self, + extended_dynamic_state3_alpha_to_one_enable: bool, + ) -> Self { + self.inner.extended_dynamic_state3_alpha_to_one_enable = + extended_dynamic_state3_alpha_to_one_enable.into(); + self + } + #[inline] + pub fn extended_dynamic_state3_logic_op_enable( + mut self, + extended_dynamic_state3_logic_op_enable: bool, + ) -> Self { + self.inner.extended_dynamic_state3_logic_op_enable = + extended_dynamic_state3_logic_op_enable.into(); + self + } + #[inline] + pub fn extended_dynamic_state3_color_blend_enable( + mut self, + extended_dynamic_state3_color_blend_enable: bool, + ) -> Self { + self.inner.extended_dynamic_state3_color_blend_enable = + extended_dynamic_state3_color_blend_enable.into(); + self + } + #[inline] + pub fn extended_dynamic_state3_color_blend_equation( + mut self, + extended_dynamic_state3_color_blend_equation: bool, + ) -> Self { + self.inner.extended_dynamic_state3_color_blend_equation = + extended_dynamic_state3_color_blend_equation.into(); + self + } + #[inline] + pub fn extended_dynamic_state3_color_write_mask( + mut self, + extended_dynamic_state3_color_write_mask: bool, + ) -> Self { + self.inner.extended_dynamic_state3_color_write_mask = + extended_dynamic_state3_color_write_mask.into(); + self + } + #[inline] + pub fn extended_dynamic_state3_rasterization_stream( + mut self, + extended_dynamic_state3_rasterization_stream: bool, + ) -> Self { + self.inner.extended_dynamic_state3_rasterization_stream = + extended_dynamic_state3_rasterization_stream.into(); + self + } + #[inline] + pub fn extended_dynamic_state3_conservative_rasterization_mode( + mut self, + extended_dynamic_state3_conservative_rasterization_mode: bool, + ) -> Self { + self.inner + .extended_dynamic_state3_conservative_rasterization_mode = + extended_dynamic_state3_conservative_rasterization_mode.into(); + self + } + #[inline] + pub fn extended_dynamic_state3_extra_primitive_overestimation_size( + mut self, + extended_dynamic_state3_extra_primitive_overestimation_size: bool, + ) -> Self { + self.inner + .extended_dynamic_state3_extra_primitive_overestimation_size = + extended_dynamic_state3_extra_primitive_overestimation_size.into(); + self + } + #[inline] + pub fn extended_dynamic_state3_depth_clip_enable( + mut self, + extended_dynamic_state3_depth_clip_enable: bool, + ) -> Self { + self.inner.extended_dynamic_state3_depth_clip_enable = + extended_dynamic_state3_depth_clip_enable.into(); + self + } + #[inline] + pub fn extended_dynamic_state3_sample_locations_enable( + mut self, + extended_dynamic_state3_sample_locations_enable: bool, + ) -> Self { + self.inner.extended_dynamic_state3_sample_locations_enable = + extended_dynamic_state3_sample_locations_enable.into(); + self + } + #[inline] + pub fn extended_dynamic_state3_color_blend_advanced( + mut self, + extended_dynamic_state3_color_blend_advanced: bool, + ) -> Self { + self.inner.extended_dynamic_state3_color_blend_advanced = + extended_dynamic_state3_color_blend_advanced.into(); + self + } + #[inline] + pub fn extended_dynamic_state3_provoking_vertex_mode( + mut self, + extended_dynamic_state3_provoking_vertex_mode: bool, + ) -> Self { + self.inner.extended_dynamic_state3_provoking_vertex_mode = + extended_dynamic_state3_provoking_vertex_mode.into(); + self + } + #[inline] + pub fn extended_dynamic_state3_line_rasterization_mode( + mut self, + extended_dynamic_state3_line_rasterization_mode: bool, + ) -> Self { + self.inner.extended_dynamic_state3_line_rasterization_mode = + extended_dynamic_state3_line_rasterization_mode.into(); + self + } + #[inline] + pub fn extended_dynamic_state3_line_stipple_enable( + mut self, + extended_dynamic_state3_line_stipple_enable: bool, + ) -> Self { + self.inner.extended_dynamic_state3_line_stipple_enable = + extended_dynamic_state3_line_stipple_enable.into(); + self + } + #[inline] + pub fn extended_dynamic_state3_depth_clip_negative_one_to_one( + mut self, + extended_dynamic_state3_depth_clip_negative_one_to_one: bool, + ) -> Self { + self.inner + .extended_dynamic_state3_depth_clip_negative_one_to_one = + extended_dynamic_state3_depth_clip_negative_one_to_one.into(); + self + } + #[inline] + pub fn extended_dynamic_state3_viewport_w_scaling_enable( + mut self, + extended_dynamic_state3_viewport_w_scaling_enable: bool, + ) -> Self { + self.inner.extended_dynamic_state3_viewport_w_scaling_enable = + extended_dynamic_state3_viewport_w_scaling_enable.into(); + self + } + #[inline] + pub fn extended_dynamic_state3_viewport_swizzle( + mut self, + extended_dynamic_state3_viewport_swizzle: bool, + ) -> Self { + self.inner.extended_dynamic_state3_viewport_swizzle = + extended_dynamic_state3_viewport_swizzle.into(); + self + } + #[inline] + pub fn extended_dynamic_state3_coverage_to_color_enable( + mut self, + extended_dynamic_state3_coverage_to_color_enable: bool, + ) -> Self { + self.inner.extended_dynamic_state3_coverage_to_color_enable = + extended_dynamic_state3_coverage_to_color_enable.into(); + self + } + #[inline] + pub fn extended_dynamic_state3_coverage_to_color_location( + mut self, + extended_dynamic_state3_coverage_to_color_location: bool, + ) -> Self { + self.inner + .extended_dynamic_state3_coverage_to_color_location = + extended_dynamic_state3_coverage_to_color_location.into(); + self + } + #[inline] + pub fn extended_dynamic_state3_coverage_modulation_mode( + mut self, + extended_dynamic_state3_coverage_modulation_mode: bool, + ) -> Self { + self.inner.extended_dynamic_state3_coverage_modulation_mode = + extended_dynamic_state3_coverage_modulation_mode.into(); + self + } + #[inline] + pub fn extended_dynamic_state3_coverage_modulation_table_enable( + mut self, + extended_dynamic_state3_coverage_modulation_table_enable: bool, + ) -> Self { + self.inner + .extended_dynamic_state3_coverage_modulation_table_enable = + extended_dynamic_state3_coverage_modulation_table_enable.into(); + self + } + #[inline] + pub fn extended_dynamic_state3_coverage_modulation_table( + mut self, + extended_dynamic_state3_coverage_modulation_table: bool, + ) -> Self { + self.inner.extended_dynamic_state3_coverage_modulation_table = + extended_dynamic_state3_coverage_modulation_table.into(); + self + } + #[inline] + pub fn extended_dynamic_state3_coverage_reduction_mode( + mut self, + extended_dynamic_state3_coverage_reduction_mode: bool, + ) -> Self { + self.inner.extended_dynamic_state3_coverage_reduction_mode = + extended_dynamic_state3_coverage_reduction_mode.into(); + self + } + #[inline] + pub fn extended_dynamic_state3_representative_fragment_test_enable( + mut self, + extended_dynamic_state3_representative_fragment_test_enable: bool, + ) -> Self { + self.inner + .extended_dynamic_state3_representative_fragment_test_enable = + extended_dynamic_state3_representative_fragment_test_enable.into(); + self + } + #[inline] + pub fn extended_dynamic_state3_shading_rate_image_enable( + mut self, + extended_dynamic_state3_shading_rate_image_enable: bool, + ) -> Self { + self.inner.extended_dynamic_state3_shading_rate_image_enable = + extended_dynamic_state3_shading_rate_image_enable.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceExtendedDynamicState3FeaturesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceExtendedDynamicState3PropertiesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub dynamic_primitive_topology_unrestricted: Bool32, +} +impl ::std::default::Default for PhysicalDeviceExtendedDynamicState3PropertiesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + dynamic_primitive_topology_unrestricted: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceExtendedDynamicState3PropertiesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT; +} +impl PhysicalDeviceExtendedDynamicState3PropertiesEXT { + pub fn builder<'a>() -> PhysicalDeviceExtendedDynamicState3PropertiesEXTBuilder<'a> { + PhysicalDeviceExtendedDynamicState3PropertiesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceExtendedDynamicState3PropertiesEXTBuilder<'a> { + inner: PhysicalDeviceExtendedDynamicState3PropertiesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceExtendedDynamicState3PropertiesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceExtendedDynamicState3PropertiesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceExtendedDynamicState3PropertiesEXTBuilder<'a> { + type Target = PhysicalDeviceExtendedDynamicState3PropertiesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceExtendedDynamicState3PropertiesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceExtendedDynamicState3PropertiesEXTBuilder<'a> { + #[inline] + pub fn dynamic_primitive_topology_unrestricted( + mut self, + dynamic_primitive_topology_unrestricted: bool, + ) -> Self { + self.inner.dynamic_primitive_topology_unrestricted = + dynamic_primitive_topology_unrestricted.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceExtendedDynamicState3PropertiesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct ColorBlendEquationEXT { + pub src_color_blend_factor: BlendFactor, + pub dst_color_blend_factor: BlendFactor, + pub color_blend_op: BlendOp, + pub src_alpha_blend_factor: BlendFactor, + pub dst_alpha_blend_factor: BlendFactor, + pub alpha_blend_op: BlendOp, +} +impl ColorBlendEquationEXT { + pub fn builder<'a>() -> ColorBlendEquationEXTBuilder<'a> { + ColorBlendEquationEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ColorBlendEquationEXTBuilder<'a> { + inner: ColorBlendEquationEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ColorBlendEquationEXTBuilder<'a> { + type Target = ColorBlendEquationEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ColorBlendEquationEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ColorBlendEquationEXTBuilder<'a> { + #[inline] + pub fn src_color_blend_factor(mut self, src_color_blend_factor: BlendFactor) -> Self { + self.inner.src_color_blend_factor = src_color_blend_factor; + self + } + #[inline] + pub fn dst_color_blend_factor(mut self, dst_color_blend_factor: BlendFactor) -> Self { + self.inner.dst_color_blend_factor = dst_color_blend_factor; + self + } + #[inline] + pub fn color_blend_op(mut self, color_blend_op: BlendOp) -> Self { + self.inner.color_blend_op = color_blend_op; + self + } + #[inline] + pub fn src_alpha_blend_factor(mut self, src_alpha_blend_factor: BlendFactor) -> Self { + self.inner.src_alpha_blend_factor = src_alpha_blend_factor; + self + } + #[inline] + pub fn dst_alpha_blend_factor(mut self, dst_alpha_blend_factor: BlendFactor) -> Self { + self.inner.dst_alpha_blend_factor = dst_alpha_blend_factor; + self + } + #[inline] + pub fn alpha_blend_op(mut self, alpha_blend_op: BlendOp) -> Self { + self.inner.alpha_blend_op = alpha_blend_op; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ColorBlendEquationEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct ColorBlendAdvancedEXT { + pub advanced_blend_op: BlendOp, + pub src_premultiplied: Bool32, + pub dst_premultiplied: Bool32, + pub blend_overlap: BlendOverlapEXT, + pub clamp_results: Bool32, +} +impl ColorBlendAdvancedEXT { + pub fn builder<'a>() -> ColorBlendAdvancedEXTBuilder<'a> { + ColorBlendAdvancedEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ColorBlendAdvancedEXTBuilder<'a> { + inner: ColorBlendAdvancedEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ColorBlendAdvancedEXTBuilder<'a> { + type Target = ColorBlendAdvancedEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ColorBlendAdvancedEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ColorBlendAdvancedEXTBuilder<'a> { + #[inline] + pub fn advanced_blend_op(mut self, advanced_blend_op: BlendOp) -> Self { + self.inner.advanced_blend_op = advanced_blend_op; + self + } + #[inline] + pub fn src_premultiplied(mut self, src_premultiplied: bool) -> Self { + self.inner.src_premultiplied = src_premultiplied.into(); + self + } + #[inline] + pub fn dst_premultiplied(mut self, dst_premultiplied: bool) -> Self { + self.inner.dst_premultiplied = dst_premultiplied.into(); + self + } + #[inline] + pub fn blend_overlap(mut self, blend_overlap: BlendOverlapEXT) -> Self { + self.inner.blend_overlap = blend_overlap; + self + } + #[inline] + pub fn clamp_results(mut self, clamp_results: bool) -> Self { + self.inner.clamp_results = clamp_results.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ColorBlendAdvancedEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct RenderPassTransformBeginInfoQCOM { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub transform: SurfaceTransformFlagsKHR, +} +impl ::std::default::Default for RenderPassTransformBeginInfoQCOM { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + transform: SurfaceTransformFlagsKHR::default(), + } + } +} +unsafe impl TaggedStructure for RenderPassTransformBeginInfoQCOM { + const STRUCTURE_TYPE: StructureType = StructureType::RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM; +} +impl RenderPassTransformBeginInfoQCOM { + pub fn builder<'a>() -> RenderPassTransformBeginInfoQCOMBuilder<'a> { + RenderPassTransformBeginInfoQCOMBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct RenderPassTransformBeginInfoQCOMBuilder<'a> { + inner: RenderPassTransformBeginInfoQCOM, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsRenderPassBeginInfo for RenderPassTransformBeginInfoQCOMBuilder<'_> {} +unsafe impl ExtendsRenderPassBeginInfo for RenderPassTransformBeginInfoQCOM {} +impl<'a> ::std::ops::Deref for RenderPassTransformBeginInfoQCOMBuilder<'a> { + type Target = RenderPassTransformBeginInfoQCOM; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for RenderPassTransformBeginInfoQCOMBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> RenderPassTransformBeginInfoQCOMBuilder<'a> { + #[inline] + pub fn transform(mut self, transform: SurfaceTransformFlagsKHR) -> Self { + self.inner.transform = transform; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> RenderPassTransformBeginInfoQCOM { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct CopyCommandTransformInfoQCOM { + pub s_type: StructureType, + pub p_next: *const c_void, + pub transform: SurfaceTransformFlagsKHR, +} +impl ::std::default::Default for CopyCommandTransformInfoQCOM { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + transform: SurfaceTransformFlagsKHR::default(), + } + } +} +unsafe impl TaggedStructure for CopyCommandTransformInfoQCOM { + const STRUCTURE_TYPE: StructureType = StructureType::COPY_COMMAND_TRANSFORM_INFO_QCOM; +} +impl CopyCommandTransformInfoQCOM { + pub fn builder<'a>() -> CopyCommandTransformInfoQCOMBuilder<'a> { + CopyCommandTransformInfoQCOMBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct CopyCommandTransformInfoQCOMBuilder<'a> { + inner: CopyCommandTransformInfoQCOM, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsBufferImageCopy2 for CopyCommandTransformInfoQCOMBuilder<'_> {} +unsafe impl ExtendsBufferImageCopy2 for CopyCommandTransformInfoQCOM {} +unsafe impl ExtendsImageBlit2 for CopyCommandTransformInfoQCOMBuilder<'_> {} +unsafe impl ExtendsImageBlit2 for CopyCommandTransformInfoQCOM {} +impl<'a> ::std::ops::Deref for CopyCommandTransformInfoQCOMBuilder<'a> { + type Target = CopyCommandTransformInfoQCOM; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for CopyCommandTransformInfoQCOMBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> CopyCommandTransformInfoQCOMBuilder<'a> { + #[inline] + pub fn transform(mut self, transform: SurfaceTransformFlagsKHR) -> Self { + self.inner.transform = transform; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> CopyCommandTransformInfoQCOM { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct CommandBufferInheritanceRenderPassTransformInfoQCOM { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub transform: SurfaceTransformFlagsKHR, + pub render_area: Rect2D, +} +impl ::std::default::Default for CommandBufferInheritanceRenderPassTransformInfoQCOM { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + transform: SurfaceTransformFlagsKHR::default(), + render_area: Rect2D::default(), + } + } +} +unsafe impl TaggedStructure for CommandBufferInheritanceRenderPassTransformInfoQCOM { + const STRUCTURE_TYPE: StructureType = + StructureType::COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM; +} +impl CommandBufferInheritanceRenderPassTransformInfoQCOM { + pub fn builder<'a>() -> CommandBufferInheritanceRenderPassTransformInfoQCOMBuilder<'a> { + CommandBufferInheritanceRenderPassTransformInfoQCOMBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct CommandBufferInheritanceRenderPassTransformInfoQCOMBuilder<'a> { + inner: CommandBufferInheritanceRenderPassTransformInfoQCOM, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsCommandBufferInheritanceInfo + for CommandBufferInheritanceRenderPassTransformInfoQCOMBuilder<'_> +{ +} +unsafe impl ExtendsCommandBufferInheritanceInfo + for CommandBufferInheritanceRenderPassTransformInfoQCOM +{ +} +impl<'a> ::std::ops::Deref for CommandBufferInheritanceRenderPassTransformInfoQCOMBuilder<'a> { + type Target = CommandBufferInheritanceRenderPassTransformInfoQCOM; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for CommandBufferInheritanceRenderPassTransformInfoQCOMBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> CommandBufferInheritanceRenderPassTransformInfoQCOMBuilder<'a> { + #[inline] + pub fn transform(mut self, transform: SurfaceTransformFlagsKHR) -> Self { + self.inner.transform = transform; + self + } + #[inline] + pub fn render_area(mut self, render_area: Rect2D) -> Self { + self.inner.render_area = render_area; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> CommandBufferInheritanceRenderPassTransformInfoQCOM { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceDiagnosticsConfigFeaturesNV { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub diagnostics_config: Bool32, +} +impl ::std::default::Default for PhysicalDeviceDiagnosticsConfigFeaturesNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + diagnostics_config: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceDiagnosticsConfigFeaturesNV { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV; +} +impl PhysicalDeviceDiagnosticsConfigFeaturesNV { + pub fn builder<'a>() -> PhysicalDeviceDiagnosticsConfigFeaturesNVBuilder<'a> { + PhysicalDeviceDiagnosticsConfigFeaturesNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceDiagnosticsConfigFeaturesNVBuilder<'a> { + inner: PhysicalDeviceDiagnosticsConfigFeaturesNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceDiagnosticsConfigFeaturesNVBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceDiagnosticsConfigFeaturesNV {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDiagnosticsConfigFeaturesNVBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDiagnosticsConfigFeaturesNV {} +impl<'a> ::std::ops::Deref for PhysicalDeviceDiagnosticsConfigFeaturesNVBuilder<'a> { + type Target = PhysicalDeviceDiagnosticsConfigFeaturesNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceDiagnosticsConfigFeaturesNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceDiagnosticsConfigFeaturesNVBuilder<'a> { + #[inline] + pub fn diagnostics_config(mut self, diagnostics_config: bool) -> Self { + self.inner.diagnostics_config = diagnostics_config.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceDiagnosticsConfigFeaturesNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DeviceDiagnosticsConfigCreateInfoNV { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: DeviceDiagnosticsConfigFlagsNV, +} +impl ::std::default::Default for DeviceDiagnosticsConfigCreateInfoNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: DeviceDiagnosticsConfigFlagsNV::default(), + } + } +} +unsafe impl TaggedStructure for DeviceDiagnosticsConfigCreateInfoNV { + const STRUCTURE_TYPE: StructureType = StructureType::DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV; +} +impl DeviceDiagnosticsConfigCreateInfoNV { + pub fn builder<'a>() -> DeviceDiagnosticsConfigCreateInfoNVBuilder<'a> { + DeviceDiagnosticsConfigCreateInfoNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DeviceDiagnosticsConfigCreateInfoNVBuilder<'a> { + inner: DeviceDiagnosticsConfigCreateInfoNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsDeviceCreateInfo for DeviceDiagnosticsConfigCreateInfoNVBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for DeviceDiagnosticsConfigCreateInfoNV {} +impl<'a> ::std::ops::Deref for DeviceDiagnosticsConfigCreateInfoNVBuilder<'a> { + type Target = DeviceDiagnosticsConfigCreateInfoNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DeviceDiagnosticsConfigCreateInfoNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DeviceDiagnosticsConfigCreateInfoNVBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: DeviceDiagnosticsConfigFlagsNV) -> Self { + self.inner.flags = flags; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DeviceDiagnosticsConfigCreateInfoNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub shader_zero_initialize_workgroup_memory: Bool32, +} +impl ::std::default::Default for PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + shader_zero_initialize_workgroup_memory: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES; +} +impl PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures { + pub fn builder<'a>() -> PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesBuilder<'a> { + PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesBuilder<'a> { + inner: PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures {} +unsafe impl ExtendsDeviceCreateInfo + for PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesBuilder<'_> +{ +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures {} +impl<'a> ::std::ops::Deref for PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesBuilder<'a> { + type Target = PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesBuilder<'a> { + #[inline] + pub fn shader_zero_initialize_workgroup_memory( + mut self, + shader_zero_initialize_workgroup_memory: bool, + ) -> Self { + self.inner.shader_zero_initialize_workgroup_memory = + shader_zero_initialize_workgroup_memory.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub shader_subgroup_uniform_control_flow: Bool32, +} +impl ::std::default::Default for PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + shader_subgroup_uniform_control_flow: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR; +} +impl PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR { + pub fn builder<'a>() -> PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHRBuilder<'a> { + PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHRBuilder<'a> { + inner: PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHRBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR +{ +} +unsafe impl ExtendsDeviceCreateInfo + for PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHRBuilder<'_> +{ +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR {} +impl<'a> ::std::ops::Deref + for PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHRBuilder<'a> +{ + type Target = PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut + for PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHRBuilder<'a> +{ + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHRBuilder<'a> { + #[inline] + pub fn shader_subgroup_uniform_control_flow( + mut self, + shader_subgroup_uniform_control_flow: bool, + ) -> Self { + self.inner.shader_subgroup_uniform_control_flow = + shader_subgroup_uniform_control_flow.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceRobustness2FeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub robust_buffer_access2: Bool32, + pub robust_image_access2: Bool32, + pub null_descriptor: Bool32, +} +impl ::std::default::Default for PhysicalDeviceRobustness2FeaturesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + robust_buffer_access2: Bool32::default(), + robust_image_access2: Bool32::default(), + null_descriptor: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceRobustness2FeaturesEXT { + const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT; +} +impl PhysicalDeviceRobustness2FeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceRobustness2FeaturesEXTBuilder<'a> { + PhysicalDeviceRobustness2FeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceRobustness2FeaturesEXTBuilder<'a> { + inner: PhysicalDeviceRobustness2FeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceRobustness2FeaturesEXTBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceRobustness2FeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceRobustness2FeaturesEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceRobustness2FeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceRobustness2FeaturesEXTBuilder<'a> { + type Target = PhysicalDeviceRobustness2FeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceRobustness2FeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceRobustness2FeaturesEXTBuilder<'a> { + #[inline] + pub fn robust_buffer_access2(mut self, robust_buffer_access2: bool) -> Self { + self.inner.robust_buffer_access2 = robust_buffer_access2.into(); + self + } + #[inline] + pub fn robust_image_access2(mut self, robust_image_access2: bool) -> Self { + self.inner.robust_image_access2 = robust_image_access2.into(); + self + } + #[inline] + pub fn null_descriptor(mut self, null_descriptor: bool) -> Self { + self.inner.null_descriptor = null_descriptor.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceRobustness2FeaturesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceRobustness2PropertiesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub robust_storage_buffer_access_size_alignment: DeviceSize, + pub robust_uniform_buffer_access_size_alignment: DeviceSize, +} +impl ::std::default::Default for PhysicalDeviceRobustness2PropertiesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + robust_storage_buffer_access_size_alignment: DeviceSize::default(), + robust_uniform_buffer_access_size_alignment: DeviceSize::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceRobustness2PropertiesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT; +} +impl PhysicalDeviceRobustness2PropertiesEXT { + pub fn builder<'a>() -> PhysicalDeviceRobustness2PropertiesEXTBuilder<'a> { + PhysicalDeviceRobustness2PropertiesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceRobustness2PropertiesEXTBuilder<'a> { + inner: PhysicalDeviceRobustness2PropertiesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceRobustness2PropertiesEXTBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceRobustness2PropertiesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceRobustness2PropertiesEXTBuilder<'a> { + type Target = PhysicalDeviceRobustness2PropertiesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceRobustness2PropertiesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceRobustness2PropertiesEXTBuilder<'a> { + #[inline] + pub fn robust_storage_buffer_access_size_alignment( + mut self, + robust_storage_buffer_access_size_alignment: DeviceSize, + ) -> Self { + self.inner.robust_storage_buffer_access_size_alignment = + robust_storage_buffer_access_size_alignment; + self + } + #[inline] + pub fn robust_uniform_buffer_access_size_alignment( + mut self, + robust_uniform_buffer_access_size_alignment: DeviceSize, + ) -> Self { + self.inner.robust_uniform_buffer_access_size_alignment = + robust_uniform_buffer_access_size_alignment; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceRobustness2PropertiesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceImageRobustnessFeatures { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub robust_image_access: Bool32, +} +impl ::std::default::Default for PhysicalDeviceImageRobustnessFeatures { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + robust_image_access: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceImageRobustnessFeatures { + const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES; +} +impl PhysicalDeviceImageRobustnessFeatures { + pub fn builder<'a>() -> PhysicalDeviceImageRobustnessFeaturesBuilder<'a> { + PhysicalDeviceImageRobustnessFeaturesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceImageRobustnessFeaturesBuilder<'a> { + inner: PhysicalDeviceImageRobustnessFeatures, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceImageRobustnessFeaturesBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceImageRobustnessFeatures {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceImageRobustnessFeaturesBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceImageRobustnessFeatures {} +impl<'a> ::std::ops::Deref for PhysicalDeviceImageRobustnessFeaturesBuilder<'a> { + type Target = PhysicalDeviceImageRobustnessFeatures; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceImageRobustnessFeaturesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceImageRobustnessFeaturesBuilder<'a> { + #[inline] + pub fn robust_image_access(mut self, robust_image_access: bool) -> Self { + self.inner.robust_image_access = robust_image_access.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceImageRobustnessFeatures { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub workgroup_memory_explicit_layout: Bool32, + pub workgroup_memory_explicit_layout_scalar_block_layout: Bool32, + pub workgroup_memory_explicit_layout8_bit_access: Bool32, + pub workgroup_memory_explicit_layout16_bit_access: Bool32, +} +impl ::std::default::Default for PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + workgroup_memory_explicit_layout: Bool32::default(), + workgroup_memory_explicit_layout_scalar_block_layout: Bool32::default(), + workgroup_memory_explicit_layout8_bit_access: Bool32::default(), + workgroup_memory_explicit_layout16_bit_access: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR; +} +impl PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR { + pub fn builder<'a>() -> PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHRBuilder<'a> { + PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHRBuilder<'a> { + inner: PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHRBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR +{ +} +unsafe impl ExtendsDeviceCreateInfo + for PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHRBuilder<'_> +{ +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR {} +impl<'a> ::std::ops::Deref for PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHRBuilder<'a> { + type Target = PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut + for PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHRBuilder<'a> +{ + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHRBuilder<'a> { + #[inline] + pub fn workgroup_memory_explicit_layout( + mut self, + workgroup_memory_explicit_layout: bool, + ) -> Self { + self.inner.workgroup_memory_explicit_layout = workgroup_memory_explicit_layout.into(); + self + } + #[inline] + pub fn workgroup_memory_explicit_layout_scalar_block_layout( + mut self, + workgroup_memory_explicit_layout_scalar_block_layout: bool, + ) -> Self { + self.inner + .workgroup_memory_explicit_layout_scalar_block_layout = + workgroup_memory_explicit_layout_scalar_block_layout.into(); + self + } + #[inline] + pub fn workgroup_memory_explicit_layout8_bit_access( + mut self, + workgroup_memory_explicit_layout8_bit_access: bool, + ) -> Self { + self.inner.workgroup_memory_explicit_layout8_bit_access = + workgroup_memory_explicit_layout8_bit_access.into(); + self + } + #[inline] + pub fn workgroup_memory_explicit_layout16_bit_access( + mut self, + workgroup_memory_explicit_layout16_bit_access: bool, + ) -> Self { + self.inner.workgroup_memory_explicit_layout16_bit_access = + workgroup_memory_explicit_layout16_bit_access.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDevicePortabilitySubsetFeaturesKHR { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub constant_alpha_color_blend_factors: Bool32, + pub events: Bool32, + pub image_view_format_reinterpretation: Bool32, + pub image_view_format_swizzle: Bool32, + pub image_view2_d_on3_d_image: Bool32, + pub multisample_array_image: Bool32, + pub mutable_comparison_samplers: Bool32, + pub point_polygons: Bool32, + pub sampler_mip_lod_bias: Bool32, + pub separate_stencil_mask_ref: Bool32, + pub shader_sample_rate_interpolation_functions: Bool32, + pub tessellation_isolines: Bool32, + pub tessellation_point_mode: Bool32, + pub triangle_fans: Bool32, + pub vertex_attribute_access_beyond_stride: Bool32, +} +impl ::std::default::Default for PhysicalDevicePortabilitySubsetFeaturesKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + constant_alpha_color_blend_factors: Bool32::default(), + events: Bool32::default(), + image_view_format_reinterpretation: Bool32::default(), + image_view_format_swizzle: Bool32::default(), + image_view2_d_on3_d_image: Bool32::default(), + multisample_array_image: Bool32::default(), + mutable_comparison_samplers: Bool32::default(), + point_polygons: Bool32::default(), + sampler_mip_lod_bias: Bool32::default(), + separate_stencil_mask_ref: Bool32::default(), + shader_sample_rate_interpolation_functions: Bool32::default(), + tessellation_isolines: Bool32::default(), + tessellation_point_mode: Bool32::default(), + triangle_fans: Bool32::default(), + vertex_attribute_access_beyond_stride: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDevicePortabilitySubsetFeaturesKHR { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR; +} +impl PhysicalDevicePortabilitySubsetFeaturesKHR { + pub fn builder<'a>() -> PhysicalDevicePortabilitySubsetFeaturesKHRBuilder<'a> { + PhysicalDevicePortabilitySubsetFeaturesKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDevicePortabilitySubsetFeaturesKHRBuilder<'a> { + inner: PhysicalDevicePortabilitySubsetFeaturesKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDevicePortabilitySubsetFeaturesKHRBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePortabilitySubsetFeaturesKHR {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePortabilitySubsetFeaturesKHRBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePortabilitySubsetFeaturesKHR {} +impl<'a> ::std::ops::Deref for PhysicalDevicePortabilitySubsetFeaturesKHRBuilder<'a> { + type Target = PhysicalDevicePortabilitySubsetFeaturesKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDevicePortabilitySubsetFeaturesKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDevicePortabilitySubsetFeaturesKHRBuilder<'a> { + #[inline] + pub fn constant_alpha_color_blend_factors( + mut self, + constant_alpha_color_blend_factors: bool, + ) -> Self { + self.inner.constant_alpha_color_blend_factors = constant_alpha_color_blend_factors.into(); + self + } + #[inline] + pub fn events(mut self, events: bool) -> Self { + self.inner.events = events.into(); + self + } + #[inline] + pub fn image_view_format_reinterpretation( + mut self, + image_view_format_reinterpretation: bool, + ) -> Self { + self.inner.image_view_format_reinterpretation = image_view_format_reinterpretation.into(); + self + } + #[inline] + pub fn image_view_format_swizzle(mut self, image_view_format_swizzle: bool) -> Self { + self.inner.image_view_format_swizzle = image_view_format_swizzle.into(); + self + } + #[inline] + pub fn image_view2_d_on3_d_image(mut self, image_view2_d_on3_d_image: bool) -> Self { + self.inner.image_view2_d_on3_d_image = image_view2_d_on3_d_image.into(); + self + } + #[inline] + pub fn multisample_array_image(mut self, multisample_array_image: bool) -> Self { + self.inner.multisample_array_image = multisample_array_image.into(); + self + } + #[inline] + pub fn mutable_comparison_samplers(mut self, mutable_comparison_samplers: bool) -> Self { + self.inner.mutable_comparison_samplers = mutable_comparison_samplers.into(); + self + } + #[inline] + pub fn point_polygons(mut self, point_polygons: bool) -> Self { + self.inner.point_polygons = point_polygons.into(); + self + } + #[inline] + pub fn sampler_mip_lod_bias(mut self, sampler_mip_lod_bias: bool) -> Self { + self.inner.sampler_mip_lod_bias = sampler_mip_lod_bias.into(); + self + } + #[inline] + pub fn separate_stencil_mask_ref(mut self, separate_stencil_mask_ref: bool) -> Self { + self.inner.separate_stencil_mask_ref = separate_stencil_mask_ref.into(); + self + } + #[inline] + pub fn shader_sample_rate_interpolation_functions( + mut self, + shader_sample_rate_interpolation_functions: bool, + ) -> Self { + self.inner.shader_sample_rate_interpolation_functions = + shader_sample_rate_interpolation_functions.into(); + self + } + #[inline] + pub fn tessellation_isolines(mut self, tessellation_isolines: bool) -> Self { + self.inner.tessellation_isolines = tessellation_isolines.into(); + self + } + #[inline] + pub fn tessellation_point_mode(mut self, tessellation_point_mode: bool) -> Self { + self.inner.tessellation_point_mode = tessellation_point_mode.into(); + self + } + #[inline] + pub fn triangle_fans(mut self, triangle_fans: bool) -> Self { + self.inner.triangle_fans = triangle_fans.into(); + self + } + #[inline] + pub fn vertex_attribute_access_beyond_stride( + mut self, + vertex_attribute_access_beyond_stride: bool, + ) -> Self { + self.inner.vertex_attribute_access_beyond_stride = + vertex_attribute_access_beyond_stride.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDevicePortabilitySubsetFeaturesKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDevicePortabilitySubsetPropertiesKHR { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub min_vertex_input_binding_stride_alignment: u32, +} +impl ::std::default::Default for PhysicalDevicePortabilitySubsetPropertiesKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + min_vertex_input_binding_stride_alignment: u32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDevicePortabilitySubsetPropertiesKHR { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR; +} +impl PhysicalDevicePortabilitySubsetPropertiesKHR { + pub fn builder<'a>() -> PhysicalDevicePortabilitySubsetPropertiesKHRBuilder<'a> { + PhysicalDevicePortabilitySubsetPropertiesKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDevicePortabilitySubsetPropertiesKHRBuilder<'a> { + inner: PhysicalDevicePortabilitySubsetPropertiesKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDevicePortabilitySubsetPropertiesKHRBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDevicePortabilitySubsetPropertiesKHR {} +impl<'a> ::std::ops::Deref for PhysicalDevicePortabilitySubsetPropertiesKHRBuilder<'a> { + type Target = PhysicalDevicePortabilitySubsetPropertiesKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDevicePortabilitySubsetPropertiesKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDevicePortabilitySubsetPropertiesKHRBuilder<'a> { + #[inline] + pub fn min_vertex_input_binding_stride_alignment( + mut self, + min_vertex_input_binding_stride_alignment: u32, + ) -> Self { + self.inner.min_vertex_input_binding_stride_alignment = + min_vertex_input_binding_stride_alignment; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDevicePortabilitySubsetPropertiesKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDevice4444FormatsFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub format_a4r4g4b4: Bool32, + pub format_a4b4g4r4: Bool32, +} +impl ::std::default::Default for PhysicalDevice4444FormatsFeaturesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + format_a4r4g4b4: Bool32::default(), + format_a4b4g4r4: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDevice4444FormatsFeaturesEXT { + const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT; +} +impl PhysicalDevice4444FormatsFeaturesEXT { + pub fn builder<'a>() -> PhysicalDevice4444FormatsFeaturesEXTBuilder<'a> { + PhysicalDevice4444FormatsFeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDevice4444FormatsFeaturesEXTBuilder<'a> { + inner: PhysicalDevice4444FormatsFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevice4444FormatsFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevice4444FormatsFeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDevice4444FormatsFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDevice4444FormatsFeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDevice4444FormatsFeaturesEXTBuilder<'a> { + type Target = PhysicalDevice4444FormatsFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDevice4444FormatsFeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDevice4444FormatsFeaturesEXTBuilder<'a> { + #[inline] + pub fn format_a4r4g4b4(mut self, format_a4r4g4b4: bool) -> Self { + self.inner.format_a4r4g4b4 = format_a4r4g4b4.into(); + self + } + #[inline] + pub fn format_a4b4g4r4(mut self, format_a4b4g4r4: bool) -> Self { + self.inner.format_a4b4g4r4 = format_a4b4g4r4.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDevice4444FormatsFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceSubpassShadingFeaturesHUAWEI { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub subpass_shading: Bool32, +} +impl ::std::default::Default for PhysicalDeviceSubpassShadingFeaturesHUAWEI { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + subpass_shading: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceSubpassShadingFeaturesHUAWEI { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI; +} +impl PhysicalDeviceSubpassShadingFeaturesHUAWEI { + pub fn builder<'a>() -> PhysicalDeviceSubpassShadingFeaturesHUAWEIBuilder<'a> { + PhysicalDeviceSubpassShadingFeaturesHUAWEIBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceSubpassShadingFeaturesHUAWEIBuilder<'a> { + inner: PhysicalDeviceSubpassShadingFeaturesHUAWEI, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceSubpassShadingFeaturesHUAWEIBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceSubpassShadingFeaturesHUAWEI {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceSubpassShadingFeaturesHUAWEIBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceSubpassShadingFeaturesHUAWEI {} +impl<'a> ::std::ops::Deref for PhysicalDeviceSubpassShadingFeaturesHUAWEIBuilder<'a> { + type Target = PhysicalDeviceSubpassShadingFeaturesHUAWEI; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceSubpassShadingFeaturesHUAWEIBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceSubpassShadingFeaturesHUAWEIBuilder<'a> { + #[inline] + pub fn subpass_shading(mut self, subpass_shading: bool) -> Self { + self.inner.subpass_shading = subpass_shading.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceSubpassShadingFeaturesHUAWEI { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct BufferCopy2 { + pub s_type: StructureType, + pub p_next: *const c_void, + pub src_offset: DeviceSize, + pub dst_offset: DeviceSize, + pub size: DeviceSize, +} +impl ::std::default::Default for BufferCopy2 { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + src_offset: DeviceSize::default(), + dst_offset: DeviceSize::default(), + size: DeviceSize::default(), + } + } +} +unsafe impl TaggedStructure for BufferCopy2 { + const STRUCTURE_TYPE: StructureType = StructureType::BUFFER_COPY_2; +} +impl BufferCopy2 { + pub fn builder<'a>() -> BufferCopy2Builder<'a> { + BufferCopy2Builder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct BufferCopy2Builder<'a> { + inner: BufferCopy2, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for BufferCopy2Builder<'a> { + type Target = BufferCopy2; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for BufferCopy2Builder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> BufferCopy2Builder<'a> { + #[inline] + pub fn src_offset(mut self, src_offset: DeviceSize) -> Self { + self.inner.src_offset = src_offset; + self + } + #[inline] + pub fn dst_offset(mut self, dst_offset: DeviceSize) -> Self { + self.inner.dst_offset = dst_offset; + self + } + #[inline] + pub fn size(mut self, size: DeviceSize) -> Self { + self.inner.size = size; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> BufferCopy2 { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ImageCopy2 { + pub s_type: StructureType, + pub p_next: *const c_void, + pub src_subresource: ImageSubresourceLayers, + pub src_offset: Offset3D, + pub dst_subresource: ImageSubresourceLayers, + pub dst_offset: Offset3D, + pub extent: Extent3D, +} +impl ::std::default::Default for ImageCopy2 { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + src_subresource: ImageSubresourceLayers::default(), + src_offset: Offset3D::default(), + dst_subresource: ImageSubresourceLayers::default(), + dst_offset: Offset3D::default(), + extent: Extent3D::default(), + } + } +} +unsafe impl TaggedStructure for ImageCopy2 { + const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_COPY_2; +} +impl ImageCopy2 { + pub fn builder<'a>() -> ImageCopy2Builder<'a> { + ImageCopy2Builder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ImageCopy2Builder<'a> { + inner: ImageCopy2, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ImageCopy2Builder<'a> { + type Target = ImageCopy2; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ImageCopy2Builder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ImageCopy2Builder<'a> { + #[inline] + pub fn src_subresource(mut self, src_subresource: ImageSubresourceLayers) -> Self { + self.inner.src_subresource = src_subresource; + self + } + #[inline] + pub fn src_offset(mut self, src_offset: Offset3D) -> Self { + self.inner.src_offset = src_offset; + self + } + #[inline] + pub fn dst_subresource(mut self, dst_subresource: ImageSubresourceLayers) -> Self { + self.inner.dst_subresource = dst_subresource; + self + } + #[inline] + pub fn dst_offset(mut self, dst_offset: Offset3D) -> Self { + self.inner.dst_offset = dst_offset; + self + } + #[inline] + pub fn extent(mut self, extent: Extent3D) -> Self { + self.inner.extent = extent; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ImageCopy2 { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ImageBlit2 { + pub s_type: StructureType, + pub p_next: *const c_void, + pub src_subresource: ImageSubresourceLayers, + pub src_offsets: [Offset3D; 2], + pub dst_subresource: ImageSubresourceLayers, + pub dst_offsets: [Offset3D; 2], +} +impl ::std::default::Default for ImageBlit2 { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + src_subresource: ImageSubresourceLayers::default(), + src_offsets: unsafe { ::std::mem::zeroed() }, + dst_subresource: ImageSubresourceLayers::default(), + dst_offsets: unsafe { ::std::mem::zeroed() }, + } + } +} +unsafe impl TaggedStructure for ImageBlit2 { + const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_BLIT_2; +} +impl ImageBlit2 { + pub fn builder<'a>() -> ImageBlit2Builder<'a> { + ImageBlit2Builder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ImageBlit2Builder<'a> { + inner: ImageBlit2, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsImageBlit2 {} +impl<'a> ::std::ops::Deref for ImageBlit2Builder<'a> { + type Target = ImageBlit2; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ImageBlit2Builder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ImageBlit2Builder<'a> { + #[inline] + pub fn src_subresource(mut self, src_subresource: ImageSubresourceLayers) -> Self { + self.inner.src_subresource = src_subresource; + self + } + #[inline] + pub fn src_offsets(mut self, src_offsets: [Offset3D; 2]) -> Self { + self.inner.src_offsets = src_offsets; + self + } + #[inline] + pub fn dst_subresource(mut self, dst_subresource: ImageSubresourceLayers) -> Self { + self.inner.dst_subresource = dst_subresource; + self + } + #[inline] + pub fn dst_offsets(mut self, dst_offsets: [Offset3D; 2]) -> Self { + self.inner.dst_offsets = dst_offsets; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ImageBlit2 { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct BufferImageCopy2 { + pub s_type: StructureType, + pub p_next: *const c_void, + pub buffer_offset: DeviceSize, + pub buffer_row_length: u32, + pub buffer_image_height: u32, + pub image_subresource: ImageSubresourceLayers, + pub image_offset: Offset3D, + pub image_extent: Extent3D, +} +impl ::std::default::Default for BufferImageCopy2 { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + buffer_offset: DeviceSize::default(), + buffer_row_length: u32::default(), + buffer_image_height: u32::default(), + image_subresource: ImageSubresourceLayers::default(), + image_offset: Offset3D::default(), + image_extent: Extent3D::default(), + } + } +} +unsafe impl TaggedStructure for BufferImageCopy2 { + const STRUCTURE_TYPE: StructureType = StructureType::BUFFER_IMAGE_COPY_2; +} +impl BufferImageCopy2 { + pub fn builder<'a>() -> BufferImageCopy2Builder<'a> { + BufferImageCopy2Builder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct BufferImageCopy2Builder<'a> { + inner: BufferImageCopy2, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsBufferImageCopy2 {} +impl<'a> ::std::ops::Deref for BufferImageCopy2Builder<'a> { + type Target = BufferImageCopy2; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for BufferImageCopy2Builder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> BufferImageCopy2Builder<'a> { + #[inline] + pub fn buffer_offset(mut self, buffer_offset: DeviceSize) -> Self { + self.inner.buffer_offset = buffer_offset; + self + } + #[inline] + pub fn buffer_row_length(mut self, buffer_row_length: u32) -> Self { + self.inner.buffer_row_length = buffer_row_length; + self + } + #[inline] + pub fn buffer_image_height(mut self, buffer_image_height: u32) -> Self { + self.inner.buffer_image_height = buffer_image_height; + self + } + #[inline] + pub fn image_subresource(mut self, image_subresource: ImageSubresourceLayers) -> Self { + self.inner.image_subresource = image_subresource; + self + } + #[inline] + pub fn image_offset(mut self, image_offset: Offset3D) -> Self { + self.inner.image_offset = image_offset; + self + } + #[inline] + pub fn image_extent(mut self, image_extent: Extent3D) -> Self { + self.inner.image_extent = image_extent; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> BufferImageCopy2 { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ImageResolve2 { + pub s_type: StructureType, + pub p_next: *const c_void, + pub src_subresource: ImageSubresourceLayers, + pub src_offset: Offset3D, + pub dst_subresource: ImageSubresourceLayers, + pub dst_offset: Offset3D, + pub extent: Extent3D, +} +impl ::std::default::Default for ImageResolve2 { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + src_subresource: ImageSubresourceLayers::default(), + src_offset: Offset3D::default(), + dst_subresource: ImageSubresourceLayers::default(), + dst_offset: Offset3D::default(), + extent: Extent3D::default(), + } + } +} +unsafe impl TaggedStructure for ImageResolve2 { + const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_RESOLVE_2; +} +impl ImageResolve2 { + pub fn builder<'a>() -> ImageResolve2Builder<'a> { + ImageResolve2Builder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ImageResolve2Builder<'a> { + inner: ImageResolve2, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ImageResolve2Builder<'a> { + type Target = ImageResolve2; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ImageResolve2Builder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ImageResolve2Builder<'a> { + #[inline] + pub fn src_subresource(mut self, src_subresource: ImageSubresourceLayers) -> Self { + self.inner.src_subresource = src_subresource; + self + } + #[inline] + pub fn src_offset(mut self, src_offset: Offset3D) -> Self { + self.inner.src_offset = src_offset; + self + } + #[inline] + pub fn dst_subresource(mut self, dst_subresource: ImageSubresourceLayers) -> Self { + self.inner.dst_subresource = dst_subresource; + self + } + #[inline] + pub fn dst_offset(mut self, dst_offset: Offset3D) -> Self { + self.inner.dst_offset = dst_offset; + self + } + #[inline] + pub fn extent(mut self, extent: Extent3D) -> Self { + self.inner.extent = extent; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ImageResolve2 { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct CopyBufferInfo2 { + pub s_type: StructureType, + pub p_next: *const c_void, + pub src_buffer: Buffer, + pub dst_buffer: Buffer, + pub region_count: u32, + pub p_regions: *const BufferCopy2, +} +impl ::std::default::Default for CopyBufferInfo2 { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + src_buffer: Buffer::default(), + dst_buffer: Buffer::default(), + region_count: u32::default(), + p_regions: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for CopyBufferInfo2 { + const STRUCTURE_TYPE: StructureType = StructureType::COPY_BUFFER_INFO_2; +} +impl CopyBufferInfo2 { + pub fn builder<'a>() -> CopyBufferInfo2Builder<'a> { + CopyBufferInfo2Builder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct CopyBufferInfo2Builder<'a> { + inner: CopyBufferInfo2, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for CopyBufferInfo2Builder<'a> { + type Target = CopyBufferInfo2; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for CopyBufferInfo2Builder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> CopyBufferInfo2Builder<'a> { + #[inline] + pub fn src_buffer(mut self, src_buffer: Buffer) -> Self { + self.inner.src_buffer = src_buffer; + self + } + #[inline] + pub fn dst_buffer(mut self, dst_buffer: Buffer) -> Self { + self.inner.dst_buffer = dst_buffer; + self + } + #[inline] + pub fn regions(mut self, regions: &'a [BufferCopy2]) -> Self { + self.inner.region_count = regions.len() as _; + self.inner.p_regions = regions.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> CopyBufferInfo2 { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct CopyImageInfo2 { + pub s_type: StructureType, + pub p_next: *const c_void, + pub src_image: Image, + pub src_image_layout: ImageLayout, + pub dst_image: Image, + pub dst_image_layout: ImageLayout, + pub region_count: u32, + pub p_regions: *const ImageCopy2, +} +impl ::std::default::Default for CopyImageInfo2 { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + src_image: Image::default(), + src_image_layout: ImageLayout::default(), + dst_image: Image::default(), + dst_image_layout: ImageLayout::default(), + region_count: u32::default(), + p_regions: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for CopyImageInfo2 { + const STRUCTURE_TYPE: StructureType = StructureType::COPY_IMAGE_INFO_2; +} +impl CopyImageInfo2 { + pub fn builder<'a>() -> CopyImageInfo2Builder<'a> { + CopyImageInfo2Builder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct CopyImageInfo2Builder<'a> { + inner: CopyImageInfo2, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for CopyImageInfo2Builder<'a> { + type Target = CopyImageInfo2; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for CopyImageInfo2Builder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> CopyImageInfo2Builder<'a> { + #[inline] + pub fn src_image(mut self, src_image: Image) -> Self { + self.inner.src_image = src_image; + self + } + #[inline] + pub fn src_image_layout(mut self, src_image_layout: ImageLayout) -> Self { + self.inner.src_image_layout = src_image_layout; + self + } + #[inline] + pub fn dst_image(mut self, dst_image: Image) -> Self { + self.inner.dst_image = dst_image; + self + } + #[inline] + pub fn dst_image_layout(mut self, dst_image_layout: ImageLayout) -> Self { + self.inner.dst_image_layout = dst_image_layout; + self + } + #[inline] + pub fn regions(mut self, regions: &'a [ImageCopy2]) -> Self { + self.inner.region_count = regions.len() as _; + self.inner.p_regions = regions.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> CopyImageInfo2 { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct BlitImageInfo2 { + pub s_type: StructureType, + pub p_next: *const c_void, + pub src_image: Image, + pub src_image_layout: ImageLayout, + pub dst_image: Image, + pub dst_image_layout: ImageLayout, + pub region_count: u32, + pub p_regions: *const ImageBlit2, + pub filter: Filter, +} +impl ::std::default::Default for BlitImageInfo2 { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + src_image: Image::default(), + src_image_layout: ImageLayout::default(), + dst_image: Image::default(), + dst_image_layout: ImageLayout::default(), + region_count: u32::default(), + p_regions: ::std::ptr::null(), + filter: Filter::default(), + } + } +} +unsafe impl TaggedStructure for BlitImageInfo2 { + const STRUCTURE_TYPE: StructureType = StructureType::BLIT_IMAGE_INFO_2; +} +impl BlitImageInfo2 { + pub fn builder<'a>() -> BlitImageInfo2Builder<'a> { + BlitImageInfo2Builder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct BlitImageInfo2Builder<'a> { + inner: BlitImageInfo2, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for BlitImageInfo2Builder<'a> { + type Target = BlitImageInfo2; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for BlitImageInfo2Builder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> BlitImageInfo2Builder<'a> { + #[inline] + pub fn src_image(mut self, src_image: Image) -> Self { + self.inner.src_image = src_image; + self + } + #[inline] + pub fn src_image_layout(mut self, src_image_layout: ImageLayout) -> Self { + self.inner.src_image_layout = src_image_layout; + self + } + #[inline] + pub fn dst_image(mut self, dst_image: Image) -> Self { + self.inner.dst_image = dst_image; + self + } + #[inline] + pub fn dst_image_layout(mut self, dst_image_layout: ImageLayout) -> Self { + self.inner.dst_image_layout = dst_image_layout; + self + } + #[inline] + pub fn regions(mut self, regions: &'a [ImageBlit2]) -> Self { + self.inner.region_count = regions.len() as _; + self.inner.p_regions = regions.as_ptr(); + self + } + #[inline] + pub fn filter(mut self, filter: Filter) -> Self { + self.inner.filter = filter; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> BlitImageInfo2 { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct CopyBufferToImageInfo2 { + pub s_type: StructureType, + pub p_next: *const c_void, + pub src_buffer: Buffer, + pub dst_image: Image, + pub dst_image_layout: ImageLayout, + pub region_count: u32, + pub p_regions: *const BufferImageCopy2, +} +impl ::std::default::Default for CopyBufferToImageInfo2 { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + src_buffer: Buffer::default(), + dst_image: Image::default(), + dst_image_layout: ImageLayout::default(), + region_count: u32::default(), + p_regions: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for CopyBufferToImageInfo2 { + const STRUCTURE_TYPE: StructureType = StructureType::COPY_BUFFER_TO_IMAGE_INFO_2; +} +impl CopyBufferToImageInfo2 { + pub fn builder<'a>() -> CopyBufferToImageInfo2Builder<'a> { + CopyBufferToImageInfo2Builder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct CopyBufferToImageInfo2Builder<'a> { + inner: CopyBufferToImageInfo2, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for CopyBufferToImageInfo2Builder<'a> { + type Target = CopyBufferToImageInfo2; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for CopyBufferToImageInfo2Builder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> CopyBufferToImageInfo2Builder<'a> { + #[inline] + pub fn src_buffer(mut self, src_buffer: Buffer) -> Self { + self.inner.src_buffer = src_buffer; + self + } + #[inline] + pub fn dst_image(mut self, dst_image: Image) -> Self { + self.inner.dst_image = dst_image; + self + } + #[inline] + pub fn dst_image_layout(mut self, dst_image_layout: ImageLayout) -> Self { + self.inner.dst_image_layout = dst_image_layout; + self + } + #[inline] + pub fn regions(mut self, regions: &'a [BufferImageCopy2]) -> Self { + self.inner.region_count = regions.len() as _; + self.inner.p_regions = regions.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> CopyBufferToImageInfo2 { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct CopyImageToBufferInfo2 { + pub s_type: StructureType, + pub p_next: *const c_void, + pub src_image: Image, + pub src_image_layout: ImageLayout, + pub dst_buffer: Buffer, + pub region_count: u32, + pub p_regions: *const BufferImageCopy2, +} +impl ::std::default::Default for CopyImageToBufferInfo2 { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + src_image: Image::default(), + src_image_layout: ImageLayout::default(), + dst_buffer: Buffer::default(), + region_count: u32::default(), + p_regions: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for CopyImageToBufferInfo2 { + const STRUCTURE_TYPE: StructureType = StructureType::COPY_IMAGE_TO_BUFFER_INFO_2; +} +impl CopyImageToBufferInfo2 { + pub fn builder<'a>() -> CopyImageToBufferInfo2Builder<'a> { + CopyImageToBufferInfo2Builder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct CopyImageToBufferInfo2Builder<'a> { + inner: CopyImageToBufferInfo2, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for CopyImageToBufferInfo2Builder<'a> { + type Target = CopyImageToBufferInfo2; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for CopyImageToBufferInfo2Builder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> CopyImageToBufferInfo2Builder<'a> { + #[inline] + pub fn src_image(mut self, src_image: Image) -> Self { + self.inner.src_image = src_image; + self + } + #[inline] + pub fn src_image_layout(mut self, src_image_layout: ImageLayout) -> Self { + self.inner.src_image_layout = src_image_layout; + self + } + #[inline] + pub fn dst_buffer(mut self, dst_buffer: Buffer) -> Self { + self.inner.dst_buffer = dst_buffer; + self + } + #[inline] + pub fn regions(mut self, regions: &'a [BufferImageCopy2]) -> Self { + self.inner.region_count = regions.len() as _; + self.inner.p_regions = regions.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> CopyImageToBufferInfo2 { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ResolveImageInfo2 { + pub s_type: StructureType, + pub p_next: *const c_void, + pub src_image: Image, + pub src_image_layout: ImageLayout, + pub dst_image: Image, + pub dst_image_layout: ImageLayout, + pub region_count: u32, + pub p_regions: *const ImageResolve2, +} +impl ::std::default::Default for ResolveImageInfo2 { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + src_image: Image::default(), + src_image_layout: ImageLayout::default(), + dst_image: Image::default(), + dst_image_layout: ImageLayout::default(), + region_count: u32::default(), + p_regions: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for ResolveImageInfo2 { + const STRUCTURE_TYPE: StructureType = StructureType::RESOLVE_IMAGE_INFO_2; +} +impl ResolveImageInfo2 { + pub fn builder<'a>() -> ResolveImageInfo2Builder<'a> { + ResolveImageInfo2Builder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ResolveImageInfo2Builder<'a> { + inner: ResolveImageInfo2, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ResolveImageInfo2Builder<'a> { + type Target = ResolveImageInfo2; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ResolveImageInfo2Builder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ResolveImageInfo2Builder<'a> { + #[inline] + pub fn src_image(mut self, src_image: Image) -> Self { + self.inner.src_image = src_image; + self + } + #[inline] + pub fn src_image_layout(mut self, src_image_layout: ImageLayout) -> Self { + self.inner.src_image_layout = src_image_layout; + self + } + #[inline] + pub fn dst_image(mut self, dst_image: Image) -> Self { + self.inner.dst_image = dst_image; + self + } + #[inline] + pub fn dst_image_layout(mut self, dst_image_layout: ImageLayout) -> Self { + self.inner.dst_image_layout = dst_image_layout; + self + } + #[inline] + pub fn regions(mut self, regions: &'a [ImageResolve2]) -> Self { + self.inner.region_count = regions.len() as _; + self.inner.p_regions = regions.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ResolveImageInfo2 { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceShaderImageAtomicInt64FeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub shader_image_int64_atomics: Bool32, + pub sparse_image_int64_atomics: Bool32, +} +impl ::std::default::Default for PhysicalDeviceShaderImageAtomicInt64FeaturesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + shader_image_int64_atomics: Bool32::default(), + sparse_image_int64_atomics: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceShaderImageAtomicInt64FeaturesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT; +} +impl PhysicalDeviceShaderImageAtomicInt64FeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceShaderImageAtomicInt64FeaturesEXTBuilder<'a> { + PhysicalDeviceShaderImageAtomicInt64FeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceShaderImageAtomicInt64FeaturesEXTBuilder<'a> { + inner: PhysicalDeviceShaderImageAtomicInt64FeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceShaderImageAtomicInt64FeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderImageAtomicInt64FeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderImageAtomicInt64FeaturesEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderImageAtomicInt64FeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceShaderImageAtomicInt64FeaturesEXTBuilder<'a> { + type Target = PhysicalDeviceShaderImageAtomicInt64FeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderImageAtomicInt64FeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceShaderImageAtomicInt64FeaturesEXTBuilder<'a> { + #[inline] + pub fn shader_image_int64_atomics(mut self, shader_image_int64_atomics: bool) -> Self { + self.inner.shader_image_int64_atomics = shader_image_int64_atomics.into(); + self + } + #[inline] + pub fn sparse_image_int64_atomics(mut self, sparse_image_int64_atomics: bool) -> Self { + self.inner.sparse_image_int64_atomics = sparse_image_int64_atomics.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceShaderImageAtomicInt64FeaturesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct FragmentShadingRateAttachmentInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub p_fragment_shading_rate_attachment: *const AttachmentReference2, + pub shading_rate_attachment_texel_size: Extent2D, +} +impl ::std::default::Default for FragmentShadingRateAttachmentInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + p_fragment_shading_rate_attachment: ::std::ptr::null(), + shading_rate_attachment_texel_size: Extent2D::default(), + } + } +} +unsafe impl TaggedStructure for FragmentShadingRateAttachmentInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR; +} +impl FragmentShadingRateAttachmentInfoKHR { + pub fn builder<'a>() -> FragmentShadingRateAttachmentInfoKHRBuilder<'a> { + FragmentShadingRateAttachmentInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct FragmentShadingRateAttachmentInfoKHRBuilder<'a> { + inner: FragmentShadingRateAttachmentInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsSubpassDescription2 for FragmentShadingRateAttachmentInfoKHRBuilder<'_> {} +unsafe impl ExtendsSubpassDescription2 for FragmentShadingRateAttachmentInfoKHR {} +impl<'a> ::std::ops::Deref for FragmentShadingRateAttachmentInfoKHRBuilder<'a> { + type Target = FragmentShadingRateAttachmentInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for FragmentShadingRateAttachmentInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> FragmentShadingRateAttachmentInfoKHRBuilder<'a> { + #[inline] + pub fn fragment_shading_rate_attachment( + mut self, + fragment_shading_rate_attachment: &'a AttachmentReference2, + ) -> Self { + self.inner.p_fragment_shading_rate_attachment = fragment_shading_rate_attachment; + self + } + #[inline] + pub fn shading_rate_attachment_texel_size( + mut self, + shading_rate_attachment_texel_size: Extent2D, + ) -> Self { + self.inner.shading_rate_attachment_texel_size = shading_rate_attachment_texel_size; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> FragmentShadingRateAttachmentInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PipelineFragmentShadingRateStateCreateInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub fragment_size: Extent2D, + pub combiner_ops: [FragmentShadingRateCombinerOpKHR; 2], +} +impl ::std::default::Default for PipelineFragmentShadingRateStateCreateInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + fragment_size: Extent2D::default(), + combiner_ops: unsafe { ::std::mem::zeroed() }, + } + } +} +unsafe impl TaggedStructure for PipelineFragmentShadingRateStateCreateInfoKHR { + const STRUCTURE_TYPE: StructureType = + StructureType::PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR; +} +impl PipelineFragmentShadingRateStateCreateInfoKHR { + pub fn builder<'a>() -> PipelineFragmentShadingRateStateCreateInfoKHRBuilder<'a> { + PipelineFragmentShadingRateStateCreateInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PipelineFragmentShadingRateStateCreateInfoKHRBuilder<'a> { + inner: PipelineFragmentShadingRateStateCreateInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsGraphicsPipelineCreateInfo + for PipelineFragmentShadingRateStateCreateInfoKHRBuilder<'_> +{ +} +unsafe impl ExtendsGraphicsPipelineCreateInfo for PipelineFragmentShadingRateStateCreateInfoKHR {} +impl<'a> ::std::ops::Deref for PipelineFragmentShadingRateStateCreateInfoKHRBuilder<'a> { + type Target = PipelineFragmentShadingRateStateCreateInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PipelineFragmentShadingRateStateCreateInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PipelineFragmentShadingRateStateCreateInfoKHRBuilder<'a> { + #[inline] + pub fn fragment_size(mut self, fragment_size: Extent2D) -> Self { + self.inner.fragment_size = fragment_size; + self + } + #[inline] + pub fn combiner_ops(mut self, combiner_ops: [FragmentShadingRateCombinerOpKHR; 2]) -> Self { + self.inner.combiner_ops = combiner_ops; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PipelineFragmentShadingRateStateCreateInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceFragmentShadingRateFeaturesKHR { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub pipeline_fragment_shading_rate: Bool32, + pub primitive_fragment_shading_rate: Bool32, + pub attachment_fragment_shading_rate: Bool32, +} +impl ::std::default::Default for PhysicalDeviceFragmentShadingRateFeaturesKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + pipeline_fragment_shading_rate: Bool32::default(), + primitive_fragment_shading_rate: Bool32::default(), + attachment_fragment_shading_rate: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceFragmentShadingRateFeaturesKHR { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR; +} +impl PhysicalDeviceFragmentShadingRateFeaturesKHR { + pub fn builder<'a>() -> PhysicalDeviceFragmentShadingRateFeaturesKHRBuilder<'a> { + PhysicalDeviceFragmentShadingRateFeaturesKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceFragmentShadingRateFeaturesKHRBuilder<'a> { + inner: PhysicalDeviceFragmentShadingRateFeaturesKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceFragmentShadingRateFeaturesKHRBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceFragmentShadingRateFeaturesKHR {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFragmentShadingRateFeaturesKHRBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFragmentShadingRateFeaturesKHR {} +impl<'a> ::std::ops::Deref for PhysicalDeviceFragmentShadingRateFeaturesKHRBuilder<'a> { + type Target = PhysicalDeviceFragmentShadingRateFeaturesKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceFragmentShadingRateFeaturesKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceFragmentShadingRateFeaturesKHRBuilder<'a> { + #[inline] + pub fn pipeline_fragment_shading_rate(mut self, pipeline_fragment_shading_rate: bool) -> Self { + self.inner.pipeline_fragment_shading_rate = pipeline_fragment_shading_rate.into(); + self + } + #[inline] + pub fn primitive_fragment_shading_rate( + mut self, + primitive_fragment_shading_rate: bool, + ) -> Self { + self.inner.primitive_fragment_shading_rate = primitive_fragment_shading_rate.into(); + self + } + #[inline] + pub fn attachment_fragment_shading_rate( + mut self, + attachment_fragment_shading_rate: bool, + ) -> Self { + self.inner.attachment_fragment_shading_rate = attachment_fragment_shading_rate.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceFragmentShadingRateFeaturesKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceFragmentShadingRatePropertiesKHR { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub min_fragment_shading_rate_attachment_texel_size: Extent2D, + pub max_fragment_shading_rate_attachment_texel_size: Extent2D, + pub max_fragment_shading_rate_attachment_texel_size_aspect_ratio: u32, + pub primitive_fragment_shading_rate_with_multiple_viewports: Bool32, + pub layered_shading_rate_attachments: Bool32, + pub fragment_shading_rate_non_trivial_combiner_ops: Bool32, + pub max_fragment_size: Extent2D, + pub max_fragment_size_aspect_ratio: u32, + pub max_fragment_shading_rate_coverage_samples: u32, + pub max_fragment_shading_rate_rasterization_samples: SampleCountFlags, + pub fragment_shading_rate_with_shader_depth_stencil_writes: Bool32, + pub fragment_shading_rate_with_sample_mask: Bool32, + pub fragment_shading_rate_with_shader_sample_mask: Bool32, + pub fragment_shading_rate_with_conservative_rasterization: Bool32, + pub fragment_shading_rate_with_fragment_shader_interlock: Bool32, + pub fragment_shading_rate_with_custom_sample_locations: Bool32, + pub fragment_shading_rate_strict_multiply_combiner: Bool32, +} +impl ::std::default::Default for PhysicalDeviceFragmentShadingRatePropertiesKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + min_fragment_shading_rate_attachment_texel_size: Extent2D::default(), + max_fragment_shading_rate_attachment_texel_size: Extent2D::default(), + max_fragment_shading_rate_attachment_texel_size_aspect_ratio: u32::default(), + primitive_fragment_shading_rate_with_multiple_viewports: Bool32::default(), + layered_shading_rate_attachments: Bool32::default(), + fragment_shading_rate_non_trivial_combiner_ops: Bool32::default(), + max_fragment_size: Extent2D::default(), + max_fragment_size_aspect_ratio: u32::default(), + max_fragment_shading_rate_coverage_samples: u32::default(), + max_fragment_shading_rate_rasterization_samples: SampleCountFlags::default(), + fragment_shading_rate_with_shader_depth_stencil_writes: Bool32::default(), + fragment_shading_rate_with_sample_mask: Bool32::default(), + fragment_shading_rate_with_shader_sample_mask: Bool32::default(), + fragment_shading_rate_with_conservative_rasterization: Bool32::default(), + fragment_shading_rate_with_fragment_shader_interlock: Bool32::default(), + fragment_shading_rate_with_custom_sample_locations: Bool32::default(), + fragment_shading_rate_strict_multiply_combiner: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceFragmentShadingRatePropertiesKHR { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR; +} +impl PhysicalDeviceFragmentShadingRatePropertiesKHR { + pub fn builder<'a>() -> PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder<'a> { + PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder<'a> { + inner: PhysicalDeviceFragmentShadingRatePropertiesKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceFragmentShadingRatePropertiesKHR {} +impl<'a> ::std::ops::Deref for PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder<'a> { + type Target = PhysicalDeviceFragmentShadingRatePropertiesKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder<'a> { + #[inline] + pub fn min_fragment_shading_rate_attachment_texel_size( + mut self, + min_fragment_shading_rate_attachment_texel_size: Extent2D, + ) -> Self { + self.inner.min_fragment_shading_rate_attachment_texel_size = + min_fragment_shading_rate_attachment_texel_size; + self + } + #[inline] + pub fn max_fragment_shading_rate_attachment_texel_size( + mut self, + max_fragment_shading_rate_attachment_texel_size: Extent2D, + ) -> Self { + self.inner.max_fragment_shading_rate_attachment_texel_size = + max_fragment_shading_rate_attachment_texel_size; + self + } + #[inline] + pub fn max_fragment_shading_rate_attachment_texel_size_aspect_ratio( + mut self, + max_fragment_shading_rate_attachment_texel_size_aspect_ratio: u32, + ) -> Self { + self.inner + .max_fragment_shading_rate_attachment_texel_size_aspect_ratio = + max_fragment_shading_rate_attachment_texel_size_aspect_ratio; + self + } + #[inline] + pub fn primitive_fragment_shading_rate_with_multiple_viewports( + mut self, + primitive_fragment_shading_rate_with_multiple_viewports: bool, + ) -> Self { + self.inner + .primitive_fragment_shading_rate_with_multiple_viewports = + primitive_fragment_shading_rate_with_multiple_viewports.into(); + self + } + #[inline] + pub fn layered_shading_rate_attachments( + mut self, + layered_shading_rate_attachments: bool, + ) -> Self { + self.inner.layered_shading_rate_attachments = layered_shading_rate_attachments.into(); + self + } + #[inline] + pub fn fragment_shading_rate_non_trivial_combiner_ops( + mut self, + fragment_shading_rate_non_trivial_combiner_ops: bool, + ) -> Self { + self.inner.fragment_shading_rate_non_trivial_combiner_ops = + fragment_shading_rate_non_trivial_combiner_ops.into(); + self + } + #[inline] + pub fn max_fragment_size(mut self, max_fragment_size: Extent2D) -> Self { + self.inner.max_fragment_size = max_fragment_size; + self + } + #[inline] + pub fn max_fragment_size_aspect_ratio(mut self, max_fragment_size_aspect_ratio: u32) -> Self { + self.inner.max_fragment_size_aspect_ratio = max_fragment_size_aspect_ratio; + self + } + #[inline] + pub fn max_fragment_shading_rate_coverage_samples( + mut self, + max_fragment_shading_rate_coverage_samples: u32, + ) -> Self { + self.inner.max_fragment_shading_rate_coverage_samples = + max_fragment_shading_rate_coverage_samples; + self + } + #[inline] + pub fn max_fragment_shading_rate_rasterization_samples( + mut self, + max_fragment_shading_rate_rasterization_samples: SampleCountFlags, + ) -> Self { + self.inner.max_fragment_shading_rate_rasterization_samples = + max_fragment_shading_rate_rasterization_samples; + self + } + #[inline] + pub fn fragment_shading_rate_with_shader_depth_stencil_writes( + mut self, + fragment_shading_rate_with_shader_depth_stencil_writes: bool, + ) -> Self { + self.inner + .fragment_shading_rate_with_shader_depth_stencil_writes = + fragment_shading_rate_with_shader_depth_stencil_writes.into(); + self + } + #[inline] + pub fn fragment_shading_rate_with_sample_mask( + mut self, + fragment_shading_rate_with_sample_mask: bool, + ) -> Self { + self.inner.fragment_shading_rate_with_sample_mask = + fragment_shading_rate_with_sample_mask.into(); + self + } + #[inline] + pub fn fragment_shading_rate_with_shader_sample_mask( + mut self, + fragment_shading_rate_with_shader_sample_mask: bool, + ) -> Self { + self.inner.fragment_shading_rate_with_shader_sample_mask = + fragment_shading_rate_with_shader_sample_mask.into(); + self + } + #[inline] + pub fn fragment_shading_rate_with_conservative_rasterization( + mut self, + fragment_shading_rate_with_conservative_rasterization: bool, + ) -> Self { + self.inner + .fragment_shading_rate_with_conservative_rasterization = + fragment_shading_rate_with_conservative_rasterization.into(); + self + } + #[inline] + pub fn fragment_shading_rate_with_fragment_shader_interlock( + mut self, + fragment_shading_rate_with_fragment_shader_interlock: bool, + ) -> Self { + self.inner + .fragment_shading_rate_with_fragment_shader_interlock = + fragment_shading_rate_with_fragment_shader_interlock.into(); + self + } + #[inline] + pub fn fragment_shading_rate_with_custom_sample_locations( + mut self, + fragment_shading_rate_with_custom_sample_locations: bool, + ) -> Self { + self.inner + .fragment_shading_rate_with_custom_sample_locations = + fragment_shading_rate_with_custom_sample_locations.into(); + self + } + #[inline] + pub fn fragment_shading_rate_strict_multiply_combiner( + mut self, + fragment_shading_rate_strict_multiply_combiner: bool, + ) -> Self { + self.inner.fragment_shading_rate_strict_multiply_combiner = + fragment_shading_rate_strict_multiply_combiner.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceFragmentShadingRatePropertiesKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceFragmentShadingRateKHR { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub sample_counts: SampleCountFlags, + pub fragment_size: Extent2D, +} +impl ::std::default::Default for PhysicalDeviceFragmentShadingRateKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + sample_counts: SampleCountFlags::default(), + fragment_size: Extent2D::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceFragmentShadingRateKHR { + const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR; +} +impl PhysicalDeviceFragmentShadingRateKHR { + pub fn builder<'a>() -> PhysicalDeviceFragmentShadingRateKHRBuilder<'a> { + PhysicalDeviceFragmentShadingRateKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceFragmentShadingRateKHRBuilder<'a> { + inner: PhysicalDeviceFragmentShadingRateKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PhysicalDeviceFragmentShadingRateKHRBuilder<'a> { + type Target = PhysicalDeviceFragmentShadingRateKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceFragmentShadingRateKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceFragmentShadingRateKHRBuilder<'a> { + #[inline] + pub fn sample_counts(mut self, sample_counts: SampleCountFlags) -> Self { + self.inner.sample_counts = sample_counts; + self + } + #[inline] + pub fn fragment_size(mut self, fragment_size: Extent2D) -> Self { + self.inner.fragment_size = fragment_size; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceFragmentShadingRateKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceShaderTerminateInvocationFeatures { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub shader_terminate_invocation: Bool32, +} +impl ::std::default::Default for PhysicalDeviceShaderTerminateInvocationFeatures { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + shader_terminate_invocation: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceShaderTerminateInvocationFeatures { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES; +} +impl PhysicalDeviceShaderTerminateInvocationFeatures { + pub fn builder<'a>() -> PhysicalDeviceShaderTerminateInvocationFeaturesBuilder<'a> { + PhysicalDeviceShaderTerminateInvocationFeaturesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceShaderTerminateInvocationFeaturesBuilder<'a> { + inner: PhysicalDeviceShaderTerminateInvocationFeatures, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceShaderTerminateInvocationFeaturesBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderTerminateInvocationFeatures {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderTerminateInvocationFeaturesBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderTerminateInvocationFeatures {} +impl<'a> ::std::ops::Deref for PhysicalDeviceShaderTerminateInvocationFeaturesBuilder<'a> { + type Target = PhysicalDeviceShaderTerminateInvocationFeatures; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderTerminateInvocationFeaturesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceShaderTerminateInvocationFeaturesBuilder<'a> { + #[inline] + pub fn shader_terminate_invocation(mut self, shader_terminate_invocation: bool) -> Self { + self.inner.shader_terminate_invocation = shader_terminate_invocation.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceShaderTerminateInvocationFeatures { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceFragmentShadingRateEnumsFeaturesNV { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub fragment_shading_rate_enums: Bool32, + pub supersample_fragment_shading_rates: Bool32, + pub no_invocation_fragment_shading_rates: Bool32, +} +impl ::std::default::Default for PhysicalDeviceFragmentShadingRateEnumsFeaturesNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + fragment_shading_rate_enums: Bool32::default(), + supersample_fragment_shading_rates: Bool32::default(), + no_invocation_fragment_shading_rates: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceFragmentShadingRateEnumsFeaturesNV { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV; +} +impl PhysicalDeviceFragmentShadingRateEnumsFeaturesNV { + pub fn builder<'a>() -> PhysicalDeviceFragmentShadingRateEnumsFeaturesNVBuilder<'a> { + PhysicalDeviceFragmentShadingRateEnumsFeaturesNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceFragmentShadingRateEnumsFeaturesNVBuilder<'a> { + inner: PhysicalDeviceFragmentShadingRateEnumsFeaturesNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceFragmentShadingRateEnumsFeaturesNVBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceFragmentShadingRateEnumsFeaturesNV {} +unsafe impl ExtendsDeviceCreateInfo + for PhysicalDeviceFragmentShadingRateEnumsFeaturesNVBuilder<'_> +{ +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFragmentShadingRateEnumsFeaturesNV {} +impl<'a> ::std::ops::Deref for PhysicalDeviceFragmentShadingRateEnumsFeaturesNVBuilder<'a> { + type Target = PhysicalDeviceFragmentShadingRateEnumsFeaturesNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceFragmentShadingRateEnumsFeaturesNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceFragmentShadingRateEnumsFeaturesNVBuilder<'a> { + #[inline] + pub fn fragment_shading_rate_enums(mut self, fragment_shading_rate_enums: bool) -> Self { + self.inner.fragment_shading_rate_enums = fragment_shading_rate_enums.into(); + self + } + #[inline] + pub fn supersample_fragment_shading_rates( + mut self, + supersample_fragment_shading_rates: bool, + ) -> Self { + self.inner.supersample_fragment_shading_rates = supersample_fragment_shading_rates.into(); + self + } + #[inline] + pub fn no_invocation_fragment_shading_rates( + mut self, + no_invocation_fragment_shading_rates: bool, + ) -> Self { + self.inner.no_invocation_fragment_shading_rates = + no_invocation_fragment_shading_rates.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceFragmentShadingRateEnumsFeaturesNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceFragmentShadingRateEnumsPropertiesNV { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub max_fragment_shading_rate_invocation_count: SampleCountFlags, +} +impl ::std::default::Default for PhysicalDeviceFragmentShadingRateEnumsPropertiesNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + max_fragment_shading_rate_invocation_count: SampleCountFlags::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceFragmentShadingRateEnumsPropertiesNV { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV; +} +impl PhysicalDeviceFragmentShadingRateEnumsPropertiesNV { + pub fn builder<'a>() -> PhysicalDeviceFragmentShadingRateEnumsPropertiesNVBuilder<'a> { + PhysicalDeviceFragmentShadingRateEnumsPropertiesNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceFragmentShadingRateEnumsPropertiesNVBuilder<'a> { + inner: PhysicalDeviceFragmentShadingRateEnumsPropertiesNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceFragmentShadingRateEnumsPropertiesNVBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceFragmentShadingRateEnumsPropertiesNV +{ +} +impl<'a> ::std::ops::Deref for PhysicalDeviceFragmentShadingRateEnumsPropertiesNVBuilder<'a> { + type Target = PhysicalDeviceFragmentShadingRateEnumsPropertiesNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceFragmentShadingRateEnumsPropertiesNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceFragmentShadingRateEnumsPropertiesNVBuilder<'a> { + #[inline] + pub fn max_fragment_shading_rate_invocation_count( + mut self, + max_fragment_shading_rate_invocation_count: SampleCountFlags, + ) -> Self { + self.inner.max_fragment_shading_rate_invocation_count = + max_fragment_shading_rate_invocation_count; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceFragmentShadingRateEnumsPropertiesNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PipelineFragmentShadingRateEnumStateCreateInfoNV { + pub s_type: StructureType, + pub p_next: *const c_void, + pub shading_rate_type: FragmentShadingRateTypeNV, + pub shading_rate: FragmentShadingRateNV, + pub combiner_ops: [FragmentShadingRateCombinerOpKHR; 2], +} +impl ::std::default::Default for PipelineFragmentShadingRateEnumStateCreateInfoNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + shading_rate_type: FragmentShadingRateTypeNV::default(), + shading_rate: FragmentShadingRateNV::default(), + combiner_ops: unsafe { ::std::mem::zeroed() }, + } + } +} +unsafe impl TaggedStructure for PipelineFragmentShadingRateEnumStateCreateInfoNV { + const STRUCTURE_TYPE: StructureType = + StructureType::PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV; +} +impl PipelineFragmentShadingRateEnumStateCreateInfoNV { + pub fn builder<'a>() -> PipelineFragmentShadingRateEnumStateCreateInfoNVBuilder<'a> { + PipelineFragmentShadingRateEnumStateCreateInfoNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PipelineFragmentShadingRateEnumStateCreateInfoNVBuilder<'a> { + inner: PipelineFragmentShadingRateEnumStateCreateInfoNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsGraphicsPipelineCreateInfo + for PipelineFragmentShadingRateEnumStateCreateInfoNVBuilder<'_> +{ +} +unsafe impl ExtendsGraphicsPipelineCreateInfo for PipelineFragmentShadingRateEnumStateCreateInfoNV {} +impl<'a> ::std::ops::Deref for PipelineFragmentShadingRateEnumStateCreateInfoNVBuilder<'a> { + type Target = PipelineFragmentShadingRateEnumStateCreateInfoNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PipelineFragmentShadingRateEnumStateCreateInfoNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PipelineFragmentShadingRateEnumStateCreateInfoNVBuilder<'a> { + #[inline] + pub fn shading_rate_type(mut self, shading_rate_type: FragmentShadingRateTypeNV) -> Self { + self.inner.shading_rate_type = shading_rate_type; + self + } + #[inline] + pub fn shading_rate(mut self, shading_rate: FragmentShadingRateNV) -> Self { + self.inner.shading_rate = shading_rate; + self + } + #[inline] + pub fn combiner_ops(mut self, combiner_ops: [FragmentShadingRateCombinerOpKHR; 2]) -> Self { + self.inner.combiner_ops = combiner_ops; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PipelineFragmentShadingRateEnumStateCreateInfoNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct AccelerationStructureBuildSizesInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub acceleration_structure_size: DeviceSize, + pub update_scratch_size: DeviceSize, + pub build_scratch_size: DeviceSize, +} +impl ::std::default::Default for AccelerationStructureBuildSizesInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + acceleration_structure_size: DeviceSize::default(), + update_scratch_size: DeviceSize::default(), + build_scratch_size: DeviceSize::default(), + } + } +} +unsafe impl TaggedStructure for AccelerationStructureBuildSizesInfoKHR { + const STRUCTURE_TYPE: StructureType = + StructureType::ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR; +} +impl AccelerationStructureBuildSizesInfoKHR { + pub fn builder<'a>() -> AccelerationStructureBuildSizesInfoKHRBuilder<'a> { + AccelerationStructureBuildSizesInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct AccelerationStructureBuildSizesInfoKHRBuilder<'a> { + inner: AccelerationStructureBuildSizesInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for AccelerationStructureBuildSizesInfoKHRBuilder<'a> { + type Target = AccelerationStructureBuildSizesInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for AccelerationStructureBuildSizesInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> AccelerationStructureBuildSizesInfoKHRBuilder<'a> { + #[inline] + pub fn acceleration_structure_size(mut self, acceleration_structure_size: DeviceSize) -> Self { + self.inner.acceleration_structure_size = acceleration_structure_size; + self + } + #[inline] + pub fn update_scratch_size(mut self, update_scratch_size: DeviceSize) -> Self { + self.inner.update_scratch_size = update_scratch_size; + self + } + #[inline] + pub fn build_scratch_size(mut self, build_scratch_size: DeviceSize) -> Self { + self.inner.build_scratch_size = build_scratch_size; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> AccelerationStructureBuildSizesInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceImage2DViewOf3DFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub image2_d_view_of3_d: Bool32, + pub sampler2_d_view_of3_d: Bool32, +} +impl ::std::default::Default for PhysicalDeviceImage2DViewOf3DFeaturesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + image2_d_view_of3_d: Bool32::default(), + sampler2_d_view_of3_d: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceImage2DViewOf3DFeaturesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT; +} +impl PhysicalDeviceImage2DViewOf3DFeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceImage2DViewOf3DFeaturesEXTBuilder<'a> { + PhysicalDeviceImage2DViewOf3DFeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceImage2DViewOf3DFeaturesEXTBuilder<'a> { + inner: PhysicalDeviceImage2DViewOf3DFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceImage2DViewOf3DFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceImage2DViewOf3DFeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceImage2DViewOf3DFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceImage2DViewOf3DFeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceImage2DViewOf3DFeaturesEXTBuilder<'a> { + type Target = PhysicalDeviceImage2DViewOf3DFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceImage2DViewOf3DFeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceImage2DViewOf3DFeaturesEXTBuilder<'a> { + #[inline] + pub fn image2_d_view_of3_d(mut self, image2_d_view_of3_d: bool) -> Self { + self.inner.image2_d_view_of3_d = image2_d_view_of3_d.into(); + self + } + #[inline] + pub fn sampler2_d_view_of3_d(mut self, sampler2_d_view_of3_d: bool) -> Self { + self.inner.sampler2_d_view_of3_d = sampler2_d_view_of3_d.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceImage2DViewOf3DFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceMutableDescriptorTypeFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub mutable_descriptor_type: Bool32, +} +impl ::std::default::Default for PhysicalDeviceMutableDescriptorTypeFeaturesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + mutable_descriptor_type: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceMutableDescriptorTypeFeaturesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT; +} +impl PhysicalDeviceMutableDescriptorTypeFeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceMutableDescriptorTypeFeaturesEXTBuilder<'a> { + PhysicalDeviceMutableDescriptorTypeFeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceMutableDescriptorTypeFeaturesEXTBuilder<'a> { + inner: PhysicalDeviceMutableDescriptorTypeFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceMutableDescriptorTypeFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceMutableDescriptorTypeFeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMutableDescriptorTypeFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMutableDescriptorTypeFeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceMutableDescriptorTypeFeaturesEXTBuilder<'a> { + type Target = PhysicalDeviceMutableDescriptorTypeFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceMutableDescriptorTypeFeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceMutableDescriptorTypeFeaturesEXTBuilder<'a> { + #[inline] + pub fn mutable_descriptor_type(mut self, mutable_descriptor_type: bool) -> Self { + self.inner.mutable_descriptor_type = mutable_descriptor_type.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceMutableDescriptorTypeFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct MutableDescriptorTypeListEXT { + pub descriptor_type_count: u32, + pub p_descriptor_types: *const DescriptorType, +} +impl ::std::default::Default for MutableDescriptorTypeListEXT { + #[inline] + fn default() -> Self { + Self { + descriptor_type_count: u32::default(), + p_descriptor_types: ::std::ptr::null(), + } + } +} +impl MutableDescriptorTypeListEXT { + pub fn builder<'a>() -> MutableDescriptorTypeListEXTBuilder<'a> { + MutableDescriptorTypeListEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct MutableDescriptorTypeListEXTBuilder<'a> { + inner: MutableDescriptorTypeListEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for MutableDescriptorTypeListEXTBuilder<'a> { + type Target = MutableDescriptorTypeListEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for MutableDescriptorTypeListEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> MutableDescriptorTypeListEXTBuilder<'a> { + #[inline] + pub fn descriptor_types(mut self, descriptor_types: &'a [DescriptorType]) -> Self { + self.inner.descriptor_type_count = descriptor_types.len() as _; + self.inner.p_descriptor_types = descriptor_types.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> MutableDescriptorTypeListEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct MutableDescriptorTypeCreateInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub mutable_descriptor_type_list_count: u32, + pub p_mutable_descriptor_type_lists: *const MutableDescriptorTypeListEXT, +} +impl ::std::default::Default for MutableDescriptorTypeCreateInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + mutable_descriptor_type_list_count: u32::default(), + p_mutable_descriptor_type_lists: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for MutableDescriptorTypeCreateInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT; +} +impl MutableDescriptorTypeCreateInfoEXT { + pub fn builder<'a>() -> MutableDescriptorTypeCreateInfoEXTBuilder<'a> { + MutableDescriptorTypeCreateInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct MutableDescriptorTypeCreateInfoEXTBuilder<'a> { + inner: MutableDescriptorTypeCreateInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsDescriptorSetLayoutCreateInfo for MutableDescriptorTypeCreateInfoEXTBuilder<'_> {} +unsafe impl ExtendsDescriptorSetLayoutCreateInfo for MutableDescriptorTypeCreateInfoEXT {} +unsafe impl ExtendsDescriptorPoolCreateInfo for MutableDescriptorTypeCreateInfoEXTBuilder<'_> {} +unsafe impl ExtendsDescriptorPoolCreateInfo for MutableDescriptorTypeCreateInfoEXT {} +impl<'a> ::std::ops::Deref for MutableDescriptorTypeCreateInfoEXTBuilder<'a> { + type Target = MutableDescriptorTypeCreateInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for MutableDescriptorTypeCreateInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> MutableDescriptorTypeCreateInfoEXTBuilder<'a> { + #[inline] + pub fn mutable_descriptor_type_lists( + mut self, + mutable_descriptor_type_lists: &'a [MutableDescriptorTypeListEXT], + ) -> Self { + self.inner.mutable_descriptor_type_list_count = mutable_descriptor_type_lists.len() as _; + self.inner.p_mutable_descriptor_type_lists = mutable_descriptor_type_lists.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> MutableDescriptorTypeCreateInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceDepthClipControlFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub depth_clip_control: Bool32, +} +impl ::std::default::Default for PhysicalDeviceDepthClipControlFeaturesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + depth_clip_control: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceDepthClipControlFeaturesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT; +} +impl PhysicalDeviceDepthClipControlFeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceDepthClipControlFeaturesEXTBuilder<'a> { + PhysicalDeviceDepthClipControlFeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceDepthClipControlFeaturesEXTBuilder<'a> { + inner: PhysicalDeviceDepthClipControlFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceDepthClipControlFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceDepthClipControlFeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDepthClipControlFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDepthClipControlFeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceDepthClipControlFeaturesEXTBuilder<'a> { + type Target = PhysicalDeviceDepthClipControlFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceDepthClipControlFeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceDepthClipControlFeaturesEXTBuilder<'a> { + #[inline] + pub fn depth_clip_control(mut self, depth_clip_control: bool) -> Self { + self.inner.depth_clip_control = depth_clip_control.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceDepthClipControlFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PipelineViewportDepthClipControlCreateInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub negative_one_to_one: Bool32, +} +impl ::std::default::Default for PipelineViewportDepthClipControlCreateInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + negative_one_to_one: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PipelineViewportDepthClipControlCreateInfoEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT; +} +impl PipelineViewportDepthClipControlCreateInfoEXT { + pub fn builder<'a>() -> PipelineViewportDepthClipControlCreateInfoEXTBuilder<'a> { + PipelineViewportDepthClipControlCreateInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PipelineViewportDepthClipControlCreateInfoEXTBuilder<'a> { + inner: PipelineViewportDepthClipControlCreateInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPipelineViewportStateCreateInfo + for PipelineViewportDepthClipControlCreateInfoEXTBuilder<'_> +{ +} +unsafe impl ExtendsPipelineViewportStateCreateInfo + for PipelineViewportDepthClipControlCreateInfoEXT +{ +} +impl<'a> ::std::ops::Deref for PipelineViewportDepthClipControlCreateInfoEXTBuilder<'a> { + type Target = PipelineViewportDepthClipControlCreateInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PipelineViewportDepthClipControlCreateInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PipelineViewportDepthClipControlCreateInfoEXTBuilder<'a> { + #[inline] + pub fn negative_one_to_one(mut self, negative_one_to_one: bool) -> Self { + self.inner.negative_one_to_one = negative_one_to_one.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PipelineViewportDepthClipControlCreateInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceVertexInputDynamicStateFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub vertex_input_dynamic_state: Bool32, +} +impl ::std::default::Default for PhysicalDeviceVertexInputDynamicStateFeaturesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + vertex_input_dynamic_state: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceVertexInputDynamicStateFeaturesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT; +} +impl PhysicalDeviceVertexInputDynamicStateFeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceVertexInputDynamicStateFeaturesEXTBuilder<'a> { + PhysicalDeviceVertexInputDynamicStateFeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceVertexInputDynamicStateFeaturesEXTBuilder<'a> { + inner: PhysicalDeviceVertexInputDynamicStateFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceVertexInputDynamicStateFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceVertexInputDynamicStateFeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo + for PhysicalDeviceVertexInputDynamicStateFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVertexInputDynamicStateFeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceVertexInputDynamicStateFeaturesEXTBuilder<'a> { + type Target = PhysicalDeviceVertexInputDynamicStateFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceVertexInputDynamicStateFeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceVertexInputDynamicStateFeaturesEXTBuilder<'a> { + #[inline] + pub fn vertex_input_dynamic_state(mut self, vertex_input_dynamic_state: bool) -> Self { + self.inner.vertex_input_dynamic_state = vertex_input_dynamic_state.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceVertexInputDynamicStateFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceExternalMemoryRDMAFeaturesNV { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub external_memory_rdma: Bool32, +} +impl ::std::default::Default for PhysicalDeviceExternalMemoryRDMAFeaturesNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + external_memory_rdma: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceExternalMemoryRDMAFeaturesNV { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV; +} +impl PhysicalDeviceExternalMemoryRDMAFeaturesNV { + pub fn builder<'a>() -> PhysicalDeviceExternalMemoryRDMAFeaturesNVBuilder<'a> { + PhysicalDeviceExternalMemoryRDMAFeaturesNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceExternalMemoryRDMAFeaturesNVBuilder<'a> { + inner: PhysicalDeviceExternalMemoryRDMAFeaturesNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceExternalMemoryRDMAFeaturesNVBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceExternalMemoryRDMAFeaturesNV {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceExternalMemoryRDMAFeaturesNVBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceExternalMemoryRDMAFeaturesNV {} +impl<'a> ::std::ops::Deref for PhysicalDeviceExternalMemoryRDMAFeaturesNVBuilder<'a> { + type Target = PhysicalDeviceExternalMemoryRDMAFeaturesNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceExternalMemoryRDMAFeaturesNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceExternalMemoryRDMAFeaturesNVBuilder<'a> { + #[inline] + pub fn external_memory_rdma(mut self, external_memory_rdma: bool) -> Self { + self.inner.external_memory_rdma = external_memory_rdma.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceExternalMemoryRDMAFeaturesNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct VertexInputBindingDescription2EXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub binding: u32, + pub stride: u32, + pub input_rate: VertexInputRate, + pub divisor: u32, +} +impl ::std::default::Default for VertexInputBindingDescription2EXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + binding: u32::default(), + stride: u32::default(), + input_rate: VertexInputRate::default(), + divisor: u32::default(), + } + } +} +unsafe impl TaggedStructure for VertexInputBindingDescription2EXT { + const STRUCTURE_TYPE: StructureType = StructureType::VERTEX_INPUT_BINDING_DESCRIPTION_2_EXT; +} +impl VertexInputBindingDescription2EXT { + pub fn builder<'a>() -> VertexInputBindingDescription2EXTBuilder<'a> { + VertexInputBindingDescription2EXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VertexInputBindingDescription2EXTBuilder<'a> { + inner: VertexInputBindingDescription2EXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for VertexInputBindingDescription2EXTBuilder<'a> { + type Target = VertexInputBindingDescription2EXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VertexInputBindingDescription2EXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VertexInputBindingDescription2EXTBuilder<'a> { + #[inline] + pub fn binding(mut self, binding: u32) -> Self { + self.inner.binding = binding; + self + } + #[inline] + pub fn stride(mut self, stride: u32) -> Self { + self.inner.stride = stride; + self + } + #[inline] + pub fn input_rate(mut self, input_rate: VertexInputRate) -> Self { + self.inner.input_rate = input_rate; + self + } + #[inline] + pub fn divisor(mut self, divisor: u32) -> Self { + self.inner.divisor = divisor; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VertexInputBindingDescription2EXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct VertexInputAttributeDescription2EXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub location: u32, + pub binding: u32, + pub format: Format, + pub offset: u32, +} +impl ::std::default::Default for VertexInputAttributeDescription2EXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + location: u32::default(), + binding: u32::default(), + format: Format::default(), + offset: u32::default(), + } + } +} +unsafe impl TaggedStructure for VertexInputAttributeDescription2EXT { + const STRUCTURE_TYPE: StructureType = StructureType::VERTEX_INPUT_ATTRIBUTE_DESCRIPTION_2_EXT; +} +impl VertexInputAttributeDescription2EXT { + pub fn builder<'a>() -> VertexInputAttributeDescription2EXTBuilder<'a> { + VertexInputAttributeDescription2EXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VertexInputAttributeDescription2EXTBuilder<'a> { + inner: VertexInputAttributeDescription2EXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for VertexInputAttributeDescription2EXTBuilder<'a> { + type Target = VertexInputAttributeDescription2EXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VertexInputAttributeDescription2EXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VertexInputAttributeDescription2EXTBuilder<'a> { + #[inline] + pub fn location(mut self, location: u32) -> Self { + self.inner.location = location; + self + } + #[inline] + pub fn binding(mut self, binding: u32) -> Self { + self.inner.binding = binding; + self + } + #[inline] + pub fn format(mut self, format: Format) -> Self { + self.inner.format = format; + self + } + #[inline] + pub fn offset(mut self, offset: u32) -> Self { + self.inner.offset = offset; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VertexInputAttributeDescription2EXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceColorWriteEnableFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub color_write_enable: Bool32, +} +impl ::std::default::Default for PhysicalDeviceColorWriteEnableFeaturesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + color_write_enable: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceColorWriteEnableFeaturesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT; +} +impl PhysicalDeviceColorWriteEnableFeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceColorWriteEnableFeaturesEXTBuilder<'a> { + PhysicalDeviceColorWriteEnableFeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceColorWriteEnableFeaturesEXTBuilder<'a> { + inner: PhysicalDeviceColorWriteEnableFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceColorWriteEnableFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceColorWriteEnableFeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceColorWriteEnableFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceColorWriteEnableFeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceColorWriteEnableFeaturesEXTBuilder<'a> { + type Target = PhysicalDeviceColorWriteEnableFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceColorWriteEnableFeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceColorWriteEnableFeaturesEXTBuilder<'a> { + #[inline] + pub fn color_write_enable(mut self, color_write_enable: bool) -> Self { + self.inner.color_write_enable = color_write_enable.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceColorWriteEnableFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PipelineColorWriteCreateInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub attachment_count: u32, + pub p_color_write_enables: *const Bool32, +} +impl ::std::default::Default for PipelineColorWriteCreateInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + attachment_count: u32::default(), + p_color_write_enables: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for PipelineColorWriteCreateInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::PIPELINE_COLOR_WRITE_CREATE_INFO_EXT; +} +impl PipelineColorWriteCreateInfoEXT { + pub fn builder<'a>() -> PipelineColorWriteCreateInfoEXTBuilder<'a> { + PipelineColorWriteCreateInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PipelineColorWriteCreateInfoEXTBuilder<'a> { + inner: PipelineColorWriteCreateInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPipelineColorBlendStateCreateInfo + for PipelineColorWriteCreateInfoEXTBuilder<'_> +{ +} +unsafe impl ExtendsPipelineColorBlendStateCreateInfo for PipelineColorWriteCreateInfoEXT {} +impl<'a> ::std::ops::Deref for PipelineColorWriteCreateInfoEXTBuilder<'a> { + type Target = PipelineColorWriteCreateInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PipelineColorWriteCreateInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PipelineColorWriteCreateInfoEXTBuilder<'a> { + #[inline] + pub fn color_write_enables(mut self, color_write_enables: &'a [Bool32]) -> Self { + self.inner.attachment_count = color_write_enables.len() as _; + self.inner.p_color_write_enables = color_write_enables.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PipelineColorWriteCreateInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct MemoryBarrier2 { + pub s_type: StructureType, + pub p_next: *const c_void, + pub src_stage_mask: PipelineStageFlags2, + pub src_access_mask: AccessFlags2, + pub dst_stage_mask: PipelineStageFlags2, + pub dst_access_mask: AccessFlags2, +} +impl ::std::default::Default for MemoryBarrier2 { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + src_stage_mask: PipelineStageFlags2::default(), + src_access_mask: AccessFlags2::default(), + dst_stage_mask: PipelineStageFlags2::default(), + dst_access_mask: AccessFlags2::default(), + } + } +} +unsafe impl TaggedStructure for MemoryBarrier2 { + const STRUCTURE_TYPE: StructureType = StructureType::MEMORY_BARRIER_2; +} +impl MemoryBarrier2 { + pub fn builder<'a>() -> MemoryBarrier2Builder<'a> { + MemoryBarrier2Builder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct MemoryBarrier2Builder<'a> { + inner: MemoryBarrier2, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsSubpassDependency2 for MemoryBarrier2Builder<'_> {} +unsafe impl ExtendsSubpassDependency2 for MemoryBarrier2 {} +impl<'a> ::std::ops::Deref for MemoryBarrier2Builder<'a> { + type Target = MemoryBarrier2; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for MemoryBarrier2Builder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> MemoryBarrier2Builder<'a> { + #[inline] + pub fn src_stage_mask(mut self, src_stage_mask: PipelineStageFlags2) -> Self { + self.inner.src_stage_mask = src_stage_mask; + self + } + #[inline] + pub fn src_access_mask(mut self, src_access_mask: AccessFlags2) -> Self { + self.inner.src_access_mask = src_access_mask; + self + } + #[inline] + pub fn dst_stage_mask(mut self, dst_stage_mask: PipelineStageFlags2) -> Self { + self.inner.dst_stage_mask = dst_stage_mask; + self + } + #[inline] + pub fn dst_access_mask(mut self, dst_access_mask: AccessFlags2) -> Self { + self.inner.dst_access_mask = dst_access_mask; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> MemoryBarrier2 { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ImageMemoryBarrier2 { + pub s_type: StructureType, + pub p_next: *const c_void, + pub src_stage_mask: PipelineStageFlags2, + pub src_access_mask: AccessFlags2, + pub dst_stage_mask: PipelineStageFlags2, + pub dst_access_mask: AccessFlags2, + pub old_layout: ImageLayout, + pub new_layout: ImageLayout, + pub src_queue_family_index: u32, + pub dst_queue_family_index: u32, + pub image: Image, + pub subresource_range: ImageSubresourceRange, +} +impl ::std::default::Default for ImageMemoryBarrier2 { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + src_stage_mask: PipelineStageFlags2::default(), + src_access_mask: AccessFlags2::default(), + dst_stage_mask: PipelineStageFlags2::default(), + dst_access_mask: AccessFlags2::default(), + old_layout: ImageLayout::default(), + new_layout: ImageLayout::default(), + src_queue_family_index: u32::default(), + dst_queue_family_index: u32::default(), + image: Image::default(), + subresource_range: ImageSubresourceRange::default(), + } + } +} +unsafe impl TaggedStructure for ImageMemoryBarrier2 { + const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_MEMORY_BARRIER_2; +} +impl ImageMemoryBarrier2 { + pub fn builder<'a>() -> ImageMemoryBarrier2Builder<'a> { + ImageMemoryBarrier2Builder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ImageMemoryBarrier2Builder<'a> { + inner: ImageMemoryBarrier2, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsImageMemoryBarrier2 {} +impl<'a> ::std::ops::Deref for ImageMemoryBarrier2Builder<'a> { + type Target = ImageMemoryBarrier2; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ImageMemoryBarrier2Builder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ImageMemoryBarrier2Builder<'a> { + #[inline] + pub fn src_stage_mask(mut self, src_stage_mask: PipelineStageFlags2) -> Self { + self.inner.src_stage_mask = src_stage_mask; + self + } + #[inline] + pub fn src_access_mask(mut self, src_access_mask: AccessFlags2) -> Self { + self.inner.src_access_mask = src_access_mask; + self + } + #[inline] + pub fn dst_stage_mask(mut self, dst_stage_mask: PipelineStageFlags2) -> Self { + self.inner.dst_stage_mask = dst_stage_mask; + self + } + #[inline] + pub fn dst_access_mask(mut self, dst_access_mask: AccessFlags2) -> Self { + self.inner.dst_access_mask = dst_access_mask; + self + } + #[inline] + pub fn old_layout(mut self, old_layout: ImageLayout) -> Self { + self.inner.old_layout = old_layout; + self + } + #[inline] + pub fn new_layout(mut self, new_layout: ImageLayout) -> Self { + self.inner.new_layout = new_layout; + self + } + #[inline] + pub fn src_queue_family_index(mut self, src_queue_family_index: u32) -> Self { + self.inner.src_queue_family_index = src_queue_family_index; + self + } + #[inline] + pub fn dst_queue_family_index(mut self, dst_queue_family_index: u32) -> Self { + self.inner.dst_queue_family_index = dst_queue_family_index; + self + } + #[inline] + pub fn image(mut self, image: Image) -> Self { + self.inner.image = image; + self + } + #[inline] + pub fn subresource_range(mut self, subresource_range: ImageSubresourceRange) -> Self { + self.inner.subresource_range = subresource_range; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ImageMemoryBarrier2 { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct BufferMemoryBarrier2 { + pub s_type: StructureType, + pub p_next: *const c_void, + pub src_stage_mask: PipelineStageFlags2, + pub src_access_mask: AccessFlags2, + pub dst_stage_mask: PipelineStageFlags2, + pub dst_access_mask: AccessFlags2, + pub src_queue_family_index: u32, + pub dst_queue_family_index: u32, + pub buffer: Buffer, + pub offset: DeviceSize, + pub size: DeviceSize, +} +impl ::std::default::Default for BufferMemoryBarrier2 { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + src_stage_mask: PipelineStageFlags2::default(), + src_access_mask: AccessFlags2::default(), + dst_stage_mask: PipelineStageFlags2::default(), + dst_access_mask: AccessFlags2::default(), + src_queue_family_index: u32::default(), + dst_queue_family_index: u32::default(), + buffer: Buffer::default(), + offset: DeviceSize::default(), + size: DeviceSize::default(), + } + } +} +unsafe impl TaggedStructure for BufferMemoryBarrier2 { + const STRUCTURE_TYPE: StructureType = StructureType::BUFFER_MEMORY_BARRIER_2; +} +impl BufferMemoryBarrier2 { + pub fn builder<'a>() -> BufferMemoryBarrier2Builder<'a> { + BufferMemoryBarrier2Builder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct BufferMemoryBarrier2Builder<'a> { + inner: BufferMemoryBarrier2, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for BufferMemoryBarrier2Builder<'a> { + type Target = BufferMemoryBarrier2; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for BufferMemoryBarrier2Builder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> BufferMemoryBarrier2Builder<'a> { + #[inline] + pub fn src_stage_mask(mut self, src_stage_mask: PipelineStageFlags2) -> Self { + self.inner.src_stage_mask = src_stage_mask; + self + } + #[inline] + pub fn src_access_mask(mut self, src_access_mask: AccessFlags2) -> Self { + self.inner.src_access_mask = src_access_mask; + self + } + #[inline] + pub fn dst_stage_mask(mut self, dst_stage_mask: PipelineStageFlags2) -> Self { + self.inner.dst_stage_mask = dst_stage_mask; + self + } + #[inline] + pub fn dst_access_mask(mut self, dst_access_mask: AccessFlags2) -> Self { + self.inner.dst_access_mask = dst_access_mask; + self + } + #[inline] + pub fn src_queue_family_index(mut self, src_queue_family_index: u32) -> Self { + self.inner.src_queue_family_index = src_queue_family_index; + self + } + #[inline] + pub fn dst_queue_family_index(mut self, dst_queue_family_index: u32) -> Self { + self.inner.dst_queue_family_index = dst_queue_family_index; + self + } + #[inline] + pub fn buffer(mut self, buffer: Buffer) -> Self { + self.inner.buffer = buffer; + self + } + #[inline] + pub fn offset(mut self, offset: DeviceSize) -> Self { + self.inner.offset = offset; + self + } + #[inline] + pub fn size(mut self, size: DeviceSize) -> Self { + self.inner.size = size; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> BufferMemoryBarrier2 { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DependencyInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub dependency_flags: DependencyFlags, + pub memory_barrier_count: u32, + pub p_memory_barriers: *const MemoryBarrier2, + pub buffer_memory_barrier_count: u32, + pub p_buffer_memory_barriers: *const BufferMemoryBarrier2, + pub image_memory_barrier_count: u32, + pub p_image_memory_barriers: *const ImageMemoryBarrier2, +} +impl ::std::default::Default for DependencyInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + dependency_flags: DependencyFlags::default(), + memory_barrier_count: u32::default(), + p_memory_barriers: ::std::ptr::null(), + buffer_memory_barrier_count: u32::default(), + p_buffer_memory_barriers: ::std::ptr::null(), + image_memory_barrier_count: u32::default(), + p_image_memory_barriers: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for DependencyInfo { + const STRUCTURE_TYPE: StructureType = StructureType::DEPENDENCY_INFO; +} +impl DependencyInfo { + pub fn builder<'a>() -> DependencyInfoBuilder<'a> { + DependencyInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DependencyInfoBuilder<'a> { + inner: DependencyInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DependencyInfoBuilder<'a> { + type Target = DependencyInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DependencyInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DependencyInfoBuilder<'a> { + #[inline] + pub fn dependency_flags(mut self, dependency_flags: DependencyFlags) -> Self { + self.inner.dependency_flags = dependency_flags; + self + } + #[inline] + pub fn memory_barriers(mut self, memory_barriers: &'a [MemoryBarrier2]) -> Self { + self.inner.memory_barrier_count = memory_barriers.len() as _; + self.inner.p_memory_barriers = memory_barriers.as_ptr(); + self + } + #[inline] + pub fn buffer_memory_barriers( + mut self, + buffer_memory_barriers: &'a [BufferMemoryBarrier2], + ) -> Self { + self.inner.buffer_memory_barrier_count = buffer_memory_barriers.len() as _; + self.inner.p_buffer_memory_barriers = buffer_memory_barriers.as_ptr(); + self + } + #[inline] + pub fn image_memory_barriers( + mut self, + image_memory_barriers: &'a [ImageMemoryBarrier2], + ) -> Self { + self.inner.image_memory_barrier_count = image_memory_barriers.len() as _; + self.inner.p_image_memory_barriers = image_memory_barriers.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DependencyInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SemaphoreSubmitInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub semaphore: Semaphore, + pub value: u64, + pub stage_mask: PipelineStageFlags2, + pub device_index: u32, +} +impl ::std::default::Default for SemaphoreSubmitInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + semaphore: Semaphore::default(), + value: u64::default(), + stage_mask: PipelineStageFlags2::default(), + device_index: u32::default(), + } + } +} +unsafe impl TaggedStructure for SemaphoreSubmitInfo { + const STRUCTURE_TYPE: StructureType = StructureType::SEMAPHORE_SUBMIT_INFO; +} +impl SemaphoreSubmitInfo { + pub fn builder<'a>() -> SemaphoreSubmitInfoBuilder<'a> { + SemaphoreSubmitInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SemaphoreSubmitInfoBuilder<'a> { + inner: SemaphoreSubmitInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for SemaphoreSubmitInfoBuilder<'a> { + type Target = SemaphoreSubmitInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SemaphoreSubmitInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SemaphoreSubmitInfoBuilder<'a> { + #[inline] + pub fn semaphore(mut self, semaphore: Semaphore) -> Self { + self.inner.semaphore = semaphore; + self + } + #[inline] + pub fn value(mut self, value: u64) -> Self { + self.inner.value = value; + self + } + #[inline] + pub fn stage_mask(mut self, stage_mask: PipelineStageFlags2) -> Self { + self.inner.stage_mask = stage_mask; + self + } + #[inline] + pub fn device_index(mut self, device_index: u32) -> Self { + self.inner.device_index = device_index; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SemaphoreSubmitInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct CommandBufferSubmitInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub command_buffer: CommandBuffer, + pub device_mask: u32, +} +impl ::std::default::Default for CommandBufferSubmitInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + command_buffer: CommandBuffer::default(), + device_mask: u32::default(), + } + } +} +unsafe impl TaggedStructure for CommandBufferSubmitInfo { + const STRUCTURE_TYPE: StructureType = StructureType::COMMAND_BUFFER_SUBMIT_INFO; +} +impl CommandBufferSubmitInfo { + pub fn builder<'a>() -> CommandBufferSubmitInfoBuilder<'a> { + CommandBufferSubmitInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct CommandBufferSubmitInfoBuilder<'a> { + inner: CommandBufferSubmitInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for CommandBufferSubmitInfoBuilder<'a> { + type Target = CommandBufferSubmitInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for CommandBufferSubmitInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> CommandBufferSubmitInfoBuilder<'a> { + #[inline] + pub fn command_buffer(mut self, command_buffer: CommandBuffer) -> Self { + self.inner.command_buffer = command_buffer; + self + } + #[inline] + pub fn device_mask(mut self, device_mask: u32) -> Self { + self.inner.device_mask = device_mask; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> CommandBufferSubmitInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SubmitInfo2 { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: SubmitFlags, + pub wait_semaphore_info_count: u32, + pub p_wait_semaphore_infos: *const SemaphoreSubmitInfo, + pub command_buffer_info_count: u32, + pub p_command_buffer_infos: *const CommandBufferSubmitInfo, + pub signal_semaphore_info_count: u32, + pub p_signal_semaphore_infos: *const SemaphoreSubmitInfo, +} +impl ::std::default::Default for SubmitInfo2 { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: SubmitFlags::default(), + wait_semaphore_info_count: u32::default(), + p_wait_semaphore_infos: ::std::ptr::null(), + command_buffer_info_count: u32::default(), + p_command_buffer_infos: ::std::ptr::null(), + signal_semaphore_info_count: u32::default(), + p_signal_semaphore_infos: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for SubmitInfo2 { + const STRUCTURE_TYPE: StructureType = StructureType::SUBMIT_INFO_2; +} +impl SubmitInfo2 { + pub fn builder<'a>() -> SubmitInfo2Builder<'a> { + SubmitInfo2Builder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SubmitInfo2Builder<'a> { + inner: SubmitInfo2, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsSubmitInfo2 {} +impl<'a> ::std::ops::Deref for SubmitInfo2Builder<'a> { + type Target = SubmitInfo2; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SubmitInfo2Builder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SubmitInfo2Builder<'a> { + #[inline] + pub fn flags(mut self, flags: SubmitFlags) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn wait_semaphore_infos(mut self, wait_semaphore_infos: &'a [SemaphoreSubmitInfo]) -> Self { + self.inner.wait_semaphore_info_count = wait_semaphore_infos.len() as _; + self.inner.p_wait_semaphore_infos = wait_semaphore_infos.as_ptr(); + self + } + #[inline] + pub fn command_buffer_infos( + mut self, + command_buffer_infos: &'a [CommandBufferSubmitInfo], + ) -> Self { + self.inner.command_buffer_info_count = command_buffer_infos.len() as _; + self.inner.p_command_buffer_infos = command_buffer_infos.as_ptr(); + self + } + #[inline] + pub fn signal_semaphore_infos( + mut self, + signal_semaphore_infos: &'a [SemaphoreSubmitInfo], + ) -> Self { + self.inner.signal_semaphore_info_count = signal_semaphore_infos.len() as _; + self.inner.p_signal_semaphore_infos = signal_semaphore_infos.as_ptr(); + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SubmitInfo2 { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct QueueFamilyCheckpointProperties2NV { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub checkpoint_execution_stage_mask: PipelineStageFlags2, +} +impl ::std::default::Default for QueueFamilyCheckpointProperties2NV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + checkpoint_execution_stage_mask: PipelineStageFlags2::default(), + } + } +} +unsafe impl TaggedStructure for QueueFamilyCheckpointProperties2NV { + const STRUCTURE_TYPE: StructureType = StructureType::QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV; +} +impl QueueFamilyCheckpointProperties2NV { + pub fn builder<'a>() -> QueueFamilyCheckpointProperties2NVBuilder<'a> { + QueueFamilyCheckpointProperties2NVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct QueueFamilyCheckpointProperties2NVBuilder<'a> { + inner: QueueFamilyCheckpointProperties2NV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsQueueFamilyProperties2 for QueueFamilyCheckpointProperties2NVBuilder<'_> {} +unsafe impl ExtendsQueueFamilyProperties2 for QueueFamilyCheckpointProperties2NV {} +impl<'a> ::std::ops::Deref for QueueFamilyCheckpointProperties2NVBuilder<'a> { + type Target = QueueFamilyCheckpointProperties2NV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for QueueFamilyCheckpointProperties2NVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> QueueFamilyCheckpointProperties2NVBuilder<'a> { + #[inline] + pub fn checkpoint_execution_stage_mask( + mut self, + checkpoint_execution_stage_mask: PipelineStageFlags2, + ) -> Self { + self.inner.checkpoint_execution_stage_mask = checkpoint_execution_stage_mask; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> QueueFamilyCheckpointProperties2NV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct CheckpointData2NV { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub stage: PipelineStageFlags2, + pub p_checkpoint_marker: *mut c_void, +} +impl ::std::default::Default for CheckpointData2NV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + stage: PipelineStageFlags2::default(), + p_checkpoint_marker: ::std::ptr::null_mut(), + } + } +} +unsafe impl TaggedStructure for CheckpointData2NV { + const STRUCTURE_TYPE: StructureType = StructureType::CHECKPOINT_DATA_2_NV; +} +impl CheckpointData2NV { + pub fn builder<'a>() -> CheckpointData2NVBuilder<'a> { + CheckpointData2NVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct CheckpointData2NVBuilder<'a> { + inner: CheckpointData2NV, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for CheckpointData2NVBuilder<'a> { + type Target = CheckpointData2NV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for CheckpointData2NVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> CheckpointData2NVBuilder<'a> { + #[inline] + pub fn stage(mut self, stage: PipelineStageFlags2) -> Self { + self.inner.stage = stage; + self + } + #[inline] + pub fn checkpoint_marker(mut self, checkpoint_marker: *mut c_void) -> Self { + self.inner.p_checkpoint_marker = checkpoint_marker; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> CheckpointData2NV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceSynchronization2Features { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub synchronization2: Bool32, +} +impl ::std::default::Default for PhysicalDeviceSynchronization2Features { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + synchronization2: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceSynchronization2Features { + const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES; +} +impl PhysicalDeviceSynchronization2Features { + pub fn builder<'a>() -> PhysicalDeviceSynchronization2FeaturesBuilder<'a> { + PhysicalDeviceSynchronization2FeaturesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceSynchronization2FeaturesBuilder<'a> { + inner: PhysicalDeviceSynchronization2Features, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceSynchronization2FeaturesBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceSynchronization2Features {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceSynchronization2FeaturesBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceSynchronization2Features {} +impl<'a> ::std::ops::Deref for PhysicalDeviceSynchronization2FeaturesBuilder<'a> { + type Target = PhysicalDeviceSynchronization2Features; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceSynchronization2FeaturesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceSynchronization2FeaturesBuilder<'a> { + #[inline] + pub fn synchronization2(mut self, synchronization2: bool) -> Self { + self.inner.synchronization2 = synchronization2.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceSynchronization2Features { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub primitives_generated_query: Bool32, + pub primitives_generated_query_with_rasterizer_discard: Bool32, + pub primitives_generated_query_with_non_zero_streams: Bool32, +} +impl ::std::default::Default for PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + primitives_generated_query: Bool32::default(), + primitives_generated_query_with_rasterizer_discard: Bool32::default(), + primitives_generated_query_with_non_zero_streams: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT; +} +impl PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT { + pub fn builder<'a>() -> PhysicalDevicePrimitivesGeneratedQueryFeaturesEXTBuilder<'a> { + PhysicalDevicePrimitivesGeneratedQueryFeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDevicePrimitivesGeneratedQueryFeaturesEXTBuilder<'a> { + inner: PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDevicePrimitivesGeneratedQueryFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo + for PhysicalDevicePrimitivesGeneratedQueryFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDevicePrimitivesGeneratedQueryFeaturesEXTBuilder<'a> { + type Target = PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDevicePrimitivesGeneratedQueryFeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDevicePrimitivesGeneratedQueryFeaturesEXTBuilder<'a> { + #[inline] + pub fn primitives_generated_query(mut self, primitives_generated_query: bool) -> Self { + self.inner.primitives_generated_query = primitives_generated_query.into(); + self + } + #[inline] + pub fn primitives_generated_query_with_rasterizer_discard( + mut self, + primitives_generated_query_with_rasterizer_discard: bool, + ) -> Self { + self.inner + .primitives_generated_query_with_rasterizer_discard = + primitives_generated_query_with_rasterizer_discard.into(); + self + } + #[inline] + pub fn primitives_generated_query_with_non_zero_streams( + mut self, + primitives_generated_query_with_non_zero_streams: bool, + ) -> Self { + self.inner.primitives_generated_query_with_non_zero_streams = + primitives_generated_query_with_non_zero_streams.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceLegacyDitheringFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub legacy_dithering: Bool32, +} +impl ::std::default::Default for PhysicalDeviceLegacyDitheringFeaturesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + legacy_dithering: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceLegacyDitheringFeaturesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT; +} +impl PhysicalDeviceLegacyDitheringFeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceLegacyDitheringFeaturesEXTBuilder<'a> { + PhysicalDeviceLegacyDitheringFeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceLegacyDitheringFeaturesEXTBuilder<'a> { + inner: PhysicalDeviceLegacyDitheringFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceLegacyDitheringFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceLegacyDitheringFeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceLegacyDitheringFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceLegacyDitheringFeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceLegacyDitheringFeaturesEXTBuilder<'a> { + type Target = PhysicalDeviceLegacyDitheringFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceLegacyDitheringFeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceLegacyDitheringFeaturesEXTBuilder<'a> { + #[inline] + pub fn legacy_dithering(mut self, legacy_dithering: bool) -> Self { + self.inner.legacy_dithering = legacy_dithering.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceLegacyDitheringFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub multisampled_render_to_single_sampled: Bool32, +} +impl ::std::default::Default for PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + multisampled_render_to_single_sampled: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT; +} +impl PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXTBuilder<'a> { + PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXTBuilder<'a> { + inner: PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT +{ +} +unsafe impl ExtendsDeviceCreateInfo + for PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT {} +impl<'a> ::std::ops::Deref + for PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXTBuilder<'a> +{ + type Target = PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut + for PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXTBuilder<'a> +{ + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXTBuilder<'a> { + #[inline] + pub fn multisampled_render_to_single_sampled( + mut self, + multisampled_render_to_single_sampled: bool, + ) -> Self { + self.inner.multisampled_render_to_single_sampled = + multisampled_render_to_single_sampled.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SubpassResolvePerformanceQueryEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub optimal: Bool32, +} +impl ::std::default::Default for SubpassResolvePerformanceQueryEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + optimal: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for SubpassResolvePerformanceQueryEXT { + const STRUCTURE_TYPE: StructureType = StructureType::SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT; +} +impl SubpassResolvePerformanceQueryEXT { + pub fn builder<'a>() -> SubpassResolvePerformanceQueryEXTBuilder<'a> { + SubpassResolvePerformanceQueryEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SubpassResolvePerformanceQueryEXTBuilder<'a> { + inner: SubpassResolvePerformanceQueryEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsFormatProperties2 for SubpassResolvePerformanceQueryEXTBuilder<'_> {} +unsafe impl ExtendsFormatProperties2 for SubpassResolvePerformanceQueryEXT {} +impl<'a> ::std::ops::Deref for SubpassResolvePerformanceQueryEXTBuilder<'a> { + type Target = SubpassResolvePerformanceQueryEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SubpassResolvePerformanceQueryEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SubpassResolvePerformanceQueryEXTBuilder<'a> { + #[inline] + pub fn optimal(mut self, optimal: bool) -> Self { + self.inner.optimal = optimal.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SubpassResolvePerformanceQueryEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct MultisampledRenderToSingleSampledInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub multisampled_render_to_single_sampled_enable: Bool32, + pub rasterization_samples: SampleCountFlags, +} +impl ::std::default::Default for MultisampledRenderToSingleSampledInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + multisampled_render_to_single_sampled_enable: Bool32::default(), + rasterization_samples: SampleCountFlags::default(), + } + } +} +unsafe impl TaggedStructure for MultisampledRenderToSingleSampledInfoEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT; +} +impl MultisampledRenderToSingleSampledInfoEXT { + pub fn builder<'a>() -> MultisampledRenderToSingleSampledInfoEXTBuilder<'a> { + MultisampledRenderToSingleSampledInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct MultisampledRenderToSingleSampledInfoEXTBuilder<'a> { + inner: MultisampledRenderToSingleSampledInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsSubpassDescription2 for MultisampledRenderToSingleSampledInfoEXTBuilder<'_> {} +unsafe impl ExtendsSubpassDescription2 for MultisampledRenderToSingleSampledInfoEXT {} +unsafe impl ExtendsRenderingInfo for MultisampledRenderToSingleSampledInfoEXTBuilder<'_> {} +unsafe impl ExtendsRenderingInfo for MultisampledRenderToSingleSampledInfoEXT {} +impl<'a> ::std::ops::Deref for MultisampledRenderToSingleSampledInfoEXTBuilder<'a> { + type Target = MultisampledRenderToSingleSampledInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for MultisampledRenderToSingleSampledInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> MultisampledRenderToSingleSampledInfoEXTBuilder<'a> { + #[inline] + pub fn multisampled_render_to_single_sampled_enable( + mut self, + multisampled_render_to_single_sampled_enable: bool, + ) -> Self { + self.inner.multisampled_render_to_single_sampled_enable = + multisampled_render_to_single_sampled_enable.into(); + self + } + #[inline] + pub fn rasterization_samples(mut self, rasterization_samples: SampleCountFlags) -> Self { + self.inner.rasterization_samples = rasterization_samples; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> MultisampledRenderToSingleSampledInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDevicePipelineProtectedAccessFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub pipeline_protected_access: Bool32, +} +impl ::std::default::Default for PhysicalDevicePipelineProtectedAccessFeaturesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + pipeline_protected_access: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDevicePipelineProtectedAccessFeaturesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT; +} +impl PhysicalDevicePipelineProtectedAccessFeaturesEXT { + pub fn builder<'a>() -> PhysicalDevicePipelineProtectedAccessFeaturesEXTBuilder<'a> { + PhysicalDevicePipelineProtectedAccessFeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDevicePipelineProtectedAccessFeaturesEXTBuilder<'a> { + inner: PhysicalDevicePipelineProtectedAccessFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDevicePipelineProtectedAccessFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePipelineProtectedAccessFeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo + for PhysicalDevicePipelineProtectedAccessFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePipelineProtectedAccessFeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDevicePipelineProtectedAccessFeaturesEXTBuilder<'a> { + type Target = PhysicalDevicePipelineProtectedAccessFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDevicePipelineProtectedAccessFeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDevicePipelineProtectedAccessFeaturesEXTBuilder<'a> { + #[inline] + pub fn pipeline_protected_access(mut self, pipeline_protected_access: bool) -> Self { + self.inner.pipeline_protected_access = pipeline_protected_access.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDevicePipelineProtectedAccessFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct QueueFamilyVideoPropertiesKHR { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub video_codec_operations: VideoCodecOperationFlagsKHR, +} +impl ::std::default::Default for QueueFamilyVideoPropertiesKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + video_codec_operations: VideoCodecOperationFlagsKHR::default(), + } + } +} +unsafe impl TaggedStructure for QueueFamilyVideoPropertiesKHR { + const STRUCTURE_TYPE: StructureType = StructureType::QUEUE_FAMILY_VIDEO_PROPERTIES_KHR; +} +impl QueueFamilyVideoPropertiesKHR { + pub fn builder<'a>() -> QueueFamilyVideoPropertiesKHRBuilder<'a> { + QueueFamilyVideoPropertiesKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct QueueFamilyVideoPropertiesKHRBuilder<'a> { + inner: QueueFamilyVideoPropertiesKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsQueueFamilyProperties2 for QueueFamilyVideoPropertiesKHRBuilder<'_> {} +unsafe impl ExtendsQueueFamilyProperties2 for QueueFamilyVideoPropertiesKHR {} +impl<'a> ::std::ops::Deref for QueueFamilyVideoPropertiesKHRBuilder<'a> { + type Target = QueueFamilyVideoPropertiesKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for QueueFamilyVideoPropertiesKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> QueueFamilyVideoPropertiesKHRBuilder<'a> { + #[inline] + pub fn video_codec_operations( + mut self, + video_codec_operations: VideoCodecOperationFlagsKHR, + ) -> Self { + self.inner.video_codec_operations = video_codec_operations; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> QueueFamilyVideoPropertiesKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct QueueFamilyQueryResultStatusPropertiesKHR { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub query_result_status_support: Bool32, +} +impl ::std::default::Default for QueueFamilyQueryResultStatusPropertiesKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + query_result_status_support: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for QueueFamilyQueryResultStatusPropertiesKHR { + const STRUCTURE_TYPE: StructureType = + StructureType::QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_KHR; +} +impl QueueFamilyQueryResultStatusPropertiesKHR { + pub fn builder<'a>() -> QueueFamilyQueryResultStatusPropertiesKHRBuilder<'a> { + QueueFamilyQueryResultStatusPropertiesKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct QueueFamilyQueryResultStatusPropertiesKHRBuilder<'a> { + inner: QueueFamilyQueryResultStatusPropertiesKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsQueueFamilyProperties2 for QueueFamilyQueryResultStatusPropertiesKHRBuilder<'_> {} +unsafe impl ExtendsQueueFamilyProperties2 for QueueFamilyQueryResultStatusPropertiesKHR {} +impl<'a> ::std::ops::Deref for QueueFamilyQueryResultStatusPropertiesKHRBuilder<'a> { + type Target = QueueFamilyQueryResultStatusPropertiesKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for QueueFamilyQueryResultStatusPropertiesKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> QueueFamilyQueryResultStatusPropertiesKHRBuilder<'a> { + #[inline] + pub fn query_result_status_support(mut self, query_result_status_support: bool) -> Self { + self.inner.query_result_status_support = query_result_status_support.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> QueueFamilyQueryResultStatusPropertiesKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct VideoProfileListInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub profile_count: u32, + pub p_profiles: *const VideoProfileInfoKHR, +} +impl ::std::default::Default for VideoProfileListInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + profile_count: u32::default(), + p_profiles: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for VideoProfileListInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_PROFILE_LIST_INFO_KHR; +} +impl VideoProfileListInfoKHR { + pub fn builder<'a>() -> VideoProfileListInfoKHRBuilder<'a> { + VideoProfileListInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VideoProfileListInfoKHRBuilder<'a> { + inner: VideoProfileListInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceImageFormatInfo2 for VideoProfileListInfoKHRBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceImageFormatInfo2 for VideoProfileListInfoKHR {} +unsafe impl ExtendsPhysicalDeviceVideoFormatInfoKHR for VideoProfileListInfoKHRBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceVideoFormatInfoKHR for VideoProfileListInfoKHR {} +unsafe impl ExtendsImageCreateInfo for VideoProfileListInfoKHRBuilder<'_> {} +unsafe impl ExtendsImageCreateInfo for VideoProfileListInfoKHR {} +unsafe impl ExtendsBufferCreateInfo for VideoProfileListInfoKHRBuilder<'_> {} +unsafe impl ExtendsBufferCreateInfo for VideoProfileListInfoKHR {} +impl<'a> ::std::ops::Deref for VideoProfileListInfoKHRBuilder<'a> { + type Target = VideoProfileListInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VideoProfileListInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VideoProfileListInfoKHRBuilder<'a> { + #[inline] + pub fn profiles(mut self, profiles: &'a [VideoProfileInfoKHR]) -> Self { + self.inner.profile_count = profiles.len() as _; + self.inner.p_profiles = profiles.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VideoProfileListInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceVideoFormatInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub image_usage: ImageUsageFlags, +} +impl ::std::default::Default for PhysicalDeviceVideoFormatInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + image_usage: ImageUsageFlags::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceVideoFormatInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR; +} +impl PhysicalDeviceVideoFormatInfoKHR { + pub fn builder<'a>() -> PhysicalDeviceVideoFormatInfoKHRBuilder<'a> { + PhysicalDeviceVideoFormatInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceVideoFormatInfoKHRBuilder<'a> { + inner: PhysicalDeviceVideoFormatInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsPhysicalDeviceVideoFormatInfoKHR {} +impl<'a> ::std::ops::Deref for PhysicalDeviceVideoFormatInfoKHRBuilder<'a> { + type Target = PhysicalDeviceVideoFormatInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceVideoFormatInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceVideoFormatInfoKHRBuilder<'a> { + #[inline] + pub fn image_usage(mut self, image_usage: ImageUsageFlags) -> Self { + self.inner.image_usage = image_usage; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next( + mut self, + next: &'a mut T, + ) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceVideoFormatInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct VideoFormatPropertiesKHR { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub format: Format, + pub component_mapping: ComponentMapping, + pub image_create_flags: ImageCreateFlags, + pub image_type: ImageType, + pub image_tiling: ImageTiling, + pub image_usage_flags: ImageUsageFlags, +} +impl ::std::default::Default for VideoFormatPropertiesKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + format: Format::default(), + component_mapping: ComponentMapping::default(), + image_create_flags: ImageCreateFlags::default(), + image_type: ImageType::default(), + image_tiling: ImageTiling::default(), + image_usage_flags: ImageUsageFlags::default(), + } + } +} +unsafe impl TaggedStructure for VideoFormatPropertiesKHR { + const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_FORMAT_PROPERTIES_KHR; +} +impl VideoFormatPropertiesKHR { + pub fn builder<'a>() -> VideoFormatPropertiesKHRBuilder<'a> { + VideoFormatPropertiesKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VideoFormatPropertiesKHRBuilder<'a> { + inner: VideoFormatPropertiesKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for VideoFormatPropertiesKHRBuilder<'a> { + type Target = VideoFormatPropertiesKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VideoFormatPropertiesKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VideoFormatPropertiesKHRBuilder<'a> { + #[inline] + pub fn format(mut self, format: Format) -> Self { + self.inner.format = format; + self + } + #[inline] + pub fn component_mapping(mut self, component_mapping: ComponentMapping) -> Self { + self.inner.component_mapping = component_mapping; + self + } + #[inline] + pub fn image_create_flags(mut self, image_create_flags: ImageCreateFlags) -> Self { + self.inner.image_create_flags = image_create_flags; + self + } + #[inline] + pub fn image_type(mut self, image_type: ImageType) -> Self { + self.inner.image_type = image_type; + self + } + #[inline] + pub fn image_tiling(mut self, image_tiling: ImageTiling) -> Self { + self.inner.image_tiling = image_tiling; + self + } + #[inline] + pub fn image_usage_flags(mut self, image_usage_flags: ImageUsageFlags) -> Self { + self.inner.image_usage_flags = image_usage_flags; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VideoFormatPropertiesKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct VideoProfileInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub video_codec_operation: VideoCodecOperationFlagsKHR, + pub chroma_subsampling: VideoChromaSubsamplingFlagsKHR, + pub luma_bit_depth: VideoComponentBitDepthFlagsKHR, + pub chroma_bit_depth: VideoComponentBitDepthFlagsKHR, +} +impl ::std::default::Default for VideoProfileInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + video_codec_operation: VideoCodecOperationFlagsKHR::default(), + chroma_subsampling: VideoChromaSubsamplingFlagsKHR::default(), + luma_bit_depth: VideoComponentBitDepthFlagsKHR::default(), + chroma_bit_depth: VideoComponentBitDepthFlagsKHR::default(), + } + } +} +unsafe impl TaggedStructure for VideoProfileInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_PROFILE_INFO_KHR; +} +impl VideoProfileInfoKHR { + pub fn builder<'a>() -> VideoProfileInfoKHRBuilder<'a> { + VideoProfileInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VideoProfileInfoKHRBuilder<'a> { + inner: VideoProfileInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsQueryPoolCreateInfo for VideoProfileInfoKHRBuilder<'_> {} +unsafe impl ExtendsQueryPoolCreateInfo for VideoProfileInfoKHR {} +pub unsafe trait ExtendsVideoProfileInfoKHR {} +impl<'a> ::std::ops::Deref for VideoProfileInfoKHRBuilder<'a> { + type Target = VideoProfileInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VideoProfileInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VideoProfileInfoKHRBuilder<'a> { + #[inline] + pub fn video_codec_operation( + mut self, + video_codec_operation: VideoCodecOperationFlagsKHR, + ) -> Self { + self.inner.video_codec_operation = video_codec_operation; + self + } + #[inline] + pub fn chroma_subsampling( + mut self, + chroma_subsampling: VideoChromaSubsamplingFlagsKHR, + ) -> Self { + self.inner.chroma_subsampling = chroma_subsampling; + self + } + #[inline] + pub fn luma_bit_depth(mut self, luma_bit_depth: VideoComponentBitDepthFlagsKHR) -> Self { + self.inner.luma_bit_depth = luma_bit_depth; + self + } + #[inline] + pub fn chroma_bit_depth(mut self, chroma_bit_depth: VideoComponentBitDepthFlagsKHR) -> Self { + self.inner.chroma_bit_depth = chroma_bit_depth; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VideoProfileInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct VideoCapabilitiesKHR { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub flags: VideoCapabilityFlagsKHR, + pub min_bitstream_buffer_offset_alignment: DeviceSize, + pub min_bitstream_buffer_size_alignment: DeviceSize, + pub picture_access_granularity: Extent2D, + pub min_coded_extent: Extent2D, + pub max_coded_extent: Extent2D, + pub max_dpb_slots: u32, + pub max_active_reference_pictures: u32, + pub std_header_version: ExtensionProperties, +} +impl ::std::default::Default for VideoCapabilitiesKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + flags: VideoCapabilityFlagsKHR::default(), + min_bitstream_buffer_offset_alignment: DeviceSize::default(), + min_bitstream_buffer_size_alignment: DeviceSize::default(), + picture_access_granularity: Extent2D::default(), + min_coded_extent: Extent2D::default(), + max_coded_extent: Extent2D::default(), + max_dpb_slots: u32::default(), + max_active_reference_pictures: u32::default(), + std_header_version: ExtensionProperties::default(), + } + } +} +unsafe impl TaggedStructure for VideoCapabilitiesKHR { + const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_CAPABILITIES_KHR; +} +impl VideoCapabilitiesKHR { + pub fn builder<'a>() -> VideoCapabilitiesKHRBuilder<'a> { + VideoCapabilitiesKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VideoCapabilitiesKHRBuilder<'a> { + inner: VideoCapabilitiesKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsVideoCapabilitiesKHR {} +impl<'a> ::std::ops::Deref for VideoCapabilitiesKHRBuilder<'a> { + type Target = VideoCapabilitiesKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VideoCapabilitiesKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VideoCapabilitiesKHRBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: VideoCapabilityFlagsKHR) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn min_bitstream_buffer_offset_alignment( + mut self, + min_bitstream_buffer_offset_alignment: DeviceSize, + ) -> Self { + self.inner.min_bitstream_buffer_offset_alignment = min_bitstream_buffer_offset_alignment; + self + } + #[inline] + pub fn min_bitstream_buffer_size_alignment( + mut self, + min_bitstream_buffer_size_alignment: DeviceSize, + ) -> Self { + self.inner.min_bitstream_buffer_size_alignment = min_bitstream_buffer_size_alignment; + self + } + #[inline] + pub fn picture_access_granularity(mut self, picture_access_granularity: Extent2D) -> Self { + self.inner.picture_access_granularity = picture_access_granularity; + self + } + #[inline] + pub fn min_coded_extent(mut self, min_coded_extent: Extent2D) -> Self { + self.inner.min_coded_extent = min_coded_extent; + self + } + #[inline] + pub fn max_coded_extent(mut self, max_coded_extent: Extent2D) -> Self { + self.inner.max_coded_extent = max_coded_extent; + self + } + #[inline] + pub fn max_dpb_slots(mut self, max_dpb_slots: u32) -> Self { + self.inner.max_dpb_slots = max_dpb_slots; + self + } + #[inline] + pub fn max_active_reference_pictures(mut self, max_active_reference_pictures: u32) -> Self { + self.inner.max_active_reference_pictures = max_active_reference_pictures; + self + } + #[inline] + pub fn std_header_version(mut self, std_header_version: ExtensionProperties) -> Self { + self.inner.std_header_version = std_header_version; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*mut T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VideoCapabilitiesKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct VideoSessionMemoryRequirementsKHR { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub memory_bind_index: u32, + pub memory_requirements: MemoryRequirements, +} +impl ::std::default::Default for VideoSessionMemoryRequirementsKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + memory_bind_index: u32::default(), + memory_requirements: MemoryRequirements::default(), + } + } +} +unsafe impl TaggedStructure for VideoSessionMemoryRequirementsKHR { + const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_SESSION_MEMORY_REQUIREMENTS_KHR; +} +impl VideoSessionMemoryRequirementsKHR { + pub fn builder<'a>() -> VideoSessionMemoryRequirementsKHRBuilder<'a> { + VideoSessionMemoryRequirementsKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VideoSessionMemoryRequirementsKHRBuilder<'a> { + inner: VideoSessionMemoryRequirementsKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for VideoSessionMemoryRequirementsKHRBuilder<'a> { + type Target = VideoSessionMemoryRequirementsKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VideoSessionMemoryRequirementsKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VideoSessionMemoryRequirementsKHRBuilder<'a> { + #[inline] + pub fn memory_bind_index(mut self, memory_bind_index: u32) -> Self { + self.inner.memory_bind_index = memory_bind_index; + self + } + #[inline] + pub fn memory_requirements(mut self, memory_requirements: MemoryRequirements) -> Self { + self.inner.memory_requirements = memory_requirements; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VideoSessionMemoryRequirementsKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct BindVideoSessionMemoryInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub memory_bind_index: u32, + pub memory: DeviceMemory, + pub memory_offset: DeviceSize, + pub memory_size: DeviceSize, +} +impl ::std::default::Default for BindVideoSessionMemoryInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + memory_bind_index: u32::default(), + memory: DeviceMemory::default(), + memory_offset: DeviceSize::default(), + memory_size: DeviceSize::default(), + } + } +} +unsafe impl TaggedStructure for BindVideoSessionMemoryInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::BIND_VIDEO_SESSION_MEMORY_INFO_KHR; +} +impl BindVideoSessionMemoryInfoKHR { + pub fn builder<'a>() -> BindVideoSessionMemoryInfoKHRBuilder<'a> { + BindVideoSessionMemoryInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct BindVideoSessionMemoryInfoKHRBuilder<'a> { + inner: BindVideoSessionMemoryInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for BindVideoSessionMemoryInfoKHRBuilder<'a> { + type Target = BindVideoSessionMemoryInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for BindVideoSessionMemoryInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> BindVideoSessionMemoryInfoKHRBuilder<'a> { + #[inline] + pub fn memory_bind_index(mut self, memory_bind_index: u32) -> Self { + self.inner.memory_bind_index = memory_bind_index; + self + } + #[inline] + pub fn memory(mut self, memory: DeviceMemory) -> Self { + self.inner.memory = memory; + self + } + #[inline] + pub fn memory_offset(mut self, memory_offset: DeviceSize) -> Self { + self.inner.memory_offset = memory_offset; + self + } + #[inline] + pub fn memory_size(mut self, memory_size: DeviceSize) -> Self { + self.inner.memory_size = memory_size; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> BindVideoSessionMemoryInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct VideoPictureResourceInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub coded_offset: Offset2D, + pub coded_extent: Extent2D, + pub base_array_layer: u32, + pub image_view_binding: ImageView, +} +impl ::std::default::Default for VideoPictureResourceInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + coded_offset: Offset2D::default(), + coded_extent: Extent2D::default(), + base_array_layer: u32::default(), + image_view_binding: ImageView::default(), + } + } +} +unsafe impl TaggedStructure for VideoPictureResourceInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_PICTURE_RESOURCE_INFO_KHR; +} +impl VideoPictureResourceInfoKHR { + pub fn builder<'a>() -> VideoPictureResourceInfoKHRBuilder<'a> { + VideoPictureResourceInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VideoPictureResourceInfoKHRBuilder<'a> { + inner: VideoPictureResourceInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for VideoPictureResourceInfoKHRBuilder<'a> { + type Target = VideoPictureResourceInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VideoPictureResourceInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VideoPictureResourceInfoKHRBuilder<'a> { + #[inline] + pub fn coded_offset(mut self, coded_offset: Offset2D) -> Self { + self.inner.coded_offset = coded_offset; + self + } + #[inline] + pub fn coded_extent(mut self, coded_extent: Extent2D) -> Self { + self.inner.coded_extent = coded_extent; + self + } + #[inline] + pub fn base_array_layer(mut self, base_array_layer: u32) -> Self { + self.inner.base_array_layer = base_array_layer; + self + } + #[inline] + pub fn image_view_binding(mut self, image_view_binding: ImageView) -> Self { + self.inner.image_view_binding = image_view_binding; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VideoPictureResourceInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct VideoReferenceSlotInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub slot_index: i32, + pub p_picture_resource: *const VideoPictureResourceInfoKHR, +} +impl ::std::default::Default for VideoReferenceSlotInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + slot_index: i32::default(), + p_picture_resource: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for VideoReferenceSlotInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_REFERENCE_SLOT_INFO_KHR; +} +impl VideoReferenceSlotInfoKHR { + pub fn builder<'a>() -> VideoReferenceSlotInfoKHRBuilder<'a> { + VideoReferenceSlotInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VideoReferenceSlotInfoKHRBuilder<'a> { + inner: VideoReferenceSlotInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsVideoReferenceSlotInfoKHR {} +impl<'a> ::std::ops::Deref for VideoReferenceSlotInfoKHRBuilder<'a> { + type Target = VideoReferenceSlotInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VideoReferenceSlotInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VideoReferenceSlotInfoKHRBuilder<'a> { + #[inline] + pub fn slot_index(mut self, slot_index: i32) -> Self { + self.inner.slot_index = slot_index; + self + } + #[inline] + pub fn picture_resource(mut self, picture_resource: &'a VideoPictureResourceInfoKHR) -> Self { + self.inner.p_picture_resource = picture_resource; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VideoReferenceSlotInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct VideoDecodeCapabilitiesKHR { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub flags: VideoDecodeCapabilityFlagsKHR, +} +impl ::std::default::Default for VideoDecodeCapabilitiesKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + flags: VideoDecodeCapabilityFlagsKHR::default(), + } + } +} +unsafe impl TaggedStructure for VideoDecodeCapabilitiesKHR { + const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_DECODE_CAPABILITIES_KHR; +} +impl VideoDecodeCapabilitiesKHR { + pub fn builder<'a>() -> VideoDecodeCapabilitiesKHRBuilder<'a> { + VideoDecodeCapabilitiesKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VideoDecodeCapabilitiesKHRBuilder<'a> { + inner: VideoDecodeCapabilitiesKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsVideoCapabilitiesKHR for VideoDecodeCapabilitiesKHRBuilder<'_> {} +unsafe impl ExtendsVideoCapabilitiesKHR for VideoDecodeCapabilitiesKHR {} +impl<'a> ::std::ops::Deref for VideoDecodeCapabilitiesKHRBuilder<'a> { + type Target = VideoDecodeCapabilitiesKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VideoDecodeCapabilitiesKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VideoDecodeCapabilitiesKHRBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: VideoDecodeCapabilityFlagsKHR) -> Self { + self.inner.flags = flags; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VideoDecodeCapabilitiesKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct VideoDecodeUsageInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub video_usage_hints: VideoDecodeUsageFlagsKHR, +} +impl ::std::default::Default for VideoDecodeUsageInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + video_usage_hints: VideoDecodeUsageFlagsKHR::default(), + } + } +} +unsafe impl TaggedStructure for VideoDecodeUsageInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_DECODE_USAGE_INFO_KHR; +} +impl VideoDecodeUsageInfoKHR { + pub fn builder<'a>() -> VideoDecodeUsageInfoKHRBuilder<'a> { + VideoDecodeUsageInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VideoDecodeUsageInfoKHRBuilder<'a> { + inner: VideoDecodeUsageInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsVideoProfileInfoKHR for VideoDecodeUsageInfoKHRBuilder<'_> {} +unsafe impl ExtendsVideoProfileInfoKHR for VideoDecodeUsageInfoKHR {} +unsafe impl ExtendsQueryPoolCreateInfo for VideoDecodeUsageInfoKHRBuilder<'_> {} +unsafe impl ExtendsQueryPoolCreateInfo for VideoDecodeUsageInfoKHR {} +impl<'a> ::std::ops::Deref for VideoDecodeUsageInfoKHRBuilder<'a> { + type Target = VideoDecodeUsageInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VideoDecodeUsageInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VideoDecodeUsageInfoKHRBuilder<'a> { + #[inline] + pub fn video_usage_hints(mut self, video_usage_hints: VideoDecodeUsageFlagsKHR) -> Self { + self.inner.video_usage_hints = video_usage_hints; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VideoDecodeUsageInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct VideoDecodeInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: VideoDecodeFlagsKHR, + pub src_buffer: Buffer, + pub src_buffer_offset: DeviceSize, + pub src_buffer_range: DeviceSize, + pub dst_picture_resource: VideoPictureResourceInfoKHR, + pub p_setup_reference_slot: *const VideoReferenceSlotInfoKHR, + pub reference_slot_count: u32, + pub p_reference_slots: *const VideoReferenceSlotInfoKHR, +} +impl ::std::default::Default for VideoDecodeInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: VideoDecodeFlagsKHR::default(), + src_buffer: Buffer::default(), + src_buffer_offset: DeviceSize::default(), + src_buffer_range: DeviceSize::default(), + dst_picture_resource: VideoPictureResourceInfoKHR::default(), + p_setup_reference_slot: ::std::ptr::null(), + reference_slot_count: u32::default(), + p_reference_slots: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for VideoDecodeInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_DECODE_INFO_KHR; +} +impl VideoDecodeInfoKHR { + pub fn builder<'a>() -> VideoDecodeInfoKHRBuilder<'a> { + VideoDecodeInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VideoDecodeInfoKHRBuilder<'a> { + inner: VideoDecodeInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsVideoDecodeInfoKHR {} +impl<'a> ::std::ops::Deref for VideoDecodeInfoKHRBuilder<'a> { + type Target = VideoDecodeInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VideoDecodeInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VideoDecodeInfoKHRBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: VideoDecodeFlagsKHR) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn src_buffer(mut self, src_buffer: Buffer) -> Self { + self.inner.src_buffer = src_buffer; + self + } + #[inline] + pub fn src_buffer_offset(mut self, src_buffer_offset: DeviceSize) -> Self { + self.inner.src_buffer_offset = src_buffer_offset; + self + } + #[inline] + pub fn src_buffer_range(mut self, src_buffer_range: DeviceSize) -> Self { + self.inner.src_buffer_range = src_buffer_range; + self + } + #[inline] + pub fn dst_picture_resource( + mut self, + dst_picture_resource: VideoPictureResourceInfoKHR, + ) -> Self { + self.inner.dst_picture_resource = dst_picture_resource; + self + } + #[inline] + pub fn setup_reference_slot( + mut self, + setup_reference_slot: &'a VideoReferenceSlotInfoKHR, + ) -> Self { + self.inner.p_setup_reference_slot = setup_reference_slot; + self + } + #[inline] + pub fn reference_slots(mut self, reference_slots: &'a [VideoReferenceSlotInfoKHR]) -> Self { + self.inner.reference_slot_count = reference_slots.len() as _; + self.inner.p_reference_slots = reference_slots.as_ptr(); + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VideoDecodeInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct VideoDecodeH264ProfileInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub std_profile_idc: StdVideoH264ProfileIdc, + pub picture_layout: VideoDecodeH264PictureLayoutFlagsKHR, +} +impl ::std::default::Default for VideoDecodeH264ProfileInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + std_profile_idc: StdVideoH264ProfileIdc::default(), + picture_layout: VideoDecodeH264PictureLayoutFlagsKHR::default(), + } + } +} +unsafe impl TaggedStructure for VideoDecodeH264ProfileInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_DECODE_H264_PROFILE_INFO_KHR; +} +impl VideoDecodeH264ProfileInfoKHR { + pub fn builder<'a>() -> VideoDecodeH264ProfileInfoKHRBuilder<'a> { + VideoDecodeH264ProfileInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VideoDecodeH264ProfileInfoKHRBuilder<'a> { + inner: VideoDecodeH264ProfileInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsVideoProfileInfoKHR for VideoDecodeH264ProfileInfoKHRBuilder<'_> {} +unsafe impl ExtendsVideoProfileInfoKHR for VideoDecodeH264ProfileInfoKHR {} +unsafe impl ExtendsQueryPoolCreateInfo for VideoDecodeH264ProfileInfoKHRBuilder<'_> {} +unsafe impl ExtendsQueryPoolCreateInfo for VideoDecodeH264ProfileInfoKHR {} +impl<'a> ::std::ops::Deref for VideoDecodeH264ProfileInfoKHRBuilder<'a> { + type Target = VideoDecodeH264ProfileInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VideoDecodeH264ProfileInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VideoDecodeH264ProfileInfoKHRBuilder<'a> { + #[inline] + pub fn std_profile_idc(mut self, std_profile_idc: StdVideoH264ProfileIdc) -> Self { + self.inner.std_profile_idc = std_profile_idc; + self + } + #[inline] + pub fn picture_layout(mut self, picture_layout: VideoDecodeH264PictureLayoutFlagsKHR) -> Self { + self.inner.picture_layout = picture_layout; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VideoDecodeH264ProfileInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct VideoDecodeH264CapabilitiesKHR { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub max_level_idc: StdVideoH264LevelIdc, + pub field_offset_granularity: Offset2D, +} +impl ::std::default::Default for VideoDecodeH264CapabilitiesKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + max_level_idc: StdVideoH264LevelIdc::default(), + field_offset_granularity: Offset2D::default(), + } + } +} +unsafe impl TaggedStructure for VideoDecodeH264CapabilitiesKHR { + const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_DECODE_H264_CAPABILITIES_KHR; +} +impl VideoDecodeH264CapabilitiesKHR { + pub fn builder<'a>() -> VideoDecodeH264CapabilitiesKHRBuilder<'a> { + VideoDecodeH264CapabilitiesKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VideoDecodeH264CapabilitiesKHRBuilder<'a> { + inner: VideoDecodeH264CapabilitiesKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsVideoCapabilitiesKHR for VideoDecodeH264CapabilitiesKHRBuilder<'_> {} +unsafe impl ExtendsVideoCapabilitiesKHR for VideoDecodeH264CapabilitiesKHR {} +impl<'a> ::std::ops::Deref for VideoDecodeH264CapabilitiesKHRBuilder<'a> { + type Target = VideoDecodeH264CapabilitiesKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VideoDecodeH264CapabilitiesKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VideoDecodeH264CapabilitiesKHRBuilder<'a> { + #[inline] + pub fn max_level_idc(mut self, max_level_idc: StdVideoH264LevelIdc) -> Self { + self.inner.max_level_idc = max_level_idc; + self + } + #[inline] + pub fn field_offset_granularity(mut self, field_offset_granularity: Offset2D) -> Self { + self.inner.field_offset_granularity = field_offset_granularity; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VideoDecodeH264CapabilitiesKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct VideoDecodeH264SessionParametersAddInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub std_sps_count: u32, + pub p_std_sp_ss: *const StdVideoH264SequenceParameterSet, + pub std_pps_count: u32, + pub p_std_pp_ss: *const StdVideoH264PictureParameterSet, +} +impl ::std::default::Default for VideoDecodeH264SessionParametersAddInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + std_sps_count: u32::default(), + p_std_sp_ss: ::std::ptr::null(), + std_pps_count: u32::default(), + p_std_pp_ss: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for VideoDecodeH264SessionParametersAddInfoKHR { + const STRUCTURE_TYPE: StructureType = + StructureType::VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR; +} +impl VideoDecodeH264SessionParametersAddInfoKHR { + pub fn builder<'a>() -> VideoDecodeH264SessionParametersAddInfoKHRBuilder<'a> { + VideoDecodeH264SessionParametersAddInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VideoDecodeH264SessionParametersAddInfoKHRBuilder<'a> { + inner: VideoDecodeH264SessionParametersAddInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsVideoSessionParametersUpdateInfoKHR + for VideoDecodeH264SessionParametersAddInfoKHRBuilder<'_> +{ +} +unsafe impl ExtendsVideoSessionParametersUpdateInfoKHR + for VideoDecodeH264SessionParametersAddInfoKHR +{ +} +impl<'a> ::std::ops::Deref for VideoDecodeH264SessionParametersAddInfoKHRBuilder<'a> { + type Target = VideoDecodeH264SessionParametersAddInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VideoDecodeH264SessionParametersAddInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VideoDecodeH264SessionParametersAddInfoKHRBuilder<'a> { + #[inline] + pub fn std_sp_ss(mut self, std_sp_ss: &'a [StdVideoH264SequenceParameterSet]) -> Self { + self.inner.std_sps_count = std_sp_ss.len() as _; + self.inner.p_std_sp_ss = std_sp_ss.as_ptr(); + self + } + #[inline] + pub fn std_pp_ss(mut self, std_pp_ss: &'a [StdVideoH264PictureParameterSet]) -> Self { + self.inner.std_pps_count = std_pp_ss.len() as _; + self.inner.p_std_pp_ss = std_pp_ss.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VideoDecodeH264SessionParametersAddInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct VideoDecodeH264SessionParametersCreateInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub max_std_sps_count: u32, + pub max_std_pps_count: u32, + pub p_parameters_add_info: *const VideoDecodeH264SessionParametersAddInfoKHR, +} +impl ::std::default::Default for VideoDecodeH264SessionParametersCreateInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + max_std_sps_count: u32::default(), + max_std_pps_count: u32::default(), + p_parameters_add_info: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for VideoDecodeH264SessionParametersCreateInfoKHR { + const STRUCTURE_TYPE: StructureType = + StructureType::VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR; +} +impl VideoDecodeH264SessionParametersCreateInfoKHR { + pub fn builder<'a>() -> VideoDecodeH264SessionParametersCreateInfoKHRBuilder<'a> { + VideoDecodeH264SessionParametersCreateInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VideoDecodeH264SessionParametersCreateInfoKHRBuilder<'a> { + inner: VideoDecodeH264SessionParametersCreateInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsVideoSessionParametersCreateInfoKHR + for VideoDecodeH264SessionParametersCreateInfoKHRBuilder<'_> +{ +} +unsafe impl ExtendsVideoSessionParametersCreateInfoKHR + for VideoDecodeH264SessionParametersCreateInfoKHR +{ +} +impl<'a> ::std::ops::Deref for VideoDecodeH264SessionParametersCreateInfoKHRBuilder<'a> { + type Target = VideoDecodeH264SessionParametersCreateInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VideoDecodeH264SessionParametersCreateInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VideoDecodeH264SessionParametersCreateInfoKHRBuilder<'a> { + #[inline] + pub fn max_std_sps_count(mut self, max_std_sps_count: u32) -> Self { + self.inner.max_std_sps_count = max_std_sps_count; + self + } + #[inline] + pub fn max_std_pps_count(mut self, max_std_pps_count: u32) -> Self { + self.inner.max_std_pps_count = max_std_pps_count; + self + } + #[inline] + pub fn parameters_add_info( + mut self, + parameters_add_info: &'a VideoDecodeH264SessionParametersAddInfoKHR, + ) -> Self { + self.inner.p_parameters_add_info = parameters_add_info; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VideoDecodeH264SessionParametersCreateInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct VideoDecodeH264PictureInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub p_std_picture_info: *const StdVideoDecodeH264PictureInfo, + pub slice_count: u32, + pub p_slice_offsets: *const u32, +} +impl ::std::default::Default for VideoDecodeH264PictureInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + p_std_picture_info: ::std::ptr::null(), + slice_count: u32::default(), + p_slice_offsets: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for VideoDecodeH264PictureInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_DECODE_H264_PICTURE_INFO_KHR; +} +impl VideoDecodeH264PictureInfoKHR { + pub fn builder<'a>() -> VideoDecodeH264PictureInfoKHRBuilder<'a> { + VideoDecodeH264PictureInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VideoDecodeH264PictureInfoKHRBuilder<'a> { + inner: VideoDecodeH264PictureInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsVideoDecodeInfoKHR for VideoDecodeH264PictureInfoKHRBuilder<'_> {} +unsafe impl ExtendsVideoDecodeInfoKHR for VideoDecodeH264PictureInfoKHR {} +impl<'a> ::std::ops::Deref for VideoDecodeH264PictureInfoKHRBuilder<'a> { + type Target = VideoDecodeH264PictureInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VideoDecodeH264PictureInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VideoDecodeH264PictureInfoKHRBuilder<'a> { + #[inline] + pub fn std_picture_info(mut self, std_picture_info: &'a StdVideoDecodeH264PictureInfo) -> Self { + self.inner.p_std_picture_info = std_picture_info; + self + } + #[inline] + pub fn slice_offsets(mut self, slice_offsets: &'a [u32]) -> Self { + self.inner.slice_count = slice_offsets.len() as _; + self.inner.p_slice_offsets = slice_offsets.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VideoDecodeH264PictureInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct VideoDecodeH264DpbSlotInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub p_std_reference_info: *const StdVideoDecodeH264ReferenceInfo, +} +impl ::std::default::Default for VideoDecodeH264DpbSlotInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + p_std_reference_info: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for VideoDecodeH264DpbSlotInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_DECODE_H264_DPB_SLOT_INFO_KHR; +} +impl VideoDecodeH264DpbSlotInfoKHR { + pub fn builder<'a>() -> VideoDecodeH264DpbSlotInfoKHRBuilder<'a> { + VideoDecodeH264DpbSlotInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VideoDecodeH264DpbSlotInfoKHRBuilder<'a> { + inner: VideoDecodeH264DpbSlotInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsVideoReferenceSlotInfoKHR for VideoDecodeH264DpbSlotInfoKHRBuilder<'_> {} +unsafe impl ExtendsVideoReferenceSlotInfoKHR for VideoDecodeH264DpbSlotInfoKHR {} +impl<'a> ::std::ops::Deref for VideoDecodeH264DpbSlotInfoKHRBuilder<'a> { + type Target = VideoDecodeH264DpbSlotInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VideoDecodeH264DpbSlotInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VideoDecodeH264DpbSlotInfoKHRBuilder<'a> { + #[inline] + pub fn std_reference_info( + mut self, + std_reference_info: &'a StdVideoDecodeH264ReferenceInfo, + ) -> Self { + self.inner.p_std_reference_info = std_reference_info; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VideoDecodeH264DpbSlotInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct VideoDecodeH265ProfileInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub std_profile_idc: StdVideoH265ProfileIdc, +} +impl ::std::default::Default for VideoDecodeH265ProfileInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + std_profile_idc: StdVideoH265ProfileIdc::default(), + } + } +} +unsafe impl TaggedStructure for VideoDecodeH265ProfileInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_DECODE_H265_PROFILE_INFO_KHR; +} +impl VideoDecodeH265ProfileInfoKHR { + pub fn builder<'a>() -> VideoDecodeH265ProfileInfoKHRBuilder<'a> { + VideoDecodeH265ProfileInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VideoDecodeH265ProfileInfoKHRBuilder<'a> { + inner: VideoDecodeH265ProfileInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsVideoProfileInfoKHR for VideoDecodeH265ProfileInfoKHRBuilder<'_> {} +unsafe impl ExtendsVideoProfileInfoKHR for VideoDecodeH265ProfileInfoKHR {} +unsafe impl ExtendsQueryPoolCreateInfo for VideoDecodeH265ProfileInfoKHRBuilder<'_> {} +unsafe impl ExtendsQueryPoolCreateInfo for VideoDecodeH265ProfileInfoKHR {} +impl<'a> ::std::ops::Deref for VideoDecodeH265ProfileInfoKHRBuilder<'a> { + type Target = VideoDecodeH265ProfileInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VideoDecodeH265ProfileInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VideoDecodeH265ProfileInfoKHRBuilder<'a> { + #[inline] + pub fn std_profile_idc(mut self, std_profile_idc: StdVideoH265ProfileIdc) -> Self { + self.inner.std_profile_idc = std_profile_idc; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VideoDecodeH265ProfileInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct VideoDecodeH265CapabilitiesKHR { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub max_level_idc: StdVideoH265LevelIdc, +} +impl ::std::default::Default for VideoDecodeH265CapabilitiesKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + max_level_idc: StdVideoH265LevelIdc::default(), + } + } +} +unsafe impl TaggedStructure for VideoDecodeH265CapabilitiesKHR { + const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_DECODE_H265_CAPABILITIES_KHR; +} +impl VideoDecodeH265CapabilitiesKHR { + pub fn builder<'a>() -> VideoDecodeH265CapabilitiesKHRBuilder<'a> { + VideoDecodeH265CapabilitiesKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VideoDecodeH265CapabilitiesKHRBuilder<'a> { + inner: VideoDecodeH265CapabilitiesKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsVideoCapabilitiesKHR for VideoDecodeH265CapabilitiesKHRBuilder<'_> {} +unsafe impl ExtendsVideoCapabilitiesKHR for VideoDecodeH265CapabilitiesKHR {} +impl<'a> ::std::ops::Deref for VideoDecodeH265CapabilitiesKHRBuilder<'a> { + type Target = VideoDecodeH265CapabilitiesKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VideoDecodeH265CapabilitiesKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VideoDecodeH265CapabilitiesKHRBuilder<'a> { + #[inline] + pub fn max_level_idc(mut self, max_level_idc: StdVideoH265LevelIdc) -> Self { + self.inner.max_level_idc = max_level_idc; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VideoDecodeH265CapabilitiesKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct VideoDecodeH265SessionParametersAddInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub std_vps_count: u32, + pub p_std_vp_ss: *const StdVideoH265VideoParameterSet, + pub std_sps_count: u32, + pub p_std_sp_ss: *const StdVideoH265SequenceParameterSet, + pub std_pps_count: u32, + pub p_std_pp_ss: *const StdVideoH265PictureParameterSet, +} +impl ::std::default::Default for VideoDecodeH265SessionParametersAddInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + std_vps_count: u32::default(), + p_std_vp_ss: ::std::ptr::null(), + std_sps_count: u32::default(), + p_std_sp_ss: ::std::ptr::null(), + std_pps_count: u32::default(), + p_std_pp_ss: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for VideoDecodeH265SessionParametersAddInfoKHR { + const STRUCTURE_TYPE: StructureType = + StructureType::VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR; +} +impl VideoDecodeH265SessionParametersAddInfoKHR { + pub fn builder<'a>() -> VideoDecodeH265SessionParametersAddInfoKHRBuilder<'a> { + VideoDecodeH265SessionParametersAddInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VideoDecodeH265SessionParametersAddInfoKHRBuilder<'a> { + inner: VideoDecodeH265SessionParametersAddInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsVideoSessionParametersUpdateInfoKHR + for VideoDecodeH265SessionParametersAddInfoKHRBuilder<'_> +{ +} +unsafe impl ExtendsVideoSessionParametersUpdateInfoKHR + for VideoDecodeH265SessionParametersAddInfoKHR +{ +} +impl<'a> ::std::ops::Deref for VideoDecodeH265SessionParametersAddInfoKHRBuilder<'a> { + type Target = VideoDecodeH265SessionParametersAddInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VideoDecodeH265SessionParametersAddInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VideoDecodeH265SessionParametersAddInfoKHRBuilder<'a> { + #[inline] + pub fn std_vp_ss(mut self, std_vp_ss: &'a [StdVideoH265VideoParameterSet]) -> Self { + self.inner.std_vps_count = std_vp_ss.len() as _; + self.inner.p_std_vp_ss = std_vp_ss.as_ptr(); + self + } + #[inline] + pub fn std_sp_ss(mut self, std_sp_ss: &'a [StdVideoH265SequenceParameterSet]) -> Self { + self.inner.std_sps_count = std_sp_ss.len() as _; + self.inner.p_std_sp_ss = std_sp_ss.as_ptr(); + self + } + #[inline] + pub fn std_pp_ss(mut self, std_pp_ss: &'a [StdVideoH265PictureParameterSet]) -> Self { + self.inner.std_pps_count = std_pp_ss.len() as _; + self.inner.p_std_pp_ss = std_pp_ss.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VideoDecodeH265SessionParametersAddInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct VideoDecodeH265SessionParametersCreateInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub max_std_vps_count: u32, + pub max_std_sps_count: u32, + pub max_std_pps_count: u32, + pub p_parameters_add_info: *const VideoDecodeH265SessionParametersAddInfoKHR, +} +impl ::std::default::Default for VideoDecodeH265SessionParametersCreateInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + max_std_vps_count: u32::default(), + max_std_sps_count: u32::default(), + max_std_pps_count: u32::default(), + p_parameters_add_info: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for VideoDecodeH265SessionParametersCreateInfoKHR { + const STRUCTURE_TYPE: StructureType = + StructureType::VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR; +} +impl VideoDecodeH265SessionParametersCreateInfoKHR { + pub fn builder<'a>() -> VideoDecodeH265SessionParametersCreateInfoKHRBuilder<'a> { + VideoDecodeH265SessionParametersCreateInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VideoDecodeH265SessionParametersCreateInfoKHRBuilder<'a> { + inner: VideoDecodeH265SessionParametersCreateInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsVideoSessionParametersCreateInfoKHR + for VideoDecodeH265SessionParametersCreateInfoKHRBuilder<'_> +{ +} +unsafe impl ExtendsVideoSessionParametersCreateInfoKHR + for VideoDecodeH265SessionParametersCreateInfoKHR +{ +} +impl<'a> ::std::ops::Deref for VideoDecodeH265SessionParametersCreateInfoKHRBuilder<'a> { + type Target = VideoDecodeH265SessionParametersCreateInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VideoDecodeH265SessionParametersCreateInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VideoDecodeH265SessionParametersCreateInfoKHRBuilder<'a> { + #[inline] + pub fn max_std_vps_count(mut self, max_std_vps_count: u32) -> Self { + self.inner.max_std_vps_count = max_std_vps_count; + self + } + #[inline] + pub fn max_std_sps_count(mut self, max_std_sps_count: u32) -> Self { + self.inner.max_std_sps_count = max_std_sps_count; + self + } + #[inline] + pub fn max_std_pps_count(mut self, max_std_pps_count: u32) -> Self { + self.inner.max_std_pps_count = max_std_pps_count; + self + } + #[inline] + pub fn parameters_add_info( + mut self, + parameters_add_info: &'a VideoDecodeH265SessionParametersAddInfoKHR, + ) -> Self { + self.inner.p_parameters_add_info = parameters_add_info; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VideoDecodeH265SessionParametersCreateInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct VideoDecodeH265PictureInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub p_std_picture_info: *mut StdVideoDecodeH265PictureInfo, + pub slice_segment_count: u32, + pub p_slice_segment_offsets: *const u32, +} +impl ::std::default::Default for VideoDecodeH265PictureInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + p_std_picture_info: ::std::ptr::null_mut(), + slice_segment_count: u32::default(), + p_slice_segment_offsets: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for VideoDecodeH265PictureInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_DECODE_H265_PICTURE_INFO_KHR; +} +impl VideoDecodeH265PictureInfoKHR { + pub fn builder<'a>() -> VideoDecodeH265PictureInfoKHRBuilder<'a> { + VideoDecodeH265PictureInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VideoDecodeH265PictureInfoKHRBuilder<'a> { + inner: VideoDecodeH265PictureInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsVideoDecodeInfoKHR for VideoDecodeH265PictureInfoKHRBuilder<'_> {} +unsafe impl ExtendsVideoDecodeInfoKHR for VideoDecodeH265PictureInfoKHR {} +impl<'a> ::std::ops::Deref for VideoDecodeH265PictureInfoKHRBuilder<'a> { + type Target = VideoDecodeH265PictureInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VideoDecodeH265PictureInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VideoDecodeH265PictureInfoKHRBuilder<'a> { + #[inline] + pub fn std_picture_info( + mut self, + std_picture_info: &'a mut StdVideoDecodeH265PictureInfo, + ) -> Self { + self.inner.p_std_picture_info = std_picture_info; + self + } + #[inline] + pub fn slice_segment_offsets(mut self, slice_segment_offsets: &'a [u32]) -> Self { + self.inner.slice_segment_count = slice_segment_offsets.len() as _; + self.inner.p_slice_segment_offsets = slice_segment_offsets.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VideoDecodeH265PictureInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct VideoDecodeH265DpbSlotInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub p_std_reference_info: *const StdVideoDecodeH265ReferenceInfo, +} +impl ::std::default::Default for VideoDecodeH265DpbSlotInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + p_std_reference_info: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for VideoDecodeH265DpbSlotInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_DECODE_H265_DPB_SLOT_INFO_KHR; +} +impl VideoDecodeH265DpbSlotInfoKHR { + pub fn builder<'a>() -> VideoDecodeH265DpbSlotInfoKHRBuilder<'a> { + VideoDecodeH265DpbSlotInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VideoDecodeH265DpbSlotInfoKHRBuilder<'a> { + inner: VideoDecodeH265DpbSlotInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsVideoReferenceSlotInfoKHR for VideoDecodeH265DpbSlotInfoKHRBuilder<'_> {} +unsafe impl ExtendsVideoReferenceSlotInfoKHR for VideoDecodeH265DpbSlotInfoKHR {} +impl<'a> ::std::ops::Deref for VideoDecodeH265DpbSlotInfoKHRBuilder<'a> { + type Target = VideoDecodeH265DpbSlotInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VideoDecodeH265DpbSlotInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VideoDecodeH265DpbSlotInfoKHRBuilder<'a> { + #[inline] + pub fn std_reference_info( + mut self, + std_reference_info: &'a StdVideoDecodeH265ReferenceInfo, + ) -> Self { + self.inner.p_std_reference_info = std_reference_info; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VideoDecodeH265DpbSlotInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct VideoSessionCreateInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub queue_family_index: u32, + pub flags: VideoSessionCreateFlagsKHR, + pub p_video_profile: *const VideoProfileInfoKHR, + pub picture_format: Format, + pub max_coded_extent: Extent2D, + pub reference_picture_format: Format, + pub max_dpb_slots: u32, + pub max_active_reference_pictures: u32, + pub p_std_header_version: *const ExtensionProperties, +} +impl ::std::default::Default for VideoSessionCreateInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + queue_family_index: u32::default(), + flags: VideoSessionCreateFlagsKHR::default(), + p_video_profile: ::std::ptr::null(), + picture_format: Format::default(), + max_coded_extent: Extent2D::default(), + reference_picture_format: Format::default(), + max_dpb_slots: u32::default(), + max_active_reference_pictures: u32::default(), + p_std_header_version: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for VideoSessionCreateInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_SESSION_CREATE_INFO_KHR; +} +impl VideoSessionCreateInfoKHR { + pub fn builder<'a>() -> VideoSessionCreateInfoKHRBuilder<'a> { + VideoSessionCreateInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VideoSessionCreateInfoKHRBuilder<'a> { + inner: VideoSessionCreateInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for VideoSessionCreateInfoKHRBuilder<'a> { + type Target = VideoSessionCreateInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VideoSessionCreateInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VideoSessionCreateInfoKHRBuilder<'a> { + #[inline] + pub fn queue_family_index(mut self, queue_family_index: u32) -> Self { + self.inner.queue_family_index = queue_family_index; + self + } + #[inline] + pub fn flags(mut self, flags: VideoSessionCreateFlagsKHR) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn video_profile(mut self, video_profile: &'a VideoProfileInfoKHR) -> Self { + self.inner.p_video_profile = video_profile; + self + } + #[inline] + pub fn picture_format(mut self, picture_format: Format) -> Self { + self.inner.picture_format = picture_format; + self + } + #[inline] + pub fn max_coded_extent(mut self, max_coded_extent: Extent2D) -> Self { + self.inner.max_coded_extent = max_coded_extent; + self + } + #[inline] + pub fn reference_picture_format(mut self, reference_picture_format: Format) -> Self { + self.inner.reference_picture_format = reference_picture_format; + self + } + #[inline] + pub fn max_dpb_slots(mut self, max_dpb_slots: u32) -> Self { + self.inner.max_dpb_slots = max_dpb_slots; + self + } + #[inline] + pub fn max_active_reference_pictures(mut self, max_active_reference_pictures: u32) -> Self { + self.inner.max_active_reference_pictures = max_active_reference_pictures; + self + } + #[inline] + pub fn std_header_version(mut self, std_header_version: &'a ExtensionProperties) -> Self { + self.inner.p_std_header_version = std_header_version; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VideoSessionCreateInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct VideoSessionParametersCreateInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: VideoSessionParametersCreateFlagsKHR, + pub video_session_parameters_template: VideoSessionParametersKHR, + pub video_session: VideoSessionKHR, +} +impl ::std::default::Default for VideoSessionParametersCreateInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: VideoSessionParametersCreateFlagsKHR::default(), + video_session_parameters_template: VideoSessionParametersKHR::default(), + video_session: VideoSessionKHR::default(), + } + } +} +unsafe impl TaggedStructure for VideoSessionParametersCreateInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_SESSION_PARAMETERS_CREATE_INFO_KHR; +} +impl VideoSessionParametersCreateInfoKHR { + pub fn builder<'a>() -> VideoSessionParametersCreateInfoKHRBuilder<'a> { + VideoSessionParametersCreateInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VideoSessionParametersCreateInfoKHRBuilder<'a> { + inner: VideoSessionParametersCreateInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsVideoSessionParametersCreateInfoKHR {} +impl<'a> ::std::ops::Deref for VideoSessionParametersCreateInfoKHRBuilder<'a> { + type Target = VideoSessionParametersCreateInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VideoSessionParametersCreateInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VideoSessionParametersCreateInfoKHRBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: VideoSessionParametersCreateFlagsKHR) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn video_session_parameters_template( + mut self, + video_session_parameters_template: VideoSessionParametersKHR, + ) -> Self { + self.inner.video_session_parameters_template = video_session_parameters_template; + self + } + #[inline] + pub fn video_session(mut self, video_session: VideoSessionKHR) -> Self { + self.inner.video_session = video_session; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next( + mut self, + next: &'a mut T, + ) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VideoSessionParametersCreateInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct VideoSessionParametersUpdateInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub update_sequence_count: u32, +} +impl ::std::default::Default for VideoSessionParametersUpdateInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + update_sequence_count: u32::default(), + } + } +} +unsafe impl TaggedStructure for VideoSessionParametersUpdateInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_SESSION_PARAMETERS_UPDATE_INFO_KHR; +} +impl VideoSessionParametersUpdateInfoKHR { + pub fn builder<'a>() -> VideoSessionParametersUpdateInfoKHRBuilder<'a> { + VideoSessionParametersUpdateInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VideoSessionParametersUpdateInfoKHRBuilder<'a> { + inner: VideoSessionParametersUpdateInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsVideoSessionParametersUpdateInfoKHR {} +impl<'a> ::std::ops::Deref for VideoSessionParametersUpdateInfoKHRBuilder<'a> { + type Target = VideoSessionParametersUpdateInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VideoSessionParametersUpdateInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VideoSessionParametersUpdateInfoKHRBuilder<'a> { + #[inline] + pub fn update_sequence_count(mut self, update_sequence_count: u32) -> Self { + self.inner.update_sequence_count = update_sequence_count; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next( + mut self, + next: &'a mut T, + ) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VideoSessionParametersUpdateInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct VideoBeginCodingInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: VideoBeginCodingFlagsKHR, + pub video_session: VideoSessionKHR, + pub video_session_parameters: VideoSessionParametersKHR, + pub reference_slot_count: u32, + pub p_reference_slots: *const VideoReferenceSlotInfoKHR, +} +impl ::std::default::Default for VideoBeginCodingInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: VideoBeginCodingFlagsKHR::default(), + video_session: VideoSessionKHR::default(), + video_session_parameters: VideoSessionParametersKHR::default(), + reference_slot_count: u32::default(), + p_reference_slots: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for VideoBeginCodingInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_BEGIN_CODING_INFO_KHR; +} +impl VideoBeginCodingInfoKHR { + pub fn builder<'a>() -> VideoBeginCodingInfoKHRBuilder<'a> { + VideoBeginCodingInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VideoBeginCodingInfoKHRBuilder<'a> { + inner: VideoBeginCodingInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for VideoBeginCodingInfoKHRBuilder<'a> { + type Target = VideoBeginCodingInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VideoBeginCodingInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VideoBeginCodingInfoKHRBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: VideoBeginCodingFlagsKHR) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn video_session(mut self, video_session: VideoSessionKHR) -> Self { + self.inner.video_session = video_session; + self + } + #[inline] + pub fn video_session_parameters( + mut self, + video_session_parameters: VideoSessionParametersKHR, + ) -> Self { + self.inner.video_session_parameters = video_session_parameters; + self + } + #[inline] + pub fn reference_slots(mut self, reference_slots: &'a [VideoReferenceSlotInfoKHR]) -> Self { + self.inner.reference_slot_count = reference_slots.len() as _; + self.inner.p_reference_slots = reference_slots.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VideoBeginCodingInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct VideoEndCodingInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: VideoEndCodingFlagsKHR, +} +impl ::std::default::Default for VideoEndCodingInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: VideoEndCodingFlagsKHR::default(), + } + } +} +unsafe impl TaggedStructure for VideoEndCodingInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_END_CODING_INFO_KHR; +} +impl VideoEndCodingInfoKHR { + pub fn builder<'a>() -> VideoEndCodingInfoKHRBuilder<'a> { + VideoEndCodingInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VideoEndCodingInfoKHRBuilder<'a> { + inner: VideoEndCodingInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for VideoEndCodingInfoKHRBuilder<'a> { + type Target = VideoEndCodingInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VideoEndCodingInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VideoEndCodingInfoKHRBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: VideoEndCodingFlagsKHR) -> Self { + self.inner.flags = flags; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VideoEndCodingInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct VideoCodingControlInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: VideoCodingControlFlagsKHR, +} +impl ::std::default::Default for VideoCodingControlInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: VideoCodingControlFlagsKHR::default(), + } + } +} +unsafe impl TaggedStructure for VideoCodingControlInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_CODING_CONTROL_INFO_KHR; +} +impl VideoCodingControlInfoKHR { + pub fn builder<'a>() -> VideoCodingControlInfoKHRBuilder<'a> { + VideoCodingControlInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VideoCodingControlInfoKHRBuilder<'a> { + inner: VideoCodingControlInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsVideoCodingControlInfoKHR {} +impl<'a> ::std::ops::Deref for VideoCodingControlInfoKHRBuilder<'a> { + type Target = VideoCodingControlInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VideoCodingControlInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VideoCodingControlInfoKHRBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: VideoCodingControlFlagsKHR) -> Self { + self.inner.flags = flags; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VideoCodingControlInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct VideoEncodeUsageInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub video_usage_hints: VideoEncodeUsageFlagsKHR, + pub video_content_hints: VideoEncodeContentFlagsKHR, + pub tuning_mode: VideoEncodeTuningModeKHR, +} +impl ::std::default::Default for VideoEncodeUsageInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + video_usage_hints: VideoEncodeUsageFlagsKHR::default(), + video_content_hints: VideoEncodeContentFlagsKHR::default(), + tuning_mode: VideoEncodeTuningModeKHR::default(), + } + } +} +unsafe impl TaggedStructure for VideoEncodeUsageInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_ENCODE_USAGE_INFO_KHR; +} +impl VideoEncodeUsageInfoKHR { + pub fn builder<'a>() -> VideoEncodeUsageInfoKHRBuilder<'a> { + VideoEncodeUsageInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VideoEncodeUsageInfoKHRBuilder<'a> { + inner: VideoEncodeUsageInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsVideoProfileInfoKHR for VideoEncodeUsageInfoKHRBuilder<'_> {} +unsafe impl ExtendsVideoProfileInfoKHR for VideoEncodeUsageInfoKHR {} +unsafe impl ExtendsQueryPoolCreateInfo for VideoEncodeUsageInfoKHRBuilder<'_> {} +unsafe impl ExtendsQueryPoolCreateInfo for VideoEncodeUsageInfoKHR {} +impl<'a> ::std::ops::Deref for VideoEncodeUsageInfoKHRBuilder<'a> { + type Target = VideoEncodeUsageInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VideoEncodeUsageInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VideoEncodeUsageInfoKHRBuilder<'a> { + #[inline] + pub fn video_usage_hints(mut self, video_usage_hints: VideoEncodeUsageFlagsKHR) -> Self { + self.inner.video_usage_hints = video_usage_hints; + self + } + #[inline] + pub fn video_content_hints(mut self, video_content_hints: VideoEncodeContentFlagsKHR) -> Self { + self.inner.video_content_hints = video_content_hints; + self + } + #[inline] + pub fn tuning_mode(mut self, tuning_mode: VideoEncodeTuningModeKHR) -> Self { + self.inner.tuning_mode = tuning_mode; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VideoEncodeUsageInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct VideoEncodeInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: VideoEncodeFlagsKHR, + pub quality_level: u32, + pub dst_bitstream_buffer: Buffer, + pub dst_bitstream_buffer_offset: DeviceSize, + pub dst_bitstream_buffer_max_range: DeviceSize, + pub src_picture_resource: VideoPictureResourceInfoKHR, + pub p_setup_reference_slot: *const VideoReferenceSlotInfoKHR, + pub reference_slot_count: u32, + pub p_reference_slots: *const VideoReferenceSlotInfoKHR, + pub preceding_externally_encoded_bytes: u32, +} +impl ::std::default::Default for VideoEncodeInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: VideoEncodeFlagsKHR::default(), + quality_level: u32::default(), + dst_bitstream_buffer: Buffer::default(), + dst_bitstream_buffer_offset: DeviceSize::default(), + dst_bitstream_buffer_max_range: DeviceSize::default(), + src_picture_resource: VideoPictureResourceInfoKHR::default(), + p_setup_reference_slot: ::std::ptr::null(), + reference_slot_count: u32::default(), + p_reference_slots: ::std::ptr::null(), + preceding_externally_encoded_bytes: u32::default(), + } + } +} +unsafe impl TaggedStructure for VideoEncodeInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_ENCODE_INFO_KHR; +} +impl VideoEncodeInfoKHR { + pub fn builder<'a>() -> VideoEncodeInfoKHRBuilder<'a> { + VideoEncodeInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VideoEncodeInfoKHRBuilder<'a> { + inner: VideoEncodeInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsVideoEncodeInfoKHR {} +impl<'a> ::std::ops::Deref for VideoEncodeInfoKHRBuilder<'a> { + type Target = VideoEncodeInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VideoEncodeInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VideoEncodeInfoKHRBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: VideoEncodeFlagsKHR) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn quality_level(mut self, quality_level: u32) -> Self { + self.inner.quality_level = quality_level; + self + } + #[inline] + pub fn dst_bitstream_buffer(mut self, dst_bitstream_buffer: Buffer) -> Self { + self.inner.dst_bitstream_buffer = dst_bitstream_buffer; + self + } + #[inline] + pub fn dst_bitstream_buffer_offset(mut self, dst_bitstream_buffer_offset: DeviceSize) -> Self { + self.inner.dst_bitstream_buffer_offset = dst_bitstream_buffer_offset; + self + } + #[inline] + pub fn dst_bitstream_buffer_max_range( + mut self, + dst_bitstream_buffer_max_range: DeviceSize, + ) -> Self { + self.inner.dst_bitstream_buffer_max_range = dst_bitstream_buffer_max_range; + self + } + #[inline] + pub fn src_picture_resource( + mut self, + src_picture_resource: VideoPictureResourceInfoKHR, + ) -> Self { + self.inner.src_picture_resource = src_picture_resource; + self + } + #[inline] + pub fn setup_reference_slot( + mut self, + setup_reference_slot: &'a VideoReferenceSlotInfoKHR, + ) -> Self { + self.inner.p_setup_reference_slot = setup_reference_slot; + self + } + #[inline] + pub fn reference_slots(mut self, reference_slots: &'a [VideoReferenceSlotInfoKHR]) -> Self { + self.inner.reference_slot_count = reference_slots.len() as _; + self.inner.p_reference_slots = reference_slots.as_ptr(); + self + } + #[inline] + pub fn preceding_externally_encoded_bytes( + mut self, + preceding_externally_encoded_bytes: u32, + ) -> Self { + self.inner.preceding_externally_encoded_bytes = preceding_externally_encoded_bytes; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VideoEncodeInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct VideoEncodeRateControlInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: VideoEncodeRateControlFlagsKHR, + pub rate_control_mode: VideoEncodeRateControlModeFlagsKHR, + pub layer_count: u8, + pub p_layer_configs: *const VideoEncodeRateControlLayerInfoKHR, +} +impl ::std::default::Default for VideoEncodeRateControlInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: VideoEncodeRateControlFlagsKHR::default(), + rate_control_mode: VideoEncodeRateControlModeFlagsKHR::default(), + layer_count: u8::default(), + p_layer_configs: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for VideoEncodeRateControlInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_ENCODE_RATE_CONTROL_INFO_KHR; +} +impl VideoEncodeRateControlInfoKHR { + pub fn builder<'a>() -> VideoEncodeRateControlInfoKHRBuilder<'a> { + VideoEncodeRateControlInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VideoEncodeRateControlInfoKHRBuilder<'a> { + inner: VideoEncodeRateControlInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsVideoCodingControlInfoKHR for VideoEncodeRateControlInfoKHRBuilder<'_> {} +unsafe impl ExtendsVideoCodingControlInfoKHR for VideoEncodeRateControlInfoKHR {} +impl<'a> ::std::ops::Deref for VideoEncodeRateControlInfoKHRBuilder<'a> { + type Target = VideoEncodeRateControlInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VideoEncodeRateControlInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VideoEncodeRateControlInfoKHRBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: VideoEncodeRateControlFlagsKHR) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn rate_control_mode( + mut self, + rate_control_mode: VideoEncodeRateControlModeFlagsKHR, + ) -> Self { + self.inner.rate_control_mode = rate_control_mode; + self + } + #[inline] + pub fn layer_configs( + mut self, + layer_configs: &'a [VideoEncodeRateControlLayerInfoKHR], + ) -> Self { + self.inner.layer_count = layer_configs.len() as _; + self.inner.p_layer_configs = layer_configs.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VideoEncodeRateControlInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct VideoEncodeRateControlLayerInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub average_bitrate: u32, + pub max_bitrate: u32, + pub frame_rate_numerator: u32, + pub frame_rate_denominator: u32, + pub virtual_buffer_size_in_ms: u32, + pub initial_virtual_buffer_size_in_ms: u32, +} +impl ::std::default::Default for VideoEncodeRateControlLayerInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + average_bitrate: u32::default(), + max_bitrate: u32::default(), + frame_rate_numerator: u32::default(), + frame_rate_denominator: u32::default(), + virtual_buffer_size_in_ms: u32::default(), + initial_virtual_buffer_size_in_ms: u32::default(), + } + } +} +unsafe impl TaggedStructure for VideoEncodeRateControlLayerInfoKHR { + const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_ENCODE_RATE_CONTROL_LAYER_INFO_KHR; +} +impl VideoEncodeRateControlLayerInfoKHR { + pub fn builder<'a>() -> VideoEncodeRateControlLayerInfoKHRBuilder<'a> { + VideoEncodeRateControlLayerInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VideoEncodeRateControlLayerInfoKHRBuilder<'a> { + inner: VideoEncodeRateControlLayerInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsVideoCodingControlInfoKHR for VideoEncodeRateControlLayerInfoKHRBuilder<'_> {} +unsafe impl ExtendsVideoCodingControlInfoKHR for VideoEncodeRateControlLayerInfoKHR {} +pub unsafe trait ExtendsVideoEncodeRateControlLayerInfoKHR {} +impl<'a> ::std::ops::Deref for VideoEncodeRateControlLayerInfoKHRBuilder<'a> { + type Target = VideoEncodeRateControlLayerInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VideoEncodeRateControlLayerInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VideoEncodeRateControlLayerInfoKHRBuilder<'a> { + #[inline] + pub fn average_bitrate(mut self, average_bitrate: u32) -> Self { + self.inner.average_bitrate = average_bitrate; + self + } + #[inline] + pub fn max_bitrate(mut self, max_bitrate: u32) -> Self { + self.inner.max_bitrate = max_bitrate; + self + } + #[inline] + pub fn frame_rate_numerator(mut self, frame_rate_numerator: u32) -> Self { + self.inner.frame_rate_numerator = frame_rate_numerator; + self + } + #[inline] + pub fn frame_rate_denominator(mut self, frame_rate_denominator: u32) -> Self { + self.inner.frame_rate_denominator = frame_rate_denominator; + self + } + #[inline] + pub fn virtual_buffer_size_in_ms(mut self, virtual_buffer_size_in_ms: u32) -> Self { + self.inner.virtual_buffer_size_in_ms = virtual_buffer_size_in_ms; + self + } + #[inline] + pub fn initial_virtual_buffer_size_in_ms( + mut self, + initial_virtual_buffer_size_in_ms: u32, + ) -> Self { + self.inner.initial_virtual_buffer_size_in_ms = initial_virtual_buffer_size_in_ms; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next( + mut self, + next: &'a mut T, + ) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VideoEncodeRateControlLayerInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct VideoEncodeCapabilitiesKHR { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub flags: VideoEncodeCapabilityFlagsKHR, + pub rate_control_modes: VideoEncodeRateControlModeFlagsKHR, + pub rate_control_layer_count: u8, + pub quality_level_count: u8, + pub input_image_data_fill_alignment: Extent2D, +} +impl ::std::default::Default for VideoEncodeCapabilitiesKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + flags: VideoEncodeCapabilityFlagsKHR::default(), + rate_control_modes: VideoEncodeRateControlModeFlagsKHR::default(), + rate_control_layer_count: u8::default(), + quality_level_count: u8::default(), + input_image_data_fill_alignment: Extent2D::default(), + } + } +} +unsafe impl TaggedStructure for VideoEncodeCapabilitiesKHR { + const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_ENCODE_CAPABILITIES_KHR; +} +impl VideoEncodeCapabilitiesKHR { + pub fn builder<'a>() -> VideoEncodeCapabilitiesKHRBuilder<'a> { + VideoEncodeCapabilitiesKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VideoEncodeCapabilitiesKHRBuilder<'a> { + inner: VideoEncodeCapabilitiesKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsVideoCapabilitiesKHR for VideoEncodeCapabilitiesKHRBuilder<'_> {} +unsafe impl ExtendsVideoCapabilitiesKHR for VideoEncodeCapabilitiesKHR {} +impl<'a> ::std::ops::Deref for VideoEncodeCapabilitiesKHRBuilder<'a> { + type Target = VideoEncodeCapabilitiesKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VideoEncodeCapabilitiesKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VideoEncodeCapabilitiesKHRBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: VideoEncodeCapabilityFlagsKHR) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn rate_control_modes( + mut self, + rate_control_modes: VideoEncodeRateControlModeFlagsKHR, + ) -> Self { + self.inner.rate_control_modes = rate_control_modes; + self + } + #[inline] + pub fn rate_control_layer_count(mut self, rate_control_layer_count: u8) -> Self { + self.inner.rate_control_layer_count = rate_control_layer_count; + self + } + #[inline] + pub fn quality_level_count(mut self, quality_level_count: u8) -> Self { + self.inner.quality_level_count = quality_level_count; + self + } + #[inline] + pub fn input_image_data_fill_alignment( + mut self, + input_image_data_fill_alignment: Extent2D, + ) -> Self { + self.inner.input_image_data_fill_alignment = input_image_data_fill_alignment; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VideoEncodeCapabilitiesKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct VideoEncodeH264CapabilitiesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub flags: VideoEncodeH264CapabilityFlagsEXT, + pub input_mode_flags: VideoEncodeH264InputModeFlagsEXT, + pub output_mode_flags: VideoEncodeH264OutputModeFlagsEXT, + pub max_p_picture_l0_reference_count: u8, + pub max_b_picture_l0_reference_count: u8, + pub max_l1_reference_count: u8, + pub motion_vectors_over_pic_boundaries_flag: Bool32, + pub max_bytes_per_pic_denom: u32, + pub max_bits_per_mb_denom: u32, + pub log2_max_mv_length_horizontal: u32, + pub log2_max_mv_length_vertical: u32, +} +impl ::std::default::Default for VideoEncodeH264CapabilitiesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + flags: VideoEncodeH264CapabilityFlagsEXT::default(), + input_mode_flags: VideoEncodeH264InputModeFlagsEXT::default(), + output_mode_flags: VideoEncodeH264OutputModeFlagsEXT::default(), + max_p_picture_l0_reference_count: u8::default(), + max_b_picture_l0_reference_count: u8::default(), + max_l1_reference_count: u8::default(), + motion_vectors_over_pic_boundaries_flag: Bool32::default(), + max_bytes_per_pic_denom: u32::default(), + max_bits_per_mb_denom: u32::default(), + log2_max_mv_length_horizontal: u32::default(), + log2_max_mv_length_vertical: u32::default(), + } + } +} +unsafe impl TaggedStructure for VideoEncodeH264CapabilitiesEXT { + const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_ENCODE_H264_CAPABILITIES_EXT; +} +impl VideoEncodeH264CapabilitiesEXT { + pub fn builder<'a>() -> VideoEncodeH264CapabilitiesEXTBuilder<'a> { + VideoEncodeH264CapabilitiesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VideoEncodeH264CapabilitiesEXTBuilder<'a> { + inner: VideoEncodeH264CapabilitiesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsVideoCapabilitiesKHR for VideoEncodeH264CapabilitiesEXTBuilder<'_> {} +unsafe impl ExtendsVideoCapabilitiesKHR for VideoEncodeH264CapabilitiesEXT {} +impl<'a> ::std::ops::Deref for VideoEncodeH264CapabilitiesEXTBuilder<'a> { + type Target = VideoEncodeH264CapabilitiesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VideoEncodeH264CapabilitiesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VideoEncodeH264CapabilitiesEXTBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: VideoEncodeH264CapabilityFlagsEXT) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn input_mode_flags(mut self, input_mode_flags: VideoEncodeH264InputModeFlagsEXT) -> Self { + self.inner.input_mode_flags = input_mode_flags; + self + } + #[inline] + pub fn output_mode_flags( + mut self, + output_mode_flags: VideoEncodeH264OutputModeFlagsEXT, + ) -> Self { + self.inner.output_mode_flags = output_mode_flags; + self + } + #[inline] + pub fn max_p_picture_l0_reference_count( + mut self, + max_p_picture_l0_reference_count: u8, + ) -> Self { + self.inner.max_p_picture_l0_reference_count = max_p_picture_l0_reference_count; + self + } + #[inline] + pub fn max_b_picture_l0_reference_count( + mut self, + max_b_picture_l0_reference_count: u8, + ) -> Self { + self.inner.max_b_picture_l0_reference_count = max_b_picture_l0_reference_count; + self + } + #[inline] + pub fn max_l1_reference_count(mut self, max_l1_reference_count: u8) -> Self { + self.inner.max_l1_reference_count = max_l1_reference_count; + self + } + #[inline] + pub fn motion_vectors_over_pic_boundaries_flag( + mut self, + motion_vectors_over_pic_boundaries_flag: bool, + ) -> Self { + self.inner.motion_vectors_over_pic_boundaries_flag = + motion_vectors_over_pic_boundaries_flag.into(); + self + } + #[inline] + pub fn max_bytes_per_pic_denom(mut self, max_bytes_per_pic_denom: u32) -> Self { + self.inner.max_bytes_per_pic_denom = max_bytes_per_pic_denom; + self + } + #[inline] + pub fn max_bits_per_mb_denom(mut self, max_bits_per_mb_denom: u32) -> Self { + self.inner.max_bits_per_mb_denom = max_bits_per_mb_denom; + self + } + #[inline] + pub fn log2_max_mv_length_horizontal(mut self, log2_max_mv_length_horizontal: u32) -> Self { + self.inner.log2_max_mv_length_horizontal = log2_max_mv_length_horizontal; + self + } + #[inline] + pub fn log2_max_mv_length_vertical(mut self, log2_max_mv_length_vertical: u32) -> Self { + self.inner.log2_max_mv_length_vertical = log2_max_mv_length_vertical; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VideoEncodeH264CapabilitiesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct VideoEncodeH264SessionParametersAddInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub std_sps_count: u32, + pub p_std_sp_ss: *const StdVideoH264SequenceParameterSet, + pub std_pps_count: u32, + pub p_std_pp_ss: *const StdVideoH264PictureParameterSet, +} +impl ::std::default::Default for VideoEncodeH264SessionParametersAddInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + std_sps_count: u32::default(), + p_std_sp_ss: ::std::ptr::null(), + std_pps_count: u32::default(), + p_std_pp_ss: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for VideoEncodeH264SessionParametersAddInfoEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT; +} +impl VideoEncodeH264SessionParametersAddInfoEXT { + pub fn builder<'a>() -> VideoEncodeH264SessionParametersAddInfoEXTBuilder<'a> { + VideoEncodeH264SessionParametersAddInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VideoEncodeH264SessionParametersAddInfoEXTBuilder<'a> { + inner: VideoEncodeH264SessionParametersAddInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsVideoSessionParametersUpdateInfoKHR + for VideoEncodeH264SessionParametersAddInfoEXTBuilder<'_> +{ +} +unsafe impl ExtendsVideoSessionParametersUpdateInfoKHR + for VideoEncodeH264SessionParametersAddInfoEXT +{ +} +impl<'a> ::std::ops::Deref for VideoEncodeH264SessionParametersAddInfoEXTBuilder<'a> { + type Target = VideoEncodeH264SessionParametersAddInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VideoEncodeH264SessionParametersAddInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VideoEncodeH264SessionParametersAddInfoEXTBuilder<'a> { + #[inline] + pub fn std_sp_ss(mut self, std_sp_ss: &'a [StdVideoH264SequenceParameterSet]) -> Self { + self.inner.std_sps_count = std_sp_ss.len() as _; + self.inner.p_std_sp_ss = std_sp_ss.as_ptr(); + self + } + #[inline] + pub fn std_pp_ss(mut self, std_pp_ss: &'a [StdVideoH264PictureParameterSet]) -> Self { + self.inner.std_pps_count = std_pp_ss.len() as _; + self.inner.p_std_pp_ss = std_pp_ss.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VideoEncodeH264SessionParametersAddInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct VideoEncodeH264SessionParametersCreateInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub max_std_sps_count: u32, + pub max_std_pps_count: u32, + pub p_parameters_add_info: *const VideoEncodeH264SessionParametersAddInfoEXT, +} +impl ::std::default::Default for VideoEncodeH264SessionParametersCreateInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + max_std_sps_count: u32::default(), + max_std_pps_count: u32::default(), + p_parameters_add_info: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for VideoEncodeH264SessionParametersCreateInfoEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT; +} +impl VideoEncodeH264SessionParametersCreateInfoEXT { + pub fn builder<'a>() -> VideoEncodeH264SessionParametersCreateInfoEXTBuilder<'a> { + VideoEncodeH264SessionParametersCreateInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VideoEncodeH264SessionParametersCreateInfoEXTBuilder<'a> { + inner: VideoEncodeH264SessionParametersCreateInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsVideoSessionParametersCreateInfoKHR + for VideoEncodeH264SessionParametersCreateInfoEXTBuilder<'_> +{ +} +unsafe impl ExtendsVideoSessionParametersCreateInfoKHR + for VideoEncodeH264SessionParametersCreateInfoEXT +{ +} +impl<'a> ::std::ops::Deref for VideoEncodeH264SessionParametersCreateInfoEXTBuilder<'a> { + type Target = VideoEncodeH264SessionParametersCreateInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VideoEncodeH264SessionParametersCreateInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VideoEncodeH264SessionParametersCreateInfoEXTBuilder<'a> { + #[inline] + pub fn max_std_sps_count(mut self, max_std_sps_count: u32) -> Self { + self.inner.max_std_sps_count = max_std_sps_count; + self + } + #[inline] + pub fn max_std_pps_count(mut self, max_std_pps_count: u32) -> Self { + self.inner.max_std_pps_count = max_std_pps_count; + self + } + #[inline] + pub fn parameters_add_info( + mut self, + parameters_add_info: &'a VideoEncodeH264SessionParametersAddInfoEXT, + ) -> Self { + self.inner.p_parameters_add_info = parameters_add_info; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VideoEncodeH264SessionParametersCreateInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct VideoEncodeH264DpbSlotInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub slot_index: i8, + pub p_std_reference_info: *const StdVideoEncodeH264ReferenceInfo, +} +impl ::std::default::Default for VideoEncodeH264DpbSlotInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + slot_index: i8::default(), + p_std_reference_info: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for VideoEncodeH264DpbSlotInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_ENCODE_H264_DPB_SLOT_INFO_EXT; +} +impl VideoEncodeH264DpbSlotInfoEXT { + pub fn builder<'a>() -> VideoEncodeH264DpbSlotInfoEXTBuilder<'a> { + VideoEncodeH264DpbSlotInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VideoEncodeH264DpbSlotInfoEXTBuilder<'a> { + inner: VideoEncodeH264DpbSlotInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for VideoEncodeH264DpbSlotInfoEXTBuilder<'a> { + type Target = VideoEncodeH264DpbSlotInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VideoEncodeH264DpbSlotInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VideoEncodeH264DpbSlotInfoEXTBuilder<'a> { + #[inline] + pub fn slot_index(mut self, slot_index: i8) -> Self { + self.inner.slot_index = slot_index; + self + } + #[inline] + pub fn std_reference_info( + mut self, + std_reference_info: &'a StdVideoEncodeH264ReferenceInfo, + ) -> Self { + self.inner.p_std_reference_info = std_reference_info; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VideoEncodeH264DpbSlotInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct VideoEncodeH264VclFrameInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub p_reference_final_lists: *const VideoEncodeH264ReferenceListsInfoEXT, + pub nalu_slice_entry_count: u32, + pub p_nalu_slice_entries: *const VideoEncodeH264NaluSliceInfoEXT, + pub p_current_picture_info: *const StdVideoEncodeH264PictureInfo, +} +impl ::std::default::Default for VideoEncodeH264VclFrameInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + p_reference_final_lists: ::std::ptr::null(), + nalu_slice_entry_count: u32::default(), + p_nalu_slice_entries: ::std::ptr::null(), + p_current_picture_info: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for VideoEncodeH264VclFrameInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_ENCODE_H264_VCL_FRAME_INFO_EXT; +} +impl VideoEncodeH264VclFrameInfoEXT { + pub fn builder<'a>() -> VideoEncodeH264VclFrameInfoEXTBuilder<'a> { + VideoEncodeH264VclFrameInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VideoEncodeH264VclFrameInfoEXTBuilder<'a> { + inner: VideoEncodeH264VclFrameInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsVideoEncodeInfoKHR for VideoEncodeH264VclFrameInfoEXTBuilder<'_> {} +unsafe impl ExtendsVideoEncodeInfoKHR for VideoEncodeH264VclFrameInfoEXT {} +impl<'a> ::std::ops::Deref for VideoEncodeH264VclFrameInfoEXTBuilder<'a> { + type Target = VideoEncodeH264VclFrameInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VideoEncodeH264VclFrameInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VideoEncodeH264VclFrameInfoEXTBuilder<'a> { + #[inline] + pub fn reference_final_lists( + mut self, + reference_final_lists: &'a VideoEncodeH264ReferenceListsInfoEXT, + ) -> Self { + self.inner.p_reference_final_lists = reference_final_lists; + self + } + #[inline] + pub fn nalu_slice_entries( + mut self, + nalu_slice_entries: &'a [VideoEncodeH264NaluSliceInfoEXT], + ) -> Self { + self.inner.nalu_slice_entry_count = nalu_slice_entries.len() as _; + self.inner.p_nalu_slice_entries = nalu_slice_entries.as_ptr(); + self + } + #[inline] + pub fn current_picture_info( + mut self, + current_picture_info: &'a StdVideoEncodeH264PictureInfo, + ) -> Self { + self.inner.p_current_picture_info = current_picture_info; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VideoEncodeH264VclFrameInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct VideoEncodeH264ReferenceListsInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub reference_list0_entry_count: u8, + pub p_reference_list0_entries: *const VideoEncodeH264DpbSlotInfoEXT, + pub reference_list1_entry_count: u8, + pub p_reference_list1_entries: *const VideoEncodeH264DpbSlotInfoEXT, + pub p_mem_mgmt_ctrl_operations: *const StdVideoEncodeH264RefMemMgmtCtrlOperations, +} +impl ::std::default::Default for VideoEncodeH264ReferenceListsInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + reference_list0_entry_count: u8::default(), + p_reference_list0_entries: ::std::ptr::null(), + reference_list1_entry_count: u8::default(), + p_reference_list1_entries: ::std::ptr::null(), + p_mem_mgmt_ctrl_operations: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for VideoEncodeH264ReferenceListsInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_ENCODE_H264_REFERENCE_LISTS_INFO_EXT; +} +impl VideoEncodeH264ReferenceListsInfoEXT { + pub fn builder<'a>() -> VideoEncodeH264ReferenceListsInfoEXTBuilder<'a> { + VideoEncodeH264ReferenceListsInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VideoEncodeH264ReferenceListsInfoEXTBuilder<'a> { + inner: VideoEncodeH264ReferenceListsInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for VideoEncodeH264ReferenceListsInfoEXTBuilder<'a> { + type Target = VideoEncodeH264ReferenceListsInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VideoEncodeH264ReferenceListsInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VideoEncodeH264ReferenceListsInfoEXTBuilder<'a> { + #[inline] + pub fn reference_list0_entries( + mut self, + reference_list0_entries: &'a [VideoEncodeH264DpbSlotInfoEXT], + ) -> Self { + self.inner.reference_list0_entry_count = reference_list0_entries.len() as _; + self.inner.p_reference_list0_entries = reference_list0_entries.as_ptr(); + self + } + #[inline] + pub fn reference_list1_entries( + mut self, + reference_list1_entries: &'a [VideoEncodeH264DpbSlotInfoEXT], + ) -> Self { + self.inner.reference_list1_entry_count = reference_list1_entries.len() as _; + self.inner.p_reference_list1_entries = reference_list1_entries.as_ptr(); + self + } + #[inline] + pub fn mem_mgmt_ctrl_operations( + mut self, + mem_mgmt_ctrl_operations: &'a StdVideoEncodeH264RefMemMgmtCtrlOperations, + ) -> Self { + self.inner.p_mem_mgmt_ctrl_operations = mem_mgmt_ctrl_operations; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VideoEncodeH264ReferenceListsInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct VideoEncodeH264EmitPictureParametersInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub sps_id: u8, + pub emit_sps_enable: Bool32, + pub pps_id_entry_count: u32, + pub pps_id_entries: *const u8, +} +impl ::std::default::Default for VideoEncodeH264EmitPictureParametersInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + sps_id: u8::default(), + emit_sps_enable: Bool32::default(), + pps_id_entry_count: u32::default(), + pps_id_entries: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for VideoEncodeH264EmitPictureParametersInfoEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::VIDEO_ENCODE_H264_EMIT_PICTURE_PARAMETERS_INFO_EXT; +} +impl VideoEncodeH264EmitPictureParametersInfoEXT { + pub fn builder<'a>() -> VideoEncodeH264EmitPictureParametersInfoEXTBuilder<'a> { + VideoEncodeH264EmitPictureParametersInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VideoEncodeH264EmitPictureParametersInfoEXTBuilder<'a> { + inner: VideoEncodeH264EmitPictureParametersInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsVideoEncodeInfoKHR for VideoEncodeH264EmitPictureParametersInfoEXTBuilder<'_> {} +unsafe impl ExtendsVideoEncodeInfoKHR for VideoEncodeH264EmitPictureParametersInfoEXT {} +impl<'a> ::std::ops::Deref for VideoEncodeH264EmitPictureParametersInfoEXTBuilder<'a> { + type Target = VideoEncodeH264EmitPictureParametersInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VideoEncodeH264EmitPictureParametersInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VideoEncodeH264EmitPictureParametersInfoEXTBuilder<'a> { + #[inline] + pub fn sps_id(mut self, sps_id: u8) -> Self { + self.inner.sps_id = sps_id; + self + } + #[inline] + pub fn emit_sps_enable(mut self, emit_sps_enable: bool) -> Self { + self.inner.emit_sps_enable = emit_sps_enable.into(); + self + } + #[inline] + pub fn pps_id_entries(mut self, pps_id_entries: &'a [u8]) -> Self { + self.inner.pps_id_entry_count = pps_id_entries.len() as _; + self.inner.pps_id_entries = pps_id_entries.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VideoEncodeH264EmitPictureParametersInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct VideoEncodeH264ProfileInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub std_profile_idc: StdVideoH264ProfileIdc, +} +impl ::std::default::Default for VideoEncodeH264ProfileInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + std_profile_idc: StdVideoH264ProfileIdc::default(), + } + } +} +unsafe impl TaggedStructure for VideoEncodeH264ProfileInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_ENCODE_H264_PROFILE_INFO_EXT; +} +impl VideoEncodeH264ProfileInfoEXT { + pub fn builder<'a>() -> VideoEncodeH264ProfileInfoEXTBuilder<'a> { + VideoEncodeH264ProfileInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VideoEncodeH264ProfileInfoEXTBuilder<'a> { + inner: VideoEncodeH264ProfileInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsVideoProfileInfoKHR for VideoEncodeH264ProfileInfoEXTBuilder<'_> {} +unsafe impl ExtendsVideoProfileInfoKHR for VideoEncodeH264ProfileInfoEXT {} +unsafe impl ExtendsQueryPoolCreateInfo for VideoEncodeH264ProfileInfoEXTBuilder<'_> {} +unsafe impl ExtendsQueryPoolCreateInfo for VideoEncodeH264ProfileInfoEXT {} +impl<'a> ::std::ops::Deref for VideoEncodeH264ProfileInfoEXTBuilder<'a> { + type Target = VideoEncodeH264ProfileInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VideoEncodeH264ProfileInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VideoEncodeH264ProfileInfoEXTBuilder<'a> { + #[inline] + pub fn std_profile_idc(mut self, std_profile_idc: StdVideoH264ProfileIdc) -> Self { + self.inner.std_profile_idc = std_profile_idc; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VideoEncodeH264ProfileInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct VideoEncodeH264NaluSliceInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub mb_count: u32, + pub p_reference_final_lists: *const VideoEncodeH264ReferenceListsInfoEXT, + pub p_slice_header_std: *const StdVideoEncodeH264SliceHeader, +} +impl ::std::default::Default for VideoEncodeH264NaluSliceInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + mb_count: u32::default(), + p_reference_final_lists: ::std::ptr::null(), + p_slice_header_std: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for VideoEncodeH264NaluSliceInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_ENCODE_H264_NALU_SLICE_INFO_EXT; +} +impl VideoEncodeH264NaluSliceInfoEXT { + pub fn builder<'a>() -> VideoEncodeH264NaluSliceInfoEXTBuilder<'a> { + VideoEncodeH264NaluSliceInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VideoEncodeH264NaluSliceInfoEXTBuilder<'a> { + inner: VideoEncodeH264NaluSliceInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for VideoEncodeH264NaluSliceInfoEXTBuilder<'a> { + type Target = VideoEncodeH264NaluSliceInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VideoEncodeH264NaluSliceInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VideoEncodeH264NaluSliceInfoEXTBuilder<'a> { + #[inline] + pub fn mb_count(mut self, mb_count: u32) -> Self { + self.inner.mb_count = mb_count; + self + } + #[inline] + pub fn reference_final_lists( + mut self, + reference_final_lists: &'a VideoEncodeH264ReferenceListsInfoEXT, + ) -> Self { + self.inner.p_reference_final_lists = reference_final_lists; + self + } + #[inline] + pub fn slice_header_std(mut self, slice_header_std: &'a StdVideoEncodeH264SliceHeader) -> Self { + self.inner.p_slice_header_std = slice_header_std; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VideoEncodeH264NaluSliceInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct VideoEncodeH264RateControlInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub gop_frame_count: u32, + pub idr_period: u32, + pub consecutive_b_frame_count: u32, + pub rate_control_structure: VideoEncodeH264RateControlStructureEXT, + pub temporal_layer_count: u8, +} +impl ::std::default::Default for VideoEncodeH264RateControlInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + gop_frame_count: u32::default(), + idr_period: u32::default(), + consecutive_b_frame_count: u32::default(), + rate_control_structure: VideoEncodeH264RateControlStructureEXT::default(), + temporal_layer_count: u8::default(), + } + } +} +unsafe impl TaggedStructure for VideoEncodeH264RateControlInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_ENCODE_H264_RATE_CONTROL_INFO_EXT; +} +impl VideoEncodeH264RateControlInfoEXT { + pub fn builder<'a>() -> VideoEncodeH264RateControlInfoEXTBuilder<'a> { + VideoEncodeH264RateControlInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VideoEncodeH264RateControlInfoEXTBuilder<'a> { + inner: VideoEncodeH264RateControlInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsVideoCodingControlInfoKHR for VideoEncodeH264RateControlInfoEXTBuilder<'_> {} +unsafe impl ExtendsVideoCodingControlInfoKHR for VideoEncodeH264RateControlInfoEXT {} +impl<'a> ::std::ops::Deref for VideoEncodeH264RateControlInfoEXTBuilder<'a> { + type Target = VideoEncodeH264RateControlInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VideoEncodeH264RateControlInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VideoEncodeH264RateControlInfoEXTBuilder<'a> { + #[inline] + pub fn gop_frame_count(mut self, gop_frame_count: u32) -> Self { + self.inner.gop_frame_count = gop_frame_count; + self + } + #[inline] + pub fn idr_period(mut self, idr_period: u32) -> Self { + self.inner.idr_period = idr_period; + self + } + #[inline] + pub fn consecutive_b_frame_count(mut self, consecutive_b_frame_count: u32) -> Self { + self.inner.consecutive_b_frame_count = consecutive_b_frame_count; + self + } + #[inline] + pub fn rate_control_structure( + mut self, + rate_control_structure: VideoEncodeH264RateControlStructureEXT, + ) -> Self { + self.inner.rate_control_structure = rate_control_structure; + self + } + #[inline] + pub fn temporal_layer_count(mut self, temporal_layer_count: u8) -> Self { + self.inner.temporal_layer_count = temporal_layer_count; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VideoEncodeH264RateControlInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct VideoEncodeH264QpEXT { + pub qp_i: i32, + pub qp_p: i32, + pub qp_b: i32, +} +impl VideoEncodeH264QpEXT { + pub fn builder<'a>() -> VideoEncodeH264QpEXTBuilder<'a> { + VideoEncodeH264QpEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VideoEncodeH264QpEXTBuilder<'a> { + inner: VideoEncodeH264QpEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for VideoEncodeH264QpEXTBuilder<'a> { + type Target = VideoEncodeH264QpEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VideoEncodeH264QpEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VideoEncodeH264QpEXTBuilder<'a> { + #[inline] + pub fn qp_i(mut self, qp_i: i32) -> Self { + self.inner.qp_i = qp_i; + self + } + #[inline] + pub fn qp_p(mut self, qp_p: i32) -> Self { + self.inner.qp_p = qp_p; + self + } + #[inline] + pub fn qp_b(mut self, qp_b: i32) -> Self { + self.inner.qp_b = qp_b; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VideoEncodeH264QpEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct VideoEncodeH264FrameSizeEXT { + pub frame_i_size: u32, + pub frame_p_size: u32, + pub frame_b_size: u32, +} +impl VideoEncodeH264FrameSizeEXT { + pub fn builder<'a>() -> VideoEncodeH264FrameSizeEXTBuilder<'a> { + VideoEncodeH264FrameSizeEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VideoEncodeH264FrameSizeEXTBuilder<'a> { + inner: VideoEncodeH264FrameSizeEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for VideoEncodeH264FrameSizeEXTBuilder<'a> { + type Target = VideoEncodeH264FrameSizeEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VideoEncodeH264FrameSizeEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VideoEncodeH264FrameSizeEXTBuilder<'a> { + #[inline] + pub fn frame_i_size(mut self, frame_i_size: u32) -> Self { + self.inner.frame_i_size = frame_i_size; + self + } + #[inline] + pub fn frame_p_size(mut self, frame_p_size: u32) -> Self { + self.inner.frame_p_size = frame_p_size; + self + } + #[inline] + pub fn frame_b_size(mut self, frame_b_size: u32) -> Self { + self.inner.frame_b_size = frame_b_size; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VideoEncodeH264FrameSizeEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct VideoEncodeH264RateControlLayerInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub temporal_layer_id: u8, + pub use_initial_rc_qp: Bool32, + pub initial_rc_qp: VideoEncodeH264QpEXT, + pub use_min_qp: Bool32, + pub min_qp: VideoEncodeH264QpEXT, + pub use_max_qp: Bool32, + pub max_qp: VideoEncodeH264QpEXT, + pub use_max_frame_size: Bool32, + pub max_frame_size: VideoEncodeH264FrameSizeEXT, +} +impl ::std::default::Default for VideoEncodeH264RateControlLayerInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + temporal_layer_id: u8::default(), + use_initial_rc_qp: Bool32::default(), + initial_rc_qp: VideoEncodeH264QpEXT::default(), + use_min_qp: Bool32::default(), + min_qp: VideoEncodeH264QpEXT::default(), + use_max_qp: Bool32::default(), + max_qp: VideoEncodeH264QpEXT::default(), + use_max_frame_size: Bool32::default(), + max_frame_size: VideoEncodeH264FrameSizeEXT::default(), + } + } +} +unsafe impl TaggedStructure for VideoEncodeH264RateControlLayerInfoEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_EXT; +} +impl VideoEncodeH264RateControlLayerInfoEXT { + pub fn builder<'a>() -> VideoEncodeH264RateControlLayerInfoEXTBuilder<'a> { + VideoEncodeH264RateControlLayerInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VideoEncodeH264RateControlLayerInfoEXTBuilder<'a> { + inner: VideoEncodeH264RateControlLayerInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsVideoCodingControlInfoKHR for VideoEncodeH264RateControlLayerInfoEXTBuilder<'_> {} +unsafe impl ExtendsVideoCodingControlInfoKHR for VideoEncodeH264RateControlLayerInfoEXT {} +unsafe impl ExtendsVideoEncodeRateControlLayerInfoKHR + for VideoEncodeH264RateControlLayerInfoEXTBuilder<'_> +{ +} +unsafe impl ExtendsVideoEncodeRateControlLayerInfoKHR for VideoEncodeH264RateControlLayerInfoEXT {} +impl<'a> ::std::ops::Deref for VideoEncodeH264RateControlLayerInfoEXTBuilder<'a> { + type Target = VideoEncodeH264RateControlLayerInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VideoEncodeH264RateControlLayerInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VideoEncodeH264RateControlLayerInfoEXTBuilder<'a> { + #[inline] + pub fn temporal_layer_id(mut self, temporal_layer_id: u8) -> Self { + self.inner.temporal_layer_id = temporal_layer_id; + self + } + #[inline] + pub fn use_initial_rc_qp(mut self, use_initial_rc_qp: bool) -> Self { + self.inner.use_initial_rc_qp = use_initial_rc_qp.into(); + self + } + #[inline] + pub fn initial_rc_qp(mut self, initial_rc_qp: VideoEncodeH264QpEXT) -> Self { + self.inner.initial_rc_qp = initial_rc_qp; + self + } + #[inline] + pub fn use_min_qp(mut self, use_min_qp: bool) -> Self { + self.inner.use_min_qp = use_min_qp.into(); + self + } + #[inline] + pub fn min_qp(mut self, min_qp: VideoEncodeH264QpEXT) -> Self { + self.inner.min_qp = min_qp; + self + } + #[inline] + pub fn use_max_qp(mut self, use_max_qp: bool) -> Self { + self.inner.use_max_qp = use_max_qp.into(); + self + } + #[inline] + pub fn max_qp(mut self, max_qp: VideoEncodeH264QpEXT) -> Self { + self.inner.max_qp = max_qp; + self + } + #[inline] + pub fn use_max_frame_size(mut self, use_max_frame_size: bool) -> Self { + self.inner.use_max_frame_size = use_max_frame_size.into(); + self + } + #[inline] + pub fn max_frame_size(mut self, max_frame_size: VideoEncodeH264FrameSizeEXT) -> Self { + self.inner.max_frame_size = max_frame_size; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VideoEncodeH264RateControlLayerInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct VideoEncodeH265CapabilitiesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub flags: VideoEncodeH265CapabilityFlagsEXT, + pub input_mode_flags: VideoEncodeH265InputModeFlagsEXT, + pub output_mode_flags: VideoEncodeH265OutputModeFlagsEXT, + pub ctb_sizes: VideoEncodeH265CtbSizeFlagsEXT, + pub transform_block_sizes: VideoEncodeH265TransformBlockSizeFlagsEXT, + pub max_p_picture_l0_reference_count: u8, + pub max_b_picture_l0_reference_count: u8, + pub max_l1_reference_count: u8, + pub max_sub_layers_count: u8, + pub min_log2_min_luma_coding_block_size_minus3: u8, + pub max_log2_min_luma_coding_block_size_minus3: u8, + pub min_log2_min_luma_transform_block_size_minus2: u8, + pub max_log2_min_luma_transform_block_size_minus2: u8, + pub min_max_transform_hierarchy_depth_inter: u8, + pub max_max_transform_hierarchy_depth_inter: u8, + pub min_max_transform_hierarchy_depth_intra: u8, + pub max_max_transform_hierarchy_depth_intra: u8, + pub max_diff_cu_qp_delta_depth: u8, + pub min_max_num_merge_cand: u8, + pub max_max_num_merge_cand: u8, +} +impl ::std::default::Default for VideoEncodeH265CapabilitiesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + flags: VideoEncodeH265CapabilityFlagsEXT::default(), + input_mode_flags: VideoEncodeH265InputModeFlagsEXT::default(), + output_mode_flags: VideoEncodeH265OutputModeFlagsEXT::default(), + ctb_sizes: VideoEncodeH265CtbSizeFlagsEXT::default(), + transform_block_sizes: VideoEncodeH265TransformBlockSizeFlagsEXT::default(), + max_p_picture_l0_reference_count: u8::default(), + max_b_picture_l0_reference_count: u8::default(), + max_l1_reference_count: u8::default(), + max_sub_layers_count: u8::default(), + min_log2_min_luma_coding_block_size_minus3: u8::default(), + max_log2_min_luma_coding_block_size_minus3: u8::default(), + min_log2_min_luma_transform_block_size_minus2: u8::default(), + max_log2_min_luma_transform_block_size_minus2: u8::default(), + min_max_transform_hierarchy_depth_inter: u8::default(), + max_max_transform_hierarchy_depth_inter: u8::default(), + min_max_transform_hierarchy_depth_intra: u8::default(), + max_max_transform_hierarchy_depth_intra: u8::default(), + max_diff_cu_qp_delta_depth: u8::default(), + min_max_num_merge_cand: u8::default(), + max_max_num_merge_cand: u8::default(), + } + } +} +unsafe impl TaggedStructure for VideoEncodeH265CapabilitiesEXT { + const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_ENCODE_H265_CAPABILITIES_EXT; +} +impl VideoEncodeH265CapabilitiesEXT { + pub fn builder<'a>() -> VideoEncodeH265CapabilitiesEXTBuilder<'a> { + VideoEncodeH265CapabilitiesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VideoEncodeH265CapabilitiesEXTBuilder<'a> { + inner: VideoEncodeH265CapabilitiesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsVideoCapabilitiesKHR for VideoEncodeH265CapabilitiesEXTBuilder<'_> {} +unsafe impl ExtendsVideoCapabilitiesKHR for VideoEncodeH265CapabilitiesEXT {} +impl<'a> ::std::ops::Deref for VideoEncodeH265CapabilitiesEXTBuilder<'a> { + type Target = VideoEncodeH265CapabilitiesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VideoEncodeH265CapabilitiesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VideoEncodeH265CapabilitiesEXTBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: VideoEncodeH265CapabilityFlagsEXT) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn input_mode_flags(mut self, input_mode_flags: VideoEncodeH265InputModeFlagsEXT) -> Self { + self.inner.input_mode_flags = input_mode_flags; + self + } + #[inline] + pub fn output_mode_flags( + mut self, + output_mode_flags: VideoEncodeH265OutputModeFlagsEXT, + ) -> Self { + self.inner.output_mode_flags = output_mode_flags; + self + } + #[inline] + pub fn ctb_sizes(mut self, ctb_sizes: VideoEncodeH265CtbSizeFlagsEXT) -> Self { + self.inner.ctb_sizes = ctb_sizes; + self + } + #[inline] + pub fn transform_block_sizes( + mut self, + transform_block_sizes: VideoEncodeH265TransformBlockSizeFlagsEXT, + ) -> Self { + self.inner.transform_block_sizes = transform_block_sizes; + self + } + #[inline] + pub fn max_p_picture_l0_reference_count( + mut self, + max_p_picture_l0_reference_count: u8, + ) -> Self { + self.inner.max_p_picture_l0_reference_count = max_p_picture_l0_reference_count; + self + } + #[inline] + pub fn max_b_picture_l0_reference_count( + mut self, + max_b_picture_l0_reference_count: u8, + ) -> Self { + self.inner.max_b_picture_l0_reference_count = max_b_picture_l0_reference_count; + self + } + #[inline] + pub fn max_l1_reference_count(mut self, max_l1_reference_count: u8) -> Self { + self.inner.max_l1_reference_count = max_l1_reference_count; + self + } + #[inline] + pub fn max_sub_layers_count(mut self, max_sub_layers_count: u8) -> Self { + self.inner.max_sub_layers_count = max_sub_layers_count; + self + } + #[inline] + pub fn min_log2_min_luma_coding_block_size_minus3( + mut self, + min_log2_min_luma_coding_block_size_minus3: u8, + ) -> Self { + self.inner.min_log2_min_luma_coding_block_size_minus3 = + min_log2_min_luma_coding_block_size_minus3; + self + } + #[inline] + pub fn max_log2_min_luma_coding_block_size_minus3( + mut self, + max_log2_min_luma_coding_block_size_minus3: u8, + ) -> Self { + self.inner.max_log2_min_luma_coding_block_size_minus3 = + max_log2_min_luma_coding_block_size_minus3; + self + } + #[inline] + pub fn min_log2_min_luma_transform_block_size_minus2( + mut self, + min_log2_min_luma_transform_block_size_minus2: u8, + ) -> Self { + self.inner.min_log2_min_luma_transform_block_size_minus2 = + min_log2_min_luma_transform_block_size_minus2; + self + } + #[inline] + pub fn max_log2_min_luma_transform_block_size_minus2( + mut self, + max_log2_min_luma_transform_block_size_minus2: u8, + ) -> Self { + self.inner.max_log2_min_luma_transform_block_size_minus2 = + max_log2_min_luma_transform_block_size_minus2; + self + } + #[inline] + pub fn min_max_transform_hierarchy_depth_inter( + mut self, + min_max_transform_hierarchy_depth_inter: u8, + ) -> Self { + self.inner.min_max_transform_hierarchy_depth_inter = + min_max_transform_hierarchy_depth_inter; + self + } + #[inline] + pub fn max_max_transform_hierarchy_depth_inter( + mut self, + max_max_transform_hierarchy_depth_inter: u8, + ) -> Self { + self.inner.max_max_transform_hierarchy_depth_inter = + max_max_transform_hierarchy_depth_inter; + self + } + #[inline] + pub fn min_max_transform_hierarchy_depth_intra( + mut self, + min_max_transform_hierarchy_depth_intra: u8, + ) -> Self { + self.inner.min_max_transform_hierarchy_depth_intra = + min_max_transform_hierarchy_depth_intra; + self + } + #[inline] + pub fn max_max_transform_hierarchy_depth_intra( + mut self, + max_max_transform_hierarchy_depth_intra: u8, + ) -> Self { + self.inner.max_max_transform_hierarchy_depth_intra = + max_max_transform_hierarchy_depth_intra; + self + } + #[inline] + pub fn max_diff_cu_qp_delta_depth(mut self, max_diff_cu_qp_delta_depth: u8) -> Self { + self.inner.max_diff_cu_qp_delta_depth = max_diff_cu_qp_delta_depth; + self + } + #[inline] + pub fn min_max_num_merge_cand(mut self, min_max_num_merge_cand: u8) -> Self { + self.inner.min_max_num_merge_cand = min_max_num_merge_cand; + self + } + #[inline] + pub fn max_max_num_merge_cand(mut self, max_max_num_merge_cand: u8) -> Self { + self.inner.max_max_num_merge_cand = max_max_num_merge_cand; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VideoEncodeH265CapabilitiesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct VideoEncodeH265SessionParametersAddInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub std_vps_count: u32, + pub p_std_vp_ss: *const StdVideoH265VideoParameterSet, + pub std_sps_count: u32, + pub p_std_sp_ss: *const StdVideoH265SequenceParameterSet, + pub std_pps_count: u32, + pub p_std_pp_ss: *const StdVideoH265PictureParameterSet, +} +impl ::std::default::Default for VideoEncodeH265SessionParametersAddInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + std_vps_count: u32::default(), + p_std_vp_ss: ::std::ptr::null(), + std_sps_count: u32::default(), + p_std_sp_ss: ::std::ptr::null(), + std_pps_count: u32::default(), + p_std_pp_ss: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for VideoEncodeH265SessionParametersAddInfoEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT; +} +impl VideoEncodeH265SessionParametersAddInfoEXT { + pub fn builder<'a>() -> VideoEncodeH265SessionParametersAddInfoEXTBuilder<'a> { + VideoEncodeH265SessionParametersAddInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VideoEncodeH265SessionParametersAddInfoEXTBuilder<'a> { + inner: VideoEncodeH265SessionParametersAddInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsVideoSessionParametersUpdateInfoKHR + for VideoEncodeH265SessionParametersAddInfoEXTBuilder<'_> +{ +} +unsafe impl ExtendsVideoSessionParametersUpdateInfoKHR + for VideoEncodeH265SessionParametersAddInfoEXT +{ +} +impl<'a> ::std::ops::Deref for VideoEncodeH265SessionParametersAddInfoEXTBuilder<'a> { + type Target = VideoEncodeH265SessionParametersAddInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VideoEncodeH265SessionParametersAddInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VideoEncodeH265SessionParametersAddInfoEXTBuilder<'a> { + #[inline] + pub fn std_vp_ss(mut self, std_vp_ss: &'a [StdVideoH265VideoParameterSet]) -> Self { + self.inner.std_vps_count = std_vp_ss.len() as _; + self.inner.p_std_vp_ss = std_vp_ss.as_ptr(); + self + } + #[inline] + pub fn std_sp_ss(mut self, std_sp_ss: &'a [StdVideoH265SequenceParameterSet]) -> Self { + self.inner.std_sps_count = std_sp_ss.len() as _; + self.inner.p_std_sp_ss = std_sp_ss.as_ptr(); + self + } + #[inline] + pub fn std_pp_ss(mut self, std_pp_ss: &'a [StdVideoH265PictureParameterSet]) -> Self { + self.inner.std_pps_count = std_pp_ss.len() as _; + self.inner.p_std_pp_ss = std_pp_ss.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VideoEncodeH265SessionParametersAddInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct VideoEncodeH265SessionParametersCreateInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub max_std_vps_count: u32, + pub max_std_sps_count: u32, + pub max_std_pps_count: u32, + pub p_parameters_add_info: *const VideoEncodeH265SessionParametersAddInfoEXT, +} +impl ::std::default::Default for VideoEncodeH265SessionParametersCreateInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + max_std_vps_count: u32::default(), + max_std_sps_count: u32::default(), + max_std_pps_count: u32::default(), + p_parameters_add_info: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for VideoEncodeH265SessionParametersCreateInfoEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT; +} +impl VideoEncodeH265SessionParametersCreateInfoEXT { + pub fn builder<'a>() -> VideoEncodeH265SessionParametersCreateInfoEXTBuilder<'a> { + VideoEncodeH265SessionParametersCreateInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VideoEncodeH265SessionParametersCreateInfoEXTBuilder<'a> { + inner: VideoEncodeH265SessionParametersCreateInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsVideoSessionParametersCreateInfoKHR + for VideoEncodeH265SessionParametersCreateInfoEXTBuilder<'_> +{ +} +unsafe impl ExtendsVideoSessionParametersCreateInfoKHR + for VideoEncodeH265SessionParametersCreateInfoEXT +{ +} +impl<'a> ::std::ops::Deref for VideoEncodeH265SessionParametersCreateInfoEXTBuilder<'a> { + type Target = VideoEncodeH265SessionParametersCreateInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VideoEncodeH265SessionParametersCreateInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VideoEncodeH265SessionParametersCreateInfoEXTBuilder<'a> { + #[inline] + pub fn max_std_vps_count(mut self, max_std_vps_count: u32) -> Self { + self.inner.max_std_vps_count = max_std_vps_count; + self + } + #[inline] + pub fn max_std_sps_count(mut self, max_std_sps_count: u32) -> Self { + self.inner.max_std_sps_count = max_std_sps_count; + self + } + #[inline] + pub fn max_std_pps_count(mut self, max_std_pps_count: u32) -> Self { + self.inner.max_std_pps_count = max_std_pps_count; + self + } + #[inline] + pub fn parameters_add_info( + mut self, + parameters_add_info: &'a VideoEncodeH265SessionParametersAddInfoEXT, + ) -> Self { + self.inner.p_parameters_add_info = parameters_add_info; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VideoEncodeH265SessionParametersCreateInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct VideoEncodeH265VclFrameInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub p_reference_final_lists: *const VideoEncodeH265ReferenceListsInfoEXT, + pub nalu_slice_segment_entry_count: u32, + pub p_nalu_slice_segment_entries: *const VideoEncodeH265NaluSliceSegmentInfoEXT, + pub p_current_picture_info: *const StdVideoEncodeH265PictureInfo, +} +impl ::std::default::Default for VideoEncodeH265VclFrameInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + p_reference_final_lists: ::std::ptr::null(), + nalu_slice_segment_entry_count: u32::default(), + p_nalu_slice_segment_entries: ::std::ptr::null(), + p_current_picture_info: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for VideoEncodeH265VclFrameInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_ENCODE_H265_VCL_FRAME_INFO_EXT; +} +impl VideoEncodeH265VclFrameInfoEXT { + pub fn builder<'a>() -> VideoEncodeH265VclFrameInfoEXTBuilder<'a> { + VideoEncodeH265VclFrameInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VideoEncodeH265VclFrameInfoEXTBuilder<'a> { + inner: VideoEncodeH265VclFrameInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsVideoEncodeInfoKHR for VideoEncodeH265VclFrameInfoEXTBuilder<'_> {} +unsafe impl ExtendsVideoEncodeInfoKHR for VideoEncodeH265VclFrameInfoEXT {} +impl<'a> ::std::ops::Deref for VideoEncodeH265VclFrameInfoEXTBuilder<'a> { + type Target = VideoEncodeH265VclFrameInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VideoEncodeH265VclFrameInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VideoEncodeH265VclFrameInfoEXTBuilder<'a> { + #[inline] + pub fn reference_final_lists( + mut self, + reference_final_lists: &'a VideoEncodeH265ReferenceListsInfoEXT, + ) -> Self { + self.inner.p_reference_final_lists = reference_final_lists; + self + } + #[inline] + pub fn nalu_slice_segment_entries( + mut self, + nalu_slice_segment_entries: &'a [VideoEncodeH265NaluSliceSegmentInfoEXT], + ) -> Self { + self.inner.nalu_slice_segment_entry_count = nalu_slice_segment_entries.len() as _; + self.inner.p_nalu_slice_segment_entries = nalu_slice_segment_entries.as_ptr(); + self + } + #[inline] + pub fn current_picture_info( + mut self, + current_picture_info: &'a StdVideoEncodeH265PictureInfo, + ) -> Self { + self.inner.p_current_picture_info = current_picture_info; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VideoEncodeH265VclFrameInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct VideoEncodeH265EmitPictureParametersInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub vps_id: u8, + pub sps_id: u8, + pub emit_vps_enable: Bool32, + pub emit_sps_enable: Bool32, + pub pps_id_entry_count: u32, + pub pps_id_entries: *const u8, +} +impl ::std::default::Default for VideoEncodeH265EmitPictureParametersInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + vps_id: u8::default(), + sps_id: u8::default(), + emit_vps_enable: Bool32::default(), + emit_sps_enable: Bool32::default(), + pps_id_entry_count: u32::default(), + pps_id_entries: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for VideoEncodeH265EmitPictureParametersInfoEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::VIDEO_ENCODE_H265_EMIT_PICTURE_PARAMETERS_INFO_EXT; +} +impl VideoEncodeH265EmitPictureParametersInfoEXT { + pub fn builder<'a>() -> VideoEncodeH265EmitPictureParametersInfoEXTBuilder<'a> { + VideoEncodeH265EmitPictureParametersInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VideoEncodeH265EmitPictureParametersInfoEXTBuilder<'a> { + inner: VideoEncodeH265EmitPictureParametersInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsVideoEncodeInfoKHR for VideoEncodeH265EmitPictureParametersInfoEXTBuilder<'_> {} +unsafe impl ExtendsVideoEncodeInfoKHR for VideoEncodeH265EmitPictureParametersInfoEXT {} +impl<'a> ::std::ops::Deref for VideoEncodeH265EmitPictureParametersInfoEXTBuilder<'a> { + type Target = VideoEncodeH265EmitPictureParametersInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VideoEncodeH265EmitPictureParametersInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VideoEncodeH265EmitPictureParametersInfoEXTBuilder<'a> { + #[inline] + pub fn vps_id(mut self, vps_id: u8) -> Self { + self.inner.vps_id = vps_id; + self + } + #[inline] + pub fn sps_id(mut self, sps_id: u8) -> Self { + self.inner.sps_id = sps_id; + self + } + #[inline] + pub fn emit_vps_enable(mut self, emit_vps_enable: bool) -> Self { + self.inner.emit_vps_enable = emit_vps_enable.into(); + self + } + #[inline] + pub fn emit_sps_enable(mut self, emit_sps_enable: bool) -> Self { + self.inner.emit_sps_enable = emit_sps_enable.into(); + self + } + #[inline] + pub fn pps_id_entries(mut self, pps_id_entries: &'a [u8]) -> Self { + self.inner.pps_id_entry_count = pps_id_entries.len() as _; + self.inner.pps_id_entries = pps_id_entries.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VideoEncodeH265EmitPictureParametersInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct VideoEncodeH265NaluSliceSegmentInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub ctb_count: u32, + pub p_reference_final_lists: *const VideoEncodeH265ReferenceListsInfoEXT, + pub p_slice_segment_header_std: *const StdVideoEncodeH265SliceSegmentHeader, +} +impl ::std::default::Default for VideoEncodeH265NaluSliceSegmentInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + ctb_count: u32::default(), + p_reference_final_lists: ::std::ptr::null(), + p_slice_segment_header_std: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for VideoEncodeH265NaluSliceSegmentInfoEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::VIDEO_ENCODE_H265_NALU_SLICE_SEGMENT_INFO_EXT; +} +impl VideoEncodeH265NaluSliceSegmentInfoEXT { + pub fn builder<'a>() -> VideoEncodeH265NaluSliceSegmentInfoEXTBuilder<'a> { + VideoEncodeH265NaluSliceSegmentInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VideoEncodeH265NaluSliceSegmentInfoEXTBuilder<'a> { + inner: VideoEncodeH265NaluSliceSegmentInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for VideoEncodeH265NaluSliceSegmentInfoEXTBuilder<'a> { + type Target = VideoEncodeH265NaluSliceSegmentInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VideoEncodeH265NaluSliceSegmentInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VideoEncodeH265NaluSliceSegmentInfoEXTBuilder<'a> { + #[inline] + pub fn ctb_count(mut self, ctb_count: u32) -> Self { + self.inner.ctb_count = ctb_count; + self + } + #[inline] + pub fn reference_final_lists( + mut self, + reference_final_lists: &'a VideoEncodeH265ReferenceListsInfoEXT, + ) -> Self { + self.inner.p_reference_final_lists = reference_final_lists; + self + } + #[inline] + pub fn slice_segment_header_std( + mut self, + slice_segment_header_std: &'a StdVideoEncodeH265SliceSegmentHeader, + ) -> Self { + self.inner.p_slice_segment_header_std = slice_segment_header_std; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VideoEncodeH265NaluSliceSegmentInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct VideoEncodeH265RateControlInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub gop_frame_count: u32, + pub idr_period: u32, + pub consecutive_b_frame_count: u32, + pub rate_control_structure: VideoEncodeH265RateControlStructureEXT, + pub sub_layer_count: u8, +} +impl ::std::default::Default for VideoEncodeH265RateControlInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + gop_frame_count: u32::default(), + idr_period: u32::default(), + consecutive_b_frame_count: u32::default(), + rate_control_structure: VideoEncodeH265RateControlStructureEXT::default(), + sub_layer_count: u8::default(), + } + } +} +unsafe impl TaggedStructure for VideoEncodeH265RateControlInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_ENCODE_H265_RATE_CONTROL_INFO_EXT; +} +impl VideoEncodeH265RateControlInfoEXT { + pub fn builder<'a>() -> VideoEncodeH265RateControlInfoEXTBuilder<'a> { + VideoEncodeH265RateControlInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VideoEncodeH265RateControlInfoEXTBuilder<'a> { + inner: VideoEncodeH265RateControlInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsVideoCodingControlInfoKHR for VideoEncodeH265RateControlInfoEXTBuilder<'_> {} +unsafe impl ExtendsVideoCodingControlInfoKHR for VideoEncodeH265RateControlInfoEXT {} +impl<'a> ::std::ops::Deref for VideoEncodeH265RateControlInfoEXTBuilder<'a> { + type Target = VideoEncodeH265RateControlInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VideoEncodeH265RateControlInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VideoEncodeH265RateControlInfoEXTBuilder<'a> { + #[inline] + pub fn gop_frame_count(mut self, gop_frame_count: u32) -> Self { + self.inner.gop_frame_count = gop_frame_count; + self + } + #[inline] + pub fn idr_period(mut self, idr_period: u32) -> Self { + self.inner.idr_period = idr_period; + self + } + #[inline] + pub fn consecutive_b_frame_count(mut self, consecutive_b_frame_count: u32) -> Self { + self.inner.consecutive_b_frame_count = consecutive_b_frame_count; + self + } + #[inline] + pub fn rate_control_structure( + mut self, + rate_control_structure: VideoEncodeH265RateControlStructureEXT, + ) -> Self { + self.inner.rate_control_structure = rate_control_structure; + self + } + #[inline] + pub fn sub_layer_count(mut self, sub_layer_count: u8) -> Self { + self.inner.sub_layer_count = sub_layer_count; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VideoEncodeH265RateControlInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct VideoEncodeH265QpEXT { + pub qp_i: i32, + pub qp_p: i32, + pub qp_b: i32, +} +impl VideoEncodeH265QpEXT { + pub fn builder<'a>() -> VideoEncodeH265QpEXTBuilder<'a> { + VideoEncodeH265QpEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VideoEncodeH265QpEXTBuilder<'a> { + inner: VideoEncodeH265QpEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for VideoEncodeH265QpEXTBuilder<'a> { + type Target = VideoEncodeH265QpEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VideoEncodeH265QpEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VideoEncodeH265QpEXTBuilder<'a> { + #[inline] + pub fn qp_i(mut self, qp_i: i32) -> Self { + self.inner.qp_i = qp_i; + self + } + #[inline] + pub fn qp_p(mut self, qp_p: i32) -> Self { + self.inner.qp_p = qp_p; + self + } + #[inline] + pub fn qp_b(mut self, qp_b: i32) -> Self { + self.inner.qp_b = qp_b; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VideoEncodeH265QpEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct VideoEncodeH265FrameSizeEXT { + pub frame_i_size: u32, + pub frame_p_size: u32, + pub frame_b_size: u32, +} +impl VideoEncodeH265FrameSizeEXT { + pub fn builder<'a>() -> VideoEncodeH265FrameSizeEXTBuilder<'a> { + VideoEncodeH265FrameSizeEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VideoEncodeH265FrameSizeEXTBuilder<'a> { + inner: VideoEncodeH265FrameSizeEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for VideoEncodeH265FrameSizeEXTBuilder<'a> { + type Target = VideoEncodeH265FrameSizeEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VideoEncodeH265FrameSizeEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VideoEncodeH265FrameSizeEXTBuilder<'a> { + #[inline] + pub fn frame_i_size(mut self, frame_i_size: u32) -> Self { + self.inner.frame_i_size = frame_i_size; + self + } + #[inline] + pub fn frame_p_size(mut self, frame_p_size: u32) -> Self { + self.inner.frame_p_size = frame_p_size; + self + } + #[inline] + pub fn frame_b_size(mut self, frame_b_size: u32) -> Self { + self.inner.frame_b_size = frame_b_size; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VideoEncodeH265FrameSizeEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct VideoEncodeH265RateControlLayerInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub temporal_id: u8, + pub use_initial_rc_qp: Bool32, + pub initial_rc_qp: VideoEncodeH265QpEXT, + pub use_min_qp: Bool32, + pub min_qp: VideoEncodeH265QpEXT, + pub use_max_qp: Bool32, + pub max_qp: VideoEncodeH265QpEXT, + pub use_max_frame_size: Bool32, + pub max_frame_size: VideoEncodeH265FrameSizeEXT, +} +impl ::std::default::Default for VideoEncodeH265RateControlLayerInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + temporal_id: u8::default(), + use_initial_rc_qp: Bool32::default(), + initial_rc_qp: VideoEncodeH265QpEXT::default(), + use_min_qp: Bool32::default(), + min_qp: VideoEncodeH265QpEXT::default(), + use_max_qp: Bool32::default(), + max_qp: VideoEncodeH265QpEXT::default(), + use_max_frame_size: Bool32::default(), + max_frame_size: VideoEncodeH265FrameSizeEXT::default(), + } + } +} +unsafe impl TaggedStructure for VideoEncodeH265RateControlLayerInfoEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_EXT; +} +impl VideoEncodeH265RateControlLayerInfoEXT { + pub fn builder<'a>() -> VideoEncodeH265RateControlLayerInfoEXTBuilder<'a> { + VideoEncodeH265RateControlLayerInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VideoEncodeH265RateControlLayerInfoEXTBuilder<'a> { + inner: VideoEncodeH265RateControlLayerInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsVideoCodingControlInfoKHR for VideoEncodeH265RateControlLayerInfoEXTBuilder<'_> {} +unsafe impl ExtendsVideoCodingControlInfoKHR for VideoEncodeH265RateControlLayerInfoEXT {} +unsafe impl ExtendsVideoEncodeRateControlLayerInfoKHR + for VideoEncodeH265RateControlLayerInfoEXTBuilder<'_> +{ +} +unsafe impl ExtendsVideoEncodeRateControlLayerInfoKHR for VideoEncodeH265RateControlLayerInfoEXT {} +impl<'a> ::std::ops::Deref for VideoEncodeH265RateControlLayerInfoEXTBuilder<'a> { + type Target = VideoEncodeH265RateControlLayerInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VideoEncodeH265RateControlLayerInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VideoEncodeH265RateControlLayerInfoEXTBuilder<'a> { + #[inline] + pub fn temporal_id(mut self, temporal_id: u8) -> Self { + self.inner.temporal_id = temporal_id; + self + } + #[inline] + pub fn use_initial_rc_qp(mut self, use_initial_rc_qp: bool) -> Self { + self.inner.use_initial_rc_qp = use_initial_rc_qp.into(); + self + } + #[inline] + pub fn initial_rc_qp(mut self, initial_rc_qp: VideoEncodeH265QpEXT) -> Self { + self.inner.initial_rc_qp = initial_rc_qp; + self + } + #[inline] + pub fn use_min_qp(mut self, use_min_qp: bool) -> Self { + self.inner.use_min_qp = use_min_qp.into(); + self + } + #[inline] + pub fn min_qp(mut self, min_qp: VideoEncodeH265QpEXT) -> Self { + self.inner.min_qp = min_qp; + self + } + #[inline] + pub fn use_max_qp(mut self, use_max_qp: bool) -> Self { + self.inner.use_max_qp = use_max_qp.into(); + self + } + #[inline] + pub fn max_qp(mut self, max_qp: VideoEncodeH265QpEXT) -> Self { + self.inner.max_qp = max_qp; + self + } + #[inline] + pub fn use_max_frame_size(mut self, use_max_frame_size: bool) -> Self { + self.inner.use_max_frame_size = use_max_frame_size.into(); + self + } + #[inline] + pub fn max_frame_size(mut self, max_frame_size: VideoEncodeH265FrameSizeEXT) -> Self { + self.inner.max_frame_size = max_frame_size; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VideoEncodeH265RateControlLayerInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct VideoEncodeH265ProfileInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub std_profile_idc: StdVideoH265ProfileIdc, +} +impl ::std::default::Default for VideoEncodeH265ProfileInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + std_profile_idc: StdVideoH265ProfileIdc::default(), + } + } +} +unsafe impl TaggedStructure for VideoEncodeH265ProfileInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_ENCODE_H265_PROFILE_INFO_EXT; +} +impl VideoEncodeH265ProfileInfoEXT { + pub fn builder<'a>() -> VideoEncodeH265ProfileInfoEXTBuilder<'a> { + VideoEncodeH265ProfileInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VideoEncodeH265ProfileInfoEXTBuilder<'a> { + inner: VideoEncodeH265ProfileInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsVideoProfileInfoKHR for VideoEncodeH265ProfileInfoEXTBuilder<'_> {} +unsafe impl ExtendsVideoProfileInfoKHR for VideoEncodeH265ProfileInfoEXT {} +unsafe impl ExtendsQueryPoolCreateInfo for VideoEncodeH265ProfileInfoEXTBuilder<'_> {} +unsafe impl ExtendsQueryPoolCreateInfo for VideoEncodeH265ProfileInfoEXT {} +impl<'a> ::std::ops::Deref for VideoEncodeH265ProfileInfoEXTBuilder<'a> { + type Target = VideoEncodeH265ProfileInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VideoEncodeH265ProfileInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VideoEncodeH265ProfileInfoEXTBuilder<'a> { + #[inline] + pub fn std_profile_idc(mut self, std_profile_idc: StdVideoH265ProfileIdc) -> Self { + self.inner.std_profile_idc = std_profile_idc; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VideoEncodeH265ProfileInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct VideoEncodeH265DpbSlotInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub slot_index: i8, + pub p_std_reference_info: *const StdVideoEncodeH265ReferenceInfo, +} +impl ::std::default::Default for VideoEncodeH265DpbSlotInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + slot_index: i8::default(), + p_std_reference_info: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for VideoEncodeH265DpbSlotInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_ENCODE_H265_DPB_SLOT_INFO_EXT; +} +impl VideoEncodeH265DpbSlotInfoEXT { + pub fn builder<'a>() -> VideoEncodeH265DpbSlotInfoEXTBuilder<'a> { + VideoEncodeH265DpbSlotInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VideoEncodeH265DpbSlotInfoEXTBuilder<'a> { + inner: VideoEncodeH265DpbSlotInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for VideoEncodeH265DpbSlotInfoEXTBuilder<'a> { + type Target = VideoEncodeH265DpbSlotInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VideoEncodeH265DpbSlotInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VideoEncodeH265DpbSlotInfoEXTBuilder<'a> { + #[inline] + pub fn slot_index(mut self, slot_index: i8) -> Self { + self.inner.slot_index = slot_index; + self + } + #[inline] + pub fn std_reference_info( + mut self, + std_reference_info: &'a StdVideoEncodeH265ReferenceInfo, + ) -> Self { + self.inner.p_std_reference_info = std_reference_info; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VideoEncodeH265DpbSlotInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct VideoEncodeH265ReferenceListsInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub reference_list0_entry_count: u8, + pub p_reference_list0_entries: *const VideoEncodeH265DpbSlotInfoEXT, + pub reference_list1_entry_count: u8, + pub p_reference_list1_entries: *const VideoEncodeH265DpbSlotInfoEXT, + pub p_reference_modifications: *const StdVideoEncodeH265ReferenceModifications, +} +impl ::std::default::Default for VideoEncodeH265ReferenceListsInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + reference_list0_entry_count: u8::default(), + p_reference_list0_entries: ::std::ptr::null(), + reference_list1_entry_count: u8::default(), + p_reference_list1_entries: ::std::ptr::null(), + p_reference_modifications: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for VideoEncodeH265ReferenceListsInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_ENCODE_H265_REFERENCE_LISTS_INFO_EXT; +} +impl VideoEncodeH265ReferenceListsInfoEXT { + pub fn builder<'a>() -> VideoEncodeH265ReferenceListsInfoEXTBuilder<'a> { + VideoEncodeH265ReferenceListsInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct VideoEncodeH265ReferenceListsInfoEXTBuilder<'a> { + inner: VideoEncodeH265ReferenceListsInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for VideoEncodeH265ReferenceListsInfoEXTBuilder<'a> { + type Target = VideoEncodeH265ReferenceListsInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for VideoEncodeH265ReferenceListsInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> VideoEncodeH265ReferenceListsInfoEXTBuilder<'a> { + #[inline] + pub fn reference_list0_entries( + mut self, + reference_list0_entries: &'a [VideoEncodeH265DpbSlotInfoEXT], + ) -> Self { + self.inner.reference_list0_entry_count = reference_list0_entries.len() as _; + self.inner.p_reference_list0_entries = reference_list0_entries.as_ptr(); + self + } + #[inline] + pub fn reference_list1_entries( + mut self, + reference_list1_entries: &'a [VideoEncodeH265DpbSlotInfoEXT], + ) -> Self { + self.inner.reference_list1_entry_count = reference_list1_entries.len() as _; + self.inner.p_reference_list1_entries = reference_list1_entries.as_ptr(); + self + } + #[inline] + pub fn reference_modifications( + mut self, + reference_modifications: &'a StdVideoEncodeH265ReferenceModifications, + ) -> Self { + self.inner.p_reference_modifications = reference_modifications; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> VideoEncodeH265ReferenceListsInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceInheritedViewportScissorFeaturesNV { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub inherited_viewport_scissor2_d: Bool32, +} +impl ::std::default::Default for PhysicalDeviceInheritedViewportScissorFeaturesNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + inherited_viewport_scissor2_d: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceInheritedViewportScissorFeaturesNV { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV; +} +impl PhysicalDeviceInheritedViewportScissorFeaturesNV { + pub fn builder<'a>() -> PhysicalDeviceInheritedViewportScissorFeaturesNVBuilder<'a> { + PhysicalDeviceInheritedViewportScissorFeaturesNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceInheritedViewportScissorFeaturesNVBuilder<'a> { + inner: PhysicalDeviceInheritedViewportScissorFeaturesNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceInheritedViewportScissorFeaturesNVBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceInheritedViewportScissorFeaturesNV {} +unsafe impl ExtendsDeviceCreateInfo + for PhysicalDeviceInheritedViewportScissorFeaturesNVBuilder<'_> +{ +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceInheritedViewportScissorFeaturesNV {} +impl<'a> ::std::ops::Deref for PhysicalDeviceInheritedViewportScissorFeaturesNVBuilder<'a> { + type Target = PhysicalDeviceInheritedViewportScissorFeaturesNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceInheritedViewportScissorFeaturesNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceInheritedViewportScissorFeaturesNVBuilder<'a> { + #[inline] + pub fn inherited_viewport_scissor2_d(mut self, inherited_viewport_scissor2_d: bool) -> Self { + self.inner.inherited_viewport_scissor2_d = inherited_viewport_scissor2_d.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceInheritedViewportScissorFeaturesNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct CommandBufferInheritanceViewportScissorInfoNV { + pub s_type: StructureType, + pub p_next: *const c_void, + pub viewport_scissor2_d: Bool32, + pub viewport_depth_count: u32, + pub p_viewport_depths: *const Viewport, +} +impl ::std::default::Default for CommandBufferInheritanceViewportScissorInfoNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + viewport_scissor2_d: Bool32::default(), + viewport_depth_count: u32::default(), + p_viewport_depths: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for CommandBufferInheritanceViewportScissorInfoNV { + const STRUCTURE_TYPE: StructureType = + StructureType::COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV; +} +impl CommandBufferInheritanceViewportScissorInfoNV { + pub fn builder<'a>() -> CommandBufferInheritanceViewportScissorInfoNVBuilder<'a> { + CommandBufferInheritanceViewportScissorInfoNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct CommandBufferInheritanceViewportScissorInfoNVBuilder<'a> { + inner: CommandBufferInheritanceViewportScissorInfoNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsCommandBufferInheritanceInfo + for CommandBufferInheritanceViewportScissorInfoNVBuilder<'_> +{ +} +unsafe impl ExtendsCommandBufferInheritanceInfo for CommandBufferInheritanceViewportScissorInfoNV {} +impl<'a> ::std::ops::Deref for CommandBufferInheritanceViewportScissorInfoNVBuilder<'a> { + type Target = CommandBufferInheritanceViewportScissorInfoNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for CommandBufferInheritanceViewportScissorInfoNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> CommandBufferInheritanceViewportScissorInfoNVBuilder<'a> { + #[inline] + pub fn viewport_scissor2_d(mut self, viewport_scissor2_d: bool) -> Self { + self.inner.viewport_scissor2_d = viewport_scissor2_d.into(); + self + } + #[inline] + pub fn viewport_depth_count(mut self, viewport_depth_count: u32) -> Self { + self.inner.viewport_depth_count = viewport_depth_count; + self + } + #[inline] + pub fn viewport_depths(mut self, viewport_depths: &'a Viewport) -> Self { + self.inner.p_viewport_depths = viewport_depths; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> CommandBufferInheritanceViewportScissorInfoNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub ycbcr2plane444_formats: Bool32, +} +impl ::std::default::Default for PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + ycbcr2plane444_formats: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT; +} +impl PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXTBuilder<'a> { + PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXTBuilder<'a> { + inner: PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXTBuilder<'a> { + type Target = PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXTBuilder<'a> { + #[inline] + pub fn ycbcr2plane444_formats(mut self, ycbcr2plane444_formats: bool) -> Self { + self.inner.ycbcr2plane444_formats = ycbcr2plane444_formats.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceProvokingVertexFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub provoking_vertex_last: Bool32, + pub transform_feedback_preserves_provoking_vertex: Bool32, +} +impl ::std::default::Default for PhysicalDeviceProvokingVertexFeaturesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + provoking_vertex_last: Bool32::default(), + transform_feedback_preserves_provoking_vertex: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceProvokingVertexFeaturesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT; +} +impl PhysicalDeviceProvokingVertexFeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceProvokingVertexFeaturesEXTBuilder<'a> { + PhysicalDeviceProvokingVertexFeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceProvokingVertexFeaturesEXTBuilder<'a> { + inner: PhysicalDeviceProvokingVertexFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceProvokingVertexFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceProvokingVertexFeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceProvokingVertexFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceProvokingVertexFeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceProvokingVertexFeaturesEXTBuilder<'a> { + type Target = PhysicalDeviceProvokingVertexFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceProvokingVertexFeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceProvokingVertexFeaturesEXTBuilder<'a> { + #[inline] + pub fn provoking_vertex_last(mut self, provoking_vertex_last: bool) -> Self { + self.inner.provoking_vertex_last = provoking_vertex_last.into(); + self + } + #[inline] + pub fn transform_feedback_preserves_provoking_vertex( + mut self, + transform_feedback_preserves_provoking_vertex: bool, + ) -> Self { + self.inner.transform_feedback_preserves_provoking_vertex = + transform_feedback_preserves_provoking_vertex.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceProvokingVertexFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceProvokingVertexPropertiesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub provoking_vertex_mode_per_pipeline: Bool32, + pub transform_feedback_preserves_triangle_fan_provoking_vertex: Bool32, +} +impl ::std::default::Default for PhysicalDeviceProvokingVertexPropertiesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + provoking_vertex_mode_per_pipeline: Bool32::default(), + transform_feedback_preserves_triangle_fan_provoking_vertex: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceProvokingVertexPropertiesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT; +} +impl PhysicalDeviceProvokingVertexPropertiesEXT { + pub fn builder<'a>() -> PhysicalDeviceProvokingVertexPropertiesEXTBuilder<'a> { + PhysicalDeviceProvokingVertexPropertiesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceProvokingVertexPropertiesEXTBuilder<'a> { + inner: PhysicalDeviceProvokingVertexPropertiesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceProvokingVertexPropertiesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceProvokingVertexPropertiesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceProvokingVertexPropertiesEXTBuilder<'a> { + type Target = PhysicalDeviceProvokingVertexPropertiesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceProvokingVertexPropertiesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceProvokingVertexPropertiesEXTBuilder<'a> { + #[inline] + pub fn provoking_vertex_mode_per_pipeline( + mut self, + provoking_vertex_mode_per_pipeline: bool, + ) -> Self { + self.inner.provoking_vertex_mode_per_pipeline = provoking_vertex_mode_per_pipeline.into(); + self + } + #[inline] + pub fn transform_feedback_preserves_triangle_fan_provoking_vertex( + mut self, + transform_feedback_preserves_triangle_fan_provoking_vertex: bool, + ) -> Self { + self.inner + .transform_feedback_preserves_triangle_fan_provoking_vertex = + transform_feedback_preserves_triangle_fan_provoking_vertex.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceProvokingVertexPropertiesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PipelineRasterizationProvokingVertexStateCreateInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub provoking_vertex_mode: ProvokingVertexModeEXT, +} +impl ::std::default::Default for PipelineRasterizationProvokingVertexStateCreateInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + provoking_vertex_mode: ProvokingVertexModeEXT::default(), + } + } +} +unsafe impl TaggedStructure for PipelineRasterizationProvokingVertexStateCreateInfoEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT; +} +impl PipelineRasterizationProvokingVertexStateCreateInfoEXT { + pub fn builder<'a>() -> PipelineRasterizationProvokingVertexStateCreateInfoEXTBuilder<'a> { + PipelineRasterizationProvokingVertexStateCreateInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PipelineRasterizationProvokingVertexStateCreateInfoEXTBuilder<'a> { + inner: PipelineRasterizationProvokingVertexStateCreateInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPipelineRasterizationStateCreateInfo + for PipelineRasterizationProvokingVertexStateCreateInfoEXTBuilder<'_> +{ +} +unsafe impl ExtendsPipelineRasterizationStateCreateInfo + for PipelineRasterizationProvokingVertexStateCreateInfoEXT +{ +} +impl<'a> ::std::ops::Deref for PipelineRasterizationProvokingVertexStateCreateInfoEXTBuilder<'a> { + type Target = PipelineRasterizationProvokingVertexStateCreateInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut + for PipelineRasterizationProvokingVertexStateCreateInfoEXTBuilder<'a> +{ + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PipelineRasterizationProvokingVertexStateCreateInfoEXTBuilder<'a> { + #[inline] + pub fn provoking_vertex_mode(mut self, provoking_vertex_mode: ProvokingVertexModeEXT) -> Self { + self.inner.provoking_vertex_mode = provoking_vertex_mode; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PipelineRasterizationProvokingVertexStateCreateInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct CuModuleCreateInfoNVX { + pub s_type: StructureType, + pub p_next: *const c_void, + pub data_size: usize, + pub p_data: *const c_void, +} +impl ::std::default::Default for CuModuleCreateInfoNVX { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + data_size: usize::default(), + p_data: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for CuModuleCreateInfoNVX { + const STRUCTURE_TYPE: StructureType = StructureType::CU_MODULE_CREATE_INFO_NVX; +} +impl CuModuleCreateInfoNVX { + pub fn builder<'a>() -> CuModuleCreateInfoNVXBuilder<'a> { + CuModuleCreateInfoNVXBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct CuModuleCreateInfoNVXBuilder<'a> { + inner: CuModuleCreateInfoNVX, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for CuModuleCreateInfoNVXBuilder<'a> { + type Target = CuModuleCreateInfoNVX; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for CuModuleCreateInfoNVXBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> CuModuleCreateInfoNVXBuilder<'a> { + #[inline] + pub fn data(mut self, data: &'a [u8]) -> Self { + self.inner.data_size = data.len(); + self.inner.p_data = data.as_ptr().cast(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> CuModuleCreateInfoNVX { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct CuFunctionCreateInfoNVX { + pub s_type: StructureType, + pub p_next: *const c_void, + pub module: CuModuleNVX, + pub p_name: *const c_char, +} +impl ::std::default::Default for CuFunctionCreateInfoNVX { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + module: CuModuleNVX::default(), + p_name: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for CuFunctionCreateInfoNVX { + const STRUCTURE_TYPE: StructureType = StructureType::CU_FUNCTION_CREATE_INFO_NVX; +} +impl CuFunctionCreateInfoNVX { + pub fn builder<'a>() -> CuFunctionCreateInfoNVXBuilder<'a> { + CuFunctionCreateInfoNVXBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct CuFunctionCreateInfoNVXBuilder<'a> { + inner: CuFunctionCreateInfoNVX, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for CuFunctionCreateInfoNVXBuilder<'a> { + type Target = CuFunctionCreateInfoNVX; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for CuFunctionCreateInfoNVXBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> CuFunctionCreateInfoNVXBuilder<'a> { + #[inline] + pub fn module(mut self, module: CuModuleNVX) -> Self { + self.inner.module = module; + self + } + #[inline] + pub fn name(mut self, name: &'a ::std::ffi::CStr) -> Self { + self.inner.p_name = name.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> CuFunctionCreateInfoNVX { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct CuLaunchInfoNVX { + pub s_type: StructureType, + pub p_next: *const c_void, + pub function: CuFunctionNVX, + pub grid_dim_x: u32, + pub grid_dim_y: u32, + pub grid_dim_z: u32, + pub block_dim_x: u32, + pub block_dim_y: u32, + pub block_dim_z: u32, + pub shared_mem_bytes: u32, + pub param_count: usize, + pub p_params: *const *const c_void, + pub extra_count: usize, + pub p_extras: *const *const c_void, +} +impl ::std::default::Default for CuLaunchInfoNVX { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + function: CuFunctionNVX::default(), + grid_dim_x: u32::default(), + grid_dim_y: u32::default(), + grid_dim_z: u32::default(), + block_dim_x: u32::default(), + block_dim_y: u32::default(), + block_dim_z: u32::default(), + shared_mem_bytes: u32::default(), + param_count: usize::default(), + p_params: ::std::ptr::null(), + extra_count: usize::default(), + p_extras: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for CuLaunchInfoNVX { + const STRUCTURE_TYPE: StructureType = StructureType::CU_LAUNCH_INFO_NVX; +} +impl CuLaunchInfoNVX { + pub fn builder<'a>() -> CuLaunchInfoNVXBuilder<'a> { + CuLaunchInfoNVXBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct CuLaunchInfoNVXBuilder<'a> { + inner: CuLaunchInfoNVX, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for CuLaunchInfoNVXBuilder<'a> { + type Target = CuLaunchInfoNVX; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for CuLaunchInfoNVXBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> CuLaunchInfoNVXBuilder<'a> { + #[inline] + pub fn function(mut self, function: CuFunctionNVX) -> Self { + self.inner.function = function; + self + } + #[inline] + pub fn grid_dim_x(mut self, grid_dim_x: u32) -> Self { + self.inner.grid_dim_x = grid_dim_x; + self + } + #[inline] + pub fn grid_dim_y(mut self, grid_dim_y: u32) -> Self { + self.inner.grid_dim_y = grid_dim_y; + self + } + #[inline] + pub fn grid_dim_z(mut self, grid_dim_z: u32) -> Self { + self.inner.grid_dim_z = grid_dim_z; + self + } + #[inline] + pub fn block_dim_x(mut self, block_dim_x: u32) -> Self { + self.inner.block_dim_x = block_dim_x; + self + } + #[inline] + pub fn block_dim_y(mut self, block_dim_y: u32) -> Self { + self.inner.block_dim_y = block_dim_y; + self + } + #[inline] + pub fn block_dim_z(mut self, block_dim_z: u32) -> Self { + self.inner.block_dim_z = block_dim_z; + self + } + #[inline] + pub fn shared_mem_bytes(mut self, shared_mem_bytes: u32) -> Self { + self.inner.shared_mem_bytes = shared_mem_bytes; + self + } + #[inline] + pub fn params(mut self, params: &'a [*const c_void]) -> Self { + self.inner.param_count = params.len(); + self.inner.p_params = params.as_ptr(); + self + } + #[inline] + pub fn extras(mut self, extras: &'a [*const c_void]) -> Self { + self.inner.extra_count = extras.len(); + self.inner.p_extras = extras.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> CuLaunchInfoNVX { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceDescriptorBufferFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub descriptor_buffer: Bool32, + pub descriptor_buffer_capture_replay: Bool32, + pub descriptor_buffer_image_layout_ignored: Bool32, + pub descriptor_buffer_push_descriptors: Bool32, +} +impl ::std::default::Default for PhysicalDeviceDescriptorBufferFeaturesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + descriptor_buffer: Bool32::default(), + descriptor_buffer_capture_replay: Bool32::default(), + descriptor_buffer_image_layout_ignored: Bool32::default(), + descriptor_buffer_push_descriptors: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceDescriptorBufferFeaturesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT; +} +impl PhysicalDeviceDescriptorBufferFeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceDescriptorBufferFeaturesEXTBuilder<'a> { + PhysicalDeviceDescriptorBufferFeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceDescriptorBufferFeaturesEXTBuilder<'a> { + inner: PhysicalDeviceDescriptorBufferFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceDescriptorBufferFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceDescriptorBufferFeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDescriptorBufferFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDescriptorBufferFeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceDescriptorBufferFeaturesEXTBuilder<'a> { + type Target = PhysicalDeviceDescriptorBufferFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceDescriptorBufferFeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceDescriptorBufferFeaturesEXTBuilder<'a> { + #[inline] + pub fn descriptor_buffer(mut self, descriptor_buffer: bool) -> Self { + self.inner.descriptor_buffer = descriptor_buffer.into(); + self + } + #[inline] + pub fn descriptor_buffer_capture_replay( + mut self, + descriptor_buffer_capture_replay: bool, + ) -> Self { + self.inner.descriptor_buffer_capture_replay = descriptor_buffer_capture_replay.into(); + self + } + #[inline] + pub fn descriptor_buffer_image_layout_ignored( + mut self, + descriptor_buffer_image_layout_ignored: bool, + ) -> Self { + self.inner.descriptor_buffer_image_layout_ignored = + descriptor_buffer_image_layout_ignored.into(); + self + } + #[inline] + pub fn descriptor_buffer_push_descriptors( + mut self, + descriptor_buffer_push_descriptors: bool, + ) -> Self { + self.inner.descriptor_buffer_push_descriptors = descriptor_buffer_push_descriptors.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceDescriptorBufferFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceDescriptorBufferPropertiesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub combined_image_sampler_descriptor_single_array: Bool32, + pub bufferless_push_descriptors: Bool32, + pub allow_sampler_image_view_post_submit_creation: Bool32, + pub descriptor_buffer_offset_alignment: DeviceSize, + pub max_descriptor_buffer_bindings: u32, + pub max_resource_descriptor_buffer_bindings: u32, + pub max_sampler_descriptor_buffer_bindings: u32, + pub max_embedded_immutable_sampler_bindings: u32, + pub max_embedded_immutable_samplers: u32, + pub buffer_capture_replay_descriptor_data_size: usize, + pub image_capture_replay_descriptor_data_size: usize, + pub image_view_capture_replay_descriptor_data_size: usize, + pub sampler_capture_replay_descriptor_data_size: usize, + pub acceleration_structure_capture_replay_descriptor_data_size: usize, + pub sampler_descriptor_size: usize, + pub combined_image_sampler_descriptor_size: usize, + pub sampled_image_descriptor_size: usize, + pub storage_image_descriptor_size: usize, + pub uniform_texel_buffer_descriptor_size: usize, + pub robust_uniform_texel_buffer_descriptor_size: usize, + pub storage_texel_buffer_descriptor_size: usize, + pub robust_storage_texel_buffer_descriptor_size: usize, + pub uniform_buffer_descriptor_size: usize, + pub robust_uniform_buffer_descriptor_size: usize, + pub storage_buffer_descriptor_size: usize, + pub robust_storage_buffer_descriptor_size: usize, + pub input_attachment_descriptor_size: usize, + pub acceleration_structure_descriptor_size: usize, + pub max_sampler_descriptor_buffer_range: DeviceSize, + pub max_resource_descriptor_buffer_range: DeviceSize, + pub sampler_descriptor_buffer_address_space_size: DeviceSize, + pub resource_descriptor_buffer_address_space_size: DeviceSize, + pub descriptor_buffer_address_space_size: DeviceSize, +} +impl ::std::default::Default for PhysicalDeviceDescriptorBufferPropertiesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + combined_image_sampler_descriptor_single_array: Bool32::default(), + bufferless_push_descriptors: Bool32::default(), + allow_sampler_image_view_post_submit_creation: Bool32::default(), + descriptor_buffer_offset_alignment: DeviceSize::default(), + max_descriptor_buffer_bindings: u32::default(), + max_resource_descriptor_buffer_bindings: u32::default(), + max_sampler_descriptor_buffer_bindings: u32::default(), + max_embedded_immutable_sampler_bindings: u32::default(), + max_embedded_immutable_samplers: u32::default(), + buffer_capture_replay_descriptor_data_size: usize::default(), + image_capture_replay_descriptor_data_size: usize::default(), + image_view_capture_replay_descriptor_data_size: usize::default(), + sampler_capture_replay_descriptor_data_size: usize::default(), + acceleration_structure_capture_replay_descriptor_data_size: usize::default(), + sampler_descriptor_size: usize::default(), + combined_image_sampler_descriptor_size: usize::default(), + sampled_image_descriptor_size: usize::default(), + storage_image_descriptor_size: usize::default(), + uniform_texel_buffer_descriptor_size: usize::default(), + robust_uniform_texel_buffer_descriptor_size: usize::default(), + storage_texel_buffer_descriptor_size: usize::default(), + robust_storage_texel_buffer_descriptor_size: usize::default(), + uniform_buffer_descriptor_size: usize::default(), + robust_uniform_buffer_descriptor_size: usize::default(), + storage_buffer_descriptor_size: usize::default(), + robust_storage_buffer_descriptor_size: usize::default(), + input_attachment_descriptor_size: usize::default(), + acceleration_structure_descriptor_size: usize::default(), + max_sampler_descriptor_buffer_range: DeviceSize::default(), + max_resource_descriptor_buffer_range: DeviceSize::default(), + sampler_descriptor_buffer_address_space_size: DeviceSize::default(), + resource_descriptor_buffer_address_space_size: DeviceSize::default(), + descriptor_buffer_address_space_size: DeviceSize::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceDescriptorBufferPropertiesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT; +} +impl PhysicalDeviceDescriptorBufferPropertiesEXT { + pub fn builder<'a>() -> PhysicalDeviceDescriptorBufferPropertiesEXTBuilder<'a> { + PhysicalDeviceDescriptorBufferPropertiesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceDescriptorBufferPropertiesEXTBuilder<'a> { + inner: PhysicalDeviceDescriptorBufferPropertiesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceDescriptorBufferPropertiesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceDescriptorBufferPropertiesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceDescriptorBufferPropertiesEXTBuilder<'a> { + type Target = PhysicalDeviceDescriptorBufferPropertiesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceDescriptorBufferPropertiesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceDescriptorBufferPropertiesEXTBuilder<'a> { + #[inline] + pub fn combined_image_sampler_descriptor_single_array( + mut self, + combined_image_sampler_descriptor_single_array: bool, + ) -> Self { + self.inner.combined_image_sampler_descriptor_single_array = + combined_image_sampler_descriptor_single_array.into(); + self + } + #[inline] + pub fn bufferless_push_descriptors(mut self, bufferless_push_descriptors: bool) -> Self { + self.inner.bufferless_push_descriptors = bufferless_push_descriptors.into(); + self + } + #[inline] + pub fn allow_sampler_image_view_post_submit_creation( + mut self, + allow_sampler_image_view_post_submit_creation: bool, + ) -> Self { + self.inner.allow_sampler_image_view_post_submit_creation = + allow_sampler_image_view_post_submit_creation.into(); + self + } + #[inline] + pub fn descriptor_buffer_offset_alignment( + mut self, + descriptor_buffer_offset_alignment: DeviceSize, + ) -> Self { + self.inner.descriptor_buffer_offset_alignment = descriptor_buffer_offset_alignment; + self + } + #[inline] + pub fn max_descriptor_buffer_bindings(mut self, max_descriptor_buffer_bindings: u32) -> Self { + self.inner.max_descriptor_buffer_bindings = max_descriptor_buffer_bindings; + self + } + #[inline] + pub fn max_resource_descriptor_buffer_bindings( + mut self, + max_resource_descriptor_buffer_bindings: u32, + ) -> Self { + self.inner.max_resource_descriptor_buffer_bindings = + max_resource_descriptor_buffer_bindings; + self + } + #[inline] + pub fn max_sampler_descriptor_buffer_bindings( + mut self, + max_sampler_descriptor_buffer_bindings: u32, + ) -> Self { + self.inner.max_sampler_descriptor_buffer_bindings = max_sampler_descriptor_buffer_bindings; + self + } + #[inline] + pub fn max_embedded_immutable_sampler_bindings( + mut self, + max_embedded_immutable_sampler_bindings: u32, + ) -> Self { + self.inner.max_embedded_immutable_sampler_bindings = + max_embedded_immutable_sampler_bindings; + self + } + #[inline] + pub fn max_embedded_immutable_samplers(mut self, max_embedded_immutable_samplers: u32) -> Self { + self.inner.max_embedded_immutable_samplers = max_embedded_immutable_samplers; + self + } + #[inline] + pub fn buffer_capture_replay_descriptor_data_size( + mut self, + buffer_capture_replay_descriptor_data_size: usize, + ) -> Self { + self.inner.buffer_capture_replay_descriptor_data_size = + buffer_capture_replay_descriptor_data_size; + self + } + #[inline] + pub fn image_capture_replay_descriptor_data_size( + mut self, + image_capture_replay_descriptor_data_size: usize, + ) -> Self { + self.inner.image_capture_replay_descriptor_data_size = + image_capture_replay_descriptor_data_size; + self + } + #[inline] + pub fn image_view_capture_replay_descriptor_data_size( + mut self, + image_view_capture_replay_descriptor_data_size: usize, + ) -> Self { + self.inner.image_view_capture_replay_descriptor_data_size = + image_view_capture_replay_descriptor_data_size; + self + } + #[inline] + pub fn sampler_capture_replay_descriptor_data_size( + mut self, + sampler_capture_replay_descriptor_data_size: usize, + ) -> Self { + self.inner.sampler_capture_replay_descriptor_data_size = + sampler_capture_replay_descriptor_data_size; + self + } + #[inline] + pub fn acceleration_structure_capture_replay_descriptor_data_size( + mut self, + acceleration_structure_capture_replay_descriptor_data_size: usize, + ) -> Self { + self.inner + .acceleration_structure_capture_replay_descriptor_data_size = + acceleration_structure_capture_replay_descriptor_data_size; + self + } + #[inline] + pub fn sampler_descriptor_size(mut self, sampler_descriptor_size: usize) -> Self { + self.inner.sampler_descriptor_size = sampler_descriptor_size; + self + } + #[inline] + pub fn combined_image_sampler_descriptor_size( + mut self, + combined_image_sampler_descriptor_size: usize, + ) -> Self { + self.inner.combined_image_sampler_descriptor_size = combined_image_sampler_descriptor_size; + self + } + #[inline] + pub fn sampled_image_descriptor_size(mut self, sampled_image_descriptor_size: usize) -> Self { + self.inner.sampled_image_descriptor_size = sampled_image_descriptor_size; + self + } + #[inline] + pub fn storage_image_descriptor_size(mut self, storage_image_descriptor_size: usize) -> Self { + self.inner.storage_image_descriptor_size = storage_image_descriptor_size; + self + } + #[inline] + pub fn uniform_texel_buffer_descriptor_size( + mut self, + uniform_texel_buffer_descriptor_size: usize, + ) -> Self { + self.inner.uniform_texel_buffer_descriptor_size = uniform_texel_buffer_descriptor_size; + self + } + #[inline] + pub fn robust_uniform_texel_buffer_descriptor_size( + mut self, + robust_uniform_texel_buffer_descriptor_size: usize, + ) -> Self { + self.inner.robust_uniform_texel_buffer_descriptor_size = + robust_uniform_texel_buffer_descriptor_size; + self + } + #[inline] + pub fn storage_texel_buffer_descriptor_size( + mut self, + storage_texel_buffer_descriptor_size: usize, + ) -> Self { + self.inner.storage_texel_buffer_descriptor_size = storage_texel_buffer_descriptor_size; + self + } + #[inline] + pub fn robust_storage_texel_buffer_descriptor_size( + mut self, + robust_storage_texel_buffer_descriptor_size: usize, + ) -> Self { + self.inner.robust_storage_texel_buffer_descriptor_size = + robust_storage_texel_buffer_descriptor_size; + self + } + #[inline] + pub fn uniform_buffer_descriptor_size(mut self, uniform_buffer_descriptor_size: usize) -> Self { + self.inner.uniform_buffer_descriptor_size = uniform_buffer_descriptor_size; + self + } + #[inline] + pub fn robust_uniform_buffer_descriptor_size( + mut self, + robust_uniform_buffer_descriptor_size: usize, + ) -> Self { + self.inner.robust_uniform_buffer_descriptor_size = robust_uniform_buffer_descriptor_size; + self + } + #[inline] + pub fn storage_buffer_descriptor_size(mut self, storage_buffer_descriptor_size: usize) -> Self { + self.inner.storage_buffer_descriptor_size = storage_buffer_descriptor_size; + self + } + #[inline] + pub fn robust_storage_buffer_descriptor_size( + mut self, + robust_storage_buffer_descriptor_size: usize, + ) -> Self { + self.inner.robust_storage_buffer_descriptor_size = robust_storage_buffer_descriptor_size; + self + } + #[inline] + pub fn input_attachment_descriptor_size( + mut self, + input_attachment_descriptor_size: usize, + ) -> Self { + self.inner.input_attachment_descriptor_size = input_attachment_descriptor_size; + self + } + #[inline] + pub fn acceleration_structure_descriptor_size( + mut self, + acceleration_structure_descriptor_size: usize, + ) -> Self { + self.inner.acceleration_structure_descriptor_size = acceleration_structure_descriptor_size; + self + } + #[inline] + pub fn max_sampler_descriptor_buffer_range( + mut self, + max_sampler_descriptor_buffer_range: DeviceSize, + ) -> Self { + self.inner.max_sampler_descriptor_buffer_range = max_sampler_descriptor_buffer_range; + self + } + #[inline] + pub fn max_resource_descriptor_buffer_range( + mut self, + max_resource_descriptor_buffer_range: DeviceSize, + ) -> Self { + self.inner.max_resource_descriptor_buffer_range = max_resource_descriptor_buffer_range; + self + } + #[inline] + pub fn sampler_descriptor_buffer_address_space_size( + mut self, + sampler_descriptor_buffer_address_space_size: DeviceSize, + ) -> Self { + self.inner.sampler_descriptor_buffer_address_space_size = + sampler_descriptor_buffer_address_space_size; + self + } + #[inline] + pub fn resource_descriptor_buffer_address_space_size( + mut self, + resource_descriptor_buffer_address_space_size: DeviceSize, + ) -> Self { + self.inner.resource_descriptor_buffer_address_space_size = + resource_descriptor_buffer_address_space_size; + self + } + #[inline] + pub fn descriptor_buffer_address_space_size( + mut self, + descriptor_buffer_address_space_size: DeviceSize, + ) -> Self { + self.inner.descriptor_buffer_address_space_size = descriptor_buffer_address_space_size; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceDescriptorBufferPropertiesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub combined_image_sampler_density_map_descriptor_size: usize, +} +impl ::std::default::Default for PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + combined_image_sampler_density_map_descriptor_size: usize::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT; +} +impl PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT { + pub fn builder<'a>() -> PhysicalDeviceDescriptorBufferDensityMapPropertiesEXTBuilder<'a> { + PhysicalDeviceDescriptorBufferDensityMapPropertiesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceDescriptorBufferDensityMapPropertiesEXTBuilder<'a> { + inner: PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceDescriptorBufferDensityMapPropertiesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT +{ +} +impl<'a> ::std::ops::Deref for PhysicalDeviceDescriptorBufferDensityMapPropertiesEXTBuilder<'a> { + type Target = PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceDescriptorBufferDensityMapPropertiesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceDescriptorBufferDensityMapPropertiesEXTBuilder<'a> { + #[inline] + pub fn combined_image_sampler_density_map_descriptor_size( + mut self, + combined_image_sampler_density_map_descriptor_size: usize, + ) -> Self { + self.inner + .combined_image_sampler_density_map_descriptor_size = + combined_image_sampler_density_map_descriptor_size; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DescriptorAddressInfoEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub address: DeviceAddress, + pub range: DeviceSize, + pub format: Format, +} +impl ::std::default::Default for DescriptorAddressInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + address: DeviceAddress::default(), + range: DeviceSize::default(), + format: Format::default(), + } + } +} +unsafe impl TaggedStructure for DescriptorAddressInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::DESCRIPTOR_ADDRESS_INFO_EXT; +} +impl DescriptorAddressInfoEXT { + pub fn builder<'a>() -> DescriptorAddressInfoEXTBuilder<'a> { + DescriptorAddressInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DescriptorAddressInfoEXTBuilder<'a> { + inner: DescriptorAddressInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DescriptorAddressInfoEXTBuilder<'a> { + type Target = DescriptorAddressInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DescriptorAddressInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DescriptorAddressInfoEXTBuilder<'a> { + #[inline] + pub fn address(mut self, address: DeviceAddress) -> Self { + self.inner.address = address; + self + } + #[inline] + pub fn range(mut self, range: DeviceSize) -> Self { + self.inner.range = range; + self + } + #[inline] + pub fn format(mut self, format: Format) -> Self { + self.inner.format = format; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DescriptorAddressInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DescriptorBufferBindingInfoEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub address: DeviceAddress, + pub usage: BufferUsageFlags, +} +impl ::std::default::Default for DescriptorBufferBindingInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + address: DeviceAddress::default(), + usage: BufferUsageFlags::default(), + } + } +} +unsafe impl TaggedStructure for DescriptorBufferBindingInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::DESCRIPTOR_BUFFER_BINDING_INFO_EXT; +} +impl DescriptorBufferBindingInfoEXT { + pub fn builder<'a>() -> DescriptorBufferBindingInfoEXTBuilder<'a> { + DescriptorBufferBindingInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DescriptorBufferBindingInfoEXTBuilder<'a> { + inner: DescriptorBufferBindingInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsDescriptorBufferBindingInfoEXT {} +impl<'a> ::std::ops::Deref for DescriptorBufferBindingInfoEXTBuilder<'a> { + type Target = DescriptorBufferBindingInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DescriptorBufferBindingInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DescriptorBufferBindingInfoEXTBuilder<'a> { + #[inline] + pub fn address(mut self, address: DeviceAddress) -> Self { + self.inner.address = address; + self + } + #[inline] + pub fn usage(mut self, usage: BufferUsageFlags) -> Self { + self.inner.usage = usage; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*mut T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DescriptorBufferBindingInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DescriptorBufferBindingPushDescriptorBufferHandleEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub buffer: Buffer, +} +impl ::std::default::Default for DescriptorBufferBindingPushDescriptorBufferHandleEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + buffer: Buffer::default(), + } + } +} +unsafe impl TaggedStructure for DescriptorBufferBindingPushDescriptorBufferHandleEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::DESCRIPTOR_BUFFER_BINDING_PUSH_DESCRIPTOR_BUFFER_HANDLE_EXT; +} +impl DescriptorBufferBindingPushDescriptorBufferHandleEXT { + pub fn builder<'a>() -> DescriptorBufferBindingPushDescriptorBufferHandleEXTBuilder<'a> { + DescriptorBufferBindingPushDescriptorBufferHandleEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DescriptorBufferBindingPushDescriptorBufferHandleEXTBuilder<'a> { + inner: DescriptorBufferBindingPushDescriptorBufferHandleEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsDescriptorBufferBindingInfoEXT + for DescriptorBufferBindingPushDescriptorBufferHandleEXTBuilder<'_> +{ +} +unsafe impl ExtendsDescriptorBufferBindingInfoEXT + for DescriptorBufferBindingPushDescriptorBufferHandleEXT +{ +} +impl<'a> ::std::ops::Deref for DescriptorBufferBindingPushDescriptorBufferHandleEXTBuilder<'a> { + type Target = DescriptorBufferBindingPushDescriptorBufferHandleEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DescriptorBufferBindingPushDescriptorBufferHandleEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DescriptorBufferBindingPushDescriptorBufferHandleEXTBuilder<'a> { + #[inline] + pub fn buffer(mut self, buffer: Buffer) -> Self { + self.inner.buffer = buffer; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DescriptorBufferBindingPushDescriptorBufferHandleEXT { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[doc = ""] +pub union DescriptorDataEXT { + pub p_sampler: *const Sampler, + pub p_combined_image_sampler: *const DescriptorImageInfo, + pub p_input_attachment_image: *const DescriptorImageInfo, + pub p_sampled_image: *const DescriptorImageInfo, + pub p_storage_image: *const DescriptorImageInfo, + pub p_uniform_texel_buffer: *const DescriptorAddressInfoEXT, + pub p_storage_texel_buffer: *const DescriptorAddressInfoEXT, + pub p_uniform_buffer: *const DescriptorAddressInfoEXT, + pub p_storage_buffer: *const DescriptorAddressInfoEXT, + pub acceleration_structure: DeviceAddress, +} +impl ::std::default::Default for DescriptorDataEXT { + #[inline] + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DescriptorGetInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub ty: DescriptorType, + pub data: DescriptorDataEXT, +} +#[cfg(feature = "debug")] +impl fmt::Debug for DescriptorGetInfoEXT { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fmt.debug_struct("DescriptorGetInfoEXT") + .field("s_type", &self.s_type) + .field("p_next", &self.p_next) + .field("ty", &self.ty) + .field("data", &"union") + .finish() + } +} +impl ::std::default::Default for DescriptorGetInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + ty: DescriptorType::default(), + data: DescriptorDataEXT::default(), + } + } +} +unsafe impl TaggedStructure for DescriptorGetInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::DESCRIPTOR_GET_INFO_EXT; +} +impl DescriptorGetInfoEXT { + pub fn builder<'a>() -> DescriptorGetInfoEXTBuilder<'a> { + DescriptorGetInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DescriptorGetInfoEXTBuilder<'a> { + inner: DescriptorGetInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DescriptorGetInfoEXTBuilder<'a> { + type Target = DescriptorGetInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DescriptorGetInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DescriptorGetInfoEXTBuilder<'a> { + #[inline] + pub fn ty(mut self, ty: DescriptorType) -> Self { + self.inner.ty = ty; + self + } + #[inline] + pub fn data(mut self, data: DescriptorDataEXT) -> Self { + self.inner.data = data; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DescriptorGetInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct BufferCaptureDescriptorDataInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub buffer: Buffer, +} +impl ::std::default::Default for BufferCaptureDescriptorDataInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + buffer: Buffer::default(), + } + } +} +unsafe impl TaggedStructure for BufferCaptureDescriptorDataInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::BUFFER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT; +} +impl BufferCaptureDescriptorDataInfoEXT { + pub fn builder<'a>() -> BufferCaptureDescriptorDataInfoEXTBuilder<'a> { + BufferCaptureDescriptorDataInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct BufferCaptureDescriptorDataInfoEXTBuilder<'a> { + inner: BufferCaptureDescriptorDataInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for BufferCaptureDescriptorDataInfoEXTBuilder<'a> { + type Target = BufferCaptureDescriptorDataInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for BufferCaptureDescriptorDataInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> BufferCaptureDescriptorDataInfoEXTBuilder<'a> { + #[inline] + pub fn buffer(mut self, buffer: Buffer) -> Self { + self.inner.buffer = buffer; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> BufferCaptureDescriptorDataInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ImageCaptureDescriptorDataInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub image: Image, +} +impl ::std::default::Default for ImageCaptureDescriptorDataInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + image: Image::default(), + } + } +} +unsafe impl TaggedStructure for ImageCaptureDescriptorDataInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT; +} +impl ImageCaptureDescriptorDataInfoEXT { + pub fn builder<'a>() -> ImageCaptureDescriptorDataInfoEXTBuilder<'a> { + ImageCaptureDescriptorDataInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ImageCaptureDescriptorDataInfoEXTBuilder<'a> { + inner: ImageCaptureDescriptorDataInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ImageCaptureDescriptorDataInfoEXTBuilder<'a> { + type Target = ImageCaptureDescriptorDataInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ImageCaptureDescriptorDataInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ImageCaptureDescriptorDataInfoEXTBuilder<'a> { + #[inline] + pub fn image(mut self, image: Image) -> Self { + self.inner.image = image; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ImageCaptureDescriptorDataInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ImageViewCaptureDescriptorDataInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub image_view: ImageView, +} +impl ::std::default::Default for ImageViewCaptureDescriptorDataInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + image_view: ImageView::default(), + } + } +} +unsafe impl TaggedStructure for ImageViewCaptureDescriptorDataInfoEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::IMAGE_VIEW_CAPTURE_DESCRIPTOR_DATA_INFO_EXT; +} +impl ImageViewCaptureDescriptorDataInfoEXT { + pub fn builder<'a>() -> ImageViewCaptureDescriptorDataInfoEXTBuilder<'a> { + ImageViewCaptureDescriptorDataInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ImageViewCaptureDescriptorDataInfoEXTBuilder<'a> { + inner: ImageViewCaptureDescriptorDataInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ImageViewCaptureDescriptorDataInfoEXTBuilder<'a> { + type Target = ImageViewCaptureDescriptorDataInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ImageViewCaptureDescriptorDataInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ImageViewCaptureDescriptorDataInfoEXTBuilder<'a> { + #[inline] + pub fn image_view(mut self, image_view: ImageView) -> Self { + self.inner.image_view = image_view; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ImageViewCaptureDescriptorDataInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SamplerCaptureDescriptorDataInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub sampler: Sampler, +} +impl ::std::default::Default for SamplerCaptureDescriptorDataInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + sampler: Sampler::default(), + } + } +} +unsafe impl TaggedStructure for SamplerCaptureDescriptorDataInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::SAMPLER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT; +} +impl SamplerCaptureDescriptorDataInfoEXT { + pub fn builder<'a>() -> SamplerCaptureDescriptorDataInfoEXTBuilder<'a> { + SamplerCaptureDescriptorDataInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SamplerCaptureDescriptorDataInfoEXTBuilder<'a> { + inner: SamplerCaptureDescriptorDataInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for SamplerCaptureDescriptorDataInfoEXTBuilder<'a> { + type Target = SamplerCaptureDescriptorDataInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SamplerCaptureDescriptorDataInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SamplerCaptureDescriptorDataInfoEXTBuilder<'a> { + #[inline] + pub fn sampler(mut self, sampler: Sampler) -> Self { + self.inner.sampler = sampler; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SamplerCaptureDescriptorDataInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct AccelerationStructureCaptureDescriptorDataInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub acceleration_structure: AccelerationStructureKHR, + pub acceleration_structure_nv: AccelerationStructureNV, +} +impl ::std::default::Default for AccelerationStructureCaptureDescriptorDataInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + acceleration_structure: AccelerationStructureKHR::default(), + acceleration_structure_nv: AccelerationStructureNV::default(), + } + } +} +unsafe impl TaggedStructure for AccelerationStructureCaptureDescriptorDataInfoEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::ACCELERATION_STRUCTURE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT; +} +impl AccelerationStructureCaptureDescriptorDataInfoEXT { + pub fn builder<'a>() -> AccelerationStructureCaptureDescriptorDataInfoEXTBuilder<'a> { + AccelerationStructureCaptureDescriptorDataInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct AccelerationStructureCaptureDescriptorDataInfoEXTBuilder<'a> { + inner: AccelerationStructureCaptureDescriptorDataInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for AccelerationStructureCaptureDescriptorDataInfoEXTBuilder<'a> { + type Target = AccelerationStructureCaptureDescriptorDataInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for AccelerationStructureCaptureDescriptorDataInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> AccelerationStructureCaptureDescriptorDataInfoEXTBuilder<'a> { + #[inline] + pub fn acceleration_structure( + mut self, + acceleration_structure: AccelerationStructureKHR, + ) -> Self { + self.inner.acceleration_structure = acceleration_structure; + self + } + #[inline] + pub fn acceleration_structure_nv( + mut self, + acceleration_structure_nv: AccelerationStructureNV, + ) -> Self { + self.inner.acceleration_structure_nv = acceleration_structure_nv; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> AccelerationStructureCaptureDescriptorDataInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct OpaqueCaptureDescriptorDataCreateInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub opaque_capture_descriptor_data: *const c_void, +} +impl ::std::default::Default for OpaqueCaptureDescriptorDataCreateInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + opaque_capture_descriptor_data: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for OpaqueCaptureDescriptorDataCreateInfoEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT; +} +impl OpaqueCaptureDescriptorDataCreateInfoEXT { + pub fn builder<'a>() -> OpaqueCaptureDescriptorDataCreateInfoEXTBuilder<'a> { + OpaqueCaptureDescriptorDataCreateInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct OpaqueCaptureDescriptorDataCreateInfoEXTBuilder<'a> { + inner: OpaqueCaptureDescriptorDataCreateInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsBufferCreateInfo for OpaqueCaptureDescriptorDataCreateInfoEXTBuilder<'_> {} +unsafe impl ExtendsBufferCreateInfo for OpaqueCaptureDescriptorDataCreateInfoEXT {} +unsafe impl ExtendsImageCreateInfo for OpaqueCaptureDescriptorDataCreateInfoEXTBuilder<'_> {} +unsafe impl ExtendsImageCreateInfo for OpaqueCaptureDescriptorDataCreateInfoEXT {} +unsafe impl ExtendsImageViewCreateInfo for OpaqueCaptureDescriptorDataCreateInfoEXTBuilder<'_> {} +unsafe impl ExtendsImageViewCreateInfo for OpaqueCaptureDescriptorDataCreateInfoEXT {} +unsafe impl ExtendsSamplerCreateInfo for OpaqueCaptureDescriptorDataCreateInfoEXTBuilder<'_> {} +unsafe impl ExtendsSamplerCreateInfo for OpaqueCaptureDescriptorDataCreateInfoEXT {} +unsafe impl ExtendsAccelerationStructureCreateInfoKHR + for OpaqueCaptureDescriptorDataCreateInfoEXTBuilder<'_> +{ +} +unsafe impl ExtendsAccelerationStructureCreateInfoKHR for OpaqueCaptureDescriptorDataCreateInfoEXT {} +unsafe impl ExtendsAccelerationStructureCreateInfoNV + for OpaqueCaptureDescriptorDataCreateInfoEXTBuilder<'_> +{ +} +unsafe impl ExtendsAccelerationStructureCreateInfoNV for OpaqueCaptureDescriptorDataCreateInfoEXT {} +impl<'a> ::std::ops::Deref for OpaqueCaptureDescriptorDataCreateInfoEXTBuilder<'a> { + type Target = OpaqueCaptureDescriptorDataCreateInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for OpaqueCaptureDescriptorDataCreateInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> OpaqueCaptureDescriptorDataCreateInfoEXTBuilder<'a> { + #[inline] + pub fn opaque_capture_descriptor_data( + mut self, + opaque_capture_descriptor_data: *const c_void, + ) -> Self { + self.inner.opaque_capture_descriptor_data = opaque_capture_descriptor_data; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> OpaqueCaptureDescriptorDataCreateInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceShaderIntegerDotProductFeatures { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub shader_integer_dot_product: Bool32, +} +impl ::std::default::Default for PhysicalDeviceShaderIntegerDotProductFeatures { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + shader_integer_dot_product: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceShaderIntegerDotProductFeatures { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES; +} +impl PhysicalDeviceShaderIntegerDotProductFeatures { + pub fn builder<'a>() -> PhysicalDeviceShaderIntegerDotProductFeaturesBuilder<'a> { + PhysicalDeviceShaderIntegerDotProductFeaturesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceShaderIntegerDotProductFeaturesBuilder<'a> { + inner: PhysicalDeviceShaderIntegerDotProductFeatures, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceShaderIntegerDotProductFeaturesBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderIntegerDotProductFeatures {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderIntegerDotProductFeaturesBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderIntegerDotProductFeatures {} +impl<'a> ::std::ops::Deref for PhysicalDeviceShaderIntegerDotProductFeaturesBuilder<'a> { + type Target = PhysicalDeviceShaderIntegerDotProductFeatures; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderIntegerDotProductFeaturesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceShaderIntegerDotProductFeaturesBuilder<'a> { + #[inline] + pub fn shader_integer_dot_product(mut self, shader_integer_dot_product: bool) -> Self { + self.inner.shader_integer_dot_product = shader_integer_dot_product.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceShaderIntegerDotProductFeatures { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceShaderIntegerDotProductProperties { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub integer_dot_product8_bit_unsigned_accelerated: Bool32, + pub integer_dot_product8_bit_signed_accelerated: Bool32, + pub integer_dot_product8_bit_mixed_signedness_accelerated: Bool32, + pub integer_dot_product4x8_bit_packed_unsigned_accelerated: Bool32, + pub integer_dot_product4x8_bit_packed_signed_accelerated: Bool32, + pub integer_dot_product4x8_bit_packed_mixed_signedness_accelerated: Bool32, + pub integer_dot_product16_bit_unsigned_accelerated: Bool32, + pub integer_dot_product16_bit_signed_accelerated: Bool32, + pub integer_dot_product16_bit_mixed_signedness_accelerated: Bool32, + pub integer_dot_product32_bit_unsigned_accelerated: Bool32, + pub integer_dot_product32_bit_signed_accelerated: Bool32, + pub integer_dot_product32_bit_mixed_signedness_accelerated: Bool32, + pub integer_dot_product64_bit_unsigned_accelerated: Bool32, + pub integer_dot_product64_bit_signed_accelerated: Bool32, + pub integer_dot_product64_bit_mixed_signedness_accelerated: Bool32, + pub integer_dot_product_accumulating_saturating8_bit_unsigned_accelerated: Bool32, + pub integer_dot_product_accumulating_saturating8_bit_signed_accelerated: Bool32, + pub integer_dot_product_accumulating_saturating8_bit_mixed_signedness_accelerated: Bool32, + pub integer_dot_product_accumulating_saturating4x8_bit_packed_unsigned_accelerated: Bool32, + pub integer_dot_product_accumulating_saturating4x8_bit_packed_signed_accelerated: Bool32, + pub integer_dot_product_accumulating_saturating4x8_bit_packed_mixed_signedness_accelerated: + Bool32, + pub integer_dot_product_accumulating_saturating16_bit_unsigned_accelerated: Bool32, + pub integer_dot_product_accumulating_saturating16_bit_signed_accelerated: Bool32, + pub integer_dot_product_accumulating_saturating16_bit_mixed_signedness_accelerated: Bool32, + pub integer_dot_product_accumulating_saturating32_bit_unsigned_accelerated: Bool32, + pub integer_dot_product_accumulating_saturating32_bit_signed_accelerated: Bool32, + pub integer_dot_product_accumulating_saturating32_bit_mixed_signedness_accelerated: Bool32, + pub integer_dot_product_accumulating_saturating64_bit_unsigned_accelerated: Bool32, + pub integer_dot_product_accumulating_saturating64_bit_signed_accelerated: Bool32, + pub integer_dot_product_accumulating_saturating64_bit_mixed_signedness_accelerated: Bool32, +} +impl ::std::default::Default for PhysicalDeviceShaderIntegerDotProductProperties { + #[inline] + fn default() -> Self { + Self { s_type : Self :: STRUCTURE_TYPE , p_next : :: std :: ptr :: null_mut () , integer_dot_product8_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product8_bit_signed_accelerated : Bool32 :: default () , integer_dot_product8_bit_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product4x8_bit_packed_unsigned_accelerated : Bool32 :: default () , integer_dot_product4x8_bit_packed_signed_accelerated : Bool32 :: default () , integer_dot_product4x8_bit_packed_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product16_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product16_bit_signed_accelerated : Bool32 :: default () , integer_dot_product16_bit_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product32_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product32_bit_signed_accelerated : Bool32 :: default () , integer_dot_product32_bit_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product64_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product64_bit_signed_accelerated : Bool32 :: default () , integer_dot_product64_bit_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating8_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating8_bit_signed_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating8_bit_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating4x8_bit_packed_unsigned_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating4x8_bit_packed_signed_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating4x8_bit_packed_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating16_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating16_bit_signed_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating16_bit_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating32_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating32_bit_signed_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating32_bit_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating64_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating64_bit_signed_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating64_bit_mixed_signedness_accelerated : Bool32 :: default () } + } +} +unsafe impl TaggedStructure for PhysicalDeviceShaderIntegerDotProductProperties { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES; +} +impl PhysicalDeviceShaderIntegerDotProductProperties { + pub fn builder<'a>() -> PhysicalDeviceShaderIntegerDotProductPropertiesBuilder<'a> { + PhysicalDeviceShaderIntegerDotProductPropertiesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceShaderIntegerDotProductPropertiesBuilder<'a> { + inner: PhysicalDeviceShaderIntegerDotProductProperties, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceShaderIntegerDotProductPropertiesBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceShaderIntegerDotProductProperties {} +impl<'a> ::std::ops::Deref for PhysicalDeviceShaderIntegerDotProductPropertiesBuilder<'a> { + type Target = PhysicalDeviceShaderIntegerDotProductProperties; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderIntegerDotProductPropertiesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceShaderIntegerDotProductPropertiesBuilder<'a> { + #[inline] + pub fn integer_dot_product8_bit_unsigned_accelerated( + mut self, + integer_dot_product8_bit_unsigned_accelerated: bool, + ) -> Self { + self.inner.integer_dot_product8_bit_unsigned_accelerated = + integer_dot_product8_bit_unsigned_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product8_bit_signed_accelerated( + mut self, + integer_dot_product8_bit_signed_accelerated: bool, + ) -> Self { + self.inner.integer_dot_product8_bit_signed_accelerated = + integer_dot_product8_bit_signed_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product8_bit_mixed_signedness_accelerated( + mut self, + integer_dot_product8_bit_mixed_signedness_accelerated: bool, + ) -> Self { + self.inner + .integer_dot_product8_bit_mixed_signedness_accelerated = + integer_dot_product8_bit_mixed_signedness_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product4x8_bit_packed_unsigned_accelerated( + mut self, + integer_dot_product4x8_bit_packed_unsigned_accelerated: bool, + ) -> Self { + self.inner + .integer_dot_product4x8_bit_packed_unsigned_accelerated = + integer_dot_product4x8_bit_packed_unsigned_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product4x8_bit_packed_signed_accelerated( + mut self, + integer_dot_product4x8_bit_packed_signed_accelerated: bool, + ) -> Self { + self.inner + .integer_dot_product4x8_bit_packed_signed_accelerated = + integer_dot_product4x8_bit_packed_signed_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product4x8_bit_packed_mixed_signedness_accelerated( + mut self, + integer_dot_product4x8_bit_packed_mixed_signedness_accelerated: bool, + ) -> Self { + self.inner + .integer_dot_product4x8_bit_packed_mixed_signedness_accelerated = + integer_dot_product4x8_bit_packed_mixed_signedness_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product16_bit_unsigned_accelerated( + mut self, + integer_dot_product16_bit_unsigned_accelerated: bool, + ) -> Self { + self.inner.integer_dot_product16_bit_unsigned_accelerated = + integer_dot_product16_bit_unsigned_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product16_bit_signed_accelerated( + mut self, + integer_dot_product16_bit_signed_accelerated: bool, + ) -> Self { + self.inner.integer_dot_product16_bit_signed_accelerated = + integer_dot_product16_bit_signed_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product16_bit_mixed_signedness_accelerated( + mut self, + integer_dot_product16_bit_mixed_signedness_accelerated: bool, + ) -> Self { + self.inner + .integer_dot_product16_bit_mixed_signedness_accelerated = + integer_dot_product16_bit_mixed_signedness_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product32_bit_unsigned_accelerated( + mut self, + integer_dot_product32_bit_unsigned_accelerated: bool, + ) -> Self { + self.inner.integer_dot_product32_bit_unsigned_accelerated = + integer_dot_product32_bit_unsigned_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product32_bit_signed_accelerated( + mut self, + integer_dot_product32_bit_signed_accelerated: bool, + ) -> Self { + self.inner.integer_dot_product32_bit_signed_accelerated = + integer_dot_product32_bit_signed_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product32_bit_mixed_signedness_accelerated( + mut self, + integer_dot_product32_bit_mixed_signedness_accelerated: bool, + ) -> Self { + self.inner + .integer_dot_product32_bit_mixed_signedness_accelerated = + integer_dot_product32_bit_mixed_signedness_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product64_bit_unsigned_accelerated( + mut self, + integer_dot_product64_bit_unsigned_accelerated: bool, + ) -> Self { + self.inner.integer_dot_product64_bit_unsigned_accelerated = + integer_dot_product64_bit_unsigned_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product64_bit_signed_accelerated( + mut self, + integer_dot_product64_bit_signed_accelerated: bool, + ) -> Self { + self.inner.integer_dot_product64_bit_signed_accelerated = + integer_dot_product64_bit_signed_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product64_bit_mixed_signedness_accelerated( + mut self, + integer_dot_product64_bit_mixed_signedness_accelerated: bool, + ) -> Self { + self.inner + .integer_dot_product64_bit_mixed_signedness_accelerated = + integer_dot_product64_bit_mixed_signedness_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product_accumulating_saturating8_bit_unsigned_accelerated( + mut self, + integer_dot_product_accumulating_saturating8_bit_unsigned_accelerated: bool, + ) -> Self { + self.inner + .integer_dot_product_accumulating_saturating8_bit_unsigned_accelerated = + integer_dot_product_accumulating_saturating8_bit_unsigned_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product_accumulating_saturating8_bit_signed_accelerated( + mut self, + integer_dot_product_accumulating_saturating8_bit_signed_accelerated: bool, + ) -> Self { + self.inner + .integer_dot_product_accumulating_saturating8_bit_signed_accelerated = + integer_dot_product_accumulating_saturating8_bit_signed_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product_accumulating_saturating8_bit_mixed_signedness_accelerated( + mut self, + integer_dot_product_accumulating_saturating8_bit_mixed_signedness_accelerated: bool, + ) -> Self { + self.inner + .integer_dot_product_accumulating_saturating8_bit_mixed_signedness_accelerated = + integer_dot_product_accumulating_saturating8_bit_mixed_signedness_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product_accumulating_saturating4x8_bit_packed_unsigned_accelerated( + mut self, + integer_dot_product_accumulating_saturating4x8_bit_packed_unsigned_accelerated: bool, + ) -> Self { + self.inner + .integer_dot_product_accumulating_saturating4x8_bit_packed_unsigned_accelerated = + integer_dot_product_accumulating_saturating4x8_bit_packed_unsigned_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product_accumulating_saturating4x8_bit_packed_signed_accelerated( + mut self, + integer_dot_product_accumulating_saturating4x8_bit_packed_signed_accelerated: bool, + ) -> Self { + self.inner + .integer_dot_product_accumulating_saturating4x8_bit_packed_signed_accelerated = + integer_dot_product_accumulating_saturating4x8_bit_packed_signed_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product_accumulating_saturating4x8_bit_packed_mixed_signedness_accelerated( + mut self, + integer_dot_product_accumulating_saturating4x8_bit_packed_mixed_signedness_accelerated : bool, + ) -> Self { + self . inner . integer_dot_product_accumulating_saturating4x8_bit_packed_mixed_signedness_accelerated = integer_dot_product_accumulating_saturating4x8_bit_packed_mixed_signedness_accelerated . into () ; + self + } + #[inline] + pub fn integer_dot_product_accumulating_saturating16_bit_unsigned_accelerated( + mut self, + integer_dot_product_accumulating_saturating16_bit_unsigned_accelerated: bool, + ) -> Self { + self.inner + .integer_dot_product_accumulating_saturating16_bit_unsigned_accelerated = + integer_dot_product_accumulating_saturating16_bit_unsigned_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product_accumulating_saturating16_bit_signed_accelerated( + mut self, + integer_dot_product_accumulating_saturating16_bit_signed_accelerated: bool, + ) -> Self { + self.inner + .integer_dot_product_accumulating_saturating16_bit_signed_accelerated = + integer_dot_product_accumulating_saturating16_bit_signed_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product_accumulating_saturating16_bit_mixed_signedness_accelerated( + mut self, + integer_dot_product_accumulating_saturating16_bit_mixed_signedness_accelerated: bool, + ) -> Self { + self.inner + .integer_dot_product_accumulating_saturating16_bit_mixed_signedness_accelerated = + integer_dot_product_accumulating_saturating16_bit_mixed_signedness_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product_accumulating_saturating32_bit_unsigned_accelerated( + mut self, + integer_dot_product_accumulating_saturating32_bit_unsigned_accelerated: bool, + ) -> Self { + self.inner + .integer_dot_product_accumulating_saturating32_bit_unsigned_accelerated = + integer_dot_product_accumulating_saturating32_bit_unsigned_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product_accumulating_saturating32_bit_signed_accelerated( + mut self, + integer_dot_product_accumulating_saturating32_bit_signed_accelerated: bool, + ) -> Self { + self.inner + .integer_dot_product_accumulating_saturating32_bit_signed_accelerated = + integer_dot_product_accumulating_saturating32_bit_signed_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product_accumulating_saturating32_bit_mixed_signedness_accelerated( + mut self, + integer_dot_product_accumulating_saturating32_bit_mixed_signedness_accelerated: bool, + ) -> Self { + self.inner + .integer_dot_product_accumulating_saturating32_bit_mixed_signedness_accelerated = + integer_dot_product_accumulating_saturating32_bit_mixed_signedness_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product_accumulating_saturating64_bit_unsigned_accelerated( + mut self, + integer_dot_product_accumulating_saturating64_bit_unsigned_accelerated: bool, + ) -> Self { + self.inner + .integer_dot_product_accumulating_saturating64_bit_unsigned_accelerated = + integer_dot_product_accumulating_saturating64_bit_unsigned_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product_accumulating_saturating64_bit_signed_accelerated( + mut self, + integer_dot_product_accumulating_saturating64_bit_signed_accelerated: bool, + ) -> Self { + self.inner + .integer_dot_product_accumulating_saturating64_bit_signed_accelerated = + integer_dot_product_accumulating_saturating64_bit_signed_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product_accumulating_saturating64_bit_mixed_signedness_accelerated( + mut self, + integer_dot_product_accumulating_saturating64_bit_mixed_signedness_accelerated: bool, + ) -> Self { + self.inner + .integer_dot_product_accumulating_saturating64_bit_mixed_signedness_accelerated = + integer_dot_product_accumulating_saturating64_bit_mixed_signedness_accelerated.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceShaderIntegerDotProductProperties { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceDrmPropertiesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub has_primary: Bool32, + pub has_render: Bool32, + pub primary_major: i64, + pub primary_minor: i64, + pub render_major: i64, + pub render_minor: i64, +} +impl ::std::default::Default for PhysicalDeviceDrmPropertiesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + has_primary: Bool32::default(), + has_render: Bool32::default(), + primary_major: i64::default(), + primary_minor: i64::default(), + render_major: i64::default(), + render_minor: i64::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceDrmPropertiesEXT { + const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_DRM_PROPERTIES_EXT; +} +impl PhysicalDeviceDrmPropertiesEXT { + pub fn builder<'a>() -> PhysicalDeviceDrmPropertiesEXTBuilder<'a> { + PhysicalDeviceDrmPropertiesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceDrmPropertiesEXTBuilder<'a> { + inner: PhysicalDeviceDrmPropertiesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceDrmPropertiesEXTBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceDrmPropertiesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceDrmPropertiesEXTBuilder<'a> { + type Target = PhysicalDeviceDrmPropertiesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceDrmPropertiesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceDrmPropertiesEXTBuilder<'a> { + #[inline] + pub fn has_primary(mut self, has_primary: bool) -> Self { + self.inner.has_primary = has_primary.into(); + self + } + #[inline] + pub fn has_render(mut self, has_render: bool) -> Self { + self.inner.has_render = has_render.into(); + self + } + #[inline] + pub fn primary_major(mut self, primary_major: i64) -> Self { + self.inner.primary_major = primary_major; + self + } + #[inline] + pub fn primary_minor(mut self, primary_minor: i64) -> Self { + self.inner.primary_minor = primary_minor; + self + } + #[inline] + pub fn render_major(mut self, render_major: i64) -> Self { + self.inner.render_major = render_major; + self + } + #[inline] + pub fn render_minor(mut self, render_minor: i64) -> Self { + self.inner.render_minor = render_minor; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceDrmPropertiesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceFragmentShaderBarycentricFeaturesKHR { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub fragment_shader_barycentric: Bool32, +} +impl ::std::default::Default for PhysicalDeviceFragmentShaderBarycentricFeaturesKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + fragment_shader_barycentric: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceFragmentShaderBarycentricFeaturesKHR { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR; +} +impl PhysicalDeviceFragmentShaderBarycentricFeaturesKHR { + pub fn builder<'a>() -> PhysicalDeviceFragmentShaderBarycentricFeaturesKHRBuilder<'a> { + PhysicalDeviceFragmentShaderBarycentricFeaturesKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceFragmentShaderBarycentricFeaturesKHRBuilder<'a> { + inner: PhysicalDeviceFragmentShaderBarycentricFeaturesKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceFragmentShaderBarycentricFeaturesKHRBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceFragmentShaderBarycentricFeaturesKHR {} +unsafe impl ExtendsDeviceCreateInfo + for PhysicalDeviceFragmentShaderBarycentricFeaturesKHRBuilder<'_> +{ +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFragmentShaderBarycentricFeaturesKHR {} +impl<'a> ::std::ops::Deref for PhysicalDeviceFragmentShaderBarycentricFeaturesKHRBuilder<'a> { + type Target = PhysicalDeviceFragmentShaderBarycentricFeaturesKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceFragmentShaderBarycentricFeaturesKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceFragmentShaderBarycentricFeaturesKHRBuilder<'a> { + #[inline] + pub fn fragment_shader_barycentric(mut self, fragment_shader_barycentric: bool) -> Self { + self.inner.fragment_shader_barycentric = fragment_shader_barycentric.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceFragmentShaderBarycentricFeaturesKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceFragmentShaderBarycentricPropertiesKHR { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub tri_strip_vertex_order_independent_of_provoking_vertex: Bool32, +} +impl ::std::default::Default for PhysicalDeviceFragmentShaderBarycentricPropertiesKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + tri_strip_vertex_order_independent_of_provoking_vertex: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceFragmentShaderBarycentricPropertiesKHR { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR; +} +impl PhysicalDeviceFragmentShaderBarycentricPropertiesKHR { + pub fn builder<'a>() -> PhysicalDeviceFragmentShaderBarycentricPropertiesKHRBuilder<'a> { + PhysicalDeviceFragmentShaderBarycentricPropertiesKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceFragmentShaderBarycentricPropertiesKHRBuilder<'a> { + inner: PhysicalDeviceFragmentShaderBarycentricPropertiesKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceFragmentShaderBarycentricPropertiesKHRBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceFragmentShaderBarycentricPropertiesKHR +{ +} +impl<'a> ::std::ops::Deref for PhysicalDeviceFragmentShaderBarycentricPropertiesKHRBuilder<'a> { + type Target = PhysicalDeviceFragmentShaderBarycentricPropertiesKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceFragmentShaderBarycentricPropertiesKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceFragmentShaderBarycentricPropertiesKHRBuilder<'a> { + #[inline] + pub fn tri_strip_vertex_order_independent_of_provoking_vertex( + mut self, + tri_strip_vertex_order_independent_of_provoking_vertex: bool, + ) -> Self { + self.inner + .tri_strip_vertex_order_independent_of_provoking_vertex = + tri_strip_vertex_order_independent_of_provoking_vertex.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceFragmentShaderBarycentricPropertiesKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceRayTracingMotionBlurFeaturesNV { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub ray_tracing_motion_blur: Bool32, + pub ray_tracing_motion_blur_pipeline_trace_rays_indirect: Bool32, +} +impl ::std::default::Default for PhysicalDeviceRayTracingMotionBlurFeaturesNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + ray_tracing_motion_blur: Bool32::default(), + ray_tracing_motion_blur_pipeline_trace_rays_indirect: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceRayTracingMotionBlurFeaturesNV { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV; +} +impl PhysicalDeviceRayTracingMotionBlurFeaturesNV { + pub fn builder<'a>() -> PhysicalDeviceRayTracingMotionBlurFeaturesNVBuilder<'a> { + PhysicalDeviceRayTracingMotionBlurFeaturesNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceRayTracingMotionBlurFeaturesNVBuilder<'a> { + inner: PhysicalDeviceRayTracingMotionBlurFeaturesNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceRayTracingMotionBlurFeaturesNVBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceRayTracingMotionBlurFeaturesNV {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceRayTracingMotionBlurFeaturesNVBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceRayTracingMotionBlurFeaturesNV {} +impl<'a> ::std::ops::Deref for PhysicalDeviceRayTracingMotionBlurFeaturesNVBuilder<'a> { + type Target = PhysicalDeviceRayTracingMotionBlurFeaturesNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceRayTracingMotionBlurFeaturesNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceRayTracingMotionBlurFeaturesNVBuilder<'a> { + #[inline] + pub fn ray_tracing_motion_blur(mut self, ray_tracing_motion_blur: bool) -> Self { + self.inner.ray_tracing_motion_blur = ray_tracing_motion_blur.into(); + self + } + #[inline] + pub fn ray_tracing_motion_blur_pipeline_trace_rays_indirect( + mut self, + ray_tracing_motion_blur_pipeline_trace_rays_indirect: bool, + ) -> Self { + self.inner + .ray_tracing_motion_blur_pipeline_trace_rays_indirect = + ray_tracing_motion_blur_pipeline_trace_rays_indirect.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceRayTracingMotionBlurFeaturesNV { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct AccelerationStructureGeometryMotionTrianglesDataNV { + pub s_type: StructureType, + pub p_next: *const c_void, + pub vertex_data: DeviceOrHostAddressConstKHR, +} +#[cfg(feature = "debug")] +impl fmt::Debug for AccelerationStructureGeometryMotionTrianglesDataNV { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fmt.debug_struct("AccelerationStructureGeometryMotionTrianglesDataNV") + .field("s_type", &self.s_type) + .field("p_next", &self.p_next) + .field("vertex_data", &"union") + .finish() + } +} +impl ::std::default::Default for AccelerationStructureGeometryMotionTrianglesDataNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + vertex_data: DeviceOrHostAddressConstKHR::default(), + } + } +} +unsafe impl TaggedStructure for AccelerationStructureGeometryMotionTrianglesDataNV { + const STRUCTURE_TYPE: StructureType = + StructureType::ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV; +} +impl AccelerationStructureGeometryMotionTrianglesDataNV { + pub fn builder<'a>() -> AccelerationStructureGeometryMotionTrianglesDataNVBuilder<'a> { + AccelerationStructureGeometryMotionTrianglesDataNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct AccelerationStructureGeometryMotionTrianglesDataNVBuilder<'a> { + inner: AccelerationStructureGeometryMotionTrianglesDataNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsAccelerationStructureGeometryTrianglesDataKHR + for AccelerationStructureGeometryMotionTrianglesDataNVBuilder<'_> +{ +} +unsafe impl ExtendsAccelerationStructureGeometryTrianglesDataKHR + for AccelerationStructureGeometryMotionTrianglesDataNV +{ +} +impl<'a> ::std::ops::Deref for AccelerationStructureGeometryMotionTrianglesDataNVBuilder<'a> { + type Target = AccelerationStructureGeometryMotionTrianglesDataNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for AccelerationStructureGeometryMotionTrianglesDataNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> AccelerationStructureGeometryMotionTrianglesDataNVBuilder<'a> { + #[inline] + pub fn vertex_data(mut self, vertex_data: DeviceOrHostAddressConstKHR) -> Self { + self.inner.vertex_data = vertex_data; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> AccelerationStructureGeometryMotionTrianglesDataNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct AccelerationStructureMotionInfoNV { + pub s_type: StructureType, + pub p_next: *const c_void, + pub max_instances: u32, + pub flags: AccelerationStructureMotionInfoFlagsNV, +} +impl ::std::default::Default for AccelerationStructureMotionInfoNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + max_instances: u32::default(), + flags: AccelerationStructureMotionInfoFlagsNV::default(), + } + } +} +unsafe impl TaggedStructure for AccelerationStructureMotionInfoNV { + const STRUCTURE_TYPE: StructureType = StructureType::ACCELERATION_STRUCTURE_MOTION_INFO_NV; +} +impl AccelerationStructureMotionInfoNV { + pub fn builder<'a>() -> AccelerationStructureMotionInfoNVBuilder<'a> { + AccelerationStructureMotionInfoNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct AccelerationStructureMotionInfoNVBuilder<'a> { + inner: AccelerationStructureMotionInfoNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsAccelerationStructureCreateInfoKHR + for AccelerationStructureMotionInfoNVBuilder<'_> +{ +} +unsafe impl ExtendsAccelerationStructureCreateInfoKHR for AccelerationStructureMotionInfoNV {} +impl<'a> ::std::ops::Deref for AccelerationStructureMotionInfoNVBuilder<'a> { + type Target = AccelerationStructureMotionInfoNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for AccelerationStructureMotionInfoNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> AccelerationStructureMotionInfoNVBuilder<'a> { + #[inline] + pub fn max_instances(mut self, max_instances: u32) -> Self { + self.inner.max_instances = max_instances; + self + } + #[inline] + pub fn flags(mut self, flags: AccelerationStructureMotionInfoFlagsNV) -> Self { + self.inner.flags = flags; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> AccelerationStructureMotionInfoNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct SRTDataNV { + pub sx: f32, + pub a: f32, + pub b: f32, + pub pvx: f32, + pub sy: f32, + pub c: f32, + pub pvy: f32, + pub sz: f32, + pub pvz: f32, + pub qx: f32, + pub qy: f32, + pub qz: f32, + pub qw: f32, + pub tx: f32, + pub ty: f32, + pub tz: f32, +} +impl SRTDataNV { + pub fn builder<'a>() -> SRTDataNVBuilder<'a> { + SRTDataNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SRTDataNVBuilder<'a> { + inner: SRTDataNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for SRTDataNVBuilder<'a> { + type Target = SRTDataNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SRTDataNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SRTDataNVBuilder<'a> { + #[inline] + pub fn sx(mut self, sx: f32) -> Self { + self.inner.sx = sx; + self + } + #[inline] + pub fn a(mut self, a: f32) -> Self { + self.inner.a = a; + self + } + #[inline] + pub fn b(mut self, b: f32) -> Self { + self.inner.b = b; + self + } + #[inline] + pub fn pvx(mut self, pvx: f32) -> Self { + self.inner.pvx = pvx; + self + } + #[inline] + pub fn sy(mut self, sy: f32) -> Self { + self.inner.sy = sy; + self + } + #[inline] + pub fn c(mut self, c: f32) -> Self { + self.inner.c = c; + self + } + #[inline] + pub fn pvy(mut self, pvy: f32) -> Self { + self.inner.pvy = pvy; + self + } + #[inline] + pub fn sz(mut self, sz: f32) -> Self { + self.inner.sz = sz; + self + } + #[inline] + pub fn pvz(mut self, pvz: f32) -> Self { + self.inner.pvz = pvz; + self + } + #[inline] + pub fn qx(mut self, qx: f32) -> Self { + self.inner.qx = qx; + self + } + #[inline] + pub fn qy(mut self, qy: f32) -> Self { + self.inner.qy = qy; + self + } + #[inline] + pub fn qz(mut self, qz: f32) -> Self { + self.inner.qz = qz; + self + } + #[inline] + pub fn qw(mut self, qw: f32) -> Self { + self.inner.qw = qw; + self + } + #[inline] + pub fn tx(mut self, tx: f32) -> Self { + self.inner.tx = tx; + self + } + #[inline] + pub fn ty(mut self, ty: f32) -> Self { + self.inner.ty = ty; + self + } + #[inline] + pub fn tz(mut self, tz: f32) -> Self { + self.inner.tz = tz; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SRTDataNV { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct AccelerationStructureSRTMotionInstanceNV { + pub transform_t0: SRTDataNV, + pub transform_t1: SRTDataNV, + #[doc = r" Use [`Packed24_8::new(instance_custom_index, mask)`][Packed24_8::new()] to construct this field"] + pub instance_custom_index_and_mask: Packed24_8, + #[doc = r" Use [`Packed24_8::new(instance_shader_binding_table_record_offset, flags)`][Packed24_8::new()] to construct this field"] + pub instance_shader_binding_table_record_offset_and_flags: Packed24_8, + pub acceleration_structure_reference: AccelerationStructureReferenceKHR, +} +#[repr(C)] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct AccelerationStructureMatrixMotionInstanceNV { + pub transform_t0: TransformMatrixKHR, + pub transform_t1: TransformMatrixKHR, + #[doc = r" Use [`Packed24_8::new(instance_custom_index, mask)`][Packed24_8::new()] to construct this field"] + pub instance_custom_index_and_mask: Packed24_8, + #[doc = r" Use [`Packed24_8::new(instance_shader_binding_table_record_offset, flags)`][Packed24_8::new()] to construct this field"] + pub instance_shader_binding_table_record_offset_and_flags: Packed24_8, + pub acceleration_structure_reference: AccelerationStructureReferenceKHR, +} +#[repr(C)] +#[derive(Copy, Clone)] +#[doc = ""] +pub union AccelerationStructureMotionInstanceDataNV { + pub static_instance: AccelerationStructureInstanceKHR, + pub matrix_motion_instance: AccelerationStructureMatrixMotionInstanceNV, + pub srt_motion_instance: AccelerationStructureSRTMotionInstanceNV, +} +impl ::std::default::Default for AccelerationStructureMotionInstanceDataNV { + #[inline] + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } +} +#[repr(C)] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct AccelerationStructureMotionInstanceNV { + pub ty: AccelerationStructureMotionInstanceTypeNV, + pub flags: AccelerationStructureMotionInstanceFlagsNV, + pub data: AccelerationStructureMotionInstanceDataNV, +} +#[cfg(feature = "debug")] +impl fmt::Debug for AccelerationStructureMotionInstanceNV { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fmt.debug_struct("AccelerationStructureMotionInstanceNV") + .field("ty", &self.ty) + .field("flags", &self.flags) + .field("data", &"union") + .finish() + } +} +impl AccelerationStructureMotionInstanceNV { + pub fn builder<'a>() -> AccelerationStructureMotionInstanceNVBuilder<'a> { + AccelerationStructureMotionInstanceNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct AccelerationStructureMotionInstanceNVBuilder<'a> { + inner: AccelerationStructureMotionInstanceNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for AccelerationStructureMotionInstanceNVBuilder<'a> { + type Target = AccelerationStructureMotionInstanceNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for AccelerationStructureMotionInstanceNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> AccelerationStructureMotionInstanceNVBuilder<'a> { + #[inline] + pub fn ty(mut self, ty: AccelerationStructureMotionInstanceTypeNV) -> Self { + self.inner.ty = ty; + self + } + #[inline] + pub fn flags(mut self, flags: AccelerationStructureMotionInstanceFlagsNV) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn data(mut self, data: AccelerationStructureMotionInstanceDataNV) -> Self { + self.inner.data = data; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> AccelerationStructureMotionInstanceNV { + self.inner + } +} +#[doc = ""] +pub type RemoteAddressNV = c_void; +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct MemoryGetRemoteAddressInfoNV { + pub s_type: StructureType, + pub p_next: *const c_void, + pub memory: DeviceMemory, + pub handle_type: ExternalMemoryHandleTypeFlags, +} +impl ::std::default::Default for MemoryGetRemoteAddressInfoNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + memory: DeviceMemory::default(), + handle_type: ExternalMemoryHandleTypeFlags::default(), + } + } +} +unsafe impl TaggedStructure for MemoryGetRemoteAddressInfoNV { + const STRUCTURE_TYPE: StructureType = StructureType::MEMORY_GET_REMOTE_ADDRESS_INFO_NV; +} +impl MemoryGetRemoteAddressInfoNV { + pub fn builder<'a>() -> MemoryGetRemoteAddressInfoNVBuilder<'a> { + MemoryGetRemoteAddressInfoNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct MemoryGetRemoteAddressInfoNVBuilder<'a> { + inner: MemoryGetRemoteAddressInfoNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for MemoryGetRemoteAddressInfoNVBuilder<'a> { + type Target = MemoryGetRemoteAddressInfoNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for MemoryGetRemoteAddressInfoNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> MemoryGetRemoteAddressInfoNVBuilder<'a> { + #[inline] + pub fn memory(mut self, memory: DeviceMemory) -> Self { + self.inner.memory = memory; + self + } + #[inline] + pub fn handle_type(mut self, handle_type: ExternalMemoryHandleTypeFlags) -> Self { + self.inner.handle_type = handle_type; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> MemoryGetRemoteAddressInfoNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ImportMemoryBufferCollectionFUCHSIA { + pub s_type: StructureType, + pub p_next: *const c_void, + pub collection: BufferCollectionFUCHSIA, + pub index: u32, +} +impl ::std::default::Default for ImportMemoryBufferCollectionFUCHSIA { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + collection: BufferCollectionFUCHSIA::default(), + index: u32::default(), + } + } +} +unsafe impl TaggedStructure for ImportMemoryBufferCollectionFUCHSIA { + const STRUCTURE_TYPE: StructureType = StructureType::IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA; +} +impl ImportMemoryBufferCollectionFUCHSIA { + pub fn builder<'a>() -> ImportMemoryBufferCollectionFUCHSIABuilder<'a> { + ImportMemoryBufferCollectionFUCHSIABuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ImportMemoryBufferCollectionFUCHSIABuilder<'a> { + inner: ImportMemoryBufferCollectionFUCHSIA, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsMemoryAllocateInfo for ImportMemoryBufferCollectionFUCHSIABuilder<'_> {} +unsafe impl ExtendsMemoryAllocateInfo for ImportMemoryBufferCollectionFUCHSIA {} +impl<'a> ::std::ops::Deref for ImportMemoryBufferCollectionFUCHSIABuilder<'a> { + type Target = ImportMemoryBufferCollectionFUCHSIA; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ImportMemoryBufferCollectionFUCHSIABuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ImportMemoryBufferCollectionFUCHSIABuilder<'a> { + #[inline] + pub fn collection(mut self, collection: BufferCollectionFUCHSIA) -> Self { + self.inner.collection = collection; + self + } + #[inline] + pub fn index(mut self, index: u32) -> Self { + self.inner.index = index; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ImportMemoryBufferCollectionFUCHSIA { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct BufferCollectionImageCreateInfoFUCHSIA { + pub s_type: StructureType, + pub p_next: *const c_void, + pub collection: BufferCollectionFUCHSIA, + pub index: u32, +} +impl ::std::default::Default for BufferCollectionImageCreateInfoFUCHSIA { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + collection: BufferCollectionFUCHSIA::default(), + index: u32::default(), + } + } +} +unsafe impl TaggedStructure for BufferCollectionImageCreateInfoFUCHSIA { + const STRUCTURE_TYPE: StructureType = + StructureType::BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA; +} +impl BufferCollectionImageCreateInfoFUCHSIA { + pub fn builder<'a>() -> BufferCollectionImageCreateInfoFUCHSIABuilder<'a> { + BufferCollectionImageCreateInfoFUCHSIABuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct BufferCollectionImageCreateInfoFUCHSIABuilder<'a> { + inner: BufferCollectionImageCreateInfoFUCHSIA, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsImageCreateInfo for BufferCollectionImageCreateInfoFUCHSIABuilder<'_> {} +unsafe impl ExtendsImageCreateInfo for BufferCollectionImageCreateInfoFUCHSIA {} +impl<'a> ::std::ops::Deref for BufferCollectionImageCreateInfoFUCHSIABuilder<'a> { + type Target = BufferCollectionImageCreateInfoFUCHSIA; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for BufferCollectionImageCreateInfoFUCHSIABuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> BufferCollectionImageCreateInfoFUCHSIABuilder<'a> { + #[inline] + pub fn collection(mut self, collection: BufferCollectionFUCHSIA) -> Self { + self.inner.collection = collection; + self + } + #[inline] + pub fn index(mut self, index: u32) -> Self { + self.inner.index = index; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> BufferCollectionImageCreateInfoFUCHSIA { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct BufferCollectionBufferCreateInfoFUCHSIA { + pub s_type: StructureType, + pub p_next: *const c_void, + pub collection: BufferCollectionFUCHSIA, + pub index: u32, +} +impl ::std::default::Default for BufferCollectionBufferCreateInfoFUCHSIA { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + collection: BufferCollectionFUCHSIA::default(), + index: u32::default(), + } + } +} +unsafe impl TaggedStructure for BufferCollectionBufferCreateInfoFUCHSIA { + const STRUCTURE_TYPE: StructureType = + StructureType::BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA; +} +impl BufferCollectionBufferCreateInfoFUCHSIA { + pub fn builder<'a>() -> BufferCollectionBufferCreateInfoFUCHSIABuilder<'a> { + BufferCollectionBufferCreateInfoFUCHSIABuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct BufferCollectionBufferCreateInfoFUCHSIABuilder<'a> { + inner: BufferCollectionBufferCreateInfoFUCHSIA, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsBufferCreateInfo for BufferCollectionBufferCreateInfoFUCHSIABuilder<'_> {} +unsafe impl ExtendsBufferCreateInfo for BufferCollectionBufferCreateInfoFUCHSIA {} +impl<'a> ::std::ops::Deref for BufferCollectionBufferCreateInfoFUCHSIABuilder<'a> { + type Target = BufferCollectionBufferCreateInfoFUCHSIA; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for BufferCollectionBufferCreateInfoFUCHSIABuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> BufferCollectionBufferCreateInfoFUCHSIABuilder<'a> { + #[inline] + pub fn collection(mut self, collection: BufferCollectionFUCHSIA) -> Self { + self.inner.collection = collection; + self + } + #[inline] + pub fn index(mut self, index: u32) -> Self { + self.inner.index = index; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> BufferCollectionBufferCreateInfoFUCHSIA { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct BufferCollectionCreateInfoFUCHSIA { + pub s_type: StructureType, + pub p_next: *const c_void, + pub collection_token: zx_handle_t, +} +impl ::std::default::Default for BufferCollectionCreateInfoFUCHSIA { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + collection_token: zx_handle_t::default(), + } + } +} +unsafe impl TaggedStructure for BufferCollectionCreateInfoFUCHSIA { + const STRUCTURE_TYPE: StructureType = StructureType::BUFFER_COLLECTION_CREATE_INFO_FUCHSIA; +} +impl BufferCollectionCreateInfoFUCHSIA { + pub fn builder<'a>() -> BufferCollectionCreateInfoFUCHSIABuilder<'a> { + BufferCollectionCreateInfoFUCHSIABuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct BufferCollectionCreateInfoFUCHSIABuilder<'a> { + inner: BufferCollectionCreateInfoFUCHSIA, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for BufferCollectionCreateInfoFUCHSIABuilder<'a> { + type Target = BufferCollectionCreateInfoFUCHSIA; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for BufferCollectionCreateInfoFUCHSIABuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> BufferCollectionCreateInfoFUCHSIABuilder<'a> { + #[inline] + pub fn collection_token(mut self, collection_token: zx_handle_t) -> Self { + self.inner.collection_token = collection_token; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> BufferCollectionCreateInfoFUCHSIA { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct BufferCollectionPropertiesFUCHSIA { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub memory_type_bits: u32, + pub buffer_count: u32, + pub create_info_index: u32, + pub sysmem_pixel_format: u64, + pub format_features: FormatFeatureFlags, + pub sysmem_color_space_index: SysmemColorSpaceFUCHSIA, + pub sampler_ycbcr_conversion_components: ComponentMapping, + pub suggested_ycbcr_model: SamplerYcbcrModelConversion, + pub suggested_ycbcr_range: SamplerYcbcrRange, + pub suggested_x_chroma_offset: ChromaLocation, + pub suggested_y_chroma_offset: ChromaLocation, +} +impl ::std::default::Default for BufferCollectionPropertiesFUCHSIA { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + memory_type_bits: u32::default(), + buffer_count: u32::default(), + create_info_index: u32::default(), + sysmem_pixel_format: u64::default(), + format_features: FormatFeatureFlags::default(), + sysmem_color_space_index: SysmemColorSpaceFUCHSIA::default(), + sampler_ycbcr_conversion_components: ComponentMapping::default(), + suggested_ycbcr_model: SamplerYcbcrModelConversion::default(), + suggested_ycbcr_range: SamplerYcbcrRange::default(), + suggested_x_chroma_offset: ChromaLocation::default(), + suggested_y_chroma_offset: ChromaLocation::default(), + } + } +} +unsafe impl TaggedStructure for BufferCollectionPropertiesFUCHSIA { + const STRUCTURE_TYPE: StructureType = StructureType::BUFFER_COLLECTION_PROPERTIES_FUCHSIA; +} +impl BufferCollectionPropertiesFUCHSIA { + pub fn builder<'a>() -> BufferCollectionPropertiesFUCHSIABuilder<'a> { + BufferCollectionPropertiesFUCHSIABuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct BufferCollectionPropertiesFUCHSIABuilder<'a> { + inner: BufferCollectionPropertiesFUCHSIA, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for BufferCollectionPropertiesFUCHSIABuilder<'a> { + type Target = BufferCollectionPropertiesFUCHSIA; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for BufferCollectionPropertiesFUCHSIABuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> BufferCollectionPropertiesFUCHSIABuilder<'a> { + #[inline] + pub fn memory_type_bits(mut self, memory_type_bits: u32) -> Self { + self.inner.memory_type_bits = memory_type_bits; + self + } + #[inline] + pub fn buffer_count(mut self, buffer_count: u32) -> Self { + self.inner.buffer_count = buffer_count; + self + } + #[inline] + pub fn create_info_index(mut self, create_info_index: u32) -> Self { + self.inner.create_info_index = create_info_index; + self + } + #[inline] + pub fn sysmem_pixel_format(mut self, sysmem_pixel_format: u64) -> Self { + self.inner.sysmem_pixel_format = sysmem_pixel_format; + self + } + #[inline] + pub fn format_features(mut self, format_features: FormatFeatureFlags) -> Self { + self.inner.format_features = format_features; + self + } + #[inline] + pub fn sysmem_color_space_index( + mut self, + sysmem_color_space_index: SysmemColorSpaceFUCHSIA, + ) -> Self { + self.inner.sysmem_color_space_index = sysmem_color_space_index; + self + } + #[inline] + pub fn sampler_ycbcr_conversion_components( + mut self, + sampler_ycbcr_conversion_components: ComponentMapping, + ) -> Self { + self.inner.sampler_ycbcr_conversion_components = sampler_ycbcr_conversion_components; + self + } + #[inline] + pub fn suggested_ycbcr_model( + mut self, + suggested_ycbcr_model: SamplerYcbcrModelConversion, + ) -> Self { + self.inner.suggested_ycbcr_model = suggested_ycbcr_model; + self + } + #[inline] + pub fn suggested_ycbcr_range(mut self, suggested_ycbcr_range: SamplerYcbcrRange) -> Self { + self.inner.suggested_ycbcr_range = suggested_ycbcr_range; + self + } + #[inline] + pub fn suggested_x_chroma_offset(mut self, suggested_x_chroma_offset: ChromaLocation) -> Self { + self.inner.suggested_x_chroma_offset = suggested_x_chroma_offset; + self + } + #[inline] + pub fn suggested_y_chroma_offset(mut self, suggested_y_chroma_offset: ChromaLocation) -> Self { + self.inner.suggested_y_chroma_offset = suggested_y_chroma_offset; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> BufferCollectionPropertiesFUCHSIA { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct BufferConstraintsInfoFUCHSIA { + pub s_type: StructureType, + pub p_next: *const c_void, + pub create_info: BufferCreateInfo, + pub required_format_features: FormatFeatureFlags, + pub buffer_collection_constraints: BufferCollectionConstraintsInfoFUCHSIA, +} +impl ::std::default::Default for BufferConstraintsInfoFUCHSIA { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + create_info: BufferCreateInfo::default(), + required_format_features: FormatFeatureFlags::default(), + buffer_collection_constraints: BufferCollectionConstraintsInfoFUCHSIA::default(), + } + } +} +unsafe impl TaggedStructure for BufferConstraintsInfoFUCHSIA { + const STRUCTURE_TYPE: StructureType = StructureType::BUFFER_CONSTRAINTS_INFO_FUCHSIA; +} +impl BufferConstraintsInfoFUCHSIA { + pub fn builder<'a>() -> BufferConstraintsInfoFUCHSIABuilder<'a> { + BufferConstraintsInfoFUCHSIABuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct BufferConstraintsInfoFUCHSIABuilder<'a> { + inner: BufferConstraintsInfoFUCHSIA, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for BufferConstraintsInfoFUCHSIABuilder<'a> { + type Target = BufferConstraintsInfoFUCHSIA; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for BufferConstraintsInfoFUCHSIABuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> BufferConstraintsInfoFUCHSIABuilder<'a> { + #[inline] + pub fn create_info(mut self, create_info: BufferCreateInfo) -> Self { + self.inner.create_info = create_info; + self + } + #[inline] + pub fn required_format_features( + mut self, + required_format_features: FormatFeatureFlags, + ) -> Self { + self.inner.required_format_features = required_format_features; + self + } + #[inline] + pub fn buffer_collection_constraints( + mut self, + buffer_collection_constraints: BufferCollectionConstraintsInfoFUCHSIA, + ) -> Self { + self.inner.buffer_collection_constraints = buffer_collection_constraints; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> BufferConstraintsInfoFUCHSIA { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SysmemColorSpaceFUCHSIA { + pub s_type: StructureType, + pub p_next: *const c_void, + pub color_space: u32, +} +impl ::std::default::Default for SysmemColorSpaceFUCHSIA { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + color_space: u32::default(), + } + } +} +unsafe impl TaggedStructure for SysmemColorSpaceFUCHSIA { + const STRUCTURE_TYPE: StructureType = StructureType::SYSMEM_COLOR_SPACE_FUCHSIA; +} +impl SysmemColorSpaceFUCHSIA { + pub fn builder<'a>() -> SysmemColorSpaceFUCHSIABuilder<'a> { + SysmemColorSpaceFUCHSIABuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SysmemColorSpaceFUCHSIABuilder<'a> { + inner: SysmemColorSpaceFUCHSIA, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for SysmemColorSpaceFUCHSIABuilder<'a> { + type Target = SysmemColorSpaceFUCHSIA; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SysmemColorSpaceFUCHSIABuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SysmemColorSpaceFUCHSIABuilder<'a> { + #[inline] + pub fn color_space(mut self, color_space: u32) -> Self { + self.inner.color_space = color_space; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SysmemColorSpaceFUCHSIA { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ImageFormatConstraintsInfoFUCHSIA { + pub s_type: StructureType, + pub p_next: *const c_void, + pub image_create_info: ImageCreateInfo, + pub required_format_features: FormatFeatureFlags, + pub flags: ImageFormatConstraintsFlagsFUCHSIA, + pub sysmem_pixel_format: u64, + pub color_space_count: u32, + pub p_color_spaces: *const SysmemColorSpaceFUCHSIA, +} +impl ::std::default::Default for ImageFormatConstraintsInfoFUCHSIA { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + image_create_info: ImageCreateInfo::default(), + required_format_features: FormatFeatureFlags::default(), + flags: ImageFormatConstraintsFlagsFUCHSIA::default(), + sysmem_pixel_format: u64::default(), + color_space_count: u32::default(), + p_color_spaces: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for ImageFormatConstraintsInfoFUCHSIA { + const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_FORMAT_CONSTRAINTS_INFO_FUCHSIA; +} +impl ImageFormatConstraintsInfoFUCHSIA { + pub fn builder<'a>() -> ImageFormatConstraintsInfoFUCHSIABuilder<'a> { + ImageFormatConstraintsInfoFUCHSIABuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ImageFormatConstraintsInfoFUCHSIABuilder<'a> { + inner: ImageFormatConstraintsInfoFUCHSIA, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ImageFormatConstraintsInfoFUCHSIABuilder<'a> { + type Target = ImageFormatConstraintsInfoFUCHSIA; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ImageFormatConstraintsInfoFUCHSIABuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ImageFormatConstraintsInfoFUCHSIABuilder<'a> { + #[inline] + pub fn image_create_info(mut self, image_create_info: ImageCreateInfo) -> Self { + self.inner.image_create_info = image_create_info; + self + } + #[inline] + pub fn required_format_features( + mut self, + required_format_features: FormatFeatureFlags, + ) -> Self { + self.inner.required_format_features = required_format_features; + self + } + #[inline] + pub fn flags(mut self, flags: ImageFormatConstraintsFlagsFUCHSIA) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn sysmem_pixel_format(mut self, sysmem_pixel_format: u64) -> Self { + self.inner.sysmem_pixel_format = sysmem_pixel_format; + self + } + #[inline] + pub fn color_spaces(mut self, color_spaces: &'a [SysmemColorSpaceFUCHSIA]) -> Self { + self.inner.color_space_count = color_spaces.len() as _; + self.inner.p_color_spaces = color_spaces.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ImageFormatConstraintsInfoFUCHSIA { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ImageConstraintsInfoFUCHSIA { + pub s_type: StructureType, + pub p_next: *const c_void, + pub format_constraints_count: u32, + pub p_format_constraints: *const ImageFormatConstraintsInfoFUCHSIA, + pub buffer_collection_constraints: BufferCollectionConstraintsInfoFUCHSIA, + pub flags: ImageConstraintsInfoFlagsFUCHSIA, +} +impl ::std::default::Default for ImageConstraintsInfoFUCHSIA { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + format_constraints_count: u32::default(), + p_format_constraints: ::std::ptr::null(), + buffer_collection_constraints: BufferCollectionConstraintsInfoFUCHSIA::default(), + flags: ImageConstraintsInfoFlagsFUCHSIA::default(), + } + } +} +unsafe impl TaggedStructure for ImageConstraintsInfoFUCHSIA { + const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_CONSTRAINTS_INFO_FUCHSIA; +} +impl ImageConstraintsInfoFUCHSIA { + pub fn builder<'a>() -> ImageConstraintsInfoFUCHSIABuilder<'a> { + ImageConstraintsInfoFUCHSIABuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ImageConstraintsInfoFUCHSIABuilder<'a> { + inner: ImageConstraintsInfoFUCHSIA, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ImageConstraintsInfoFUCHSIABuilder<'a> { + type Target = ImageConstraintsInfoFUCHSIA; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ImageConstraintsInfoFUCHSIABuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ImageConstraintsInfoFUCHSIABuilder<'a> { + #[inline] + pub fn format_constraints( + mut self, + format_constraints: &'a [ImageFormatConstraintsInfoFUCHSIA], + ) -> Self { + self.inner.format_constraints_count = format_constraints.len() as _; + self.inner.p_format_constraints = format_constraints.as_ptr(); + self + } + #[inline] + pub fn buffer_collection_constraints( + mut self, + buffer_collection_constraints: BufferCollectionConstraintsInfoFUCHSIA, + ) -> Self { + self.inner.buffer_collection_constraints = buffer_collection_constraints; + self + } + #[inline] + pub fn flags(mut self, flags: ImageConstraintsInfoFlagsFUCHSIA) -> Self { + self.inner.flags = flags; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ImageConstraintsInfoFUCHSIA { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct BufferCollectionConstraintsInfoFUCHSIA { + pub s_type: StructureType, + pub p_next: *const c_void, + pub min_buffer_count: u32, + pub max_buffer_count: u32, + pub min_buffer_count_for_camping: u32, + pub min_buffer_count_for_dedicated_slack: u32, + pub min_buffer_count_for_shared_slack: u32, +} +impl ::std::default::Default for BufferCollectionConstraintsInfoFUCHSIA { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + min_buffer_count: u32::default(), + max_buffer_count: u32::default(), + min_buffer_count_for_camping: u32::default(), + min_buffer_count_for_dedicated_slack: u32::default(), + min_buffer_count_for_shared_slack: u32::default(), + } + } +} +unsafe impl TaggedStructure for BufferCollectionConstraintsInfoFUCHSIA { + const STRUCTURE_TYPE: StructureType = StructureType::BUFFER_COLLECTION_CONSTRAINTS_INFO_FUCHSIA; +} +impl BufferCollectionConstraintsInfoFUCHSIA { + pub fn builder<'a>() -> BufferCollectionConstraintsInfoFUCHSIABuilder<'a> { + BufferCollectionConstraintsInfoFUCHSIABuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct BufferCollectionConstraintsInfoFUCHSIABuilder<'a> { + inner: BufferCollectionConstraintsInfoFUCHSIA, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for BufferCollectionConstraintsInfoFUCHSIABuilder<'a> { + type Target = BufferCollectionConstraintsInfoFUCHSIA; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for BufferCollectionConstraintsInfoFUCHSIABuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> BufferCollectionConstraintsInfoFUCHSIABuilder<'a> { + #[inline] + pub fn min_buffer_count(mut self, min_buffer_count: u32) -> Self { + self.inner.min_buffer_count = min_buffer_count; + self + } + #[inline] + pub fn max_buffer_count(mut self, max_buffer_count: u32) -> Self { + self.inner.max_buffer_count = max_buffer_count; + self + } + #[inline] + pub fn min_buffer_count_for_camping(mut self, min_buffer_count_for_camping: u32) -> Self { + self.inner.min_buffer_count_for_camping = min_buffer_count_for_camping; + self + } + #[inline] + pub fn min_buffer_count_for_dedicated_slack( + mut self, + min_buffer_count_for_dedicated_slack: u32, + ) -> Self { + self.inner.min_buffer_count_for_dedicated_slack = min_buffer_count_for_dedicated_slack; + self + } + #[inline] + pub fn min_buffer_count_for_shared_slack( + mut self, + min_buffer_count_for_shared_slack: u32, + ) -> Self { + self.inner.min_buffer_count_for_shared_slack = min_buffer_count_for_shared_slack; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> BufferCollectionConstraintsInfoFUCHSIA { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceRGBA10X6FormatsFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub format_rgba10x6_without_y_cb_cr_sampler: Bool32, +} +impl ::std::default::Default for PhysicalDeviceRGBA10X6FormatsFeaturesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + format_rgba10x6_without_y_cb_cr_sampler: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceRGBA10X6FormatsFeaturesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT; +} +impl PhysicalDeviceRGBA10X6FormatsFeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceRGBA10X6FormatsFeaturesEXTBuilder<'a> { + PhysicalDeviceRGBA10X6FormatsFeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceRGBA10X6FormatsFeaturesEXTBuilder<'a> { + inner: PhysicalDeviceRGBA10X6FormatsFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceRGBA10X6FormatsFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceRGBA10X6FormatsFeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceRGBA10X6FormatsFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceRGBA10X6FormatsFeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceRGBA10X6FormatsFeaturesEXTBuilder<'a> { + type Target = PhysicalDeviceRGBA10X6FormatsFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceRGBA10X6FormatsFeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceRGBA10X6FormatsFeaturesEXTBuilder<'a> { + #[inline] + pub fn format_rgba10x6_without_y_cb_cr_sampler( + mut self, + format_rgba10x6_without_y_cb_cr_sampler: bool, + ) -> Self { + self.inner.format_rgba10x6_without_y_cb_cr_sampler = + format_rgba10x6_without_y_cb_cr_sampler.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceRGBA10X6FormatsFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct FormatProperties3 { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub linear_tiling_features: FormatFeatureFlags2, + pub optimal_tiling_features: FormatFeatureFlags2, + pub buffer_features: FormatFeatureFlags2, +} +impl ::std::default::Default for FormatProperties3 { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + linear_tiling_features: FormatFeatureFlags2::default(), + optimal_tiling_features: FormatFeatureFlags2::default(), + buffer_features: FormatFeatureFlags2::default(), + } + } +} +unsafe impl TaggedStructure for FormatProperties3 { + const STRUCTURE_TYPE: StructureType = StructureType::FORMAT_PROPERTIES_3; +} +impl FormatProperties3 { + pub fn builder<'a>() -> FormatProperties3Builder<'a> { + FormatProperties3Builder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct FormatProperties3Builder<'a> { + inner: FormatProperties3, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsFormatProperties2 for FormatProperties3Builder<'_> {} +unsafe impl ExtendsFormatProperties2 for FormatProperties3 {} +impl<'a> ::std::ops::Deref for FormatProperties3Builder<'a> { + type Target = FormatProperties3; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for FormatProperties3Builder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> FormatProperties3Builder<'a> { + #[inline] + pub fn linear_tiling_features(mut self, linear_tiling_features: FormatFeatureFlags2) -> Self { + self.inner.linear_tiling_features = linear_tiling_features; + self + } + #[inline] + pub fn optimal_tiling_features(mut self, optimal_tiling_features: FormatFeatureFlags2) -> Self { + self.inner.optimal_tiling_features = optimal_tiling_features; + self + } + #[inline] + pub fn buffer_features(mut self, buffer_features: FormatFeatureFlags2) -> Self { + self.inner.buffer_features = buffer_features; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> FormatProperties3 { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DrmFormatModifierPropertiesList2EXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub drm_format_modifier_count: u32, + pub p_drm_format_modifier_properties: *mut DrmFormatModifierProperties2EXT, +} +impl ::std::default::Default for DrmFormatModifierPropertiesList2EXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + drm_format_modifier_count: u32::default(), + p_drm_format_modifier_properties: ::std::ptr::null_mut(), + } + } +} +unsafe impl TaggedStructure for DrmFormatModifierPropertiesList2EXT { + const STRUCTURE_TYPE: StructureType = StructureType::DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT; +} +impl DrmFormatModifierPropertiesList2EXT { + pub fn builder<'a>() -> DrmFormatModifierPropertiesList2EXTBuilder<'a> { + DrmFormatModifierPropertiesList2EXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DrmFormatModifierPropertiesList2EXTBuilder<'a> { + inner: DrmFormatModifierPropertiesList2EXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsFormatProperties2 for DrmFormatModifierPropertiesList2EXTBuilder<'_> {} +unsafe impl ExtendsFormatProperties2 for DrmFormatModifierPropertiesList2EXT {} +impl<'a> ::std::ops::Deref for DrmFormatModifierPropertiesList2EXTBuilder<'a> { + type Target = DrmFormatModifierPropertiesList2EXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DrmFormatModifierPropertiesList2EXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DrmFormatModifierPropertiesList2EXTBuilder<'a> { + #[inline] + pub fn drm_format_modifier_properties( + mut self, + drm_format_modifier_properties: &'a mut [DrmFormatModifierProperties2EXT], + ) -> Self { + self.inner.drm_format_modifier_count = drm_format_modifier_properties.len() as _; + self.inner.p_drm_format_modifier_properties = drm_format_modifier_properties.as_mut_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DrmFormatModifierPropertiesList2EXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct DrmFormatModifierProperties2EXT { + pub drm_format_modifier: u64, + pub drm_format_modifier_plane_count: u32, + pub drm_format_modifier_tiling_features: FormatFeatureFlags2, +} +impl DrmFormatModifierProperties2EXT { + pub fn builder<'a>() -> DrmFormatModifierProperties2EXTBuilder<'a> { + DrmFormatModifierProperties2EXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DrmFormatModifierProperties2EXTBuilder<'a> { + inner: DrmFormatModifierProperties2EXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DrmFormatModifierProperties2EXTBuilder<'a> { + type Target = DrmFormatModifierProperties2EXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DrmFormatModifierProperties2EXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DrmFormatModifierProperties2EXTBuilder<'a> { + #[inline] + pub fn drm_format_modifier(mut self, drm_format_modifier: u64) -> Self { + self.inner.drm_format_modifier = drm_format_modifier; + self + } + #[inline] + pub fn drm_format_modifier_plane_count(mut self, drm_format_modifier_plane_count: u32) -> Self { + self.inner.drm_format_modifier_plane_count = drm_format_modifier_plane_count; + self + } + #[inline] + pub fn drm_format_modifier_tiling_features( + mut self, + drm_format_modifier_tiling_features: FormatFeatureFlags2, + ) -> Self { + self.inner.drm_format_modifier_tiling_features = drm_format_modifier_tiling_features; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DrmFormatModifierProperties2EXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct AndroidHardwareBufferFormatProperties2ANDROID { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub format: Format, + pub external_format: u64, + pub format_features: FormatFeatureFlags2, + pub sampler_ycbcr_conversion_components: ComponentMapping, + pub suggested_ycbcr_model: SamplerYcbcrModelConversion, + pub suggested_ycbcr_range: SamplerYcbcrRange, + pub suggested_x_chroma_offset: ChromaLocation, + pub suggested_y_chroma_offset: ChromaLocation, +} +impl ::std::default::Default for AndroidHardwareBufferFormatProperties2ANDROID { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + format: Format::default(), + external_format: u64::default(), + format_features: FormatFeatureFlags2::default(), + sampler_ycbcr_conversion_components: ComponentMapping::default(), + suggested_ycbcr_model: SamplerYcbcrModelConversion::default(), + suggested_ycbcr_range: SamplerYcbcrRange::default(), + suggested_x_chroma_offset: ChromaLocation::default(), + suggested_y_chroma_offset: ChromaLocation::default(), + } + } +} +unsafe impl TaggedStructure for AndroidHardwareBufferFormatProperties2ANDROID { + const STRUCTURE_TYPE: StructureType = + StructureType::ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID; +} +impl AndroidHardwareBufferFormatProperties2ANDROID { + pub fn builder<'a>() -> AndroidHardwareBufferFormatProperties2ANDROIDBuilder<'a> { + AndroidHardwareBufferFormatProperties2ANDROIDBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct AndroidHardwareBufferFormatProperties2ANDROIDBuilder<'a> { + inner: AndroidHardwareBufferFormatProperties2ANDROID, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsAndroidHardwareBufferPropertiesANDROID + for AndroidHardwareBufferFormatProperties2ANDROIDBuilder<'_> +{ +} +unsafe impl ExtendsAndroidHardwareBufferPropertiesANDROID + for AndroidHardwareBufferFormatProperties2ANDROID +{ +} +impl<'a> ::std::ops::Deref for AndroidHardwareBufferFormatProperties2ANDROIDBuilder<'a> { + type Target = AndroidHardwareBufferFormatProperties2ANDROID; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for AndroidHardwareBufferFormatProperties2ANDROIDBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> AndroidHardwareBufferFormatProperties2ANDROIDBuilder<'a> { + #[inline] + pub fn format(mut self, format: Format) -> Self { + self.inner.format = format; + self + } + #[inline] + pub fn external_format(mut self, external_format: u64) -> Self { + self.inner.external_format = external_format; + self + } + #[inline] + pub fn format_features(mut self, format_features: FormatFeatureFlags2) -> Self { + self.inner.format_features = format_features; + self + } + #[inline] + pub fn sampler_ycbcr_conversion_components( + mut self, + sampler_ycbcr_conversion_components: ComponentMapping, + ) -> Self { + self.inner.sampler_ycbcr_conversion_components = sampler_ycbcr_conversion_components; + self + } + #[inline] + pub fn suggested_ycbcr_model( + mut self, + suggested_ycbcr_model: SamplerYcbcrModelConversion, + ) -> Self { + self.inner.suggested_ycbcr_model = suggested_ycbcr_model; + self + } + #[inline] + pub fn suggested_ycbcr_range(mut self, suggested_ycbcr_range: SamplerYcbcrRange) -> Self { + self.inner.suggested_ycbcr_range = suggested_ycbcr_range; + self + } + #[inline] + pub fn suggested_x_chroma_offset(mut self, suggested_x_chroma_offset: ChromaLocation) -> Self { + self.inner.suggested_x_chroma_offset = suggested_x_chroma_offset; + self + } + #[inline] + pub fn suggested_y_chroma_offset(mut self, suggested_y_chroma_offset: ChromaLocation) -> Self { + self.inner.suggested_y_chroma_offset = suggested_y_chroma_offset; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> AndroidHardwareBufferFormatProperties2ANDROID { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PipelineRenderingCreateInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub view_mask: u32, + pub color_attachment_count: u32, + pub p_color_attachment_formats: *const Format, + pub depth_attachment_format: Format, + pub stencil_attachment_format: Format, +} +impl ::std::default::Default for PipelineRenderingCreateInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + view_mask: u32::default(), + color_attachment_count: u32::default(), + p_color_attachment_formats: ::std::ptr::null(), + depth_attachment_format: Format::default(), + stencil_attachment_format: Format::default(), + } + } +} +unsafe impl TaggedStructure for PipelineRenderingCreateInfo { + const STRUCTURE_TYPE: StructureType = StructureType::PIPELINE_RENDERING_CREATE_INFO; +} +impl PipelineRenderingCreateInfo { + pub fn builder<'a>() -> PipelineRenderingCreateInfoBuilder<'a> { + PipelineRenderingCreateInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PipelineRenderingCreateInfoBuilder<'a> { + inner: PipelineRenderingCreateInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsGraphicsPipelineCreateInfo for PipelineRenderingCreateInfoBuilder<'_> {} +unsafe impl ExtendsGraphicsPipelineCreateInfo for PipelineRenderingCreateInfo {} +impl<'a> ::std::ops::Deref for PipelineRenderingCreateInfoBuilder<'a> { + type Target = PipelineRenderingCreateInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PipelineRenderingCreateInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PipelineRenderingCreateInfoBuilder<'a> { + #[inline] + pub fn view_mask(mut self, view_mask: u32) -> Self { + self.inner.view_mask = view_mask; + self + } + #[inline] + pub fn color_attachment_formats(mut self, color_attachment_formats: &'a [Format]) -> Self { + self.inner.color_attachment_count = color_attachment_formats.len() as _; + self.inner.p_color_attachment_formats = color_attachment_formats.as_ptr(); + self + } + #[inline] + pub fn depth_attachment_format(mut self, depth_attachment_format: Format) -> Self { + self.inner.depth_attachment_format = depth_attachment_format; + self + } + #[inline] + pub fn stencil_attachment_format(mut self, stencil_attachment_format: Format) -> Self { + self.inner.stencil_attachment_format = stencil_attachment_format; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PipelineRenderingCreateInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct RenderingInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: RenderingFlags, + pub render_area: Rect2D, + pub layer_count: u32, + pub view_mask: u32, + pub color_attachment_count: u32, + pub p_color_attachments: *const RenderingAttachmentInfo, + pub p_depth_attachment: *const RenderingAttachmentInfo, + pub p_stencil_attachment: *const RenderingAttachmentInfo, +} +impl ::std::default::Default for RenderingInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: RenderingFlags::default(), + render_area: Rect2D::default(), + layer_count: u32::default(), + view_mask: u32::default(), + color_attachment_count: u32::default(), + p_color_attachments: ::std::ptr::null(), + p_depth_attachment: ::std::ptr::null(), + p_stencil_attachment: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for RenderingInfo { + const STRUCTURE_TYPE: StructureType = StructureType::RENDERING_INFO; +} +impl RenderingInfo { + pub fn builder<'a>() -> RenderingInfoBuilder<'a> { + RenderingInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct RenderingInfoBuilder<'a> { + inner: RenderingInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsRenderingInfo {} +impl<'a> ::std::ops::Deref for RenderingInfoBuilder<'a> { + type Target = RenderingInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for RenderingInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> RenderingInfoBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: RenderingFlags) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn render_area(mut self, render_area: Rect2D) -> Self { + self.inner.render_area = render_area; + self + } + #[inline] + pub fn layer_count(mut self, layer_count: u32) -> Self { + self.inner.layer_count = layer_count; + self + } + #[inline] + pub fn view_mask(mut self, view_mask: u32) -> Self { + self.inner.view_mask = view_mask; + self + } + #[inline] + pub fn color_attachments(mut self, color_attachments: &'a [RenderingAttachmentInfo]) -> Self { + self.inner.color_attachment_count = color_attachments.len() as _; + self.inner.p_color_attachments = color_attachments.as_ptr(); + self + } + #[inline] + pub fn depth_attachment(mut self, depth_attachment: &'a RenderingAttachmentInfo) -> Self { + self.inner.p_depth_attachment = depth_attachment; + self + } + #[inline] + pub fn stencil_attachment(mut self, stencil_attachment: &'a RenderingAttachmentInfo) -> Self { + self.inner.p_stencil_attachment = stencil_attachment; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> RenderingInfo { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct RenderingAttachmentInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub image_view: ImageView, + pub image_layout: ImageLayout, + pub resolve_mode: ResolveModeFlags, + pub resolve_image_view: ImageView, + pub resolve_image_layout: ImageLayout, + pub load_op: AttachmentLoadOp, + pub store_op: AttachmentStoreOp, + pub clear_value: ClearValue, +} +#[cfg(feature = "debug")] +impl fmt::Debug for RenderingAttachmentInfo { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fmt.debug_struct("RenderingAttachmentInfo") + .field("s_type", &self.s_type) + .field("p_next", &self.p_next) + .field("image_view", &self.image_view) + .field("image_layout", &self.image_layout) + .field("resolve_mode", &self.resolve_mode) + .field("resolve_image_view", &self.resolve_image_view) + .field("resolve_image_layout", &self.resolve_image_layout) + .field("load_op", &self.load_op) + .field("store_op", &self.store_op) + .field("clear_value", &"union") + .finish() + } +} +impl ::std::default::Default for RenderingAttachmentInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + image_view: ImageView::default(), + image_layout: ImageLayout::default(), + resolve_mode: ResolveModeFlags::default(), + resolve_image_view: ImageView::default(), + resolve_image_layout: ImageLayout::default(), + load_op: AttachmentLoadOp::default(), + store_op: AttachmentStoreOp::default(), + clear_value: ClearValue::default(), + } + } +} +unsafe impl TaggedStructure for RenderingAttachmentInfo { + const STRUCTURE_TYPE: StructureType = StructureType::RENDERING_ATTACHMENT_INFO; +} +impl RenderingAttachmentInfo { + pub fn builder<'a>() -> RenderingAttachmentInfoBuilder<'a> { + RenderingAttachmentInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct RenderingAttachmentInfoBuilder<'a> { + inner: RenderingAttachmentInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for RenderingAttachmentInfoBuilder<'a> { + type Target = RenderingAttachmentInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for RenderingAttachmentInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> RenderingAttachmentInfoBuilder<'a> { + #[inline] + pub fn image_view(mut self, image_view: ImageView) -> Self { + self.inner.image_view = image_view; + self + } + #[inline] + pub fn image_layout(mut self, image_layout: ImageLayout) -> Self { + self.inner.image_layout = image_layout; + self + } + #[inline] + pub fn resolve_mode(mut self, resolve_mode: ResolveModeFlags) -> Self { + self.inner.resolve_mode = resolve_mode; + self + } + #[inline] + pub fn resolve_image_view(mut self, resolve_image_view: ImageView) -> Self { + self.inner.resolve_image_view = resolve_image_view; + self + } + #[inline] + pub fn resolve_image_layout(mut self, resolve_image_layout: ImageLayout) -> Self { + self.inner.resolve_image_layout = resolve_image_layout; + self + } + #[inline] + pub fn load_op(mut self, load_op: AttachmentLoadOp) -> Self { + self.inner.load_op = load_op; + self + } + #[inline] + pub fn store_op(mut self, store_op: AttachmentStoreOp) -> Self { + self.inner.store_op = store_op; + self + } + #[inline] + pub fn clear_value(mut self, clear_value: ClearValue) -> Self { + self.inner.clear_value = clear_value; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> RenderingAttachmentInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct RenderingFragmentShadingRateAttachmentInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub image_view: ImageView, + pub image_layout: ImageLayout, + pub shading_rate_attachment_texel_size: Extent2D, +} +impl ::std::default::Default for RenderingFragmentShadingRateAttachmentInfoKHR { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + image_view: ImageView::default(), + image_layout: ImageLayout::default(), + shading_rate_attachment_texel_size: Extent2D::default(), + } + } +} +unsafe impl TaggedStructure for RenderingFragmentShadingRateAttachmentInfoKHR { + const STRUCTURE_TYPE: StructureType = + StructureType::RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR; +} +impl RenderingFragmentShadingRateAttachmentInfoKHR { + pub fn builder<'a>() -> RenderingFragmentShadingRateAttachmentInfoKHRBuilder<'a> { + RenderingFragmentShadingRateAttachmentInfoKHRBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct RenderingFragmentShadingRateAttachmentInfoKHRBuilder<'a> { + inner: RenderingFragmentShadingRateAttachmentInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsRenderingInfo for RenderingFragmentShadingRateAttachmentInfoKHRBuilder<'_> {} +unsafe impl ExtendsRenderingInfo for RenderingFragmentShadingRateAttachmentInfoKHR {} +impl<'a> ::std::ops::Deref for RenderingFragmentShadingRateAttachmentInfoKHRBuilder<'a> { + type Target = RenderingFragmentShadingRateAttachmentInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for RenderingFragmentShadingRateAttachmentInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> RenderingFragmentShadingRateAttachmentInfoKHRBuilder<'a> { + #[inline] + pub fn image_view(mut self, image_view: ImageView) -> Self { + self.inner.image_view = image_view; + self + } + #[inline] + pub fn image_layout(mut self, image_layout: ImageLayout) -> Self { + self.inner.image_layout = image_layout; + self + } + #[inline] + pub fn shading_rate_attachment_texel_size( + mut self, + shading_rate_attachment_texel_size: Extent2D, + ) -> Self { + self.inner.shading_rate_attachment_texel_size = shading_rate_attachment_texel_size; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> RenderingFragmentShadingRateAttachmentInfoKHR { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct RenderingFragmentDensityMapAttachmentInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub image_view: ImageView, + pub image_layout: ImageLayout, +} +impl ::std::default::Default for RenderingFragmentDensityMapAttachmentInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + image_view: ImageView::default(), + image_layout: ImageLayout::default(), + } + } +} +unsafe impl TaggedStructure for RenderingFragmentDensityMapAttachmentInfoEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT; +} +impl RenderingFragmentDensityMapAttachmentInfoEXT { + pub fn builder<'a>() -> RenderingFragmentDensityMapAttachmentInfoEXTBuilder<'a> { + RenderingFragmentDensityMapAttachmentInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct RenderingFragmentDensityMapAttachmentInfoEXTBuilder<'a> { + inner: RenderingFragmentDensityMapAttachmentInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsRenderingInfo for RenderingFragmentDensityMapAttachmentInfoEXTBuilder<'_> {} +unsafe impl ExtendsRenderingInfo for RenderingFragmentDensityMapAttachmentInfoEXT {} +impl<'a> ::std::ops::Deref for RenderingFragmentDensityMapAttachmentInfoEXTBuilder<'a> { + type Target = RenderingFragmentDensityMapAttachmentInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for RenderingFragmentDensityMapAttachmentInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> RenderingFragmentDensityMapAttachmentInfoEXTBuilder<'a> { + #[inline] + pub fn image_view(mut self, image_view: ImageView) -> Self { + self.inner.image_view = image_view; + self + } + #[inline] + pub fn image_layout(mut self, image_layout: ImageLayout) -> Self { + self.inner.image_layout = image_layout; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> RenderingFragmentDensityMapAttachmentInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceDynamicRenderingFeatures { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub dynamic_rendering: Bool32, +} +impl ::std::default::Default for PhysicalDeviceDynamicRenderingFeatures { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + dynamic_rendering: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceDynamicRenderingFeatures { + const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES; +} +impl PhysicalDeviceDynamicRenderingFeatures { + pub fn builder<'a>() -> PhysicalDeviceDynamicRenderingFeaturesBuilder<'a> { + PhysicalDeviceDynamicRenderingFeaturesBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceDynamicRenderingFeaturesBuilder<'a> { + inner: PhysicalDeviceDynamicRenderingFeatures, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceDynamicRenderingFeaturesBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceDynamicRenderingFeatures {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDynamicRenderingFeaturesBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDynamicRenderingFeatures {} +impl<'a> ::std::ops::Deref for PhysicalDeviceDynamicRenderingFeaturesBuilder<'a> { + type Target = PhysicalDeviceDynamicRenderingFeatures; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceDynamicRenderingFeaturesBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceDynamicRenderingFeaturesBuilder<'a> { + #[inline] + pub fn dynamic_rendering(mut self, dynamic_rendering: bool) -> Self { + self.inner.dynamic_rendering = dynamic_rendering.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceDynamicRenderingFeatures { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct CommandBufferInheritanceRenderingInfo { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: RenderingFlags, + pub view_mask: u32, + pub color_attachment_count: u32, + pub p_color_attachment_formats: *const Format, + pub depth_attachment_format: Format, + pub stencil_attachment_format: Format, + pub rasterization_samples: SampleCountFlags, +} +impl ::std::default::Default for CommandBufferInheritanceRenderingInfo { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: RenderingFlags::default(), + view_mask: u32::default(), + color_attachment_count: u32::default(), + p_color_attachment_formats: ::std::ptr::null(), + depth_attachment_format: Format::default(), + stencil_attachment_format: Format::default(), + rasterization_samples: SampleCountFlags::default(), + } + } +} +unsafe impl TaggedStructure for CommandBufferInheritanceRenderingInfo { + const STRUCTURE_TYPE: StructureType = StructureType::COMMAND_BUFFER_INHERITANCE_RENDERING_INFO; +} +impl CommandBufferInheritanceRenderingInfo { + pub fn builder<'a>() -> CommandBufferInheritanceRenderingInfoBuilder<'a> { + CommandBufferInheritanceRenderingInfoBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct CommandBufferInheritanceRenderingInfoBuilder<'a> { + inner: CommandBufferInheritanceRenderingInfo, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsCommandBufferInheritanceInfo + for CommandBufferInheritanceRenderingInfoBuilder<'_> +{ +} +unsafe impl ExtendsCommandBufferInheritanceInfo for CommandBufferInheritanceRenderingInfo {} +impl<'a> ::std::ops::Deref for CommandBufferInheritanceRenderingInfoBuilder<'a> { + type Target = CommandBufferInheritanceRenderingInfo; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for CommandBufferInheritanceRenderingInfoBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> CommandBufferInheritanceRenderingInfoBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: RenderingFlags) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn view_mask(mut self, view_mask: u32) -> Self { + self.inner.view_mask = view_mask; + self + } + #[inline] + pub fn color_attachment_formats(mut self, color_attachment_formats: &'a [Format]) -> Self { + self.inner.color_attachment_count = color_attachment_formats.len() as _; + self.inner.p_color_attachment_formats = color_attachment_formats.as_ptr(); + self + } + #[inline] + pub fn depth_attachment_format(mut self, depth_attachment_format: Format) -> Self { + self.inner.depth_attachment_format = depth_attachment_format; + self + } + #[inline] + pub fn stencil_attachment_format(mut self, stencil_attachment_format: Format) -> Self { + self.inner.stencil_attachment_format = stencil_attachment_format; + self + } + #[inline] + pub fn rasterization_samples(mut self, rasterization_samples: SampleCountFlags) -> Self { + self.inner.rasterization_samples = rasterization_samples; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> CommandBufferInheritanceRenderingInfo { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct AttachmentSampleCountInfoAMD { + pub s_type: StructureType, + pub p_next: *const c_void, + pub color_attachment_count: u32, + pub p_color_attachment_samples: *const SampleCountFlags, + pub depth_stencil_attachment_samples: SampleCountFlags, +} +impl ::std::default::Default for AttachmentSampleCountInfoAMD { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + color_attachment_count: u32::default(), + p_color_attachment_samples: ::std::ptr::null(), + depth_stencil_attachment_samples: SampleCountFlags::default(), + } + } +} +unsafe impl TaggedStructure for AttachmentSampleCountInfoAMD { + const STRUCTURE_TYPE: StructureType = StructureType::ATTACHMENT_SAMPLE_COUNT_INFO_AMD; +} +impl AttachmentSampleCountInfoAMD { + pub fn builder<'a>() -> AttachmentSampleCountInfoAMDBuilder<'a> { + AttachmentSampleCountInfoAMDBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct AttachmentSampleCountInfoAMDBuilder<'a> { + inner: AttachmentSampleCountInfoAMD, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsCommandBufferInheritanceInfo for AttachmentSampleCountInfoAMDBuilder<'_> {} +unsafe impl ExtendsCommandBufferInheritanceInfo for AttachmentSampleCountInfoAMD {} +unsafe impl ExtendsGraphicsPipelineCreateInfo for AttachmentSampleCountInfoAMDBuilder<'_> {} +unsafe impl ExtendsGraphicsPipelineCreateInfo for AttachmentSampleCountInfoAMD {} +impl<'a> ::std::ops::Deref for AttachmentSampleCountInfoAMDBuilder<'a> { + type Target = AttachmentSampleCountInfoAMD; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for AttachmentSampleCountInfoAMDBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> AttachmentSampleCountInfoAMDBuilder<'a> { + #[inline] + pub fn color_attachment_samples( + mut self, + color_attachment_samples: &'a [SampleCountFlags], + ) -> Self { + self.inner.color_attachment_count = color_attachment_samples.len() as _; + self.inner.p_color_attachment_samples = color_attachment_samples.as_ptr(); + self + } + #[inline] + pub fn depth_stencil_attachment_samples( + mut self, + depth_stencil_attachment_samples: SampleCountFlags, + ) -> Self { + self.inner.depth_stencil_attachment_samples = depth_stencil_attachment_samples; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> AttachmentSampleCountInfoAMD { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct MultiviewPerViewAttributesInfoNVX { + pub s_type: StructureType, + pub p_next: *const c_void, + pub per_view_attributes: Bool32, + pub per_view_attributes_position_x_only: Bool32, +} +impl ::std::default::Default for MultiviewPerViewAttributesInfoNVX { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + per_view_attributes: Bool32::default(), + per_view_attributes_position_x_only: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for MultiviewPerViewAttributesInfoNVX { + const STRUCTURE_TYPE: StructureType = StructureType::MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX; +} +impl MultiviewPerViewAttributesInfoNVX { + pub fn builder<'a>() -> MultiviewPerViewAttributesInfoNVXBuilder<'a> { + MultiviewPerViewAttributesInfoNVXBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct MultiviewPerViewAttributesInfoNVXBuilder<'a> { + inner: MultiviewPerViewAttributesInfoNVX, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsCommandBufferInheritanceInfo for MultiviewPerViewAttributesInfoNVXBuilder<'_> {} +unsafe impl ExtendsCommandBufferInheritanceInfo for MultiviewPerViewAttributesInfoNVX {} +unsafe impl ExtendsGraphicsPipelineCreateInfo for MultiviewPerViewAttributesInfoNVXBuilder<'_> {} +unsafe impl ExtendsGraphicsPipelineCreateInfo for MultiviewPerViewAttributesInfoNVX {} +unsafe impl ExtendsRenderingInfo for MultiviewPerViewAttributesInfoNVXBuilder<'_> {} +unsafe impl ExtendsRenderingInfo for MultiviewPerViewAttributesInfoNVX {} +impl<'a> ::std::ops::Deref for MultiviewPerViewAttributesInfoNVXBuilder<'a> { + type Target = MultiviewPerViewAttributesInfoNVX; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for MultiviewPerViewAttributesInfoNVXBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> MultiviewPerViewAttributesInfoNVXBuilder<'a> { + #[inline] + pub fn per_view_attributes(mut self, per_view_attributes: bool) -> Self { + self.inner.per_view_attributes = per_view_attributes.into(); + self + } + #[inline] + pub fn per_view_attributes_position_x_only( + mut self, + per_view_attributes_position_x_only: bool, + ) -> Self { + self.inner.per_view_attributes_position_x_only = per_view_attributes_position_x_only.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> MultiviewPerViewAttributesInfoNVX { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceImageViewMinLodFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub min_lod: Bool32, +} +impl ::std::default::Default for PhysicalDeviceImageViewMinLodFeaturesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + min_lod: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceImageViewMinLodFeaturesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT; +} +impl PhysicalDeviceImageViewMinLodFeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceImageViewMinLodFeaturesEXTBuilder<'a> { + PhysicalDeviceImageViewMinLodFeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceImageViewMinLodFeaturesEXTBuilder<'a> { + inner: PhysicalDeviceImageViewMinLodFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceImageViewMinLodFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceImageViewMinLodFeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceImageViewMinLodFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceImageViewMinLodFeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceImageViewMinLodFeaturesEXTBuilder<'a> { + type Target = PhysicalDeviceImageViewMinLodFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceImageViewMinLodFeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceImageViewMinLodFeaturesEXTBuilder<'a> { + #[inline] + pub fn min_lod(mut self, min_lod: bool) -> Self { + self.inner.min_lod = min_lod.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceImageViewMinLodFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ImageViewMinLodCreateInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub min_lod: f32, +} +impl ::std::default::Default for ImageViewMinLodCreateInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + min_lod: f32::default(), + } + } +} +unsafe impl TaggedStructure for ImageViewMinLodCreateInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT; +} +impl ImageViewMinLodCreateInfoEXT { + pub fn builder<'a>() -> ImageViewMinLodCreateInfoEXTBuilder<'a> { + ImageViewMinLodCreateInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ImageViewMinLodCreateInfoEXTBuilder<'a> { + inner: ImageViewMinLodCreateInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsImageViewCreateInfo for ImageViewMinLodCreateInfoEXTBuilder<'_> {} +unsafe impl ExtendsImageViewCreateInfo for ImageViewMinLodCreateInfoEXT {} +impl<'a> ::std::ops::Deref for ImageViewMinLodCreateInfoEXTBuilder<'a> { + type Target = ImageViewMinLodCreateInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ImageViewMinLodCreateInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ImageViewMinLodCreateInfoEXTBuilder<'a> { + #[inline] + pub fn min_lod(mut self, min_lod: f32) -> Self { + self.inner.min_lod = min_lod; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ImageViewMinLodCreateInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub rasterization_order_color_attachment_access: Bool32, + pub rasterization_order_depth_attachment_access: Bool32, + pub rasterization_order_stencil_attachment_access: Bool32, +} +impl ::std::default::Default for PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + rasterization_order_color_attachment_access: Bool32::default(), + rasterization_order_depth_attachment_access: Bool32::default(), + rasterization_order_stencil_attachment_access: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT; +} +impl PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXTBuilder<'a> { + PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXTBuilder<'a> { + inner: PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT +{ +} +unsafe impl ExtendsDeviceCreateInfo + for PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsDeviceCreateInfo + for PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT +{ +} +impl<'a> ::std::ops::Deref + for PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXTBuilder<'a> +{ + type Target = PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut + for PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXTBuilder<'a> +{ + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXTBuilder<'a> { + #[inline] + pub fn rasterization_order_color_attachment_access( + mut self, + rasterization_order_color_attachment_access: bool, + ) -> Self { + self.inner.rasterization_order_color_attachment_access = + rasterization_order_color_attachment_access.into(); + self + } + #[inline] + pub fn rasterization_order_depth_attachment_access( + mut self, + rasterization_order_depth_attachment_access: bool, + ) -> Self { + self.inner.rasterization_order_depth_attachment_access = + rasterization_order_depth_attachment_access.into(); + self + } + #[inline] + pub fn rasterization_order_stencil_attachment_access( + mut self, + rasterization_order_stencil_attachment_access: bool, + ) -> Self { + self.inner.rasterization_order_stencil_attachment_access = + rasterization_order_stencil_attachment_access.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceLinearColorAttachmentFeaturesNV { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub linear_color_attachment: Bool32, +} +impl ::std::default::Default for PhysicalDeviceLinearColorAttachmentFeaturesNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + linear_color_attachment: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceLinearColorAttachmentFeaturesNV { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV; +} +impl PhysicalDeviceLinearColorAttachmentFeaturesNV { + pub fn builder<'a>() -> PhysicalDeviceLinearColorAttachmentFeaturesNVBuilder<'a> { + PhysicalDeviceLinearColorAttachmentFeaturesNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceLinearColorAttachmentFeaturesNVBuilder<'a> { + inner: PhysicalDeviceLinearColorAttachmentFeaturesNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceLinearColorAttachmentFeaturesNVBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceLinearColorAttachmentFeaturesNV {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceLinearColorAttachmentFeaturesNVBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceLinearColorAttachmentFeaturesNV {} +impl<'a> ::std::ops::Deref for PhysicalDeviceLinearColorAttachmentFeaturesNVBuilder<'a> { + type Target = PhysicalDeviceLinearColorAttachmentFeaturesNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceLinearColorAttachmentFeaturesNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceLinearColorAttachmentFeaturesNVBuilder<'a> { + #[inline] + pub fn linear_color_attachment(mut self, linear_color_attachment: bool) -> Self { + self.inner.linear_color_attachment = linear_color_attachment.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceLinearColorAttachmentFeaturesNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub graphics_pipeline_library: Bool32, +} +impl ::std::default::Default for PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + graphics_pipeline_library: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT; +} +impl PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceGraphicsPipelineLibraryFeaturesEXTBuilder<'a> { + PhysicalDeviceGraphicsPipelineLibraryFeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceGraphicsPipelineLibraryFeaturesEXTBuilder<'a> { + inner: PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceGraphicsPipelineLibraryFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo + for PhysicalDeviceGraphicsPipelineLibraryFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceGraphicsPipelineLibraryFeaturesEXTBuilder<'a> { + type Target = PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceGraphicsPipelineLibraryFeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceGraphicsPipelineLibraryFeaturesEXTBuilder<'a> { + #[inline] + pub fn graphics_pipeline_library(mut self, graphics_pipeline_library: bool) -> Self { + self.inner.graphics_pipeline_library = graphics_pipeline_library.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub graphics_pipeline_library_fast_linking: Bool32, + pub graphics_pipeline_library_independent_interpolation_decoration: Bool32, +} +impl ::std::default::Default for PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + graphics_pipeline_library_fast_linking: Bool32::default(), + graphics_pipeline_library_independent_interpolation_decoration: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT; +} +impl PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT { + pub fn builder<'a>() -> PhysicalDeviceGraphicsPipelineLibraryPropertiesEXTBuilder<'a> { + PhysicalDeviceGraphicsPipelineLibraryPropertiesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceGraphicsPipelineLibraryPropertiesEXTBuilder<'a> { + inner: PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceGraphicsPipelineLibraryPropertiesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT +{ +} +impl<'a> ::std::ops::Deref for PhysicalDeviceGraphicsPipelineLibraryPropertiesEXTBuilder<'a> { + type Target = PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceGraphicsPipelineLibraryPropertiesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceGraphicsPipelineLibraryPropertiesEXTBuilder<'a> { + #[inline] + pub fn graphics_pipeline_library_fast_linking( + mut self, + graphics_pipeline_library_fast_linking: bool, + ) -> Self { + self.inner.graphics_pipeline_library_fast_linking = + graphics_pipeline_library_fast_linking.into(); + self + } + #[inline] + pub fn graphics_pipeline_library_independent_interpolation_decoration( + mut self, + graphics_pipeline_library_independent_interpolation_decoration: bool, + ) -> Self { + self.inner + .graphics_pipeline_library_independent_interpolation_decoration = + graphics_pipeline_library_independent_interpolation_decoration.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct GraphicsPipelineLibraryCreateInfoEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub flags: GraphicsPipelineLibraryFlagsEXT, +} +impl ::std::default::Default for GraphicsPipelineLibraryCreateInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + flags: GraphicsPipelineLibraryFlagsEXT::default(), + } + } +} +unsafe impl TaggedStructure for GraphicsPipelineLibraryCreateInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT; +} +impl GraphicsPipelineLibraryCreateInfoEXT { + pub fn builder<'a>() -> GraphicsPipelineLibraryCreateInfoEXTBuilder<'a> { + GraphicsPipelineLibraryCreateInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct GraphicsPipelineLibraryCreateInfoEXTBuilder<'a> { + inner: GraphicsPipelineLibraryCreateInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsGraphicsPipelineCreateInfo for GraphicsPipelineLibraryCreateInfoEXTBuilder<'_> {} +unsafe impl ExtendsGraphicsPipelineCreateInfo for GraphicsPipelineLibraryCreateInfoEXT {} +impl<'a> ::std::ops::Deref for GraphicsPipelineLibraryCreateInfoEXTBuilder<'a> { + type Target = GraphicsPipelineLibraryCreateInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for GraphicsPipelineLibraryCreateInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> GraphicsPipelineLibraryCreateInfoEXTBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: GraphicsPipelineLibraryFlagsEXT) -> Self { + self.inner.flags = flags; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> GraphicsPipelineLibraryCreateInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub descriptor_set_host_mapping: Bool32, +} +impl ::std::default::Default for PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + descriptor_set_host_mapping: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE; +} +impl PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE { + pub fn builder<'a>() -> PhysicalDeviceDescriptorSetHostMappingFeaturesVALVEBuilder<'a> { + PhysicalDeviceDescriptorSetHostMappingFeaturesVALVEBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceDescriptorSetHostMappingFeaturesVALVEBuilder<'a> { + inner: PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceDescriptorSetHostMappingFeaturesVALVEBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE {} +unsafe impl ExtendsDeviceCreateInfo + for PhysicalDeviceDescriptorSetHostMappingFeaturesVALVEBuilder<'_> +{ +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE {} +impl<'a> ::std::ops::Deref for PhysicalDeviceDescriptorSetHostMappingFeaturesVALVEBuilder<'a> { + type Target = PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceDescriptorSetHostMappingFeaturesVALVEBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceDescriptorSetHostMappingFeaturesVALVEBuilder<'a> { + #[inline] + pub fn descriptor_set_host_mapping(mut self, descriptor_set_host_mapping: bool) -> Self { + self.inner.descriptor_set_host_mapping = descriptor_set_host_mapping.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DescriptorSetBindingReferenceVALVE { + pub s_type: StructureType, + pub p_next: *const c_void, + pub descriptor_set_layout: DescriptorSetLayout, + pub binding: u32, +} +impl ::std::default::Default for DescriptorSetBindingReferenceVALVE { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + descriptor_set_layout: DescriptorSetLayout::default(), + binding: u32::default(), + } + } +} +unsafe impl TaggedStructure for DescriptorSetBindingReferenceVALVE { + const STRUCTURE_TYPE: StructureType = StructureType::DESCRIPTOR_SET_BINDING_REFERENCE_VALVE; +} +impl DescriptorSetBindingReferenceVALVE { + pub fn builder<'a>() -> DescriptorSetBindingReferenceVALVEBuilder<'a> { + DescriptorSetBindingReferenceVALVEBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DescriptorSetBindingReferenceVALVEBuilder<'a> { + inner: DescriptorSetBindingReferenceVALVE, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DescriptorSetBindingReferenceVALVEBuilder<'a> { + type Target = DescriptorSetBindingReferenceVALVE; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DescriptorSetBindingReferenceVALVEBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DescriptorSetBindingReferenceVALVEBuilder<'a> { + #[inline] + pub fn descriptor_set_layout(mut self, descriptor_set_layout: DescriptorSetLayout) -> Self { + self.inner.descriptor_set_layout = descriptor_set_layout; + self + } + #[inline] + pub fn binding(mut self, binding: u32) -> Self { + self.inner.binding = binding; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DescriptorSetBindingReferenceVALVE { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DescriptorSetLayoutHostMappingInfoVALVE { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub descriptor_offset: usize, + pub descriptor_size: u32, +} +impl ::std::default::Default for DescriptorSetLayoutHostMappingInfoVALVE { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + descriptor_offset: usize::default(), + descriptor_size: u32::default(), + } + } +} +unsafe impl TaggedStructure for DescriptorSetLayoutHostMappingInfoVALVE { + const STRUCTURE_TYPE: StructureType = + StructureType::DESCRIPTOR_SET_LAYOUT_HOST_MAPPING_INFO_VALVE; +} +impl DescriptorSetLayoutHostMappingInfoVALVE { + pub fn builder<'a>() -> DescriptorSetLayoutHostMappingInfoVALVEBuilder<'a> { + DescriptorSetLayoutHostMappingInfoVALVEBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DescriptorSetLayoutHostMappingInfoVALVEBuilder<'a> { + inner: DescriptorSetLayoutHostMappingInfoVALVE, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DescriptorSetLayoutHostMappingInfoVALVEBuilder<'a> { + type Target = DescriptorSetLayoutHostMappingInfoVALVE; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DescriptorSetLayoutHostMappingInfoVALVEBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DescriptorSetLayoutHostMappingInfoVALVEBuilder<'a> { + #[inline] + pub fn descriptor_offset(mut self, descriptor_offset: usize) -> Self { + self.inner.descriptor_offset = descriptor_offset; + self + } + #[inline] + pub fn descriptor_size(mut self, descriptor_size: u32) -> Self { + self.inner.descriptor_size = descriptor_size; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DescriptorSetLayoutHostMappingInfoVALVE { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceShaderModuleIdentifierFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub shader_module_identifier: Bool32, +} +impl ::std::default::Default for PhysicalDeviceShaderModuleIdentifierFeaturesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + shader_module_identifier: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceShaderModuleIdentifierFeaturesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT; +} +impl PhysicalDeviceShaderModuleIdentifierFeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceShaderModuleIdentifierFeaturesEXTBuilder<'a> { + PhysicalDeviceShaderModuleIdentifierFeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceShaderModuleIdentifierFeaturesEXTBuilder<'a> { + inner: PhysicalDeviceShaderModuleIdentifierFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceShaderModuleIdentifierFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderModuleIdentifierFeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderModuleIdentifierFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderModuleIdentifierFeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceShaderModuleIdentifierFeaturesEXTBuilder<'a> { + type Target = PhysicalDeviceShaderModuleIdentifierFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderModuleIdentifierFeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceShaderModuleIdentifierFeaturesEXTBuilder<'a> { + #[inline] + pub fn shader_module_identifier(mut self, shader_module_identifier: bool) -> Self { + self.inner.shader_module_identifier = shader_module_identifier.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceShaderModuleIdentifierFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceShaderModuleIdentifierPropertiesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub shader_module_identifier_algorithm_uuid: [u8; UUID_SIZE], +} +impl ::std::default::Default for PhysicalDeviceShaderModuleIdentifierPropertiesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + shader_module_identifier_algorithm_uuid: unsafe { ::std::mem::zeroed() }, + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceShaderModuleIdentifierPropertiesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT; +} +impl PhysicalDeviceShaderModuleIdentifierPropertiesEXT { + pub fn builder<'a>() -> PhysicalDeviceShaderModuleIdentifierPropertiesEXTBuilder<'a> { + PhysicalDeviceShaderModuleIdentifierPropertiesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceShaderModuleIdentifierPropertiesEXTBuilder<'a> { + inner: PhysicalDeviceShaderModuleIdentifierPropertiesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceShaderModuleIdentifierPropertiesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceShaderModuleIdentifierPropertiesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceShaderModuleIdentifierPropertiesEXTBuilder<'a> { + type Target = PhysicalDeviceShaderModuleIdentifierPropertiesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderModuleIdentifierPropertiesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceShaderModuleIdentifierPropertiesEXTBuilder<'a> { + #[inline] + pub fn shader_module_identifier_algorithm_uuid( + mut self, + shader_module_identifier_algorithm_uuid: [u8; UUID_SIZE], + ) -> Self { + self.inner.shader_module_identifier_algorithm_uuid = + shader_module_identifier_algorithm_uuid; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceShaderModuleIdentifierPropertiesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PipelineShaderStageModuleIdentifierCreateInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub identifier_size: u32, + pub p_identifier: *const u8, +} +impl ::std::default::Default for PipelineShaderStageModuleIdentifierCreateInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + identifier_size: u32::default(), + p_identifier: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for PipelineShaderStageModuleIdentifierCreateInfoEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT; +} +impl PipelineShaderStageModuleIdentifierCreateInfoEXT { + pub fn builder<'a>() -> PipelineShaderStageModuleIdentifierCreateInfoEXTBuilder<'a> { + PipelineShaderStageModuleIdentifierCreateInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PipelineShaderStageModuleIdentifierCreateInfoEXTBuilder<'a> { + inner: PipelineShaderStageModuleIdentifierCreateInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPipelineShaderStageCreateInfo + for PipelineShaderStageModuleIdentifierCreateInfoEXTBuilder<'_> +{ +} +unsafe impl ExtendsPipelineShaderStageCreateInfo + for PipelineShaderStageModuleIdentifierCreateInfoEXT +{ +} +impl<'a> ::std::ops::Deref for PipelineShaderStageModuleIdentifierCreateInfoEXTBuilder<'a> { + type Target = PipelineShaderStageModuleIdentifierCreateInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PipelineShaderStageModuleIdentifierCreateInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PipelineShaderStageModuleIdentifierCreateInfoEXTBuilder<'a> { + #[inline] + pub fn identifier(mut self, identifier: &'a [u8]) -> Self { + self.inner.identifier_size = identifier.len() as _; + self.inner.p_identifier = identifier.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PipelineShaderStageModuleIdentifierCreateInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ShaderModuleIdentifierEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub identifier_size: u32, + pub identifier: [u8; MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT], +} +impl ::std::default::Default for ShaderModuleIdentifierEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + identifier_size: u32::default(), + identifier: unsafe { ::std::mem::zeroed() }, + } + } +} +unsafe impl TaggedStructure for ShaderModuleIdentifierEXT { + const STRUCTURE_TYPE: StructureType = StructureType::SHADER_MODULE_IDENTIFIER_EXT; +} +impl ShaderModuleIdentifierEXT { + pub fn builder<'a>() -> ShaderModuleIdentifierEXTBuilder<'a> { + ShaderModuleIdentifierEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ShaderModuleIdentifierEXTBuilder<'a> { + inner: ShaderModuleIdentifierEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ShaderModuleIdentifierEXTBuilder<'a> { + type Target = ShaderModuleIdentifierEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ShaderModuleIdentifierEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ShaderModuleIdentifierEXTBuilder<'a> { + #[inline] + pub fn identifier_size(mut self, identifier_size: u32) -> Self { + self.inner.identifier_size = identifier_size; + self + } + #[inline] + pub fn identifier(mut self, identifier: [u8; MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT]) -> Self { + self.inner.identifier = identifier; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ShaderModuleIdentifierEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ImageCompressionControlEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: ImageCompressionFlagsEXT, + pub compression_control_plane_count: u32, + pub p_fixed_rate_flags: *mut ImageCompressionFixedRateFlagsEXT, +} +impl ::std::default::Default for ImageCompressionControlEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: ImageCompressionFlagsEXT::default(), + compression_control_plane_count: u32::default(), + p_fixed_rate_flags: ::std::ptr::null_mut(), + } + } +} +unsafe impl TaggedStructure for ImageCompressionControlEXT { + const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_COMPRESSION_CONTROL_EXT; +} +impl ImageCompressionControlEXT { + pub fn builder<'a>() -> ImageCompressionControlEXTBuilder<'a> { + ImageCompressionControlEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ImageCompressionControlEXTBuilder<'a> { + inner: ImageCompressionControlEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsImageCreateInfo for ImageCompressionControlEXTBuilder<'_> {} +unsafe impl ExtendsImageCreateInfo for ImageCompressionControlEXT {} +unsafe impl ExtendsSwapchainCreateInfoKHR for ImageCompressionControlEXTBuilder<'_> {} +unsafe impl ExtendsSwapchainCreateInfoKHR for ImageCompressionControlEXT {} +unsafe impl ExtendsPhysicalDeviceImageFormatInfo2 for ImageCompressionControlEXTBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceImageFormatInfo2 for ImageCompressionControlEXT {} +impl<'a> ::std::ops::Deref for ImageCompressionControlEXTBuilder<'a> { + type Target = ImageCompressionControlEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ImageCompressionControlEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ImageCompressionControlEXTBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: ImageCompressionFlagsEXT) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn fixed_rate_flags( + mut self, + fixed_rate_flags: &'a mut [ImageCompressionFixedRateFlagsEXT], + ) -> Self { + self.inner.compression_control_plane_count = fixed_rate_flags.len() as _; + self.inner.p_fixed_rate_flags = fixed_rate_flags.as_mut_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ImageCompressionControlEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceImageCompressionControlFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub image_compression_control: Bool32, +} +impl ::std::default::Default for PhysicalDeviceImageCompressionControlFeaturesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + image_compression_control: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceImageCompressionControlFeaturesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT; +} +impl PhysicalDeviceImageCompressionControlFeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceImageCompressionControlFeaturesEXTBuilder<'a> { + PhysicalDeviceImageCompressionControlFeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceImageCompressionControlFeaturesEXTBuilder<'a> { + inner: PhysicalDeviceImageCompressionControlFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceImageCompressionControlFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceImageCompressionControlFeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo + for PhysicalDeviceImageCompressionControlFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceImageCompressionControlFeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceImageCompressionControlFeaturesEXTBuilder<'a> { + type Target = PhysicalDeviceImageCompressionControlFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceImageCompressionControlFeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceImageCompressionControlFeaturesEXTBuilder<'a> { + #[inline] + pub fn image_compression_control(mut self, image_compression_control: bool) -> Self { + self.inner.image_compression_control = image_compression_control.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceImageCompressionControlFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ImageCompressionPropertiesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub image_compression_flags: ImageCompressionFlagsEXT, + pub image_compression_fixed_rate_flags: ImageCompressionFixedRateFlagsEXT, +} +impl ::std::default::Default for ImageCompressionPropertiesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + image_compression_flags: ImageCompressionFlagsEXT::default(), + image_compression_fixed_rate_flags: ImageCompressionFixedRateFlagsEXT::default(), + } + } +} +unsafe impl TaggedStructure for ImageCompressionPropertiesEXT { + const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_COMPRESSION_PROPERTIES_EXT; +} +impl ImageCompressionPropertiesEXT { + pub fn builder<'a>() -> ImageCompressionPropertiesEXTBuilder<'a> { + ImageCompressionPropertiesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ImageCompressionPropertiesEXTBuilder<'a> { + inner: ImageCompressionPropertiesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsImageFormatProperties2 for ImageCompressionPropertiesEXTBuilder<'_> {} +unsafe impl ExtendsImageFormatProperties2 for ImageCompressionPropertiesEXT {} +unsafe impl ExtendsSurfaceFormat2KHR for ImageCompressionPropertiesEXTBuilder<'_> {} +unsafe impl ExtendsSurfaceFormat2KHR for ImageCompressionPropertiesEXT {} +unsafe impl ExtendsSubresourceLayout2EXT for ImageCompressionPropertiesEXTBuilder<'_> {} +unsafe impl ExtendsSubresourceLayout2EXT for ImageCompressionPropertiesEXT {} +impl<'a> ::std::ops::Deref for ImageCompressionPropertiesEXTBuilder<'a> { + type Target = ImageCompressionPropertiesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ImageCompressionPropertiesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ImageCompressionPropertiesEXTBuilder<'a> { + #[inline] + pub fn image_compression_flags( + mut self, + image_compression_flags: ImageCompressionFlagsEXT, + ) -> Self { + self.inner.image_compression_flags = image_compression_flags; + self + } + #[inline] + pub fn image_compression_fixed_rate_flags( + mut self, + image_compression_fixed_rate_flags: ImageCompressionFixedRateFlagsEXT, + ) -> Self { + self.inner.image_compression_fixed_rate_flags = image_compression_fixed_rate_flags; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ImageCompressionPropertiesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub image_compression_control_swapchain: Bool32, +} +impl ::std::default::Default for PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + image_compression_control_swapchain: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT; +} +impl PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceImageCompressionControlSwapchainFeaturesEXTBuilder<'a> { + PhysicalDeviceImageCompressionControlSwapchainFeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceImageCompressionControlSwapchainFeaturesEXTBuilder<'a> { + inner: PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceImageCompressionControlSwapchainFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT +{ +} +unsafe impl ExtendsDeviceCreateInfo + for PhysicalDeviceImageCompressionControlSwapchainFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT {} +impl<'a> ::std::ops::Deref + for PhysicalDeviceImageCompressionControlSwapchainFeaturesEXTBuilder<'a> +{ + type Target = PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut + for PhysicalDeviceImageCompressionControlSwapchainFeaturesEXTBuilder<'a> +{ + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceImageCompressionControlSwapchainFeaturesEXTBuilder<'a> { + #[inline] + pub fn image_compression_control_swapchain( + mut self, + image_compression_control_swapchain: bool, + ) -> Self { + self.inner.image_compression_control_swapchain = image_compression_control_swapchain.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ImageSubresource2EXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub image_subresource: ImageSubresource, +} +impl ::std::default::Default for ImageSubresource2EXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + image_subresource: ImageSubresource::default(), + } + } +} +unsafe impl TaggedStructure for ImageSubresource2EXT { + const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_SUBRESOURCE_2_EXT; +} +impl ImageSubresource2EXT { + pub fn builder<'a>() -> ImageSubresource2EXTBuilder<'a> { + ImageSubresource2EXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ImageSubresource2EXTBuilder<'a> { + inner: ImageSubresource2EXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ImageSubresource2EXTBuilder<'a> { + type Target = ImageSubresource2EXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ImageSubresource2EXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ImageSubresource2EXTBuilder<'a> { + #[inline] + pub fn image_subresource(mut self, image_subresource: ImageSubresource) -> Self { + self.inner.image_subresource = image_subresource; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ImageSubresource2EXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SubresourceLayout2EXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub subresource_layout: SubresourceLayout, +} +impl ::std::default::Default for SubresourceLayout2EXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + subresource_layout: SubresourceLayout::default(), + } + } +} +unsafe impl TaggedStructure for SubresourceLayout2EXT { + const STRUCTURE_TYPE: StructureType = StructureType::SUBRESOURCE_LAYOUT_2_EXT; +} +impl SubresourceLayout2EXT { + pub fn builder<'a>() -> SubresourceLayout2EXTBuilder<'a> { + SubresourceLayout2EXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SubresourceLayout2EXTBuilder<'a> { + inner: SubresourceLayout2EXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsSubresourceLayout2EXT {} +impl<'a> ::std::ops::Deref for SubresourceLayout2EXTBuilder<'a> { + type Target = SubresourceLayout2EXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SubresourceLayout2EXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SubresourceLayout2EXTBuilder<'a> { + #[inline] + pub fn subresource_layout(mut self, subresource_layout: SubresourceLayout) -> Self { + self.inner.subresource_layout = subresource_layout; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*mut T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SubresourceLayout2EXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct RenderPassCreationControlEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub disallow_merging: Bool32, +} +impl ::std::default::Default for RenderPassCreationControlEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + disallow_merging: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for RenderPassCreationControlEXT { + const STRUCTURE_TYPE: StructureType = StructureType::RENDER_PASS_CREATION_CONTROL_EXT; +} +impl RenderPassCreationControlEXT { + pub fn builder<'a>() -> RenderPassCreationControlEXTBuilder<'a> { + RenderPassCreationControlEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct RenderPassCreationControlEXTBuilder<'a> { + inner: RenderPassCreationControlEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsRenderPassCreateInfo2 for RenderPassCreationControlEXTBuilder<'_> {} +unsafe impl ExtendsRenderPassCreateInfo2 for RenderPassCreationControlEXT {} +unsafe impl ExtendsSubpassDescription2 for RenderPassCreationControlEXTBuilder<'_> {} +unsafe impl ExtendsSubpassDescription2 for RenderPassCreationControlEXT {} +impl<'a> ::std::ops::Deref for RenderPassCreationControlEXTBuilder<'a> { + type Target = RenderPassCreationControlEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for RenderPassCreationControlEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> RenderPassCreationControlEXTBuilder<'a> { + #[inline] + pub fn disallow_merging(mut self, disallow_merging: bool) -> Self { + self.inner.disallow_merging = disallow_merging.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> RenderPassCreationControlEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct RenderPassCreationFeedbackInfoEXT { + pub post_merge_subpass_count: u32, +} +impl RenderPassCreationFeedbackInfoEXT { + pub fn builder<'a>() -> RenderPassCreationFeedbackInfoEXTBuilder<'a> { + RenderPassCreationFeedbackInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct RenderPassCreationFeedbackInfoEXTBuilder<'a> { + inner: RenderPassCreationFeedbackInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for RenderPassCreationFeedbackInfoEXTBuilder<'a> { + type Target = RenderPassCreationFeedbackInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for RenderPassCreationFeedbackInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> RenderPassCreationFeedbackInfoEXTBuilder<'a> { + #[inline] + pub fn post_merge_subpass_count(mut self, post_merge_subpass_count: u32) -> Self { + self.inner.post_merge_subpass_count = post_merge_subpass_count; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> RenderPassCreationFeedbackInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct RenderPassCreationFeedbackCreateInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub p_render_pass_feedback: *mut RenderPassCreationFeedbackInfoEXT, +} +impl ::std::default::Default for RenderPassCreationFeedbackCreateInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + p_render_pass_feedback: ::std::ptr::null_mut(), + } + } +} +unsafe impl TaggedStructure for RenderPassCreationFeedbackCreateInfoEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::RENDER_PASS_CREATION_FEEDBACK_CREATE_INFO_EXT; +} +impl RenderPassCreationFeedbackCreateInfoEXT { + pub fn builder<'a>() -> RenderPassCreationFeedbackCreateInfoEXTBuilder<'a> { + RenderPassCreationFeedbackCreateInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct RenderPassCreationFeedbackCreateInfoEXTBuilder<'a> { + inner: RenderPassCreationFeedbackCreateInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsRenderPassCreateInfo2 for RenderPassCreationFeedbackCreateInfoEXTBuilder<'_> {} +unsafe impl ExtendsRenderPassCreateInfo2 for RenderPassCreationFeedbackCreateInfoEXT {} +impl<'a> ::std::ops::Deref for RenderPassCreationFeedbackCreateInfoEXTBuilder<'a> { + type Target = RenderPassCreationFeedbackCreateInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for RenderPassCreationFeedbackCreateInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> RenderPassCreationFeedbackCreateInfoEXTBuilder<'a> { + #[inline] + pub fn render_pass_feedback( + mut self, + render_pass_feedback: &'a mut RenderPassCreationFeedbackInfoEXT, + ) -> Self { + self.inner.p_render_pass_feedback = render_pass_feedback; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> RenderPassCreationFeedbackCreateInfoEXT { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct RenderPassSubpassFeedbackInfoEXT { + pub subpass_merge_status: SubpassMergeStatusEXT, + pub description: [c_char; MAX_DESCRIPTION_SIZE], + pub post_merge_index: u32, +} +#[cfg(feature = "debug")] +impl fmt::Debug for RenderPassSubpassFeedbackInfoEXT { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fmt.debug_struct("RenderPassSubpassFeedbackInfoEXT") + .field("subpass_merge_status", &self.subpass_merge_status) + .field("description", &unsafe { + ::std::ffi::CStr::from_ptr(self.description.as_ptr()) + }) + .field("post_merge_index", &self.post_merge_index) + .finish() + } +} +impl ::std::default::Default for RenderPassSubpassFeedbackInfoEXT { + #[inline] + fn default() -> Self { + Self { + subpass_merge_status: SubpassMergeStatusEXT::default(), + description: unsafe { ::std::mem::zeroed() }, + post_merge_index: u32::default(), + } + } +} +impl RenderPassSubpassFeedbackInfoEXT { + pub fn builder<'a>() -> RenderPassSubpassFeedbackInfoEXTBuilder<'a> { + RenderPassSubpassFeedbackInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct RenderPassSubpassFeedbackInfoEXTBuilder<'a> { + inner: RenderPassSubpassFeedbackInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for RenderPassSubpassFeedbackInfoEXTBuilder<'a> { + type Target = RenderPassSubpassFeedbackInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for RenderPassSubpassFeedbackInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> RenderPassSubpassFeedbackInfoEXTBuilder<'a> { + #[inline] + pub fn subpass_merge_status(mut self, subpass_merge_status: SubpassMergeStatusEXT) -> Self { + self.inner.subpass_merge_status = subpass_merge_status; + self + } + #[inline] + pub fn description(mut self, description: [c_char; MAX_DESCRIPTION_SIZE]) -> Self { + self.inner.description = description; + self + } + #[inline] + pub fn post_merge_index(mut self, post_merge_index: u32) -> Self { + self.inner.post_merge_index = post_merge_index; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> RenderPassSubpassFeedbackInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct RenderPassSubpassFeedbackCreateInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub p_subpass_feedback: *mut RenderPassSubpassFeedbackInfoEXT, +} +impl ::std::default::Default for RenderPassSubpassFeedbackCreateInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + p_subpass_feedback: ::std::ptr::null_mut(), + } + } +} +unsafe impl TaggedStructure for RenderPassSubpassFeedbackCreateInfoEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::RENDER_PASS_SUBPASS_FEEDBACK_CREATE_INFO_EXT; +} +impl RenderPassSubpassFeedbackCreateInfoEXT { + pub fn builder<'a>() -> RenderPassSubpassFeedbackCreateInfoEXTBuilder<'a> { + RenderPassSubpassFeedbackCreateInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct RenderPassSubpassFeedbackCreateInfoEXTBuilder<'a> { + inner: RenderPassSubpassFeedbackCreateInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsSubpassDescription2 for RenderPassSubpassFeedbackCreateInfoEXTBuilder<'_> {} +unsafe impl ExtendsSubpassDescription2 for RenderPassSubpassFeedbackCreateInfoEXT {} +impl<'a> ::std::ops::Deref for RenderPassSubpassFeedbackCreateInfoEXTBuilder<'a> { + type Target = RenderPassSubpassFeedbackCreateInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for RenderPassSubpassFeedbackCreateInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> RenderPassSubpassFeedbackCreateInfoEXTBuilder<'a> { + #[inline] + pub fn subpass_feedback( + mut self, + subpass_feedback: &'a mut RenderPassSubpassFeedbackInfoEXT, + ) -> Self { + self.inner.p_subpass_feedback = subpass_feedback; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> RenderPassSubpassFeedbackCreateInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceSubpassMergeFeedbackFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub subpass_merge_feedback: Bool32, +} +impl ::std::default::Default for PhysicalDeviceSubpassMergeFeedbackFeaturesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + subpass_merge_feedback: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceSubpassMergeFeedbackFeaturesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT; +} +impl PhysicalDeviceSubpassMergeFeedbackFeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceSubpassMergeFeedbackFeaturesEXTBuilder<'a> { + PhysicalDeviceSubpassMergeFeedbackFeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceSubpassMergeFeedbackFeaturesEXTBuilder<'a> { + inner: PhysicalDeviceSubpassMergeFeedbackFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceSubpassMergeFeedbackFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceSubpassMergeFeedbackFeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceSubpassMergeFeedbackFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceSubpassMergeFeedbackFeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceSubpassMergeFeedbackFeaturesEXTBuilder<'a> { + type Target = PhysicalDeviceSubpassMergeFeedbackFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceSubpassMergeFeedbackFeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceSubpassMergeFeedbackFeaturesEXTBuilder<'a> { + #[inline] + pub fn subpass_merge_feedback(mut self, subpass_merge_feedback: bool) -> Self { + self.inner.subpass_merge_feedback = subpass_merge_feedback.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceSubpassMergeFeedbackFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct MicromapBuildInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub ty: MicromapTypeEXT, + pub flags: BuildMicromapFlagsEXT, + pub mode: BuildMicromapModeEXT, + pub dst_micromap: MicromapEXT, + pub usage_counts_count: u32, + pub p_usage_counts: *const MicromapUsageEXT, + pub pp_usage_counts: *const *const MicromapUsageEXT, + pub data: DeviceOrHostAddressConstKHR, + pub scratch_data: DeviceOrHostAddressKHR, + pub triangle_array: DeviceOrHostAddressConstKHR, + pub triangle_array_stride: DeviceSize, +} +#[cfg(feature = "debug")] +impl fmt::Debug for MicromapBuildInfoEXT { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fmt.debug_struct("MicromapBuildInfoEXT") + .field("s_type", &self.s_type) + .field("p_next", &self.p_next) + .field("ty", &self.ty) + .field("flags", &self.flags) + .field("mode", &self.mode) + .field("dst_micromap", &self.dst_micromap) + .field("usage_counts_count", &self.usage_counts_count) + .field("p_usage_counts", &self.p_usage_counts) + .field("pp_usage_counts", &self.pp_usage_counts) + .field("data", &"union") + .field("scratch_data", &"union") + .field("triangle_array", &"union") + .field("triangle_array_stride", &self.triangle_array_stride) + .finish() + } +} +impl ::std::default::Default for MicromapBuildInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + ty: MicromapTypeEXT::default(), + flags: BuildMicromapFlagsEXT::default(), + mode: BuildMicromapModeEXT::default(), + dst_micromap: MicromapEXT::default(), + usage_counts_count: u32::default(), + p_usage_counts: ::std::ptr::null(), + pp_usage_counts: ::std::ptr::null(), + data: DeviceOrHostAddressConstKHR::default(), + scratch_data: DeviceOrHostAddressKHR::default(), + triangle_array: DeviceOrHostAddressConstKHR::default(), + triangle_array_stride: DeviceSize::default(), + } + } +} +unsafe impl TaggedStructure for MicromapBuildInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::MICROMAP_BUILD_INFO_EXT; +} +impl MicromapBuildInfoEXT { + pub fn builder<'a>() -> MicromapBuildInfoEXTBuilder<'a> { + MicromapBuildInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct MicromapBuildInfoEXTBuilder<'a> { + inner: MicromapBuildInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for MicromapBuildInfoEXTBuilder<'a> { + type Target = MicromapBuildInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for MicromapBuildInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> MicromapBuildInfoEXTBuilder<'a> { + #[inline] + pub fn ty(mut self, ty: MicromapTypeEXT) -> Self { + self.inner.ty = ty; + self + } + #[inline] + pub fn flags(mut self, flags: BuildMicromapFlagsEXT) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn mode(mut self, mode: BuildMicromapModeEXT) -> Self { + self.inner.mode = mode; + self + } + #[inline] + pub fn dst_micromap(mut self, dst_micromap: MicromapEXT) -> Self { + self.inner.dst_micromap = dst_micromap; + self + } + #[inline] + pub fn usage_counts(mut self, usage_counts: &'a [MicromapUsageEXT]) -> Self { + self.inner.usage_counts_count = usage_counts.len() as _; + self.inner.p_usage_counts = usage_counts.as_ptr(); + self + } + #[inline] + pub fn usage_counts_ptrs(mut self, usage_counts_ptrs: &'a [&'a MicromapUsageEXT]) -> Self { + self.inner.usage_counts_count = usage_counts_ptrs.len() as _; + self.inner.pp_usage_counts = usage_counts_ptrs.as_ptr().cast(); + self + } + #[inline] + pub fn data(mut self, data: DeviceOrHostAddressConstKHR) -> Self { + self.inner.data = data; + self + } + #[inline] + pub fn scratch_data(mut self, scratch_data: DeviceOrHostAddressKHR) -> Self { + self.inner.scratch_data = scratch_data; + self + } + #[inline] + pub fn triangle_array(mut self, triangle_array: DeviceOrHostAddressConstKHR) -> Self { + self.inner.triangle_array = triangle_array; + self + } + #[inline] + pub fn triangle_array_stride(mut self, triangle_array_stride: DeviceSize) -> Self { + self.inner.triangle_array_stride = triangle_array_stride; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> MicromapBuildInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct MicromapCreateInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub create_flags: MicromapCreateFlagsEXT, + pub buffer: Buffer, + pub offset: DeviceSize, + pub size: DeviceSize, + pub ty: MicromapTypeEXT, + pub device_address: DeviceAddress, +} +impl ::std::default::Default for MicromapCreateInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + create_flags: MicromapCreateFlagsEXT::default(), + buffer: Buffer::default(), + offset: DeviceSize::default(), + size: DeviceSize::default(), + ty: MicromapTypeEXT::default(), + device_address: DeviceAddress::default(), + } + } +} +unsafe impl TaggedStructure for MicromapCreateInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::MICROMAP_CREATE_INFO_EXT; +} +impl MicromapCreateInfoEXT { + pub fn builder<'a>() -> MicromapCreateInfoEXTBuilder<'a> { + MicromapCreateInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct MicromapCreateInfoEXTBuilder<'a> { + inner: MicromapCreateInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for MicromapCreateInfoEXTBuilder<'a> { + type Target = MicromapCreateInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for MicromapCreateInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> MicromapCreateInfoEXTBuilder<'a> { + #[inline] + pub fn create_flags(mut self, create_flags: MicromapCreateFlagsEXT) -> Self { + self.inner.create_flags = create_flags; + self + } + #[inline] + pub fn buffer(mut self, buffer: Buffer) -> Self { + self.inner.buffer = buffer; + self + } + #[inline] + pub fn offset(mut self, offset: DeviceSize) -> Self { + self.inner.offset = offset; + self + } + #[inline] + pub fn size(mut self, size: DeviceSize) -> Self { + self.inner.size = size; + self + } + #[inline] + pub fn ty(mut self, ty: MicromapTypeEXT) -> Self { + self.inner.ty = ty; + self + } + #[inline] + pub fn device_address(mut self, device_address: DeviceAddress) -> Self { + self.inner.device_address = device_address; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> MicromapCreateInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct MicromapVersionInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub p_version_data: *const [u8; 2 * UUID_SIZE], +} +impl ::std::default::Default for MicromapVersionInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + p_version_data: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for MicromapVersionInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::MICROMAP_VERSION_INFO_EXT; +} +impl MicromapVersionInfoEXT { + pub fn builder<'a>() -> MicromapVersionInfoEXTBuilder<'a> { + MicromapVersionInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct MicromapVersionInfoEXTBuilder<'a> { + inner: MicromapVersionInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for MicromapVersionInfoEXTBuilder<'a> { + type Target = MicromapVersionInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for MicromapVersionInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> MicromapVersionInfoEXTBuilder<'a> { + #[inline] + pub fn version_data(mut self, version_data: &'a [u8; 2 * UUID_SIZE]) -> Self { + self.inner.p_version_data = version_data; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> MicromapVersionInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct CopyMicromapInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub src: MicromapEXT, + pub dst: MicromapEXT, + pub mode: CopyMicromapModeEXT, +} +impl ::std::default::Default for CopyMicromapInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + src: MicromapEXT::default(), + dst: MicromapEXT::default(), + mode: CopyMicromapModeEXT::default(), + } + } +} +unsafe impl TaggedStructure for CopyMicromapInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::COPY_MICROMAP_INFO_EXT; +} +impl CopyMicromapInfoEXT { + pub fn builder<'a>() -> CopyMicromapInfoEXTBuilder<'a> { + CopyMicromapInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct CopyMicromapInfoEXTBuilder<'a> { + inner: CopyMicromapInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for CopyMicromapInfoEXTBuilder<'a> { + type Target = CopyMicromapInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for CopyMicromapInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> CopyMicromapInfoEXTBuilder<'a> { + #[inline] + pub fn src(mut self, src: MicromapEXT) -> Self { + self.inner.src = src; + self + } + #[inline] + pub fn dst(mut self, dst: MicromapEXT) -> Self { + self.inner.dst = dst; + self + } + #[inline] + pub fn mode(mut self, mode: CopyMicromapModeEXT) -> Self { + self.inner.mode = mode; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> CopyMicromapInfoEXT { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct CopyMicromapToMemoryInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub src: MicromapEXT, + pub dst: DeviceOrHostAddressKHR, + pub mode: CopyMicromapModeEXT, +} +#[cfg(feature = "debug")] +impl fmt::Debug for CopyMicromapToMemoryInfoEXT { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fmt.debug_struct("CopyMicromapToMemoryInfoEXT") + .field("s_type", &self.s_type) + .field("p_next", &self.p_next) + .field("src", &self.src) + .field("dst", &"union") + .field("mode", &self.mode) + .finish() + } +} +impl ::std::default::Default for CopyMicromapToMemoryInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + src: MicromapEXT::default(), + dst: DeviceOrHostAddressKHR::default(), + mode: CopyMicromapModeEXT::default(), + } + } +} +unsafe impl TaggedStructure for CopyMicromapToMemoryInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::COPY_MICROMAP_TO_MEMORY_INFO_EXT; +} +impl CopyMicromapToMemoryInfoEXT { + pub fn builder<'a>() -> CopyMicromapToMemoryInfoEXTBuilder<'a> { + CopyMicromapToMemoryInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct CopyMicromapToMemoryInfoEXTBuilder<'a> { + inner: CopyMicromapToMemoryInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for CopyMicromapToMemoryInfoEXTBuilder<'a> { + type Target = CopyMicromapToMemoryInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for CopyMicromapToMemoryInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> CopyMicromapToMemoryInfoEXTBuilder<'a> { + #[inline] + pub fn src(mut self, src: MicromapEXT) -> Self { + self.inner.src = src; + self + } + #[inline] + pub fn dst(mut self, dst: DeviceOrHostAddressKHR) -> Self { + self.inner.dst = dst; + self + } + #[inline] + pub fn mode(mut self, mode: CopyMicromapModeEXT) -> Self { + self.inner.mode = mode; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> CopyMicromapToMemoryInfoEXT { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct CopyMemoryToMicromapInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub src: DeviceOrHostAddressConstKHR, + pub dst: MicromapEXT, + pub mode: CopyMicromapModeEXT, +} +#[cfg(feature = "debug")] +impl fmt::Debug for CopyMemoryToMicromapInfoEXT { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fmt.debug_struct("CopyMemoryToMicromapInfoEXT") + .field("s_type", &self.s_type) + .field("p_next", &self.p_next) + .field("src", &"union") + .field("dst", &self.dst) + .field("mode", &self.mode) + .finish() + } +} +impl ::std::default::Default for CopyMemoryToMicromapInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + src: DeviceOrHostAddressConstKHR::default(), + dst: MicromapEXT::default(), + mode: CopyMicromapModeEXT::default(), + } + } +} +unsafe impl TaggedStructure for CopyMemoryToMicromapInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::COPY_MEMORY_TO_MICROMAP_INFO_EXT; +} +impl CopyMemoryToMicromapInfoEXT { + pub fn builder<'a>() -> CopyMemoryToMicromapInfoEXTBuilder<'a> { + CopyMemoryToMicromapInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct CopyMemoryToMicromapInfoEXTBuilder<'a> { + inner: CopyMemoryToMicromapInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for CopyMemoryToMicromapInfoEXTBuilder<'a> { + type Target = CopyMemoryToMicromapInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for CopyMemoryToMicromapInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> CopyMemoryToMicromapInfoEXTBuilder<'a> { + #[inline] + pub fn src(mut self, src: DeviceOrHostAddressConstKHR) -> Self { + self.inner.src = src; + self + } + #[inline] + pub fn dst(mut self, dst: MicromapEXT) -> Self { + self.inner.dst = dst; + self + } + #[inline] + pub fn mode(mut self, mode: CopyMicromapModeEXT) -> Self { + self.inner.mode = mode; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> CopyMemoryToMicromapInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct MicromapBuildSizesInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub micromap_size: DeviceSize, + pub build_scratch_size: DeviceSize, + pub discardable: Bool32, +} +impl ::std::default::Default for MicromapBuildSizesInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + micromap_size: DeviceSize::default(), + build_scratch_size: DeviceSize::default(), + discardable: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for MicromapBuildSizesInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::MICROMAP_BUILD_SIZES_INFO_EXT; +} +impl MicromapBuildSizesInfoEXT { + pub fn builder<'a>() -> MicromapBuildSizesInfoEXTBuilder<'a> { + MicromapBuildSizesInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct MicromapBuildSizesInfoEXTBuilder<'a> { + inner: MicromapBuildSizesInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for MicromapBuildSizesInfoEXTBuilder<'a> { + type Target = MicromapBuildSizesInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for MicromapBuildSizesInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> MicromapBuildSizesInfoEXTBuilder<'a> { + #[inline] + pub fn micromap_size(mut self, micromap_size: DeviceSize) -> Self { + self.inner.micromap_size = micromap_size; + self + } + #[inline] + pub fn build_scratch_size(mut self, build_scratch_size: DeviceSize) -> Self { + self.inner.build_scratch_size = build_scratch_size; + self + } + #[inline] + pub fn discardable(mut self, discardable: bool) -> Self { + self.inner.discardable = discardable.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> MicromapBuildSizesInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct MicromapUsageEXT { + pub count: u32, + pub subdivision_level: u32, + pub format: u32, +} +impl MicromapUsageEXT { + pub fn builder<'a>() -> MicromapUsageEXTBuilder<'a> { + MicromapUsageEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct MicromapUsageEXTBuilder<'a> { + inner: MicromapUsageEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for MicromapUsageEXTBuilder<'a> { + type Target = MicromapUsageEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for MicromapUsageEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> MicromapUsageEXTBuilder<'a> { + #[inline] + pub fn count(mut self, count: u32) -> Self { + self.inner.count = count; + self + } + #[inline] + pub fn subdivision_level(mut self, subdivision_level: u32) -> Self { + self.inner.subdivision_level = subdivision_level; + self + } + #[inline] + pub fn format(mut self, format: u32) -> Self { + self.inner.format = format; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> MicromapUsageEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct MicromapTriangleEXT { + pub data_offset: u32, + pub subdivision_level: u16, + pub format: u16, +} +impl MicromapTriangleEXT { + pub fn builder<'a>() -> MicromapTriangleEXTBuilder<'a> { + MicromapTriangleEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct MicromapTriangleEXTBuilder<'a> { + inner: MicromapTriangleEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for MicromapTriangleEXTBuilder<'a> { + type Target = MicromapTriangleEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for MicromapTriangleEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> MicromapTriangleEXTBuilder<'a> { + #[inline] + pub fn data_offset(mut self, data_offset: u32) -> Self { + self.inner.data_offset = data_offset; + self + } + #[inline] + pub fn subdivision_level(mut self, subdivision_level: u16) -> Self { + self.inner.subdivision_level = subdivision_level; + self + } + #[inline] + pub fn format(mut self, format: u16) -> Self { + self.inner.format = format; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> MicromapTriangleEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceOpacityMicromapFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub micromap: Bool32, + pub micromap_capture_replay: Bool32, + pub micromap_host_commands: Bool32, +} +impl ::std::default::Default for PhysicalDeviceOpacityMicromapFeaturesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + micromap: Bool32::default(), + micromap_capture_replay: Bool32::default(), + micromap_host_commands: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceOpacityMicromapFeaturesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT; +} +impl PhysicalDeviceOpacityMicromapFeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceOpacityMicromapFeaturesEXTBuilder<'a> { + PhysicalDeviceOpacityMicromapFeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceOpacityMicromapFeaturesEXTBuilder<'a> { + inner: PhysicalDeviceOpacityMicromapFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceOpacityMicromapFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceOpacityMicromapFeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceOpacityMicromapFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceOpacityMicromapFeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceOpacityMicromapFeaturesEXTBuilder<'a> { + type Target = PhysicalDeviceOpacityMicromapFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceOpacityMicromapFeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceOpacityMicromapFeaturesEXTBuilder<'a> { + #[inline] + pub fn micromap(mut self, micromap: bool) -> Self { + self.inner.micromap = micromap.into(); + self + } + #[inline] + pub fn micromap_capture_replay(mut self, micromap_capture_replay: bool) -> Self { + self.inner.micromap_capture_replay = micromap_capture_replay.into(); + self + } + #[inline] + pub fn micromap_host_commands(mut self, micromap_host_commands: bool) -> Self { + self.inner.micromap_host_commands = micromap_host_commands.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceOpacityMicromapFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceOpacityMicromapPropertiesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub max_opacity2_state_subdivision_level: u32, + pub max_opacity4_state_subdivision_level: u32, +} +impl ::std::default::Default for PhysicalDeviceOpacityMicromapPropertiesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + max_opacity2_state_subdivision_level: u32::default(), + max_opacity4_state_subdivision_level: u32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceOpacityMicromapPropertiesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT; +} +impl PhysicalDeviceOpacityMicromapPropertiesEXT { + pub fn builder<'a>() -> PhysicalDeviceOpacityMicromapPropertiesEXTBuilder<'a> { + PhysicalDeviceOpacityMicromapPropertiesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceOpacityMicromapPropertiesEXTBuilder<'a> { + inner: PhysicalDeviceOpacityMicromapPropertiesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceOpacityMicromapPropertiesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceOpacityMicromapPropertiesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceOpacityMicromapPropertiesEXTBuilder<'a> { + type Target = PhysicalDeviceOpacityMicromapPropertiesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceOpacityMicromapPropertiesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceOpacityMicromapPropertiesEXTBuilder<'a> { + #[inline] + pub fn max_opacity2_state_subdivision_level( + mut self, + max_opacity2_state_subdivision_level: u32, + ) -> Self { + self.inner.max_opacity2_state_subdivision_level = max_opacity2_state_subdivision_level; + self + } + #[inline] + pub fn max_opacity4_state_subdivision_level( + mut self, + max_opacity4_state_subdivision_level: u32, + ) -> Self { + self.inner.max_opacity4_state_subdivision_level = max_opacity4_state_subdivision_level; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceOpacityMicromapPropertiesEXT { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct AccelerationStructureTrianglesOpacityMicromapEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub index_type: IndexType, + pub index_buffer: DeviceOrHostAddressConstKHR, + pub index_stride: DeviceSize, + pub base_triangle: u32, + pub usage_counts_count: u32, + pub p_usage_counts: *const MicromapUsageEXT, + pub pp_usage_counts: *const *const MicromapUsageEXT, + pub micromap: MicromapEXT, +} +#[cfg(feature = "debug")] +impl fmt::Debug for AccelerationStructureTrianglesOpacityMicromapEXT { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fmt.debug_struct("AccelerationStructureTrianglesOpacityMicromapEXT") + .field("s_type", &self.s_type) + .field("p_next", &self.p_next) + .field("index_type", &self.index_type) + .field("index_buffer", &"union") + .field("index_stride", &self.index_stride) + .field("base_triangle", &self.base_triangle) + .field("usage_counts_count", &self.usage_counts_count) + .field("p_usage_counts", &self.p_usage_counts) + .field("pp_usage_counts", &self.pp_usage_counts) + .field("micromap", &self.micromap) + .finish() + } +} +impl ::std::default::Default for AccelerationStructureTrianglesOpacityMicromapEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + index_type: IndexType::default(), + index_buffer: DeviceOrHostAddressConstKHR::default(), + index_stride: DeviceSize::default(), + base_triangle: u32::default(), + usage_counts_count: u32::default(), + p_usage_counts: ::std::ptr::null(), + pp_usage_counts: ::std::ptr::null(), + micromap: MicromapEXT::default(), + } + } +} +unsafe impl TaggedStructure for AccelerationStructureTrianglesOpacityMicromapEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_EXT; +} +impl AccelerationStructureTrianglesOpacityMicromapEXT { + pub fn builder<'a>() -> AccelerationStructureTrianglesOpacityMicromapEXTBuilder<'a> { + AccelerationStructureTrianglesOpacityMicromapEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct AccelerationStructureTrianglesOpacityMicromapEXTBuilder<'a> { + inner: AccelerationStructureTrianglesOpacityMicromapEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsAccelerationStructureGeometryTrianglesDataKHR + for AccelerationStructureTrianglesOpacityMicromapEXTBuilder<'_> +{ +} +unsafe impl ExtendsAccelerationStructureGeometryTrianglesDataKHR + for AccelerationStructureTrianglesOpacityMicromapEXT +{ +} +impl<'a> ::std::ops::Deref for AccelerationStructureTrianglesOpacityMicromapEXTBuilder<'a> { + type Target = AccelerationStructureTrianglesOpacityMicromapEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for AccelerationStructureTrianglesOpacityMicromapEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> AccelerationStructureTrianglesOpacityMicromapEXTBuilder<'a> { + #[inline] + pub fn index_type(mut self, index_type: IndexType) -> Self { + self.inner.index_type = index_type; + self + } + #[inline] + pub fn index_buffer(mut self, index_buffer: DeviceOrHostAddressConstKHR) -> Self { + self.inner.index_buffer = index_buffer; + self + } + #[inline] + pub fn index_stride(mut self, index_stride: DeviceSize) -> Self { + self.inner.index_stride = index_stride; + self + } + #[inline] + pub fn base_triangle(mut self, base_triangle: u32) -> Self { + self.inner.base_triangle = base_triangle; + self + } + #[inline] + pub fn usage_counts(mut self, usage_counts: &'a [MicromapUsageEXT]) -> Self { + self.inner.usage_counts_count = usage_counts.len() as _; + self.inner.p_usage_counts = usage_counts.as_ptr(); + self + } + #[inline] + pub fn usage_counts_ptrs(mut self, usage_counts_ptrs: &'a [&'a MicromapUsageEXT]) -> Self { + self.inner.usage_counts_count = usage_counts_ptrs.len() as _; + self.inner.pp_usage_counts = usage_counts_ptrs.as_ptr().cast(); + self + } + #[inline] + pub fn micromap(mut self, micromap: MicromapEXT) -> Self { + self.inner.micromap = micromap; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> AccelerationStructureTrianglesOpacityMicromapEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PipelinePropertiesIdentifierEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub pipeline_identifier: [u8; UUID_SIZE], +} +impl ::std::default::Default for PipelinePropertiesIdentifierEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + pipeline_identifier: unsafe { ::std::mem::zeroed() }, + } + } +} +unsafe impl TaggedStructure for PipelinePropertiesIdentifierEXT { + const STRUCTURE_TYPE: StructureType = StructureType::PIPELINE_PROPERTIES_IDENTIFIER_EXT; +} +impl PipelinePropertiesIdentifierEXT { + pub fn builder<'a>() -> PipelinePropertiesIdentifierEXTBuilder<'a> { + PipelinePropertiesIdentifierEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PipelinePropertiesIdentifierEXTBuilder<'a> { + inner: PipelinePropertiesIdentifierEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for PipelinePropertiesIdentifierEXTBuilder<'a> { + type Target = PipelinePropertiesIdentifierEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PipelinePropertiesIdentifierEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PipelinePropertiesIdentifierEXTBuilder<'a> { + #[inline] + pub fn pipeline_identifier(mut self, pipeline_identifier: [u8; UUID_SIZE]) -> Self { + self.inner.pipeline_identifier = pipeline_identifier; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PipelinePropertiesIdentifierEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDevicePipelinePropertiesFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub pipeline_properties_identifier: Bool32, +} +impl ::std::default::Default for PhysicalDevicePipelinePropertiesFeaturesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + pipeline_properties_identifier: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDevicePipelinePropertiesFeaturesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT; +} +impl PhysicalDevicePipelinePropertiesFeaturesEXT { + pub fn builder<'a>() -> PhysicalDevicePipelinePropertiesFeaturesEXTBuilder<'a> { + PhysicalDevicePipelinePropertiesFeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDevicePipelinePropertiesFeaturesEXTBuilder<'a> { + inner: PhysicalDevicePipelinePropertiesFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDevicePipelinePropertiesFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePipelinePropertiesFeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePipelinePropertiesFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePipelinePropertiesFeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDevicePipelinePropertiesFeaturesEXTBuilder<'a> { + type Target = PhysicalDevicePipelinePropertiesFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDevicePipelinePropertiesFeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDevicePipelinePropertiesFeaturesEXTBuilder<'a> { + #[inline] + pub fn pipeline_properties_identifier(mut self, pipeline_properties_identifier: bool) -> Self { + self.inner.pipeline_properties_identifier = pipeline_properties_identifier.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDevicePipelinePropertiesFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub shader_early_and_late_fragment_tests: Bool32, +} +impl ::std::default::Default for PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + shader_early_and_late_fragment_tests: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD; +} +impl PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD { + pub fn builder<'a>() -> PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMDBuilder<'a> { + PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMDBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMDBuilder<'a> { + inner: PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMDBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD +{ +} +unsafe impl ExtendsDeviceCreateInfo + for PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMDBuilder<'_> +{ +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD {} +impl<'a> ::std::ops::Deref for PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMDBuilder<'a> { + type Target = PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut + for PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMDBuilder<'a> +{ + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMDBuilder<'a> { + #[inline] + pub fn shader_early_and_late_fragment_tests( + mut self, + shader_early_and_late_fragment_tests: bool, + ) -> Self { + self.inner.shader_early_and_late_fragment_tests = + shader_early_and_late_fragment_tests.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ExportMetalObjectCreateInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub export_object_type: ExportMetalObjectTypeFlagsEXT, +} +impl ::std::default::Default for ExportMetalObjectCreateInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + export_object_type: ExportMetalObjectTypeFlagsEXT::default(), + } + } +} +unsafe impl TaggedStructure for ExportMetalObjectCreateInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::EXPORT_METAL_OBJECT_CREATE_INFO_EXT; +} +impl ExportMetalObjectCreateInfoEXT { + pub fn builder<'a>() -> ExportMetalObjectCreateInfoEXTBuilder<'a> { + ExportMetalObjectCreateInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ExportMetalObjectCreateInfoEXTBuilder<'a> { + inner: ExportMetalObjectCreateInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsInstanceCreateInfo for ExportMetalObjectCreateInfoEXTBuilder<'_> {} +unsafe impl ExtendsInstanceCreateInfo for ExportMetalObjectCreateInfoEXT {} +unsafe impl ExtendsMemoryAllocateInfo for ExportMetalObjectCreateInfoEXTBuilder<'_> {} +unsafe impl ExtendsMemoryAllocateInfo for ExportMetalObjectCreateInfoEXT {} +unsafe impl ExtendsImageCreateInfo for ExportMetalObjectCreateInfoEXTBuilder<'_> {} +unsafe impl ExtendsImageCreateInfo for ExportMetalObjectCreateInfoEXT {} +unsafe impl ExtendsImageViewCreateInfo for ExportMetalObjectCreateInfoEXTBuilder<'_> {} +unsafe impl ExtendsImageViewCreateInfo for ExportMetalObjectCreateInfoEXT {} +unsafe impl ExtendsBufferViewCreateInfo for ExportMetalObjectCreateInfoEXTBuilder<'_> {} +unsafe impl ExtendsBufferViewCreateInfo for ExportMetalObjectCreateInfoEXT {} +unsafe impl ExtendsSemaphoreCreateInfo for ExportMetalObjectCreateInfoEXTBuilder<'_> {} +unsafe impl ExtendsSemaphoreCreateInfo for ExportMetalObjectCreateInfoEXT {} +unsafe impl ExtendsEventCreateInfo for ExportMetalObjectCreateInfoEXTBuilder<'_> {} +unsafe impl ExtendsEventCreateInfo for ExportMetalObjectCreateInfoEXT {} +impl<'a> ::std::ops::Deref for ExportMetalObjectCreateInfoEXTBuilder<'a> { + type Target = ExportMetalObjectCreateInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ExportMetalObjectCreateInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ExportMetalObjectCreateInfoEXTBuilder<'a> { + #[inline] + pub fn export_object_type(mut self, export_object_type: ExportMetalObjectTypeFlagsEXT) -> Self { + self.inner.export_object_type = export_object_type; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ExportMetalObjectCreateInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ExportMetalObjectsInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, +} +impl ::std::default::Default for ExportMetalObjectsInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for ExportMetalObjectsInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::EXPORT_METAL_OBJECTS_INFO_EXT; +} +impl ExportMetalObjectsInfoEXT { + pub fn builder<'a>() -> ExportMetalObjectsInfoEXTBuilder<'a> { + ExportMetalObjectsInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ExportMetalObjectsInfoEXTBuilder<'a> { + inner: ExportMetalObjectsInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsExportMetalObjectsInfoEXT {} +impl<'a> ::std::ops::Deref for ExportMetalObjectsInfoEXTBuilder<'a> { + type Target = ExportMetalObjectsInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ExportMetalObjectsInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ExportMetalObjectsInfoEXTBuilder<'a> { + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ExportMetalObjectsInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ExportMetalDeviceInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub mtl_device: MTLDevice_id, +} +impl ::std::default::Default for ExportMetalDeviceInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + mtl_device: unsafe { ::std::mem::zeroed() }, + } + } +} +unsafe impl TaggedStructure for ExportMetalDeviceInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::EXPORT_METAL_DEVICE_INFO_EXT; +} +impl ExportMetalDeviceInfoEXT { + pub fn builder<'a>() -> ExportMetalDeviceInfoEXTBuilder<'a> { + ExportMetalDeviceInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ExportMetalDeviceInfoEXTBuilder<'a> { + inner: ExportMetalDeviceInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsExportMetalObjectsInfoEXT for ExportMetalDeviceInfoEXTBuilder<'_> {} +unsafe impl ExtendsExportMetalObjectsInfoEXT for ExportMetalDeviceInfoEXT {} +impl<'a> ::std::ops::Deref for ExportMetalDeviceInfoEXTBuilder<'a> { + type Target = ExportMetalDeviceInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ExportMetalDeviceInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ExportMetalDeviceInfoEXTBuilder<'a> { + #[inline] + pub fn mtl_device(mut self, mtl_device: MTLDevice_id) -> Self { + self.inner.mtl_device = mtl_device; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ExportMetalDeviceInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ExportMetalCommandQueueInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub queue: Queue, + pub mtl_command_queue: MTLCommandQueue_id, +} +impl ::std::default::Default for ExportMetalCommandQueueInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + queue: Queue::default(), + mtl_command_queue: unsafe { ::std::mem::zeroed() }, + } + } +} +unsafe impl TaggedStructure for ExportMetalCommandQueueInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::EXPORT_METAL_COMMAND_QUEUE_INFO_EXT; +} +impl ExportMetalCommandQueueInfoEXT { + pub fn builder<'a>() -> ExportMetalCommandQueueInfoEXTBuilder<'a> { + ExportMetalCommandQueueInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ExportMetalCommandQueueInfoEXTBuilder<'a> { + inner: ExportMetalCommandQueueInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsExportMetalObjectsInfoEXT for ExportMetalCommandQueueInfoEXTBuilder<'_> {} +unsafe impl ExtendsExportMetalObjectsInfoEXT for ExportMetalCommandQueueInfoEXT {} +impl<'a> ::std::ops::Deref for ExportMetalCommandQueueInfoEXTBuilder<'a> { + type Target = ExportMetalCommandQueueInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ExportMetalCommandQueueInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ExportMetalCommandQueueInfoEXTBuilder<'a> { + #[inline] + pub fn queue(mut self, queue: Queue) -> Self { + self.inner.queue = queue; + self + } + #[inline] + pub fn mtl_command_queue(mut self, mtl_command_queue: MTLCommandQueue_id) -> Self { + self.inner.mtl_command_queue = mtl_command_queue; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ExportMetalCommandQueueInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ExportMetalBufferInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub memory: DeviceMemory, + pub mtl_buffer: MTLBuffer_id, +} +impl ::std::default::Default for ExportMetalBufferInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + memory: DeviceMemory::default(), + mtl_buffer: unsafe { ::std::mem::zeroed() }, + } + } +} +unsafe impl TaggedStructure for ExportMetalBufferInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::EXPORT_METAL_BUFFER_INFO_EXT; +} +impl ExportMetalBufferInfoEXT { + pub fn builder<'a>() -> ExportMetalBufferInfoEXTBuilder<'a> { + ExportMetalBufferInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ExportMetalBufferInfoEXTBuilder<'a> { + inner: ExportMetalBufferInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsExportMetalObjectsInfoEXT for ExportMetalBufferInfoEXTBuilder<'_> {} +unsafe impl ExtendsExportMetalObjectsInfoEXT for ExportMetalBufferInfoEXT {} +impl<'a> ::std::ops::Deref for ExportMetalBufferInfoEXTBuilder<'a> { + type Target = ExportMetalBufferInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ExportMetalBufferInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ExportMetalBufferInfoEXTBuilder<'a> { + #[inline] + pub fn memory(mut self, memory: DeviceMemory) -> Self { + self.inner.memory = memory; + self + } + #[inline] + pub fn mtl_buffer(mut self, mtl_buffer: MTLBuffer_id) -> Self { + self.inner.mtl_buffer = mtl_buffer; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ExportMetalBufferInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ImportMetalBufferInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub mtl_buffer: MTLBuffer_id, +} +impl ::std::default::Default for ImportMetalBufferInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + mtl_buffer: unsafe { ::std::mem::zeroed() }, + } + } +} +unsafe impl TaggedStructure for ImportMetalBufferInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::IMPORT_METAL_BUFFER_INFO_EXT; +} +impl ImportMetalBufferInfoEXT { + pub fn builder<'a>() -> ImportMetalBufferInfoEXTBuilder<'a> { + ImportMetalBufferInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ImportMetalBufferInfoEXTBuilder<'a> { + inner: ImportMetalBufferInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsMemoryAllocateInfo for ImportMetalBufferInfoEXTBuilder<'_> {} +unsafe impl ExtendsMemoryAllocateInfo for ImportMetalBufferInfoEXT {} +impl<'a> ::std::ops::Deref for ImportMetalBufferInfoEXTBuilder<'a> { + type Target = ImportMetalBufferInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ImportMetalBufferInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ImportMetalBufferInfoEXTBuilder<'a> { + #[inline] + pub fn mtl_buffer(mut self, mtl_buffer: MTLBuffer_id) -> Self { + self.inner.mtl_buffer = mtl_buffer; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ImportMetalBufferInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ExportMetalTextureInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub image: Image, + pub image_view: ImageView, + pub buffer_view: BufferView, + pub plane: ImageAspectFlags, + pub mtl_texture: MTLTexture_id, +} +impl ::std::default::Default for ExportMetalTextureInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + image: Image::default(), + image_view: ImageView::default(), + buffer_view: BufferView::default(), + plane: ImageAspectFlags::default(), + mtl_texture: unsafe { ::std::mem::zeroed() }, + } + } +} +unsafe impl TaggedStructure for ExportMetalTextureInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::EXPORT_METAL_TEXTURE_INFO_EXT; +} +impl ExportMetalTextureInfoEXT { + pub fn builder<'a>() -> ExportMetalTextureInfoEXTBuilder<'a> { + ExportMetalTextureInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ExportMetalTextureInfoEXTBuilder<'a> { + inner: ExportMetalTextureInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsExportMetalObjectsInfoEXT for ExportMetalTextureInfoEXTBuilder<'_> {} +unsafe impl ExtendsExportMetalObjectsInfoEXT for ExportMetalTextureInfoEXT {} +impl<'a> ::std::ops::Deref for ExportMetalTextureInfoEXTBuilder<'a> { + type Target = ExportMetalTextureInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ExportMetalTextureInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ExportMetalTextureInfoEXTBuilder<'a> { + #[inline] + pub fn image(mut self, image: Image) -> Self { + self.inner.image = image; + self + } + #[inline] + pub fn image_view(mut self, image_view: ImageView) -> Self { + self.inner.image_view = image_view; + self + } + #[inline] + pub fn buffer_view(mut self, buffer_view: BufferView) -> Self { + self.inner.buffer_view = buffer_view; + self + } + #[inline] + pub fn plane(mut self, plane: ImageAspectFlags) -> Self { + self.inner.plane = plane; + self + } + #[inline] + pub fn mtl_texture(mut self, mtl_texture: MTLTexture_id) -> Self { + self.inner.mtl_texture = mtl_texture; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ExportMetalTextureInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ImportMetalTextureInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub plane: ImageAspectFlags, + pub mtl_texture: MTLTexture_id, +} +impl ::std::default::Default for ImportMetalTextureInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + plane: ImageAspectFlags::default(), + mtl_texture: unsafe { ::std::mem::zeroed() }, + } + } +} +unsafe impl TaggedStructure for ImportMetalTextureInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::IMPORT_METAL_TEXTURE_INFO_EXT; +} +impl ImportMetalTextureInfoEXT { + pub fn builder<'a>() -> ImportMetalTextureInfoEXTBuilder<'a> { + ImportMetalTextureInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ImportMetalTextureInfoEXTBuilder<'a> { + inner: ImportMetalTextureInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsImageCreateInfo for ImportMetalTextureInfoEXTBuilder<'_> {} +unsafe impl ExtendsImageCreateInfo for ImportMetalTextureInfoEXT {} +impl<'a> ::std::ops::Deref for ImportMetalTextureInfoEXTBuilder<'a> { + type Target = ImportMetalTextureInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ImportMetalTextureInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ImportMetalTextureInfoEXTBuilder<'a> { + #[inline] + pub fn plane(mut self, plane: ImageAspectFlags) -> Self { + self.inner.plane = plane; + self + } + #[inline] + pub fn mtl_texture(mut self, mtl_texture: MTLTexture_id) -> Self { + self.inner.mtl_texture = mtl_texture; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ImportMetalTextureInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ExportMetalIOSurfaceInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub image: Image, + pub io_surface: IOSurfaceRef, +} +impl ::std::default::Default for ExportMetalIOSurfaceInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + image: Image::default(), + io_surface: unsafe { ::std::mem::zeroed() }, + } + } +} +unsafe impl TaggedStructure for ExportMetalIOSurfaceInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::EXPORT_METAL_IO_SURFACE_INFO_EXT; +} +impl ExportMetalIOSurfaceInfoEXT { + pub fn builder<'a>() -> ExportMetalIOSurfaceInfoEXTBuilder<'a> { + ExportMetalIOSurfaceInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ExportMetalIOSurfaceInfoEXTBuilder<'a> { + inner: ExportMetalIOSurfaceInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsExportMetalObjectsInfoEXT for ExportMetalIOSurfaceInfoEXTBuilder<'_> {} +unsafe impl ExtendsExportMetalObjectsInfoEXT for ExportMetalIOSurfaceInfoEXT {} +impl<'a> ::std::ops::Deref for ExportMetalIOSurfaceInfoEXTBuilder<'a> { + type Target = ExportMetalIOSurfaceInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ExportMetalIOSurfaceInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ExportMetalIOSurfaceInfoEXTBuilder<'a> { + #[inline] + pub fn image(mut self, image: Image) -> Self { + self.inner.image = image; + self + } + #[inline] + pub fn io_surface(mut self, io_surface: IOSurfaceRef) -> Self { + self.inner.io_surface = io_surface; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ExportMetalIOSurfaceInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ImportMetalIOSurfaceInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub io_surface: IOSurfaceRef, +} +impl ::std::default::Default for ImportMetalIOSurfaceInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + io_surface: unsafe { ::std::mem::zeroed() }, + } + } +} +unsafe impl TaggedStructure for ImportMetalIOSurfaceInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::IMPORT_METAL_IO_SURFACE_INFO_EXT; +} +impl ImportMetalIOSurfaceInfoEXT { + pub fn builder<'a>() -> ImportMetalIOSurfaceInfoEXTBuilder<'a> { + ImportMetalIOSurfaceInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ImportMetalIOSurfaceInfoEXTBuilder<'a> { + inner: ImportMetalIOSurfaceInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsImageCreateInfo for ImportMetalIOSurfaceInfoEXTBuilder<'_> {} +unsafe impl ExtendsImageCreateInfo for ImportMetalIOSurfaceInfoEXT {} +impl<'a> ::std::ops::Deref for ImportMetalIOSurfaceInfoEXTBuilder<'a> { + type Target = ImportMetalIOSurfaceInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ImportMetalIOSurfaceInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ImportMetalIOSurfaceInfoEXTBuilder<'a> { + #[inline] + pub fn io_surface(mut self, io_surface: IOSurfaceRef) -> Self { + self.inner.io_surface = io_surface; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ImportMetalIOSurfaceInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ExportMetalSharedEventInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub semaphore: Semaphore, + pub event: Event, + pub mtl_shared_event: MTLSharedEvent_id, +} +impl ::std::default::Default for ExportMetalSharedEventInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + semaphore: Semaphore::default(), + event: Event::default(), + mtl_shared_event: unsafe { ::std::mem::zeroed() }, + } + } +} +unsafe impl TaggedStructure for ExportMetalSharedEventInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::EXPORT_METAL_SHARED_EVENT_INFO_EXT; +} +impl ExportMetalSharedEventInfoEXT { + pub fn builder<'a>() -> ExportMetalSharedEventInfoEXTBuilder<'a> { + ExportMetalSharedEventInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ExportMetalSharedEventInfoEXTBuilder<'a> { + inner: ExportMetalSharedEventInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsExportMetalObjectsInfoEXT for ExportMetalSharedEventInfoEXTBuilder<'_> {} +unsafe impl ExtendsExportMetalObjectsInfoEXT for ExportMetalSharedEventInfoEXT {} +impl<'a> ::std::ops::Deref for ExportMetalSharedEventInfoEXTBuilder<'a> { + type Target = ExportMetalSharedEventInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ExportMetalSharedEventInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ExportMetalSharedEventInfoEXTBuilder<'a> { + #[inline] + pub fn semaphore(mut self, semaphore: Semaphore) -> Self { + self.inner.semaphore = semaphore; + self + } + #[inline] + pub fn event(mut self, event: Event) -> Self { + self.inner.event = event; + self + } + #[inline] + pub fn mtl_shared_event(mut self, mtl_shared_event: MTLSharedEvent_id) -> Self { + self.inner.mtl_shared_event = mtl_shared_event; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ExportMetalSharedEventInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ImportMetalSharedEventInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub mtl_shared_event: MTLSharedEvent_id, +} +impl ::std::default::Default for ImportMetalSharedEventInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + mtl_shared_event: unsafe { ::std::mem::zeroed() }, + } + } +} +unsafe impl TaggedStructure for ImportMetalSharedEventInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::IMPORT_METAL_SHARED_EVENT_INFO_EXT; +} +impl ImportMetalSharedEventInfoEXT { + pub fn builder<'a>() -> ImportMetalSharedEventInfoEXTBuilder<'a> { + ImportMetalSharedEventInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ImportMetalSharedEventInfoEXTBuilder<'a> { + inner: ImportMetalSharedEventInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsSemaphoreCreateInfo for ImportMetalSharedEventInfoEXTBuilder<'_> {} +unsafe impl ExtendsSemaphoreCreateInfo for ImportMetalSharedEventInfoEXT {} +unsafe impl ExtendsEventCreateInfo for ImportMetalSharedEventInfoEXTBuilder<'_> {} +unsafe impl ExtendsEventCreateInfo for ImportMetalSharedEventInfoEXT {} +impl<'a> ::std::ops::Deref for ImportMetalSharedEventInfoEXTBuilder<'a> { + type Target = ImportMetalSharedEventInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ImportMetalSharedEventInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ImportMetalSharedEventInfoEXTBuilder<'a> { + #[inline] + pub fn mtl_shared_event(mut self, mtl_shared_event: MTLSharedEvent_id) -> Self { + self.inner.mtl_shared_event = mtl_shared_event; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ImportMetalSharedEventInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceNonSeamlessCubeMapFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub non_seamless_cube_map: Bool32, +} +impl ::std::default::Default for PhysicalDeviceNonSeamlessCubeMapFeaturesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + non_seamless_cube_map: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceNonSeamlessCubeMapFeaturesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT; +} +impl PhysicalDeviceNonSeamlessCubeMapFeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceNonSeamlessCubeMapFeaturesEXTBuilder<'a> { + PhysicalDeviceNonSeamlessCubeMapFeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceNonSeamlessCubeMapFeaturesEXTBuilder<'a> { + inner: PhysicalDeviceNonSeamlessCubeMapFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceNonSeamlessCubeMapFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceNonSeamlessCubeMapFeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceNonSeamlessCubeMapFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceNonSeamlessCubeMapFeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceNonSeamlessCubeMapFeaturesEXTBuilder<'a> { + type Target = PhysicalDeviceNonSeamlessCubeMapFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceNonSeamlessCubeMapFeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceNonSeamlessCubeMapFeaturesEXTBuilder<'a> { + #[inline] + pub fn non_seamless_cube_map(mut self, non_seamless_cube_map: bool) -> Self { + self.inner.non_seamless_cube_map = non_seamless_cube_map.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceNonSeamlessCubeMapFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDevicePipelineRobustnessFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub pipeline_robustness: Bool32, +} +impl ::std::default::Default for PhysicalDevicePipelineRobustnessFeaturesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + pipeline_robustness: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDevicePipelineRobustnessFeaturesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT; +} +impl PhysicalDevicePipelineRobustnessFeaturesEXT { + pub fn builder<'a>() -> PhysicalDevicePipelineRobustnessFeaturesEXTBuilder<'a> { + PhysicalDevicePipelineRobustnessFeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDevicePipelineRobustnessFeaturesEXTBuilder<'a> { + inner: PhysicalDevicePipelineRobustnessFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDevicePipelineRobustnessFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePipelineRobustnessFeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePipelineRobustnessFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePipelineRobustnessFeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDevicePipelineRobustnessFeaturesEXTBuilder<'a> { + type Target = PhysicalDevicePipelineRobustnessFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDevicePipelineRobustnessFeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDevicePipelineRobustnessFeaturesEXTBuilder<'a> { + #[inline] + pub fn pipeline_robustness(mut self, pipeline_robustness: bool) -> Self { + self.inner.pipeline_robustness = pipeline_robustness.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDevicePipelineRobustnessFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PipelineRobustnessCreateInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub storage_buffers: PipelineRobustnessBufferBehaviorEXT, + pub uniform_buffers: PipelineRobustnessBufferBehaviorEXT, + pub vertex_inputs: PipelineRobustnessBufferBehaviorEXT, + pub images: PipelineRobustnessImageBehaviorEXT, +} +impl ::std::default::Default for PipelineRobustnessCreateInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + storage_buffers: PipelineRobustnessBufferBehaviorEXT::default(), + uniform_buffers: PipelineRobustnessBufferBehaviorEXT::default(), + vertex_inputs: PipelineRobustnessBufferBehaviorEXT::default(), + images: PipelineRobustnessImageBehaviorEXT::default(), + } + } +} +unsafe impl TaggedStructure for PipelineRobustnessCreateInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::PIPELINE_ROBUSTNESS_CREATE_INFO_EXT; +} +impl PipelineRobustnessCreateInfoEXT { + pub fn builder<'a>() -> PipelineRobustnessCreateInfoEXTBuilder<'a> { + PipelineRobustnessCreateInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PipelineRobustnessCreateInfoEXTBuilder<'a> { + inner: PipelineRobustnessCreateInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsGraphicsPipelineCreateInfo for PipelineRobustnessCreateInfoEXTBuilder<'_> {} +unsafe impl ExtendsGraphicsPipelineCreateInfo for PipelineRobustnessCreateInfoEXT {} +unsafe impl ExtendsComputePipelineCreateInfo for PipelineRobustnessCreateInfoEXTBuilder<'_> {} +unsafe impl ExtendsComputePipelineCreateInfo for PipelineRobustnessCreateInfoEXT {} +unsafe impl ExtendsPipelineShaderStageCreateInfo for PipelineRobustnessCreateInfoEXTBuilder<'_> {} +unsafe impl ExtendsPipelineShaderStageCreateInfo for PipelineRobustnessCreateInfoEXT {} +unsafe impl ExtendsRayTracingPipelineCreateInfoKHR for PipelineRobustnessCreateInfoEXTBuilder<'_> {} +unsafe impl ExtendsRayTracingPipelineCreateInfoKHR for PipelineRobustnessCreateInfoEXT {} +impl<'a> ::std::ops::Deref for PipelineRobustnessCreateInfoEXTBuilder<'a> { + type Target = PipelineRobustnessCreateInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PipelineRobustnessCreateInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PipelineRobustnessCreateInfoEXTBuilder<'a> { + #[inline] + pub fn storage_buffers(mut self, storage_buffers: PipelineRobustnessBufferBehaviorEXT) -> Self { + self.inner.storage_buffers = storage_buffers; + self + } + #[inline] + pub fn uniform_buffers(mut self, uniform_buffers: PipelineRobustnessBufferBehaviorEXT) -> Self { + self.inner.uniform_buffers = uniform_buffers; + self + } + #[inline] + pub fn vertex_inputs(mut self, vertex_inputs: PipelineRobustnessBufferBehaviorEXT) -> Self { + self.inner.vertex_inputs = vertex_inputs; + self + } + #[inline] + pub fn images(mut self, images: PipelineRobustnessImageBehaviorEXT) -> Self { + self.inner.images = images; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PipelineRobustnessCreateInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDevicePipelineRobustnessPropertiesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub default_robustness_storage_buffers: PipelineRobustnessBufferBehaviorEXT, + pub default_robustness_uniform_buffers: PipelineRobustnessBufferBehaviorEXT, + pub default_robustness_vertex_inputs: PipelineRobustnessBufferBehaviorEXT, + pub default_robustness_images: PipelineRobustnessImageBehaviorEXT, +} +impl ::std::default::Default for PhysicalDevicePipelineRobustnessPropertiesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + default_robustness_storage_buffers: PipelineRobustnessBufferBehaviorEXT::default(), + default_robustness_uniform_buffers: PipelineRobustnessBufferBehaviorEXT::default(), + default_robustness_vertex_inputs: PipelineRobustnessBufferBehaviorEXT::default(), + default_robustness_images: PipelineRobustnessImageBehaviorEXT::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDevicePipelineRobustnessPropertiesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES_EXT; +} +impl PhysicalDevicePipelineRobustnessPropertiesEXT { + pub fn builder<'a>() -> PhysicalDevicePipelineRobustnessPropertiesEXTBuilder<'a> { + PhysicalDevicePipelineRobustnessPropertiesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDevicePipelineRobustnessPropertiesEXTBuilder<'a> { + inner: PhysicalDevicePipelineRobustnessPropertiesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDevicePipelineRobustnessPropertiesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDevicePipelineRobustnessPropertiesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDevicePipelineRobustnessPropertiesEXTBuilder<'a> { + type Target = PhysicalDevicePipelineRobustnessPropertiesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDevicePipelineRobustnessPropertiesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDevicePipelineRobustnessPropertiesEXTBuilder<'a> { + #[inline] + pub fn default_robustness_storage_buffers( + mut self, + default_robustness_storage_buffers: PipelineRobustnessBufferBehaviorEXT, + ) -> Self { + self.inner.default_robustness_storage_buffers = default_robustness_storage_buffers; + self + } + #[inline] + pub fn default_robustness_uniform_buffers( + mut self, + default_robustness_uniform_buffers: PipelineRobustnessBufferBehaviorEXT, + ) -> Self { + self.inner.default_robustness_uniform_buffers = default_robustness_uniform_buffers; + self + } + #[inline] + pub fn default_robustness_vertex_inputs( + mut self, + default_robustness_vertex_inputs: PipelineRobustnessBufferBehaviorEXT, + ) -> Self { + self.inner.default_robustness_vertex_inputs = default_robustness_vertex_inputs; + self + } + #[inline] + pub fn default_robustness_images( + mut self, + default_robustness_images: PipelineRobustnessImageBehaviorEXT, + ) -> Self { + self.inner.default_robustness_images = default_robustness_images; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDevicePipelineRobustnessPropertiesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ImageViewSampleWeightCreateInfoQCOM { + pub s_type: StructureType, + pub p_next: *const c_void, + pub filter_center: Offset2D, + pub filter_size: Extent2D, + pub num_phases: u32, +} +impl ::std::default::Default for ImageViewSampleWeightCreateInfoQCOM { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + filter_center: Offset2D::default(), + filter_size: Extent2D::default(), + num_phases: u32::default(), + } + } +} +unsafe impl TaggedStructure for ImageViewSampleWeightCreateInfoQCOM { + const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM; +} +impl ImageViewSampleWeightCreateInfoQCOM { + pub fn builder<'a>() -> ImageViewSampleWeightCreateInfoQCOMBuilder<'a> { + ImageViewSampleWeightCreateInfoQCOMBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ImageViewSampleWeightCreateInfoQCOMBuilder<'a> { + inner: ImageViewSampleWeightCreateInfoQCOM, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsImageViewCreateInfo for ImageViewSampleWeightCreateInfoQCOMBuilder<'_> {} +unsafe impl ExtendsImageViewCreateInfo for ImageViewSampleWeightCreateInfoQCOM {} +impl<'a> ::std::ops::Deref for ImageViewSampleWeightCreateInfoQCOMBuilder<'a> { + type Target = ImageViewSampleWeightCreateInfoQCOM; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ImageViewSampleWeightCreateInfoQCOMBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ImageViewSampleWeightCreateInfoQCOMBuilder<'a> { + #[inline] + pub fn filter_center(mut self, filter_center: Offset2D) -> Self { + self.inner.filter_center = filter_center; + self + } + #[inline] + pub fn filter_size(mut self, filter_size: Extent2D) -> Self { + self.inner.filter_size = filter_size; + self + } + #[inline] + pub fn num_phases(mut self, num_phases: u32) -> Self { + self.inner.num_phases = num_phases; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ImageViewSampleWeightCreateInfoQCOM { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceImageProcessingFeaturesQCOM { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub texture_sample_weighted: Bool32, + pub texture_box_filter: Bool32, + pub texture_block_match: Bool32, +} +impl ::std::default::Default for PhysicalDeviceImageProcessingFeaturesQCOM { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + texture_sample_weighted: Bool32::default(), + texture_box_filter: Bool32::default(), + texture_block_match: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceImageProcessingFeaturesQCOM { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM; +} +impl PhysicalDeviceImageProcessingFeaturesQCOM { + pub fn builder<'a>() -> PhysicalDeviceImageProcessingFeaturesQCOMBuilder<'a> { + PhysicalDeviceImageProcessingFeaturesQCOMBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceImageProcessingFeaturesQCOMBuilder<'a> { + inner: PhysicalDeviceImageProcessingFeaturesQCOM, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceImageProcessingFeaturesQCOMBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceImageProcessingFeaturesQCOM {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceImageProcessingFeaturesQCOMBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceImageProcessingFeaturesQCOM {} +impl<'a> ::std::ops::Deref for PhysicalDeviceImageProcessingFeaturesQCOMBuilder<'a> { + type Target = PhysicalDeviceImageProcessingFeaturesQCOM; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceImageProcessingFeaturesQCOMBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceImageProcessingFeaturesQCOMBuilder<'a> { + #[inline] + pub fn texture_sample_weighted(mut self, texture_sample_weighted: bool) -> Self { + self.inner.texture_sample_weighted = texture_sample_weighted.into(); + self + } + #[inline] + pub fn texture_box_filter(mut self, texture_box_filter: bool) -> Self { + self.inner.texture_box_filter = texture_box_filter.into(); + self + } + #[inline] + pub fn texture_block_match(mut self, texture_block_match: bool) -> Self { + self.inner.texture_block_match = texture_block_match.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceImageProcessingFeaturesQCOM { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceImageProcessingPropertiesQCOM { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub max_weight_filter_phases: u32, + pub max_weight_filter_dimension: Extent2D, + pub max_block_match_region: Extent2D, + pub max_box_filter_block_size: Extent2D, +} +impl ::std::default::Default for PhysicalDeviceImageProcessingPropertiesQCOM { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + max_weight_filter_phases: u32::default(), + max_weight_filter_dimension: Extent2D::default(), + max_block_match_region: Extent2D::default(), + max_box_filter_block_size: Extent2D::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceImageProcessingPropertiesQCOM { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM; +} +impl PhysicalDeviceImageProcessingPropertiesQCOM { + pub fn builder<'a>() -> PhysicalDeviceImageProcessingPropertiesQCOMBuilder<'a> { + PhysicalDeviceImageProcessingPropertiesQCOMBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceImageProcessingPropertiesQCOMBuilder<'a> { + inner: PhysicalDeviceImageProcessingPropertiesQCOM, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceImageProcessingPropertiesQCOMBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceImageProcessingPropertiesQCOM {} +impl<'a> ::std::ops::Deref for PhysicalDeviceImageProcessingPropertiesQCOMBuilder<'a> { + type Target = PhysicalDeviceImageProcessingPropertiesQCOM; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceImageProcessingPropertiesQCOMBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceImageProcessingPropertiesQCOMBuilder<'a> { + #[inline] + pub fn max_weight_filter_phases(mut self, max_weight_filter_phases: u32) -> Self { + self.inner.max_weight_filter_phases = max_weight_filter_phases; + self + } + #[inline] + pub fn max_weight_filter_dimension(mut self, max_weight_filter_dimension: Extent2D) -> Self { + self.inner.max_weight_filter_dimension = max_weight_filter_dimension; + self + } + #[inline] + pub fn max_block_match_region(mut self, max_block_match_region: Extent2D) -> Self { + self.inner.max_block_match_region = max_block_match_region; + self + } + #[inline] + pub fn max_box_filter_block_size(mut self, max_box_filter_block_size: Extent2D) -> Self { + self.inner.max_box_filter_block_size = max_box_filter_block_size; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceImageProcessingPropertiesQCOM { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceTilePropertiesFeaturesQCOM { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub tile_properties: Bool32, +} +impl ::std::default::Default for PhysicalDeviceTilePropertiesFeaturesQCOM { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + tile_properties: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceTilePropertiesFeaturesQCOM { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM; +} +impl PhysicalDeviceTilePropertiesFeaturesQCOM { + pub fn builder<'a>() -> PhysicalDeviceTilePropertiesFeaturesQCOMBuilder<'a> { + PhysicalDeviceTilePropertiesFeaturesQCOMBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceTilePropertiesFeaturesQCOMBuilder<'a> { + inner: PhysicalDeviceTilePropertiesFeaturesQCOM, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceTilePropertiesFeaturesQCOMBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceTilePropertiesFeaturesQCOM {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceTilePropertiesFeaturesQCOMBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceTilePropertiesFeaturesQCOM {} +impl<'a> ::std::ops::Deref for PhysicalDeviceTilePropertiesFeaturesQCOMBuilder<'a> { + type Target = PhysicalDeviceTilePropertiesFeaturesQCOM; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceTilePropertiesFeaturesQCOMBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceTilePropertiesFeaturesQCOMBuilder<'a> { + #[inline] + pub fn tile_properties(mut self, tile_properties: bool) -> Self { + self.inner.tile_properties = tile_properties.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceTilePropertiesFeaturesQCOM { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct TilePropertiesQCOM { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub tile_size: Extent3D, + pub apron_size: Extent2D, + pub origin: Offset2D, +} +impl ::std::default::Default for TilePropertiesQCOM { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + tile_size: Extent3D::default(), + apron_size: Extent2D::default(), + origin: Offset2D::default(), + } + } +} +unsafe impl TaggedStructure for TilePropertiesQCOM { + const STRUCTURE_TYPE: StructureType = StructureType::TILE_PROPERTIES_QCOM; +} +impl TilePropertiesQCOM { + pub fn builder<'a>() -> TilePropertiesQCOMBuilder<'a> { + TilePropertiesQCOMBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct TilePropertiesQCOMBuilder<'a> { + inner: TilePropertiesQCOM, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for TilePropertiesQCOMBuilder<'a> { + type Target = TilePropertiesQCOM; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for TilePropertiesQCOMBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> TilePropertiesQCOMBuilder<'a> { + #[inline] + pub fn tile_size(mut self, tile_size: Extent3D) -> Self { + self.inner.tile_size = tile_size; + self + } + #[inline] + pub fn apron_size(mut self, apron_size: Extent2D) -> Self { + self.inner.apron_size = apron_size; + self + } + #[inline] + pub fn origin(mut self, origin: Offset2D) -> Self { + self.inner.origin = origin; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> TilePropertiesQCOM { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceAmigoProfilingFeaturesSEC { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub amigo_profiling: Bool32, +} +impl ::std::default::Default for PhysicalDeviceAmigoProfilingFeaturesSEC { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + amigo_profiling: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceAmigoProfilingFeaturesSEC { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_AMIGO_PROFILING_FEATURES_SEC; +} +impl PhysicalDeviceAmigoProfilingFeaturesSEC { + pub fn builder<'a>() -> PhysicalDeviceAmigoProfilingFeaturesSECBuilder<'a> { + PhysicalDeviceAmigoProfilingFeaturesSECBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceAmigoProfilingFeaturesSECBuilder<'a> { + inner: PhysicalDeviceAmigoProfilingFeaturesSEC, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceAmigoProfilingFeaturesSECBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceAmigoProfilingFeaturesSEC {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceAmigoProfilingFeaturesSECBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceAmigoProfilingFeaturesSEC {} +impl<'a> ::std::ops::Deref for PhysicalDeviceAmigoProfilingFeaturesSECBuilder<'a> { + type Target = PhysicalDeviceAmigoProfilingFeaturesSEC; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceAmigoProfilingFeaturesSECBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceAmigoProfilingFeaturesSECBuilder<'a> { + #[inline] + pub fn amigo_profiling(mut self, amigo_profiling: bool) -> Self { + self.inner.amigo_profiling = amigo_profiling.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceAmigoProfilingFeaturesSEC { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct AmigoProfilingSubmitInfoSEC { + pub s_type: StructureType, + pub p_next: *const c_void, + pub first_draw_timestamp: u64, + pub swap_buffer_timestamp: u64, +} +impl ::std::default::Default for AmigoProfilingSubmitInfoSEC { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + first_draw_timestamp: u64::default(), + swap_buffer_timestamp: u64::default(), + } + } +} +unsafe impl TaggedStructure for AmigoProfilingSubmitInfoSEC { + const STRUCTURE_TYPE: StructureType = StructureType::AMIGO_PROFILING_SUBMIT_INFO_SEC; +} +impl AmigoProfilingSubmitInfoSEC { + pub fn builder<'a>() -> AmigoProfilingSubmitInfoSECBuilder<'a> { + AmigoProfilingSubmitInfoSECBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct AmigoProfilingSubmitInfoSECBuilder<'a> { + inner: AmigoProfilingSubmitInfoSEC, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsSubmitInfo for AmigoProfilingSubmitInfoSECBuilder<'_> {} +unsafe impl ExtendsSubmitInfo for AmigoProfilingSubmitInfoSEC {} +impl<'a> ::std::ops::Deref for AmigoProfilingSubmitInfoSECBuilder<'a> { + type Target = AmigoProfilingSubmitInfoSEC; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for AmigoProfilingSubmitInfoSECBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> AmigoProfilingSubmitInfoSECBuilder<'a> { + #[inline] + pub fn first_draw_timestamp(mut self, first_draw_timestamp: u64) -> Self { + self.inner.first_draw_timestamp = first_draw_timestamp; + self + } + #[inline] + pub fn swap_buffer_timestamp(mut self, swap_buffer_timestamp: u64) -> Self { + self.inner.swap_buffer_timestamp = swap_buffer_timestamp; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> AmigoProfilingSubmitInfoSEC { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub attachment_feedback_loop_layout: Bool32, +} +impl ::std::default::Default for PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + attachment_feedback_loop_layout: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT; +} +impl PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXTBuilder<'a> { + PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXTBuilder<'a> { + inner: PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT +{ +} +unsafe impl ExtendsDeviceCreateInfo + for PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXTBuilder<'a> { + type Target = PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXTBuilder<'a> { + #[inline] + pub fn attachment_feedback_loop_layout( + mut self, + attachment_feedback_loop_layout: bool, + ) -> Self { + self.inner.attachment_feedback_loop_layout = attachment_feedback_loop_layout.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceDepthClampZeroOneFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub depth_clamp_zero_one: Bool32, +} +impl ::std::default::Default for PhysicalDeviceDepthClampZeroOneFeaturesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + depth_clamp_zero_one: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceDepthClampZeroOneFeaturesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT; +} +impl PhysicalDeviceDepthClampZeroOneFeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceDepthClampZeroOneFeaturesEXTBuilder<'a> { + PhysicalDeviceDepthClampZeroOneFeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceDepthClampZeroOneFeaturesEXTBuilder<'a> { + inner: PhysicalDeviceDepthClampZeroOneFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceDepthClampZeroOneFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceDepthClampZeroOneFeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDepthClampZeroOneFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDepthClampZeroOneFeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceDepthClampZeroOneFeaturesEXTBuilder<'a> { + type Target = PhysicalDeviceDepthClampZeroOneFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceDepthClampZeroOneFeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceDepthClampZeroOneFeaturesEXTBuilder<'a> { + #[inline] + pub fn depth_clamp_zero_one(mut self, depth_clamp_zero_one: bool) -> Self { + self.inner.depth_clamp_zero_one = depth_clamp_zero_one.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceDepthClampZeroOneFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceAddressBindingReportFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub report_address_binding: Bool32, +} +impl ::std::default::Default for PhysicalDeviceAddressBindingReportFeaturesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + report_address_binding: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceAddressBindingReportFeaturesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT; +} +impl PhysicalDeviceAddressBindingReportFeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceAddressBindingReportFeaturesEXTBuilder<'a> { + PhysicalDeviceAddressBindingReportFeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceAddressBindingReportFeaturesEXTBuilder<'a> { + inner: PhysicalDeviceAddressBindingReportFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceAddressBindingReportFeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceAddressBindingReportFeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceAddressBindingReportFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceAddressBindingReportFeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceAddressBindingReportFeaturesEXTBuilder<'a> { + type Target = PhysicalDeviceAddressBindingReportFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceAddressBindingReportFeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceAddressBindingReportFeaturesEXTBuilder<'a> { + #[inline] + pub fn report_address_binding(mut self, report_address_binding: bool) -> Self { + self.inner.report_address_binding = report_address_binding.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceAddressBindingReportFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DeviceAddressBindingCallbackDataEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub flags: DeviceAddressBindingFlagsEXT, + pub base_address: DeviceAddress, + pub size: DeviceSize, + pub binding_type: DeviceAddressBindingTypeEXT, +} +impl ::std::default::Default for DeviceAddressBindingCallbackDataEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + flags: DeviceAddressBindingFlagsEXT::default(), + base_address: DeviceAddress::default(), + size: DeviceSize::default(), + binding_type: DeviceAddressBindingTypeEXT::default(), + } + } +} +unsafe impl TaggedStructure for DeviceAddressBindingCallbackDataEXT { + const STRUCTURE_TYPE: StructureType = StructureType::DEVICE_ADDRESS_BINDING_CALLBACK_DATA_EXT; +} +impl DeviceAddressBindingCallbackDataEXT { + pub fn builder<'a>() -> DeviceAddressBindingCallbackDataEXTBuilder<'a> { + DeviceAddressBindingCallbackDataEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DeviceAddressBindingCallbackDataEXTBuilder<'a> { + inner: DeviceAddressBindingCallbackDataEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsDebugUtilsMessengerCallbackDataEXT + for DeviceAddressBindingCallbackDataEXTBuilder<'_> +{ +} +unsafe impl ExtendsDebugUtilsMessengerCallbackDataEXT for DeviceAddressBindingCallbackDataEXT {} +impl<'a> ::std::ops::Deref for DeviceAddressBindingCallbackDataEXTBuilder<'a> { + type Target = DeviceAddressBindingCallbackDataEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DeviceAddressBindingCallbackDataEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DeviceAddressBindingCallbackDataEXTBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: DeviceAddressBindingFlagsEXT) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn base_address(mut self, base_address: DeviceAddress) -> Self { + self.inner.base_address = base_address; + self + } + #[inline] + pub fn size(mut self, size: DeviceSize) -> Self { + self.inner.size = size; + self + } + #[inline] + pub fn binding_type(mut self, binding_type: DeviceAddressBindingTypeEXT) -> Self { + self.inner.binding_type = binding_type; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DeviceAddressBindingCallbackDataEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceOpticalFlowFeaturesNV { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub optical_flow: Bool32, +} +impl ::std::default::Default for PhysicalDeviceOpticalFlowFeaturesNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + optical_flow: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceOpticalFlowFeaturesNV { + const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV; +} +impl PhysicalDeviceOpticalFlowFeaturesNV { + pub fn builder<'a>() -> PhysicalDeviceOpticalFlowFeaturesNVBuilder<'a> { + PhysicalDeviceOpticalFlowFeaturesNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceOpticalFlowFeaturesNVBuilder<'a> { + inner: PhysicalDeviceOpticalFlowFeaturesNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceOpticalFlowFeaturesNVBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceOpticalFlowFeaturesNV {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceOpticalFlowFeaturesNVBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceOpticalFlowFeaturesNV {} +impl<'a> ::std::ops::Deref for PhysicalDeviceOpticalFlowFeaturesNVBuilder<'a> { + type Target = PhysicalDeviceOpticalFlowFeaturesNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceOpticalFlowFeaturesNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceOpticalFlowFeaturesNVBuilder<'a> { + #[inline] + pub fn optical_flow(mut self, optical_flow: bool) -> Self { + self.inner.optical_flow = optical_flow.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceOpticalFlowFeaturesNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceOpticalFlowPropertiesNV { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub supported_output_grid_sizes: OpticalFlowGridSizeFlagsNV, + pub supported_hint_grid_sizes: OpticalFlowGridSizeFlagsNV, + pub hint_supported: Bool32, + pub cost_supported: Bool32, + pub bidirectional_flow_supported: Bool32, + pub global_flow_supported: Bool32, + pub min_width: u32, + pub min_height: u32, + pub max_width: u32, + pub max_height: u32, + pub max_num_regions_of_interest: u32, +} +impl ::std::default::Default for PhysicalDeviceOpticalFlowPropertiesNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + supported_output_grid_sizes: OpticalFlowGridSizeFlagsNV::default(), + supported_hint_grid_sizes: OpticalFlowGridSizeFlagsNV::default(), + hint_supported: Bool32::default(), + cost_supported: Bool32::default(), + bidirectional_flow_supported: Bool32::default(), + global_flow_supported: Bool32::default(), + min_width: u32::default(), + min_height: u32::default(), + max_width: u32::default(), + max_height: u32::default(), + max_num_regions_of_interest: u32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceOpticalFlowPropertiesNV { + const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV; +} +impl PhysicalDeviceOpticalFlowPropertiesNV { + pub fn builder<'a>() -> PhysicalDeviceOpticalFlowPropertiesNVBuilder<'a> { + PhysicalDeviceOpticalFlowPropertiesNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceOpticalFlowPropertiesNVBuilder<'a> { + inner: PhysicalDeviceOpticalFlowPropertiesNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceOpticalFlowPropertiesNVBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceOpticalFlowPropertiesNV {} +impl<'a> ::std::ops::Deref for PhysicalDeviceOpticalFlowPropertiesNVBuilder<'a> { + type Target = PhysicalDeviceOpticalFlowPropertiesNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceOpticalFlowPropertiesNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceOpticalFlowPropertiesNVBuilder<'a> { + #[inline] + pub fn supported_output_grid_sizes( + mut self, + supported_output_grid_sizes: OpticalFlowGridSizeFlagsNV, + ) -> Self { + self.inner.supported_output_grid_sizes = supported_output_grid_sizes; + self + } + #[inline] + pub fn supported_hint_grid_sizes( + mut self, + supported_hint_grid_sizes: OpticalFlowGridSizeFlagsNV, + ) -> Self { + self.inner.supported_hint_grid_sizes = supported_hint_grid_sizes; + self + } + #[inline] + pub fn hint_supported(mut self, hint_supported: bool) -> Self { + self.inner.hint_supported = hint_supported.into(); + self + } + #[inline] + pub fn cost_supported(mut self, cost_supported: bool) -> Self { + self.inner.cost_supported = cost_supported.into(); + self + } + #[inline] + pub fn bidirectional_flow_supported(mut self, bidirectional_flow_supported: bool) -> Self { + self.inner.bidirectional_flow_supported = bidirectional_flow_supported.into(); + self + } + #[inline] + pub fn global_flow_supported(mut self, global_flow_supported: bool) -> Self { + self.inner.global_flow_supported = global_flow_supported.into(); + self + } + #[inline] + pub fn min_width(mut self, min_width: u32) -> Self { + self.inner.min_width = min_width; + self + } + #[inline] + pub fn min_height(mut self, min_height: u32) -> Self { + self.inner.min_height = min_height; + self + } + #[inline] + pub fn max_width(mut self, max_width: u32) -> Self { + self.inner.max_width = max_width; + self + } + #[inline] + pub fn max_height(mut self, max_height: u32) -> Self { + self.inner.max_height = max_height; + self + } + #[inline] + pub fn max_num_regions_of_interest(mut self, max_num_regions_of_interest: u32) -> Self { + self.inner.max_num_regions_of_interest = max_num_regions_of_interest; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceOpticalFlowPropertiesNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct OpticalFlowImageFormatInfoNV { + pub s_type: StructureType, + pub p_next: *const c_void, + pub usage: OpticalFlowUsageFlagsNV, +} +impl ::std::default::Default for OpticalFlowImageFormatInfoNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + usage: OpticalFlowUsageFlagsNV::default(), + } + } +} +unsafe impl TaggedStructure for OpticalFlowImageFormatInfoNV { + const STRUCTURE_TYPE: StructureType = StructureType::OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV; +} +impl OpticalFlowImageFormatInfoNV { + pub fn builder<'a>() -> OpticalFlowImageFormatInfoNVBuilder<'a> { + OpticalFlowImageFormatInfoNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct OpticalFlowImageFormatInfoNVBuilder<'a> { + inner: OpticalFlowImageFormatInfoNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceImageFormatInfo2 for OpticalFlowImageFormatInfoNVBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceImageFormatInfo2 for OpticalFlowImageFormatInfoNV {} +unsafe impl ExtendsImageCreateInfo for OpticalFlowImageFormatInfoNVBuilder<'_> {} +unsafe impl ExtendsImageCreateInfo for OpticalFlowImageFormatInfoNV {} +impl<'a> ::std::ops::Deref for OpticalFlowImageFormatInfoNVBuilder<'a> { + type Target = OpticalFlowImageFormatInfoNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for OpticalFlowImageFormatInfoNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> OpticalFlowImageFormatInfoNVBuilder<'a> { + #[inline] + pub fn usage(mut self, usage: OpticalFlowUsageFlagsNV) -> Self { + self.inner.usage = usage; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> OpticalFlowImageFormatInfoNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct OpticalFlowImageFormatPropertiesNV { + pub s_type: StructureType, + pub p_next: *const c_void, + pub format: Format, +} +impl ::std::default::Default for OpticalFlowImageFormatPropertiesNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + format: Format::default(), + } + } +} +unsafe impl TaggedStructure for OpticalFlowImageFormatPropertiesNV { + const STRUCTURE_TYPE: StructureType = StructureType::OPTICAL_FLOW_IMAGE_FORMAT_PROPERTIES_NV; +} +impl OpticalFlowImageFormatPropertiesNV { + pub fn builder<'a>() -> OpticalFlowImageFormatPropertiesNVBuilder<'a> { + OpticalFlowImageFormatPropertiesNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct OpticalFlowImageFormatPropertiesNVBuilder<'a> { + inner: OpticalFlowImageFormatPropertiesNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for OpticalFlowImageFormatPropertiesNVBuilder<'a> { + type Target = OpticalFlowImageFormatPropertiesNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for OpticalFlowImageFormatPropertiesNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> OpticalFlowImageFormatPropertiesNVBuilder<'a> { + #[inline] + pub fn format(mut self, format: Format) -> Self { + self.inner.format = format; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> OpticalFlowImageFormatPropertiesNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct OpticalFlowSessionCreateInfoNV { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub width: u32, + pub height: u32, + pub image_format: Format, + pub flow_vector_format: Format, + pub cost_format: Format, + pub output_grid_size: OpticalFlowGridSizeFlagsNV, + pub hint_grid_size: OpticalFlowGridSizeFlagsNV, + pub performance_level: OpticalFlowPerformanceLevelNV, + pub flags: OpticalFlowSessionCreateFlagsNV, +} +impl ::std::default::Default for OpticalFlowSessionCreateInfoNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + width: u32::default(), + height: u32::default(), + image_format: Format::default(), + flow_vector_format: Format::default(), + cost_format: Format::default(), + output_grid_size: OpticalFlowGridSizeFlagsNV::default(), + hint_grid_size: OpticalFlowGridSizeFlagsNV::default(), + performance_level: OpticalFlowPerformanceLevelNV::default(), + flags: OpticalFlowSessionCreateFlagsNV::default(), + } + } +} +unsafe impl TaggedStructure for OpticalFlowSessionCreateInfoNV { + const STRUCTURE_TYPE: StructureType = StructureType::OPTICAL_FLOW_SESSION_CREATE_INFO_NV; +} +impl OpticalFlowSessionCreateInfoNV { + pub fn builder<'a>() -> OpticalFlowSessionCreateInfoNVBuilder<'a> { + OpticalFlowSessionCreateInfoNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct OpticalFlowSessionCreateInfoNVBuilder<'a> { + inner: OpticalFlowSessionCreateInfoNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsOpticalFlowSessionCreateInfoNV {} +impl<'a> ::std::ops::Deref for OpticalFlowSessionCreateInfoNVBuilder<'a> { + type Target = OpticalFlowSessionCreateInfoNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for OpticalFlowSessionCreateInfoNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> OpticalFlowSessionCreateInfoNVBuilder<'a> { + #[inline] + pub fn width(mut self, width: u32) -> Self { + self.inner.width = width; + self + } + #[inline] + pub fn height(mut self, height: u32) -> Self { + self.inner.height = height; + self + } + #[inline] + pub fn image_format(mut self, image_format: Format) -> Self { + self.inner.image_format = image_format; + self + } + #[inline] + pub fn flow_vector_format(mut self, flow_vector_format: Format) -> Self { + self.inner.flow_vector_format = flow_vector_format; + self + } + #[inline] + pub fn cost_format(mut self, cost_format: Format) -> Self { + self.inner.cost_format = cost_format; + self + } + #[inline] + pub fn output_grid_size(mut self, output_grid_size: OpticalFlowGridSizeFlagsNV) -> Self { + self.inner.output_grid_size = output_grid_size; + self + } + #[inline] + pub fn hint_grid_size(mut self, hint_grid_size: OpticalFlowGridSizeFlagsNV) -> Self { + self.inner.hint_grid_size = hint_grid_size; + self + } + #[inline] + pub fn performance_level(mut self, performance_level: OpticalFlowPerformanceLevelNV) -> Self { + self.inner.performance_level = performance_level; + self + } + #[inline] + pub fn flags(mut self, flags: OpticalFlowSessionCreateFlagsNV) -> Self { + self.inner.flags = flags; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next(mut self, next: &'a mut T) -> Self { + unsafe { + let next_ptr = <*mut T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> OpticalFlowSessionCreateInfoNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct OpticalFlowSessionCreatePrivateDataInfoNV { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub id: u32, + pub size: u32, + pub p_private_data: *const c_void, +} +impl ::std::default::Default for OpticalFlowSessionCreatePrivateDataInfoNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + id: u32::default(), + size: u32::default(), + p_private_data: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for OpticalFlowSessionCreatePrivateDataInfoNV { + const STRUCTURE_TYPE: StructureType = + StructureType::OPTICAL_FLOW_SESSION_CREATE_PRIVATE_DATA_INFO_NV; +} +impl OpticalFlowSessionCreatePrivateDataInfoNV { + pub fn builder<'a>() -> OpticalFlowSessionCreatePrivateDataInfoNVBuilder<'a> { + OpticalFlowSessionCreatePrivateDataInfoNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct OpticalFlowSessionCreatePrivateDataInfoNVBuilder<'a> { + inner: OpticalFlowSessionCreatePrivateDataInfoNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsOpticalFlowSessionCreateInfoNV + for OpticalFlowSessionCreatePrivateDataInfoNVBuilder<'_> +{ +} +unsafe impl ExtendsOpticalFlowSessionCreateInfoNV for OpticalFlowSessionCreatePrivateDataInfoNV {} +impl<'a> ::std::ops::Deref for OpticalFlowSessionCreatePrivateDataInfoNVBuilder<'a> { + type Target = OpticalFlowSessionCreatePrivateDataInfoNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for OpticalFlowSessionCreatePrivateDataInfoNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> OpticalFlowSessionCreatePrivateDataInfoNVBuilder<'a> { + #[inline] + pub fn id(mut self, id: u32) -> Self { + self.inner.id = id; + self + } + #[inline] + pub fn size(mut self, size: u32) -> Self { + self.inner.size = size; + self + } + #[inline] + pub fn private_data(mut self, private_data: *const c_void) -> Self { + self.inner.p_private_data = private_data; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> OpticalFlowSessionCreatePrivateDataInfoNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct OpticalFlowExecuteInfoNV { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub flags: OpticalFlowExecuteFlagsNV, + pub region_count: u32, + pub p_regions: *const Rect2D, +} +impl ::std::default::Default for OpticalFlowExecuteInfoNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + flags: OpticalFlowExecuteFlagsNV::default(), + region_count: u32::default(), + p_regions: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for OpticalFlowExecuteInfoNV { + const STRUCTURE_TYPE: StructureType = StructureType::OPTICAL_FLOW_EXECUTE_INFO_NV; +} +impl OpticalFlowExecuteInfoNV { + pub fn builder<'a>() -> OpticalFlowExecuteInfoNVBuilder<'a> { + OpticalFlowExecuteInfoNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct OpticalFlowExecuteInfoNVBuilder<'a> { + inner: OpticalFlowExecuteInfoNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for OpticalFlowExecuteInfoNVBuilder<'a> { + type Target = OpticalFlowExecuteInfoNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for OpticalFlowExecuteInfoNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> OpticalFlowExecuteInfoNVBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: OpticalFlowExecuteFlagsNV) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn regions(mut self, regions: &'a [Rect2D]) -> Self { + self.inner.region_count = regions.len() as _; + self.inner.p_regions = regions.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> OpticalFlowExecuteInfoNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceFaultFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub device_fault: Bool32, + pub device_fault_vendor_binary: Bool32, +} +impl ::std::default::Default for PhysicalDeviceFaultFeaturesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + device_fault: Bool32::default(), + device_fault_vendor_binary: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceFaultFeaturesEXT { + const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_FAULT_FEATURES_EXT; +} +impl PhysicalDeviceFaultFeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceFaultFeaturesEXTBuilder<'a> { + PhysicalDeviceFaultFeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceFaultFeaturesEXTBuilder<'a> { + inner: PhysicalDeviceFaultFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceFaultFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceFaultFeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFaultFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFaultFeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceFaultFeaturesEXTBuilder<'a> { + type Target = PhysicalDeviceFaultFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceFaultFeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceFaultFeaturesEXTBuilder<'a> { + #[inline] + pub fn device_fault(mut self, device_fault: bool) -> Self { + self.inner.device_fault = device_fault.into(); + self + } + #[inline] + pub fn device_fault_vendor_binary(mut self, device_fault_vendor_binary: bool) -> Self { + self.inner.device_fault_vendor_binary = device_fault_vendor_binary.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceFaultFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct DeviceFaultAddressInfoEXT { + pub address_type: DeviceFaultAddressTypeEXT, + pub reported_address: DeviceAddress, + pub address_precision: DeviceSize, +} +impl DeviceFaultAddressInfoEXT { + pub fn builder<'a>() -> DeviceFaultAddressInfoEXTBuilder<'a> { + DeviceFaultAddressInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DeviceFaultAddressInfoEXTBuilder<'a> { + inner: DeviceFaultAddressInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DeviceFaultAddressInfoEXTBuilder<'a> { + type Target = DeviceFaultAddressInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DeviceFaultAddressInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DeviceFaultAddressInfoEXTBuilder<'a> { + #[inline] + pub fn address_type(mut self, address_type: DeviceFaultAddressTypeEXT) -> Self { + self.inner.address_type = address_type; + self + } + #[inline] + pub fn reported_address(mut self, reported_address: DeviceAddress) -> Self { + self.inner.reported_address = reported_address; + self + } + #[inline] + pub fn address_precision(mut self, address_precision: DeviceSize) -> Self { + self.inner.address_precision = address_precision; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DeviceFaultAddressInfoEXT { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DeviceFaultVendorInfoEXT { + pub description: [c_char; MAX_DESCRIPTION_SIZE], + pub vendor_fault_code: u64, + pub vendor_fault_data: u64, +} +#[cfg(feature = "debug")] +impl fmt::Debug for DeviceFaultVendorInfoEXT { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fmt.debug_struct("DeviceFaultVendorInfoEXT") + .field("description", &unsafe { + ::std::ffi::CStr::from_ptr(self.description.as_ptr()) + }) + .field("vendor_fault_code", &self.vendor_fault_code) + .field("vendor_fault_data", &self.vendor_fault_data) + .finish() + } +} +impl ::std::default::Default for DeviceFaultVendorInfoEXT { + #[inline] + fn default() -> Self { + Self { + description: unsafe { ::std::mem::zeroed() }, + vendor_fault_code: u64::default(), + vendor_fault_data: u64::default(), + } + } +} +impl DeviceFaultVendorInfoEXT { + pub fn builder<'a>() -> DeviceFaultVendorInfoEXTBuilder<'a> { + DeviceFaultVendorInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DeviceFaultVendorInfoEXTBuilder<'a> { + inner: DeviceFaultVendorInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DeviceFaultVendorInfoEXTBuilder<'a> { + type Target = DeviceFaultVendorInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DeviceFaultVendorInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DeviceFaultVendorInfoEXTBuilder<'a> { + #[inline] + pub fn description(mut self, description: [c_char; MAX_DESCRIPTION_SIZE]) -> Self { + self.inner.description = description; + self + } + #[inline] + pub fn vendor_fault_code(mut self, vendor_fault_code: u64) -> Self { + self.inner.vendor_fault_code = vendor_fault_code; + self + } + #[inline] + pub fn vendor_fault_data(mut self, vendor_fault_data: u64) -> Self { + self.inner.vendor_fault_data = vendor_fault_data; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DeviceFaultVendorInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DeviceFaultCountsEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub address_info_count: u32, + pub vendor_info_count: u32, + pub vendor_binary_size: DeviceSize, +} +impl ::std::default::Default for DeviceFaultCountsEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + address_info_count: u32::default(), + vendor_info_count: u32::default(), + vendor_binary_size: DeviceSize::default(), + } + } +} +unsafe impl TaggedStructure for DeviceFaultCountsEXT { + const STRUCTURE_TYPE: StructureType = StructureType::DEVICE_FAULT_COUNTS_EXT; +} +impl DeviceFaultCountsEXT { + pub fn builder<'a>() -> DeviceFaultCountsEXTBuilder<'a> { + DeviceFaultCountsEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DeviceFaultCountsEXTBuilder<'a> { + inner: DeviceFaultCountsEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DeviceFaultCountsEXTBuilder<'a> { + type Target = DeviceFaultCountsEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DeviceFaultCountsEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DeviceFaultCountsEXTBuilder<'a> { + #[inline] + pub fn address_info_count(mut self, address_info_count: u32) -> Self { + self.inner.address_info_count = address_info_count; + self + } + #[inline] + pub fn vendor_info_count(mut self, vendor_info_count: u32) -> Self { + self.inner.vendor_info_count = vendor_info_count; + self + } + #[inline] + pub fn vendor_binary_size(mut self, vendor_binary_size: DeviceSize) -> Self { + self.inner.vendor_binary_size = vendor_binary_size; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DeviceFaultCountsEXT { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DeviceFaultInfoEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub description: [c_char; MAX_DESCRIPTION_SIZE], + pub p_address_infos: *mut DeviceFaultAddressInfoEXT, + pub p_vendor_infos: *mut DeviceFaultVendorInfoEXT, + pub p_vendor_binary_data: *mut c_void, +} +#[cfg(feature = "debug")] +impl fmt::Debug for DeviceFaultInfoEXT { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fmt.debug_struct("DeviceFaultInfoEXT") + .field("s_type", &self.s_type) + .field("p_next", &self.p_next) + .field("description", &unsafe { + ::std::ffi::CStr::from_ptr(self.description.as_ptr()) + }) + .field("p_address_infos", &self.p_address_infos) + .field("p_vendor_infos", &self.p_vendor_infos) + .field("p_vendor_binary_data", &self.p_vendor_binary_data) + .finish() + } +} +impl ::std::default::Default for DeviceFaultInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + description: unsafe { ::std::mem::zeroed() }, + p_address_infos: ::std::ptr::null_mut(), + p_vendor_infos: ::std::ptr::null_mut(), + p_vendor_binary_data: ::std::ptr::null_mut(), + } + } +} +unsafe impl TaggedStructure for DeviceFaultInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::DEVICE_FAULT_INFO_EXT; +} +impl DeviceFaultInfoEXT { + pub fn builder<'a>() -> DeviceFaultInfoEXTBuilder<'a> { + DeviceFaultInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DeviceFaultInfoEXTBuilder<'a> { + inner: DeviceFaultInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DeviceFaultInfoEXTBuilder<'a> { + type Target = DeviceFaultInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DeviceFaultInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DeviceFaultInfoEXTBuilder<'a> { + #[inline] + pub fn description(mut self, description: [c_char; MAX_DESCRIPTION_SIZE]) -> Self { + self.inner.description = description; + self + } + #[inline] + pub fn address_infos(mut self, address_infos: &'a mut DeviceFaultAddressInfoEXT) -> Self { + self.inner.p_address_infos = address_infos; + self + } + #[inline] + pub fn vendor_infos(mut self, vendor_infos: &'a mut DeviceFaultVendorInfoEXT) -> Self { + self.inner.p_vendor_infos = vendor_infos; + self + } + #[inline] + pub fn vendor_binary_data(mut self, vendor_binary_data: *mut c_void) -> Self { + self.inner.p_vendor_binary_data = vendor_binary_data; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DeviceFaultInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DeviceFaultVendorBinaryHeaderVersionOneEXT { + pub header_size: u32, + pub header_version: DeviceFaultVendorBinaryHeaderVersionEXT, + pub vendor_id: u32, + pub device_id: u32, + pub driver_version: u32, + pub pipeline_cache_uuid: [u8; UUID_SIZE], + pub application_name_offset: u32, + pub application_version: u32, + pub engine_name_offset: u32, +} +impl ::std::default::Default for DeviceFaultVendorBinaryHeaderVersionOneEXT { + #[inline] + fn default() -> Self { + Self { + header_size: u32::default(), + header_version: DeviceFaultVendorBinaryHeaderVersionEXT::default(), + vendor_id: u32::default(), + device_id: u32::default(), + driver_version: u32::default(), + pipeline_cache_uuid: unsafe { ::std::mem::zeroed() }, + application_name_offset: u32::default(), + application_version: u32::default(), + engine_name_offset: u32::default(), + } + } +} +impl DeviceFaultVendorBinaryHeaderVersionOneEXT { + pub fn builder<'a>() -> DeviceFaultVendorBinaryHeaderVersionOneEXTBuilder<'a> { + DeviceFaultVendorBinaryHeaderVersionOneEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DeviceFaultVendorBinaryHeaderVersionOneEXTBuilder<'a> { + inner: DeviceFaultVendorBinaryHeaderVersionOneEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DeviceFaultVendorBinaryHeaderVersionOneEXTBuilder<'a> { + type Target = DeviceFaultVendorBinaryHeaderVersionOneEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DeviceFaultVendorBinaryHeaderVersionOneEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DeviceFaultVendorBinaryHeaderVersionOneEXTBuilder<'a> { + #[inline] + pub fn header_size(mut self, header_size: u32) -> Self { + self.inner.header_size = header_size; + self + } + #[inline] + pub fn header_version( + mut self, + header_version: DeviceFaultVendorBinaryHeaderVersionEXT, + ) -> Self { + self.inner.header_version = header_version; + self + } + #[inline] + pub fn vendor_id(mut self, vendor_id: u32) -> Self { + self.inner.vendor_id = vendor_id; + self + } + #[inline] + pub fn device_id(mut self, device_id: u32) -> Self { + self.inner.device_id = device_id; + self + } + #[inline] + pub fn driver_version(mut self, driver_version: u32) -> Self { + self.inner.driver_version = driver_version; + self + } + #[inline] + pub fn pipeline_cache_uuid(mut self, pipeline_cache_uuid: [u8; UUID_SIZE]) -> Self { + self.inner.pipeline_cache_uuid = pipeline_cache_uuid; + self + } + #[inline] + pub fn application_name_offset(mut self, application_name_offset: u32) -> Self { + self.inner.application_name_offset = application_name_offset; + self + } + #[inline] + pub fn application_version(mut self, application_version: u32) -> Self { + self.inner.application_version = application_version; + self + } + #[inline] + pub fn engine_name_offset(mut self, engine_name_offset: u32) -> Self { + self.inner.engine_name_offset = engine_name_offset; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DeviceFaultVendorBinaryHeaderVersionOneEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct DecompressMemoryRegionNV { + pub src_address: DeviceAddress, + pub dst_address: DeviceAddress, + pub compressed_size: DeviceSize, + pub decompressed_size: DeviceSize, + pub decompression_method: MemoryDecompressionMethodFlagsNV, +} +impl DecompressMemoryRegionNV { + pub fn builder<'a>() -> DecompressMemoryRegionNVBuilder<'a> { + DecompressMemoryRegionNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DecompressMemoryRegionNVBuilder<'a> { + inner: DecompressMemoryRegionNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DecompressMemoryRegionNVBuilder<'a> { + type Target = DecompressMemoryRegionNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DecompressMemoryRegionNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DecompressMemoryRegionNVBuilder<'a> { + #[inline] + pub fn src_address(mut self, src_address: DeviceAddress) -> Self { + self.inner.src_address = src_address; + self + } + #[inline] + pub fn dst_address(mut self, dst_address: DeviceAddress) -> Self { + self.inner.dst_address = dst_address; + self + } + #[inline] + pub fn compressed_size(mut self, compressed_size: DeviceSize) -> Self { + self.inner.compressed_size = compressed_size; + self + } + #[inline] + pub fn decompressed_size(mut self, decompressed_size: DeviceSize) -> Self { + self.inner.decompressed_size = decompressed_size; + self + } + #[inline] + pub fn decompression_method( + mut self, + decompression_method: MemoryDecompressionMethodFlagsNV, + ) -> Self { + self.inner.decompression_method = decompression_method; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DecompressMemoryRegionNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceShaderCoreBuiltinsPropertiesARM { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub shader_core_mask: u64, + pub shader_core_count: u32, + pub shader_warps_per_core: u32, +} +impl ::std::default::Default for PhysicalDeviceShaderCoreBuiltinsPropertiesARM { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + shader_core_mask: u64::default(), + shader_core_count: u32::default(), + shader_warps_per_core: u32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceShaderCoreBuiltinsPropertiesARM { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM; +} +impl PhysicalDeviceShaderCoreBuiltinsPropertiesARM { + pub fn builder<'a>() -> PhysicalDeviceShaderCoreBuiltinsPropertiesARMBuilder<'a> { + PhysicalDeviceShaderCoreBuiltinsPropertiesARMBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceShaderCoreBuiltinsPropertiesARMBuilder<'a> { + inner: PhysicalDeviceShaderCoreBuiltinsPropertiesARM, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceShaderCoreBuiltinsPropertiesARMBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceShaderCoreBuiltinsPropertiesARM {} +impl<'a> ::std::ops::Deref for PhysicalDeviceShaderCoreBuiltinsPropertiesARMBuilder<'a> { + type Target = PhysicalDeviceShaderCoreBuiltinsPropertiesARM; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderCoreBuiltinsPropertiesARMBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceShaderCoreBuiltinsPropertiesARMBuilder<'a> { + #[inline] + pub fn shader_core_mask(mut self, shader_core_mask: u64) -> Self { + self.inner.shader_core_mask = shader_core_mask; + self + } + #[inline] + pub fn shader_core_count(mut self, shader_core_count: u32) -> Self { + self.inner.shader_core_count = shader_core_count; + self + } + #[inline] + pub fn shader_warps_per_core(mut self, shader_warps_per_core: u32) -> Self { + self.inner.shader_warps_per_core = shader_warps_per_core; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceShaderCoreBuiltinsPropertiesARM { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceShaderCoreBuiltinsFeaturesARM { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub shader_core_builtins: Bool32, +} +impl ::std::default::Default for PhysicalDeviceShaderCoreBuiltinsFeaturesARM { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + shader_core_builtins: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceShaderCoreBuiltinsFeaturesARM { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM; +} +impl PhysicalDeviceShaderCoreBuiltinsFeaturesARM { + pub fn builder<'a>() -> PhysicalDeviceShaderCoreBuiltinsFeaturesARMBuilder<'a> { + PhysicalDeviceShaderCoreBuiltinsFeaturesARMBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceShaderCoreBuiltinsFeaturesARMBuilder<'a> { + inner: PhysicalDeviceShaderCoreBuiltinsFeaturesARM, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceShaderCoreBuiltinsFeaturesARMBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderCoreBuiltinsFeaturesARM {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderCoreBuiltinsFeaturesARMBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderCoreBuiltinsFeaturesARM {} +impl<'a> ::std::ops::Deref for PhysicalDeviceShaderCoreBuiltinsFeaturesARMBuilder<'a> { + type Target = PhysicalDeviceShaderCoreBuiltinsFeaturesARM; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderCoreBuiltinsFeaturesARMBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceShaderCoreBuiltinsFeaturesARMBuilder<'a> { + #[inline] + pub fn shader_core_builtins(mut self, shader_core_builtins: bool) -> Self { + self.inner.shader_core_builtins = shader_core_builtins.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceShaderCoreBuiltinsFeaturesARM { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SurfacePresentModeEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub present_mode: PresentModeKHR, +} +impl ::std::default::Default for SurfacePresentModeEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + present_mode: PresentModeKHR::default(), + } + } +} +unsafe impl TaggedStructure for SurfacePresentModeEXT { + const STRUCTURE_TYPE: StructureType = StructureType::SURFACE_PRESENT_MODE_EXT; +} +impl SurfacePresentModeEXT { + pub fn builder<'a>() -> SurfacePresentModeEXTBuilder<'a> { + SurfacePresentModeEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SurfacePresentModeEXTBuilder<'a> { + inner: SurfacePresentModeEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceSurfaceInfo2KHR for SurfacePresentModeEXTBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceSurfaceInfo2KHR for SurfacePresentModeEXT {} +impl<'a> ::std::ops::Deref for SurfacePresentModeEXTBuilder<'a> { + type Target = SurfacePresentModeEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SurfacePresentModeEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SurfacePresentModeEXTBuilder<'a> { + #[inline] + pub fn present_mode(mut self, present_mode: PresentModeKHR) -> Self { + self.inner.present_mode = present_mode; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SurfacePresentModeEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SurfacePresentScalingCapabilitiesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub supported_present_scaling: PresentScalingFlagsEXT, + pub supported_present_gravity_x: PresentGravityFlagsEXT, + pub supported_present_gravity_y: PresentGravityFlagsEXT, + pub min_scaled_image_extent: Extent2D, + pub max_scaled_image_extent: Extent2D, +} +impl ::std::default::Default for SurfacePresentScalingCapabilitiesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + supported_present_scaling: PresentScalingFlagsEXT::default(), + supported_present_gravity_x: PresentGravityFlagsEXT::default(), + supported_present_gravity_y: PresentGravityFlagsEXT::default(), + min_scaled_image_extent: Extent2D::default(), + max_scaled_image_extent: Extent2D::default(), + } + } +} +unsafe impl TaggedStructure for SurfacePresentScalingCapabilitiesEXT { + const STRUCTURE_TYPE: StructureType = StructureType::SURFACE_PRESENT_SCALING_CAPABILITIES_EXT; +} +impl SurfacePresentScalingCapabilitiesEXT { + pub fn builder<'a>() -> SurfacePresentScalingCapabilitiesEXTBuilder<'a> { + SurfacePresentScalingCapabilitiesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SurfacePresentScalingCapabilitiesEXTBuilder<'a> { + inner: SurfacePresentScalingCapabilitiesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsSurfaceCapabilities2KHR for SurfacePresentScalingCapabilitiesEXTBuilder<'_> {} +unsafe impl ExtendsSurfaceCapabilities2KHR for SurfacePresentScalingCapabilitiesEXT {} +impl<'a> ::std::ops::Deref for SurfacePresentScalingCapabilitiesEXTBuilder<'a> { + type Target = SurfacePresentScalingCapabilitiesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SurfacePresentScalingCapabilitiesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SurfacePresentScalingCapabilitiesEXTBuilder<'a> { + #[inline] + pub fn supported_present_scaling( + mut self, + supported_present_scaling: PresentScalingFlagsEXT, + ) -> Self { + self.inner.supported_present_scaling = supported_present_scaling; + self + } + #[inline] + pub fn supported_present_gravity_x( + mut self, + supported_present_gravity_x: PresentGravityFlagsEXT, + ) -> Self { + self.inner.supported_present_gravity_x = supported_present_gravity_x; + self + } + #[inline] + pub fn supported_present_gravity_y( + mut self, + supported_present_gravity_y: PresentGravityFlagsEXT, + ) -> Self { + self.inner.supported_present_gravity_y = supported_present_gravity_y; + self + } + #[inline] + pub fn min_scaled_image_extent(mut self, min_scaled_image_extent: Extent2D) -> Self { + self.inner.min_scaled_image_extent = min_scaled_image_extent; + self + } + #[inline] + pub fn max_scaled_image_extent(mut self, max_scaled_image_extent: Extent2D) -> Self { + self.inner.max_scaled_image_extent = max_scaled_image_extent; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SurfacePresentScalingCapabilitiesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SurfacePresentModeCompatibilityEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub present_mode_count: u32, + pub p_present_modes: *mut PresentModeKHR, +} +impl ::std::default::Default for SurfacePresentModeCompatibilityEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + present_mode_count: u32::default(), + p_present_modes: ::std::ptr::null_mut(), + } + } +} +unsafe impl TaggedStructure for SurfacePresentModeCompatibilityEXT { + const STRUCTURE_TYPE: StructureType = StructureType::SURFACE_PRESENT_MODE_COMPATIBILITY_EXT; +} +impl SurfacePresentModeCompatibilityEXT { + pub fn builder<'a>() -> SurfacePresentModeCompatibilityEXTBuilder<'a> { + SurfacePresentModeCompatibilityEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SurfacePresentModeCompatibilityEXTBuilder<'a> { + inner: SurfacePresentModeCompatibilityEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsSurfaceCapabilities2KHR for SurfacePresentModeCompatibilityEXTBuilder<'_> {} +unsafe impl ExtendsSurfaceCapabilities2KHR for SurfacePresentModeCompatibilityEXT {} +impl<'a> ::std::ops::Deref for SurfacePresentModeCompatibilityEXTBuilder<'a> { + type Target = SurfacePresentModeCompatibilityEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SurfacePresentModeCompatibilityEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SurfacePresentModeCompatibilityEXTBuilder<'a> { + #[inline] + pub fn present_modes(mut self, present_modes: &'a mut [PresentModeKHR]) -> Self { + self.inner.present_mode_count = present_modes.len() as _; + self.inner.p_present_modes = present_modes.as_mut_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SurfacePresentModeCompatibilityEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceSwapchainMaintenance1FeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub swapchain_maintenance1: Bool32, +} +impl ::std::default::Default for PhysicalDeviceSwapchainMaintenance1FeaturesEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + swapchain_maintenance1: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceSwapchainMaintenance1FeaturesEXT { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT; +} +impl PhysicalDeviceSwapchainMaintenance1FeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceSwapchainMaintenance1FeaturesEXTBuilder<'a> { + PhysicalDeviceSwapchainMaintenance1FeaturesEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceSwapchainMaintenance1FeaturesEXTBuilder<'a> { + inner: PhysicalDeviceSwapchainMaintenance1FeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceSwapchainMaintenance1FeaturesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceSwapchainMaintenance1FeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceSwapchainMaintenance1FeaturesEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceSwapchainMaintenance1FeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceSwapchainMaintenance1FeaturesEXTBuilder<'a> { + type Target = PhysicalDeviceSwapchainMaintenance1FeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceSwapchainMaintenance1FeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceSwapchainMaintenance1FeaturesEXTBuilder<'a> { + #[inline] + pub fn swapchain_maintenance1(mut self, swapchain_maintenance1: bool) -> Self { + self.inner.swapchain_maintenance1 = swapchain_maintenance1.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceSwapchainMaintenance1FeaturesEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SwapchainPresentFenceInfoEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub swapchain_count: u32, + pub p_fences: *const Fence, +} +impl ::std::default::Default for SwapchainPresentFenceInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + swapchain_count: u32::default(), + p_fences: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for SwapchainPresentFenceInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::SWAPCHAIN_PRESENT_FENCE_INFO_EXT; +} +impl SwapchainPresentFenceInfoEXT { + pub fn builder<'a>() -> SwapchainPresentFenceInfoEXTBuilder<'a> { + SwapchainPresentFenceInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SwapchainPresentFenceInfoEXTBuilder<'a> { + inner: SwapchainPresentFenceInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPresentInfoKHR for SwapchainPresentFenceInfoEXTBuilder<'_> {} +unsafe impl ExtendsPresentInfoKHR for SwapchainPresentFenceInfoEXT {} +impl<'a> ::std::ops::Deref for SwapchainPresentFenceInfoEXTBuilder<'a> { + type Target = SwapchainPresentFenceInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SwapchainPresentFenceInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SwapchainPresentFenceInfoEXTBuilder<'a> { + #[inline] + pub fn fences(mut self, fences: &'a [Fence]) -> Self { + self.inner.swapchain_count = fences.len() as _; + self.inner.p_fences = fences.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SwapchainPresentFenceInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SwapchainPresentModesCreateInfoEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub present_mode_count: u32, + pub p_present_modes: *const PresentModeKHR, +} +impl ::std::default::Default for SwapchainPresentModesCreateInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + present_mode_count: u32::default(), + p_present_modes: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for SwapchainPresentModesCreateInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::SWAPCHAIN_PRESENT_MODES_CREATE_INFO_EXT; +} +impl SwapchainPresentModesCreateInfoEXT { + pub fn builder<'a>() -> SwapchainPresentModesCreateInfoEXTBuilder<'a> { + SwapchainPresentModesCreateInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SwapchainPresentModesCreateInfoEXTBuilder<'a> { + inner: SwapchainPresentModesCreateInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsSwapchainCreateInfoKHR for SwapchainPresentModesCreateInfoEXTBuilder<'_> {} +unsafe impl ExtendsSwapchainCreateInfoKHR for SwapchainPresentModesCreateInfoEXT {} +impl<'a> ::std::ops::Deref for SwapchainPresentModesCreateInfoEXTBuilder<'a> { + type Target = SwapchainPresentModesCreateInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SwapchainPresentModesCreateInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SwapchainPresentModesCreateInfoEXTBuilder<'a> { + #[inline] + pub fn present_modes(mut self, present_modes: &'a [PresentModeKHR]) -> Self { + self.inner.present_mode_count = present_modes.len() as _; + self.inner.p_present_modes = present_modes.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SwapchainPresentModesCreateInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SwapchainPresentModeInfoEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub swapchain_count: u32, + pub p_present_modes: *const PresentModeKHR, +} +impl ::std::default::Default for SwapchainPresentModeInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + swapchain_count: u32::default(), + p_present_modes: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for SwapchainPresentModeInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::SWAPCHAIN_PRESENT_MODE_INFO_EXT; +} +impl SwapchainPresentModeInfoEXT { + pub fn builder<'a>() -> SwapchainPresentModeInfoEXTBuilder<'a> { + SwapchainPresentModeInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SwapchainPresentModeInfoEXTBuilder<'a> { + inner: SwapchainPresentModeInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPresentInfoKHR for SwapchainPresentModeInfoEXTBuilder<'_> {} +unsafe impl ExtendsPresentInfoKHR for SwapchainPresentModeInfoEXT {} +impl<'a> ::std::ops::Deref for SwapchainPresentModeInfoEXTBuilder<'a> { + type Target = SwapchainPresentModeInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SwapchainPresentModeInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SwapchainPresentModeInfoEXTBuilder<'a> { + #[inline] + pub fn present_modes(mut self, present_modes: &'a [PresentModeKHR]) -> Self { + self.inner.swapchain_count = present_modes.len() as _; + self.inner.p_present_modes = present_modes.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SwapchainPresentModeInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SwapchainPresentScalingCreateInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub scaling_behavior: PresentScalingFlagsEXT, + pub present_gravity_x: PresentGravityFlagsEXT, + pub present_gravity_y: PresentGravityFlagsEXT, +} +impl ::std::default::Default for SwapchainPresentScalingCreateInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + scaling_behavior: PresentScalingFlagsEXT::default(), + present_gravity_x: PresentGravityFlagsEXT::default(), + present_gravity_y: PresentGravityFlagsEXT::default(), + } + } +} +unsafe impl TaggedStructure for SwapchainPresentScalingCreateInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_EXT; +} +impl SwapchainPresentScalingCreateInfoEXT { + pub fn builder<'a>() -> SwapchainPresentScalingCreateInfoEXTBuilder<'a> { + SwapchainPresentScalingCreateInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SwapchainPresentScalingCreateInfoEXTBuilder<'a> { + inner: SwapchainPresentScalingCreateInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsSwapchainCreateInfoKHR for SwapchainPresentScalingCreateInfoEXTBuilder<'_> {} +unsafe impl ExtendsSwapchainCreateInfoKHR for SwapchainPresentScalingCreateInfoEXT {} +impl<'a> ::std::ops::Deref for SwapchainPresentScalingCreateInfoEXTBuilder<'a> { + type Target = SwapchainPresentScalingCreateInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SwapchainPresentScalingCreateInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SwapchainPresentScalingCreateInfoEXTBuilder<'a> { + #[inline] + pub fn scaling_behavior(mut self, scaling_behavior: PresentScalingFlagsEXT) -> Self { + self.inner.scaling_behavior = scaling_behavior; + self + } + #[inline] + pub fn present_gravity_x(mut self, present_gravity_x: PresentGravityFlagsEXT) -> Self { + self.inner.present_gravity_x = present_gravity_x; + self + } + #[inline] + pub fn present_gravity_y(mut self, present_gravity_y: PresentGravityFlagsEXT) -> Self { + self.inner.present_gravity_y = present_gravity_y; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SwapchainPresentScalingCreateInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ReleaseSwapchainImagesInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub swapchain: SwapchainKHR, + pub image_index_count: u32, + pub p_image_indices: *const u32, +} +impl ::std::default::Default for ReleaseSwapchainImagesInfoEXT { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + swapchain: SwapchainKHR::default(), + image_index_count: u32::default(), + p_image_indices: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for ReleaseSwapchainImagesInfoEXT { + const STRUCTURE_TYPE: StructureType = StructureType::RELEASE_SWAPCHAIN_IMAGES_INFO_EXT; +} +impl ReleaseSwapchainImagesInfoEXT { + pub fn builder<'a>() -> ReleaseSwapchainImagesInfoEXTBuilder<'a> { + ReleaseSwapchainImagesInfoEXTBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ReleaseSwapchainImagesInfoEXTBuilder<'a> { + inner: ReleaseSwapchainImagesInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for ReleaseSwapchainImagesInfoEXTBuilder<'a> { + type Target = ReleaseSwapchainImagesInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ReleaseSwapchainImagesInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ReleaseSwapchainImagesInfoEXTBuilder<'a> { + #[inline] + pub fn swapchain(mut self, swapchain: SwapchainKHR) -> Self { + self.inner.swapchain = swapchain; + self + } + #[inline] + pub fn image_indices(mut self, image_indices: &'a [u32]) -> Self { + self.inner.image_index_count = image_indices.len() as _; + self.inner.p_image_indices = image_indices.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ReleaseSwapchainImagesInfoEXT { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceRayTracingInvocationReorderFeaturesNV { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub ray_tracing_invocation_reorder: Bool32, +} +impl ::std::default::Default for PhysicalDeviceRayTracingInvocationReorderFeaturesNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + ray_tracing_invocation_reorder: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceRayTracingInvocationReorderFeaturesNV { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV; +} +impl PhysicalDeviceRayTracingInvocationReorderFeaturesNV { + pub fn builder<'a>() -> PhysicalDeviceRayTracingInvocationReorderFeaturesNVBuilder<'a> { + PhysicalDeviceRayTracingInvocationReorderFeaturesNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceRayTracingInvocationReorderFeaturesNVBuilder<'a> { + inner: PhysicalDeviceRayTracingInvocationReorderFeaturesNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceRayTracingInvocationReorderFeaturesNVBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceRayTracingInvocationReorderFeaturesNV {} +unsafe impl ExtendsDeviceCreateInfo + for PhysicalDeviceRayTracingInvocationReorderFeaturesNVBuilder<'_> +{ +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceRayTracingInvocationReorderFeaturesNV {} +impl<'a> ::std::ops::Deref for PhysicalDeviceRayTracingInvocationReorderFeaturesNVBuilder<'a> { + type Target = PhysicalDeviceRayTracingInvocationReorderFeaturesNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceRayTracingInvocationReorderFeaturesNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceRayTracingInvocationReorderFeaturesNVBuilder<'a> { + #[inline] + pub fn ray_tracing_invocation_reorder(mut self, ray_tracing_invocation_reorder: bool) -> Self { + self.inner.ray_tracing_invocation_reorder = ray_tracing_invocation_reorder.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceRayTracingInvocationReorderFeaturesNV { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceRayTracingInvocationReorderPropertiesNV { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub ray_tracing_invocation_reorder_reordering_hint: RayTracingInvocationReorderModeNV, +} +impl ::std::default::Default for PhysicalDeviceRayTracingInvocationReorderPropertiesNV { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + ray_tracing_invocation_reorder_reordering_hint: + RayTracingInvocationReorderModeNV::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceRayTracingInvocationReorderPropertiesNV { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV; +} +impl PhysicalDeviceRayTracingInvocationReorderPropertiesNV { + pub fn builder<'a>() -> PhysicalDeviceRayTracingInvocationReorderPropertiesNVBuilder<'a> { + PhysicalDeviceRayTracingInvocationReorderPropertiesNVBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceRayTracingInvocationReorderPropertiesNVBuilder<'a> { + inner: PhysicalDeviceRayTracingInvocationReorderPropertiesNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceRayTracingInvocationReorderPropertiesNVBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceRayTracingInvocationReorderPropertiesNV +{ +} +impl<'a> ::std::ops::Deref for PhysicalDeviceRayTracingInvocationReorderPropertiesNVBuilder<'a> { + type Target = PhysicalDeviceRayTracingInvocationReorderPropertiesNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceRayTracingInvocationReorderPropertiesNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceRayTracingInvocationReorderPropertiesNVBuilder<'a> { + #[inline] + pub fn ray_tracing_invocation_reorder_reordering_hint( + mut self, + ray_tracing_invocation_reorder_reordering_hint: RayTracingInvocationReorderModeNV, + ) -> Self { + self.inner.ray_tracing_invocation_reorder_reordering_hint = + ray_tracing_invocation_reorder_reordering_hint; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceRayTracingInvocationReorderPropertiesNV { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DirectDriverLoadingInfoLUNARG { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub flags: DirectDriverLoadingFlagsLUNARG, + pub pfn_get_instance_proc_addr: PFN_vkGetInstanceProcAddrLUNARG, +} +#[cfg(feature = "debug")] +impl fmt::Debug for DirectDriverLoadingInfoLUNARG { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fmt.debug_struct("DirectDriverLoadingInfoLUNARG") + .field("s_type", &self.s_type) + .field("p_next", &self.p_next) + .field("flags", &self.flags) + .field( + "pfn_get_instance_proc_addr", + &(self.pfn_get_instance_proc_addr.map(|x| x as *const ())), + ) + .finish() + } +} +impl ::std::default::Default for DirectDriverLoadingInfoLUNARG { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + flags: DirectDriverLoadingFlagsLUNARG::default(), + pfn_get_instance_proc_addr: PFN_vkGetInstanceProcAddrLUNARG::default(), + } + } +} +unsafe impl TaggedStructure for DirectDriverLoadingInfoLUNARG { + const STRUCTURE_TYPE: StructureType = StructureType::DIRECT_DRIVER_LOADING_INFO_LUNARG; +} +impl DirectDriverLoadingInfoLUNARG { + pub fn builder<'a>() -> DirectDriverLoadingInfoLUNARGBuilder<'a> { + DirectDriverLoadingInfoLUNARGBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DirectDriverLoadingInfoLUNARGBuilder<'a> { + inner: DirectDriverLoadingInfoLUNARG, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for DirectDriverLoadingInfoLUNARGBuilder<'a> { + type Target = DirectDriverLoadingInfoLUNARG; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DirectDriverLoadingInfoLUNARGBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DirectDriverLoadingInfoLUNARGBuilder<'a> { + #[inline] + pub fn flags(mut self, flags: DirectDriverLoadingFlagsLUNARG) -> Self { + self.inner.flags = flags; + self + } + #[inline] + pub fn pfn_get_instance_proc_addr( + mut self, + pfn_get_instance_proc_addr: PFN_vkGetInstanceProcAddrLUNARG, + ) -> Self { + self.inner.pfn_get_instance_proc_addr = pfn_get_instance_proc_addr; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DirectDriverLoadingInfoLUNARG { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DirectDriverLoadingListLUNARG { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub mode: DirectDriverLoadingModeLUNARG, + pub driver_count: u32, + pub p_drivers: *const DirectDriverLoadingInfoLUNARG, +} +impl ::std::default::Default for DirectDriverLoadingListLUNARG { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + mode: DirectDriverLoadingModeLUNARG::default(), + driver_count: u32::default(), + p_drivers: ::std::ptr::null(), + } + } +} +unsafe impl TaggedStructure for DirectDriverLoadingListLUNARG { + const STRUCTURE_TYPE: StructureType = StructureType::DIRECT_DRIVER_LOADING_LIST_LUNARG; +} +impl DirectDriverLoadingListLUNARG { + pub fn builder<'a>() -> DirectDriverLoadingListLUNARGBuilder<'a> { + DirectDriverLoadingListLUNARGBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DirectDriverLoadingListLUNARGBuilder<'a> { + inner: DirectDriverLoadingListLUNARG, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsInstanceCreateInfo for DirectDriverLoadingListLUNARGBuilder<'_> {} +unsafe impl ExtendsInstanceCreateInfo for DirectDriverLoadingListLUNARG {} +impl<'a> ::std::ops::Deref for DirectDriverLoadingListLUNARGBuilder<'a> { + type Target = DirectDriverLoadingListLUNARG; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DirectDriverLoadingListLUNARGBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DirectDriverLoadingListLUNARGBuilder<'a> { + #[inline] + pub fn mode(mut self, mode: DirectDriverLoadingModeLUNARG) -> Self { + self.inner.mode = mode; + self + } + #[inline] + pub fn drivers(mut self, drivers: &'a [DirectDriverLoadingInfoLUNARG]) -> Self { + self.inner.driver_count = drivers.len() as _; + self.inner.p_drivers = drivers.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DirectDriverLoadingListLUNARG { + self.inner + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub multiview_per_view_viewports: Bool32, +} +impl ::std::default::Default for PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + multiview_per_view_viewports: Bool32::default(), + } + } +} +unsafe impl TaggedStructure for PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM; +} +impl PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM { + pub fn builder<'a>() -> PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOMBuilder<'a> { + PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOMBuilder { + inner: Self::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOMBuilder<'a> { + inner: PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOMBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM {} +unsafe impl ExtendsDeviceCreateInfo + for PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOMBuilder<'_> +{ +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM {} +impl<'a> ::std::ops::Deref for PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOMBuilder<'a> { + type Target = PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOMBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOMBuilder<'a> { + #[inline] + pub fn multiview_per_view_viewports(mut self, multiview_per_view_viewports: bool) -> Self { + self.inner.multiview_per_view_viewports = multiview_per_view_viewports.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM { + self.inner + } +} diff --git a/third_party/rust/ash/src/vk/enums.rs b/third_party/rust/ash/src/vk/enums.rs new file mode 100644 index 0000000000..a27a55b40c --- /dev/null +++ b/third_party/rust/ash/src/vk/enums.rs @@ -0,0 +1,2917 @@ +use std::fmt; +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct ImageLayout(pub(crate) i32); +impl ImageLayout { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl ImageLayout { + #[doc = "Implicit layout an image is when its contents are undefined due to various reasons (e.g. right after creation)"] + pub const UNDEFINED: Self = Self(0); + #[doc = "General layout when image can be used for any kind of access"] + pub const GENERAL: Self = Self(1); + #[doc = "Optimal layout when image is only used for color attachment read/write"] + pub const COLOR_ATTACHMENT_OPTIMAL: Self = Self(2); + #[doc = "Optimal layout when image is only used for depth/stencil attachment read/write"] + pub const DEPTH_STENCIL_ATTACHMENT_OPTIMAL: Self = Self(3); + #[doc = "Optimal layout when image is used for read only depth/stencil attachment and shader access"] + pub const DEPTH_STENCIL_READ_ONLY_OPTIMAL: Self = Self(4); + #[doc = "Optimal layout when image is used for read only shader access"] + pub const SHADER_READ_ONLY_OPTIMAL: Self = Self(5); + #[doc = "Optimal layout when image is used only as source of transfer operations"] + pub const TRANSFER_SRC_OPTIMAL: Self = Self(6); + #[doc = "Optimal layout when image is used only as destination of transfer operations"] + pub const TRANSFER_DST_OPTIMAL: Self = Self(7); + #[doc = "Initial layout used when the data is populated by the CPU"] + pub const PREINITIALIZED: Self = Self(8); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct AttachmentLoadOp(pub(crate) i32); +impl AttachmentLoadOp { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl AttachmentLoadOp { + pub const LOAD: Self = Self(0); + pub const CLEAR: Self = Self(1); + pub const DONT_CARE: Self = Self(2); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct AttachmentStoreOp(pub(crate) i32); +impl AttachmentStoreOp { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl AttachmentStoreOp { + pub const STORE: Self = Self(0); + pub const DONT_CARE: Self = Self(1); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct ImageType(pub(crate) i32); +impl ImageType { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl ImageType { + pub const TYPE_1D: Self = Self(0); + pub const TYPE_2D: Self = Self(1); + pub const TYPE_3D: Self = Self(2); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct ImageTiling(pub(crate) i32); +impl ImageTiling { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl ImageTiling { + pub const OPTIMAL: Self = Self(0); + pub const LINEAR: Self = Self(1); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct ImageViewType(pub(crate) i32); +impl ImageViewType { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl ImageViewType { + pub const TYPE_1D: Self = Self(0); + pub const TYPE_2D: Self = Self(1); + pub const TYPE_3D: Self = Self(2); + pub const CUBE: Self = Self(3); + pub const TYPE_1D_ARRAY: Self = Self(4); + pub const TYPE_2D_ARRAY: Self = Self(5); + pub const CUBE_ARRAY: Self = Self(6); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct CommandBufferLevel(pub(crate) i32); +impl CommandBufferLevel { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl CommandBufferLevel { + pub const PRIMARY: Self = Self(0); + pub const SECONDARY: Self = Self(1); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct ComponentSwizzle(pub(crate) i32); +impl ComponentSwizzle { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl ComponentSwizzle { + pub const IDENTITY: Self = Self(0); + pub const ZERO: Self = Self(1); + pub const ONE: Self = Self(2); + pub const R: Self = Self(3); + pub const G: Self = Self(4); + pub const B: Self = Self(5); + pub const A: Self = Self(6); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct DescriptorType(pub(crate) i32); +impl DescriptorType { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl DescriptorType { + pub const SAMPLER: Self = Self(0); + pub const COMBINED_IMAGE_SAMPLER: Self = Self(1); + pub const SAMPLED_IMAGE: Self = Self(2); + pub const STORAGE_IMAGE: Self = Self(3); + pub const UNIFORM_TEXEL_BUFFER: Self = Self(4); + pub const STORAGE_TEXEL_BUFFER: Self = Self(5); + pub const UNIFORM_BUFFER: Self = Self(6); + pub const STORAGE_BUFFER: Self = Self(7); + pub const UNIFORM_BUFFER_DYNAMIC: Self = Self(8); + pub const STORAGE_BUFFER_DYNAMIC: Self = Self(9); + pub const INPUT_ATTACHMENT: Self = Self(10); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct QueryType(pub(crate) i32); +impl QueryType { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl QueryType { + pub const OCCLUSION: Self = Self(0); + #[doc = "Optional"] + pub const PIPELINE_STATISTICS: Self = Self(1); + pub const TIMESTAMP: Self = Self(2); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct BorderColor(pub(crate) i32); +impl BorderColor { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl BorderColor { + pub const FLOAT_TRANSPARENT_BLACK: Self = Self(0); + pub const INT_TRANSPARENT_BLACK: Self = Self(1); + pub const FLOAT_OPAQUE_BLACK: Self = Self(2); + pub const INT_OPAQUE_BLACK: Self = Self(3); + pub const FLOAT_OPAQUE_WHITE: Self = Self(4); + pub const INT_OPAQUE_WHITE: Self = Self(5); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct PipelineBindPoint(pub(crate) i32); +impl PipelineBindPoint { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl PipelineBindPoint { + pub const GRAPHICS: Self = Self(0); + pub const COMPUTE: Self = Self(1); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct PipelineCacheHeaderVersion(pub(crate) i32); +impl PipelineCacheHeaderVersion { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl PipelineCacheHeaderVersion { + pub const ONE: Self = Self(1); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct PrimitiveTopology(pub(crate) i32); +impl PrimitiveTopology { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl PrimitiveTopology { + pub const POINT_LIST: Self = Self(0); + pub const LINE_LIST: Self = Self(1); + pub const LINE_STRIP: Self = Self(2); + pub const TRIANGLE_LIST: Self = Self(3); + pub const TRIANGLE_STRIP: Self = Self(4); + pub const TRIANGLE_FAN: Self = Self(5); + pub const LINE_LIST_WITH_ADJACENCY: Self = Self(6); + pub const LINE_STRIP_WITH_ADJACENCY: Self = Self(7); + pub const TRIANGLE_LIST_WITH_ADJACENCY: Self = Self(8); + pub const TRIANGLE_STRIP_WITH_ADJACENCY: Self = Self(9); + pub const PATCH_LIST: Self = Self(10); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct SharingMode(pub(crate) i32); +impl SharingMode { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl SharingMode { + pub const EXCLUSIVE: Self = Self(0); + pub const CONCURRENT: Self = Self(1); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct IndexType(pub(crate) i32); +impl IndexType { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl IndexType { + pub const UINT16: Self = Self(0); + pub const UINT32: Self = Self(1); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct Filter(pub(crate) i32); +impl Filter { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl Filter { + pub const NEAREST: Self = Self(0); + pub const LINEAR: Self = Self(1); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct SamplerMipmapMode(pub(crate) i32); +impl SamplerMipmapMode { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl SamplerMipmapMode { + #[doc = "Choose nearest mip level"] + pub const NEAREST: Self = Self(0); + #[doc = "Linear filter between mip levels"] + pub const LINEAR: Self = Self(1); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct SamplerAddressMode(pub(crate) i32); +impl SamplerAddressMode { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl SamplerAddressMode { + pub const REPEAT: Self = Self(0); + pub const MIRRORED_REPEAT: Self = Self(1); + pub const CLAMP_TO_EDGE: Self = Self(2); + pub const CLAMP_TO_BORDER: Self = Self(3); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct CompareOp(pub(crate) i32); +impl CompareOp { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl CompareOp { + pub const NEVER: Self = Self(0); + pub const LESS: Self = Self(1); + pub const EQUAL: Self = Self(2); + pub const LESS_OR_EQUAL: Self = Self(3); + pub const GREATER: Self = Self(4); + pub const NOT_EQUAL: Self = Self(5); + pub const GREATER_OR_EQUAL: Self = Self(6); + pub const ALWAYS: Self = Self(7); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct PolygonMode(pub(crate) i32); +impl PolygonMode { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl PolygonMode { + pub const FILL: Self = Self(0); + pub const LINE: Self = Self(1); + pub const POINT: Self = Self(2); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct FrontFace(pub(crate) i32); +impl FrontFace { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl FrontFace { + pub const COUNTER_CLOCKWISE: Self = Self(0); + pub const CLOCKWISE: Self = Self(1); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct BlendFactor(pub(crate) i32); +impl BlendFactor { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl BlendFactor { + pub const ZERO: Self = Self(0); + pub const ONE: Self = Self(1); + pub const SRC_COLOR: Self = Self(2); + pub const ONE_MINUS_SRC_COLOR: Self = Self(3); + pub const DST_COLOR: Self = Self(4); + pub const ONE_MINUS_DST_COLOR: Self = Self(5); + pub const SRC_ALPHA: Self = Self(6); + pub const ONE_MINUS_SRC_ALPHA: Self = Self(7); + pub const DST_ALPHA: Self = Self(8); + pub const ONE_MINUS_DST_ALPHA: Self = Self(9); + pub const CONSTANT_COLOR: Self = Self(10); + pub const ONE_MINUS_CONSTANT_COLOR: Self = Self(11); + pub const CONSTANT_ALPHA: Self = Self(12); + pub const ONE_MINUS_CONSTANT_ALPHA: Self = Self(13); + pub const SRC_ALPHA_SATURATE: Self = Self(14); + pub const SRC1_COLOR: Self = Self(15); + pub const ONE_MINUS_SRC1_COLOR: Self = Self(16); + pub const SRC1_ALPHA: Self = Self(17); + pub const ONE_MINUS_SRC1_ALPHA: Self = Self(18); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct BlendOp(pub(crate) i32); +impl BlendOp { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl BlendOp { + pub const ADD: Self = Self(0); + pub const SUBTRACT: Self = Self(1); + pub const REVERSE_SUBTRACT: Self = Self(2); + pub const MIN: Self = Self(3); + pub const MAX: Self = Self(4); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct StencilOp(pub(crate) i32); +impl StencilOp { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl StencilOp { + pub const KEEP: Self = Self(0); + pub const ZERO: Self = Self(1); + pub const REPLACE: Self = Self(2); + pub const INCREMENT_AND_CLAMP: Self = Self(3); + pub const DECREMENT_AND_CLAMP: Self = Self(4); + pub const INVERT: Self = Self(5); + pub const INCREMENT_AND_WRAP: Self = Self(6); + pub const DECREMENT_AND_WRAP: Self = Self(7); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct LogicOp(pub(crate) i32); +impl LogicOp { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl LogicOp { + pub const CLEAR: Self = Self(0); + pub const AND: Self = Self(1); + pub const AND_REVERSE: Self = Self(2); + pub const COPY: Self = Self(3); + pub const AND_INVERTED: Self = Self(4); + pub const NO_OP: Self = Self(5); + pub const XOR: Self = Self(6); + pub const OR: Self = Self(7); + pub const NOR: Self = Self(8); + pub const EQUIVALENT: Self = Self(9); + pub const INVERT: Self = Self(10); + pub const OR_REVERSE: Self = Self(11); + pub const COPY_INVERTED: Self = Self(12); + pub const OR_INVERTED: Self = Self(13); + pub const NAND: Self = Self(14); + pub const SET: Self = Self(15); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct InternalAllocationType(pub(crate) i32); +impl InternalAllocationType { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl InternalAllocationType { + pub const EXECUTABLE: Self = Self(0); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct SystemAllocationScope(pub(crate) i32); +impl SystemAllocationScope { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl SystemAllocationScope { + pub const COMMAND: Self = Self(0); + pub const OBJECT: Self = Self(1); + pub const CACHE: Self = Self(2); + pub const DEVICE: Self = Self(3); + pub const INSTANCE: Self = Self(4); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct PhysicalDeviceType(pub(crate) i32); +impl PhysicalDeviceType { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl PhysicalDeviceType { + pub const OTHER: Self = Self(0); + pub const INTEGRATED_GPU: Self = Self(1); + pub const DISCRETE_GPU: Self = Self(2); + pub const VIRTUAL_GPU: Self = Self(3); + pub const CPU: Self = Self(4); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct VertexInputRate(pub(crate) i32); +impl VertexInputRate { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl VertexInputRate { + pub const VERTEX: Self = Self(0); + pub const INSTANCE: Self = Self(1); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct Format(pub(crate) i32); +impl Format { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl Format { + pub const UNDEFINED: Self = Self(0); + pub const R4G4_UNORM_PACK8: Self = Self(1); + pub const R4G4B4A4_UNORM_PACK16: Self = Self(2); + pub const B4G4R4A4_UNORM_PACK16: Self = Self(3); + pub const R5G6B5_UNORM_PACK16: Self = Self(4); + pub const B5G6R5_UNORM_PACK16: Self = Self(5); + pub const R5G5B5A1_UNORM_PACK16: Self = Self(6); + pub const B5G5R5A1_UNORM_PACK16: Self = Self(7); + pub const A1R5G5B5_UNORM_PACK16: Self = Self(8); + pub const R8_UNORM: Self = Self(9); + pub const R8_SNORM: Self = Self(10); + pub const R8_USCALED: Self = Self(11); + pub const R8_SSCALED: Self = Self(12); + pub const R8_UINT: Self = Self(13); + pub const R8_SINT: Self = Self(14); + pub const R8_SRGB: Self = Self(15); + pub const R8G8_UNORM: Self = Self(16); + pub const R8G8_SNORM: Self = Self(17); + pub const R8G8_USCALED: Self = Self(18); + pub const R8G8_SSCALED: Self = Self(19); + pub const R8G8_UINT: Self = Self(20); + pub const R8G8_SINT: Self = Self(21); + pub const R8G8_SRGB: Self = Self(22); + pub const R8G8B8_UNORM: Self = Self(23); + pub const R8G8B8_SNORM: Self = Self(24); + pub const R8G8B8_USCALED: Self = Self(25); + pub const R8G8B8_SSCALED: Self = Self(26); + pub const R8G8B8_UINT: Self = Self(27); + pub const R8G8B8_SINT: Self = Self(28); + pub const R8G8B8_SRGB: Self = Self(29); + pub const B8G8R8_UNORM: Self = Self(30); + pub const B8G8R8_SNORM: Self = Self(31); + pub const B8G8R8_USCALED: Self = Self(32); + pub const B8G8R8_SSCALED: Self = Self(33); + pub const B8G8R8_UINT: Self = Self(34); + pub const B8G8R8_SINT: Self = Self(35); + pub const B8G8R8_SRGB: Self = Self(36); + pub const R8G8B8A8_UNORM: Self = Self(37); + pub const R8G8B8A8_SNORM: Self = Self(38); + pub const R8G8B8A8_USCALED: Self = Self(39); + pub const R8G8B8A8_SSCALED: Self = Self(40); + pub const R8G8B8A8_UINT: Self = Self(41); + pub const R8G8B8A8_SINT: Self = Self(42); + pub const R8G8B8A8_SRGB: Self = Self(43); + pub const B8G8R8A8_UNORM: Self = Self(44); + pub const B8G8R8A8_SNORM: Self = Self(45); + pub const B8G8R8A8_USCALED: Self = Self(46); + pub const B8G8R8A8_SSCALED: Self = Self(47); + pub const B8G8R8A8_UINT: Self = Self(48); + pub const B8G8R8A8_SINT: Self = Self(49); + pub const B8G8R8A8_SRGB: Self = Self(50); + pub const A8B8G8R8_UNORM_PACK32: Self = Self(51); + pub const A8B8G8R8_SNORM_PACK32: Self = Self(52); + pub const A8B8G8R8_USCALED_PACK32: Self = Self(53); + pub const A8B8G8R8_SSCALED_PACK32: Self = Self(54); + pub const A8B8G8R8_UINT_PACK32: Self = Self(55); + pub const A8B8G8R8_SINT_PACK32: Self = Self(56); + pub const A8B8G8R8_SRGB_PACK32: Self = Self(57); + pub const A2R10G10B10_UNORM_PACK32: Self = Self(58); + pub const A2R10G10B10_SNORM_PACK32: Self = Self(59); + pub const A2R10G10B10_USCALED_PACK32: Self = Self(60); + pub const A2R10G10B10_SSCALED_PACK32: Self = Self(61); + pub const A2R10G10B10_UINT_PACK32: Self = Self(62); + pub const A2R10G10B10_SINT_PACK32: Self = Self(63); + pub const A2B10G10R10_UNORM_PACK32: Self = Self(64); + pub const A2B10G10R10_SNORM_PACK32: Self = Self(65); + pub const A2B10G10R10_USCALED_PACK32: Self = Self(66); + pub const A2B10G10R10_SSCALED_PACK32: Self = Self(67); + pub const A2B10G10R10_UINT_PACK32: Self = Self(68); + pub const A2B10G10R10_SINT_PACK32: Self = Self(69); + pub const R16_UNORM: Self = Self(70); + pub const R16_SNORM: Self = Self(71); + pub const R16_USCALED: Self = Self(72); + pub const R16_SSCALED: Self = Self(73); + pub const R16_UINT: Self = Self(74); + pub const R16_SINT: Self = Self(75); + pub const R16_SFLOAT: Self = Self(76); + pub const R16G16_UNORM: Self = Self(77); + pub const R16G16_SNORM: Self = Self(78); + pub const R16G16_USCALED: Self = Self(79); + pub const R16G16_SSCALED: Self = Self(80); + pub const R16G16_UINT: Self = Self(81); + pub const R16G16_SINT: Self = Self(82); + pub const R16G16_SFLOAT: Self = Self(83); + pub const R16G16B16_UNORM: Self = Self(84); + pub const R16G16B16_SNORM: Self = Self(85); + pub const R16G16B16_USCALED: Self = Self(86); + pub const R16G16B16_SSCALED: Self = Self(87); + pub const R16G16B16_UINT: Self = Self(88); + pub const R16G16B16_SINT: Self = Self(89); + pub const R16G16B16_SFLOAT: Self = Self(90); + pub const R16G16B16A16_UNORM: Self = Self(91); + pub const R16G16B16A16_SNORM: Self = Self(92); + pub const R16G16B16A16_USCALED: Self = Self(93); + pub const R16G16B16A16_SSCALED: Self = Self(94); + pub const R16G16B16A16_UINT: Self = Self(95); + pub const R16G16B16A16_SINT: Self = Self(96); + pub const R16G16B16A16_SFLOAT: Self = Self(97); + pub const R32_UINT: Self = Self(98); + pub const R32_SINT: Self = Self(99); + pub const R32_SFLOAT: Self = Self(100); + pub const R32G32_UINT: Self = Self(101); + pub const R32G32_SINT: Self = Self(102); + pub const R32G32_SFLOAT: Self = Self(103); + pub const R32G32B32_UINT: Self = Self(104); + pub const R32G32B32_SINT: Self = Self(105); + pub const R32G32B32_SFLOAT: Self = Self(106); + pub const R32G32B32A32_UINT: Self = Self(107); + pub const R32G32B32A32_SINT: Self = Self(108); + pub const R32G32B32A32_SFLOAT: Self = Self(109); + pub const R64_UINT: Self = Self(110); + pub const R64_SINT: Self = Self(111); + pub const R64_SFLOAT: Self = Self(112); + pub const R64G64_UINT: Self = Self(113); + pub const R64G64_SINT: Self = Self(114); + pub const R64G64_SFLOAT: Self = Self(115); + pub const R64G64B64_UINT: Self = Self(116); + pub const R64G64B64_SINT: Self = Self(117); + pub const R64G64B64_SFLOAT: Self = Self(118); + pub const R64G64B64A64_UINT: Self = Self(119); + pub const R64G64B64A64_SINT: Self = Self(120); + pub const R64G64B64A64_SFLOAT: Self = Self(121); + pub const B10G11R11_UFLOAT_PACK32: Self = Self(122); + pub const E5B9G9R9_UFLOAT_PACK32: Self = Self(123); + pub const D16_UNORM: Self = Self(124); + pub const X8_D24_UNORM_PACK32: Self = Self(125); + pub const D32_SFLOAT: Self = Self(126); + pub const S8_UINT: Self = Self(127); + pub const D16_UNORM_S8_UINT: Self = Self(128); + pub const D24_UNORM_S8_UINT: Self = Self(129); + pub const D32_SFLOAT_S8_UINT: Self = Self(130); + pub const BC1_RGB_UNORM_BLOCK: Self = Self(131); + pub const BC1_RGB_SRGB_BLOCK: Self = Self(132); + pub const BC1_RGBA_UNORM_BLOCK: Self = Self(133); + pub const BC1_RGBA_SRGB_BLOCK: Self = Self(134); + pub const BC2_UNORM_BLOCK: Self = Self(135); + pub const BC2_SRGB_BLOCK: Self = Self(136); + pub const BC3_UNORM_BLOCK: Self = Self(137); + pub const BC3_SRGB_BLOCK: Self = Self(138); + pub const BC4_UNORM_BLOCK: Self = Self(139); + pub const BC4_SNORM_BLOCK: Self = Self(140); + pub const BC5_UNORM_BLOCK: Self = Self(141); + pub const BC5_SNORM_BLOCK: Self = Self(142); + pub const BC6H_UFLOAT_BLOCK: Self = Self(143); + pub const BC6H_SFLOAT_BLOCK: Self = Self(144); + pub const BC7_UNORM_BLOCK: Self = Self(145); + pub const BC7_SRGB_BLOCK: Self = Self(146); + pub const ETC2_R8G8B8_UNORM_BLOCK: Self = Self(147); + pub const ETC2_R8G8B8_SRGB_BLOCK: Self = Self(148); + pub const ETC2_R8G8B8A1_UNORM_BLOCK: Self = Self(149); + pub const ETC2_R8G8B8A1_SRGB_BLOCK: Self = Self(150); + pub const ETC2_R8G8B8A8_UNORM_BLOCK: Self = Self(151); + pub const ETC2_R8G8B8A8_SRGB_BLOCK: Self = Self(152); + pub const EAC_R11_UNORM_BLOCK: Self = Self(153); + pub const EAC_R11_SNORM_BLOCK: Self = Self(154); + pub const EAC_R11G11_UNORM_BLOCK: Self = Self(155); + pub const EAC_R11G11_SNORM_BLOCK: Self = Self(156); + pub const ASTC_4X4_UNORM_BLOCK: Self = Self(157); + pub const ASTC_4X4_SRGB_BLOCK: Self = Self(158); + pub const ASTC_5X4_UNORM_BLOCK: Self = Self(159); + pub const ASTC_5X4_SRGB_BLOCK: Self = Self(160); + pub const ASTC_5X5_UNORM_BLOCK: Self = Self(161); + pub const ASTC_5X5_SRGB_BLOCK: Self = Self(162); + pub const ASTC_6X5_UNORM_BLOCK: Self = Self(163); + pub const ASTC_6X5_SRGB_BLOCK: Self = Self(164); + pub const ASTC_6X6_UNORM_BLOCK: Self = Self(165); + pub const ASTC_6X6_SRGB_BLOCK: Self = Self(166); + pub const ASTC_8X5_UNORM_BLOCK: Self = Self(167); + pub const ASTC_8X5_SRGB_BLOCK: Self = Self(168); + pub const ASTC_8X6_UNORM_BLOCK: Self = Self(169); + pub const ASTC_8X6_SRGB_BLOCK: Self = Self(170); + pub const ASTC_8X8_UNORM_BLOCK: Self = Self(171); + pub const ASTC_8X8_SRGB_BLOCK: Self = Self(172); + pub const ASTC_10X5_UNORM_BLOCK: Self = Self(173); + pub const ASTC_10X5_SRGB_BLOCK: Self = Self(174); + pub const ASTC_10X6_UNORM_BLOCK: Self = Self(175); + pub const ASTC_10X6_SRGB_BLOCK: Self = Self(176); + pub const ASTC_10X8_UNORM_BLOCK: Self = Self(177); + pub const ASTC_10X8_SRGB_BLOCK: Self = Self(178); + pub const ASTC_10X10_UNORM_BLOCK: Self = Self(179); + pub const ASTC_10X10_SRGB_BLOCK: Self = Self(180); + pub const ASTC_12X10_UNORM_BLOCK: Self = Self(181); + pub const ASTC_12X10_SRGB_BLOCK: Self = Self(182); + pub const ASTC_12X12_UNORM_BLOCK: Self = Self(183); + pub const ASTC_12X12_SRGB_BLOCK: Self = Self(184); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct StructureType(pub(crate) i32); +impl StructureType { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl StructureType { + pub const APPLICATION_INFO: Self = Self(0); + pub const INSTANCE_CREATE_INFO: Self = Self(1); + pub const DEVICE_QUEUE_CREATE_INFO: Self = Self(2); + pub const DEVICE_CREATE_INFO: Self = Self(3); + pub const SUBMIT_INFO: Self = Self(4); + pub const MEMORY_ALLOCATE_INFO: Self = Self(5); + pub const MAPPED_MEMORY_RANGE: Self = Self(6); + pub const BIND_SPARSE_INFO: Self = Self(7); + pub const FENCE_CREATE_INFO: Self = Self(8); + pub const SEMAPHORE_CREATE_INFO: Self = Self(9); + pub const EVENT_CREATE_INFO: Self = Self(10); + pub const QUERY_POOL_CREATE_INFO: Self = Self(11); + pub const BUFFER_CREATE_INFO: Self = Self(12); + pub const BUFFER_VIEW_CREATE_INFO: Self = Self(13); + pub const IMAGE_CREATE_INFO: Self = Self(14); + pub const IMAGE_VIEW_CREATE_INFO: Self = Self(15); + pub const SHADER_MODULE_CREATE_INFO: Self = Self(16); + pub const PIPELINE_CACHE_CREATE_INFO: Self = Self(17); + pub const PIPELINE_SHADER_STAGE_CREATE_INFO: Self = Self(18); + pub const PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO: Self = Self(19); + pub const PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO: Self = Self(20); + pub const PIPELINE_TESSELLATION_STATE_CREATE_INFO: Self = Self(21); + pub const PIPELINE_VIEWPORT_STATE_CREATE_INFO: Self = Self(22); + pub const PIPELINE_RASTERIZATION_STATE_CREATE_INFO: Self = Self(23); + pub const PIPELINE_MULTISAMPLE_STATE_CREATE_INFO: Self = Self(24); + pub const PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO: Self = Self(25); + pub const PIPELINE_COLOR_BLEND_STATE_CREATE_INFO: Self = Self(26); + pub const PIPELINE_DYNAMIC_STATE_CREATE_INFO: Self = Self(27); + pub const GRAPHICS_PIPELINE_CREATE_INFO: Self = Self(28); + pub const COMPUTE_PIPELINE_CREATE_INFO: Self = Self(29); + pub const PIPELINE_LAYOUT_CREATE_INFO: Self = Self(30); + pub const SAMPLER_CREATE_INFO: Self = Self(31); + pub const DESCRIPTOR_SET_LAYOUT_CREATE_INFO: Self = Self(32); + pub const DESCRIPTOR_POOL_CREATE_INFO: Self = Self(33); + pub const DESCRIPTOR_SET_ALLOCATE_INFO: Self = Self(34); + pub const WRITE_DESCRIPTOR_SET: Self = Self(35); + pub const COPY_DESCRIPTOR_SET: Self = Self(36); + pub const FRAMEBUFFER_CREATE_INFO: Self = Self(37); + pub const RENDER_PASS_CREATE_INFO: Self = Self(38); + pub const COMMAND_POOL_CREATE_INFO: Self = Self(39); + pub const COMMAND_BUFFER_ALLOCATE_INFO: Self = Self(40); + pub const COMMAND_BUFFER_INHERITANCE_INFO: Self = Self(41); + pub const COMMAND_BUFFER_BEGIN_INFO: Self = Self(42); + pub const RENDER_PASS_BEGIN_INFO: Self = Self(43); + pub const BUFFER_MEMORY_BARRIER: Self = Self(44); + pub const IMAGE_MEMORY_BARRIER: Self = Self(45); + pub const MEMORY_BARRIER: Self = Self(46); + #[doc = "Reserved for internal use by the loader, layers, and ICDs"] + pub const LOADER_INSTANCE_CREATE_INFO: Self = Self(47); + #[doc = "Reserved for internal use by the loader, layers, and ICDs"] + pub const LOADER_DEVICE_CREATE_INFO: Self = Self(48); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct SubpassContents(pub(crate) i32); +impl SubpassContents { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl SubpassContents { + pub const INLINE: Self = Self(0); + pub const SECONDARY_COMMAND_BUFFERS: Self = Self(1); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +#[must_use] +pub struct Result(pub(crate) i32); +impl Result { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl Result { + #[doc = "Command completed successfully"] + pub const SUCCESS: Self = Self(0); + #[doc = "A fence or query has not yet completed"] + pub const NOT_READY: Self = Self(1); + #[doc = "A wait operation has not completed in the specified time"] + pub const TIMEOUT: Self = Self(2); + #[doc = "An event is signaled"] + pub const EVENT_SET: Self = Self(3); + #[doc = "An event is unsignaled"] + pub const EVENT_RESET: Self = Self(4); + #[doc = "A return array was too small for the result"] + pub const INCOMPLETE: Self = Self(5); + #[doc = "A host memory allocation has failed"] + pub const ERROR_OUT_OF_HOST_MEMORY: Self = Self(-1); + #[doc = "A device memory allocation has failed"] + pub const ERROR_OUT_OF_DEVICE_MEMORY: Self = Self(-2); + #[doc = "Initialization of an object has failed"] + pub const ERROR_INITIALIZATION_FAILED: Self = Self(-3); + #[doc = "The logical device has been lost. See "] + pub const ERROR_DEVICE_LOST: Self = Self(-4); + #[doc = "Mapping of a memory object has failed"] + pub const ERROR_MEMORY_MAP_FAILED: Self = Self(-5); + #[doc = "Layer specified does not exist"] + pub const ERROR_LAYER_NOT_PRESENT: Self = Self(-6); + #[doc = "Extension specified does not exist"] + pub const ERROR_EXTENSION_NOT_PRESENT: Self = Self(-7); + #[doc = "Requested feature is not available on this device"] + pub const ERROR_FEATURE_NOT_PRESENT: Self = Self(-8); + #[doc = "Unable to find a Vulkan driver"] + pub const ERROR_INCOMPATIBLE_DRIVER: Self = Self(-9); + #[doc = "Too many objects of the type have already been created"] + pub const ERROR_TOO_MANY_OBJECTS: Self = Self(-10); + #[doc = "Requested format is not supported on this device"] + pub const ERROR_FORMAT_NOT_SUPPORTED: Self = Self(-11); + #[doc = "A requested pool allocation has failed due to fragmentation of the pool's memory"] + pub const ERROR_FRAGMENTED_POOL: Self = Self(-12); + #[doc = "An unknown error has occurred, due to an implementation or application bug"] + pub const ERROR_UNKNOWN: Self = Self(-13); +} +impl ::std::error::Error for Result {} +impl fmt::Display for Result { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + let name = match * self { Self :: SUCCESS => Some ("Command completed successfully") , Self :: NOT_READY => Some ("A fence or query has not yet completed") , Self :: TIMEOUT => Some ("A wait operation has not completed in the specified time") , Self :: EVENT_SET => Some ("An event is signaled") , Self :: EVENT_RESET => Some ("An event is unsignaled") , Self :: INCOMPLETE => Some ("A return array was too small for the result") , Self :: ERROR_OUT_OF_HOST_MEMORY => Some ("A host memory allocation has failed") , Self :: ERROR_OUT_OF_DEVICE_MEMORY => Some ("A device memory allocation has failed") , Self :: ERROR_INITIALIZATION_FAILED => Some ("Initialization of an object has failed") , Self :: ERROR_DEVICE_LOST => Some ("The logical device has been lost. See ") , Self :: ERROR_MEMORY_MAP_FAILED => Some ("Mapping of a memory object has failed") , Self :: ERROR_LAYER_NOT_PRESENT => Some ("Layer specified does not exist") , Self :: ERROR_EXTENSION_NOT_PRESENT => Some ("Extension specified does not exist") , Self :: ERROR_FEATURE_NOT_PRESENT => Some ("Requested feature is not available on this device") , Self :: ERROR_INCOMPATIBLE_DRIVER => Some ("Unable to find a Vulkan driver") , Self :: ERROR_TOO_MANY_OBJECTS => Some ("Too many objects of the type have already been created") , Self :: ERROR_FORMAT_NOT_SUPPORTED => Some ("Requested format is not supported on this device") , Self :: ERROR_FRAGMENTED_POOL => Some ("A requested pool allocation has failed due to fragmentation of the pool's memory") , Self :: ERROR_UNKNOWN => Some ("An unknown error has occurred, due to an implementation or application bug") , _ => None , } ; + if let Some(x) = name { + fmt.write_str(x) + } else { + ::fmt(self, fmt) + } + } +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct DynamicState(pub(crate) i32); +impl DynamicState { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl DynamicState { + pub const VIEWPORT: Self = Self(0); + pub const SCISSOR: Self = Self(1); + pub const LINE_WIDTH: Self = Self(2); + pub const DEPTH_BIAS: Self = Self(3); + pub const BLEND_CONSTANTS: Self = Self(4); + pub const DEPTH_BOUNDS: Self = Self(5); + pub const STENCIL_COMPARE_MASK: Self = Self(6); + pub const STENCIL_WRITE_MASK: Self = Self(7); + pub const STENCIL_REFERENCE: Self = Self(8); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct DescriptorUpdateTemplateType(pub(crate) i32); +impl DescriptorUpdateTemplateType { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl DescriptorUpdateTemplateType { + #[doc = "Create descriptor update template for descriptor set updates"] + pub const DESCRIPTOR_SET: Self = Self(0); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct ObjectType(pub(crate) i32); +impl ObjectType { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl ObjectType { + pub const UNKNOWN: Self = Self(0); + pub const INSTANCE: Self = Self(1); + pub const PHYSICAL_DEVICE: Self = Self(2); + pub const DEVICE: Self = Self(3); + pub const QUEUE: Self = Self(4); + pub const SEMAPHORE: Self = Self(5); + pub const COMMAND_BUFFER: Self = Self(6); + pub const FENCE: Self = Self(7); + pub const DEVICE_MEMORY: Self = Self(8); + pub const BUFFER: Self = Self(9); + pub const IMAGE: Self = Self(10); + pub const EVENT: Self = Self(11); + pub const QUERY_POOL: Self = Self(12); + pub const BUFFER_VIEW: Self = Self(13); + pub const IMAGE_VIEW: Self = Self(14); + pub const SHADER_MODULE: Self = Self(15); + pub const PIPELINE_CACHE: Self = Self(16); + pub const PIPELINE_LAYOUT: Self = Self(17); + pub const RENDER_PASS: Self = Self(18); + pub const PIPELINE: Self = Self(19); + pub const DESCRIPTOR_SET_LAYOUT: Self = Self(20); + pub const SAMPLER: Self = Self(21); + pub const DESCRIPTOR_POOL: Self = Self(22); + pub const DESCRIPTOR_SET: Self = Self(23); + pub const FRAMEBUFFER: Self = Self(24); + pub const COMMAND_POOL: Self = Self(25); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct RayTracingInvocationReorderModeNV(pub(crate) i32); +impl RayTracingInvocationReorderModeNV { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl RayTracingInvocationReorderModeNV { + pub const NONE: Self = Self(0); + pub const REORDER: Self = Self(1); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct DirectDriverLoadingModeLUNARG(pub(crate) i32); +impl DirectDriverLoadingModeLUNARG { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl DirectDriverLoadingModeLUNARG { + pub const EXCLUSIVE: Self = Self(0); + pub const INCLUSIVE: Self = Self(1); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct SemaphoreType(pub(crate) i32); +impl SemaphoreType { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl SemaphoreType { + pub const BINARY: Self = Self(0); + pub const TIMELINE: Self = Self(1); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct PresentModeKHR(pub(crate) i32); +impl PresentModeKHR { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl PresentModeKHR { + pub const IMMEDIATE: Self = Self(0); + pub const MAILBOX: Self = Self(1); + pub const FIFO: Self = Self(2); + pub const FIFO_RELAXED: Self = Self(3); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct ColorSpaceKHR(pub(crate) i32); +impl ColorSpaceKHR { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl ColorSpaceKHR { + pub const SRGB_NONLINEAR: Self = Self(0); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct TimeDomainEXT(pub(crate) i32); +impl TimeDomainEXT { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl TimeDomainEXT { + pub const DEVICE: Self = Self(0); + pub const CLOCK_MONOTONIC: Self = Self(1); + pub const CLOCK_MONOTONIC_RAW: Self = Self(2); + pub const QUERY_PERFORMANCE_COUNTER: Self = Self(3); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct DebugReportObjectTypeEXT(pub(crate) i32); +impl DebugReportObjectTypeEXT { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl DebugReportObjectTypeEXT { + pub const UNKNOWN: Self = Self(0); + pub const INSTANCE: Self = Self(1); + pub const PHYSICAL_DEVICE: Self = Self(2); + pub const DEVICE: Self = Self(3); + pub const QUEUE: Self = Self(4); + pub const SEMAPHORE: Self = Self(5); + pub const COMMAND_BUFFER: Self = Self(6); + pub const FENCE: Self = Self(7); + pub const DEVICE_MEMORY: Self = Self(8); + pub const BUFFER: Self = Self(9); + pub const IMAGE: Self = Self(10); + pub const EVENT: Self = Self(11); + pub const QUERY_POOL: Self = Self(12); + pub const BUFFER_VIEW: Self = Self(13); + pub const IMAGE_VIEW: Self = Self(14); + pub const SHADER_MODULE: Self = Self(15); + pub const PIPELINE_CACHE: Self = Self(16); + pub const PIPELINE_LAYOUT: Self = Self(17); + pub const RENDER_PASS: Self = Self(18); + pub const PIPELINE: Self = Self(19); + pub const DESCRIPTOR_SET_LAYOUT: Self = Self(20); + pub const SAMPLER: Self = Self(21); + pub const DESCRIPTOR_POOL: Self = Self(22); + pub const DESCRIPTOR_SET: Self = Self(23); + pub const FRAMEBUFFER: Self = Self(24); + pub const COMMAND_POOL: Self = Self(25); + pub const SURFACE_KHR: Self = Self(26); + pub const SWAPCHAIN_KHR: Self = Self(27); + pub const DEBUG_REPORT_CALLBACK_EXT: Self = Self(28); + pub const DISPLAY_KHR: Self = Self(29); + pub const DISPLAY_MODE_KHR: Self = Self(30); + pub const VALIDATION_CACHE_EXT: Self = Self(33); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct DeviceMemoryReportEventTypeEXT(pub(crate) i32); +impl DeviceMemoryReportEventTypeEXT { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl DeviceMemoryReportEventTypeEXT { + pub const ALLOCATE: Self = Self(0); + pub const FREE: Self = Self(1); + pub const IMPORT: Self = Self(2); + pub const UNIMPORT: Self = Self(3); + pub const ALLOCATION_FAILED: Self = Self(4); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct RasterizationOrderAMD(pub(crate) i32); +impl RasterizationOrderAMD { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl RasterizationOrderAMD { + pub const STRICT: Self = Self(0); + pub const RELAXED: Self = Self(1); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct ValidationCheckEXT(pub(crate) i32); +impl ValidationCheckEXT { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl ValidationCheckEXT { + pub const ALL: Self = Self(0); + pub const SHADERS: Self = Self(1); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct ValidationFeatureEnableEXT(pub(crate) i32); +impl ValidationFeatureEnableEXT { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl ValidationFeatureEnableEXT { + pub const GPU_ASSISTED: Self = Self(0); + pub const GPU_ASSISTED_RESERVE_BINDING_SLOT: Self = Self(1); + pub const BEST_PRACTICES: Self = Self(2); + pub const DEBUG_PRINTF: Self = Self(3); + pub const SYNCHRONIZATION_VALIDATION: Self = Self(4); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct ValidationFeatureDisableEXT(pub(crate) i32); +impl ValidationFeatureDisableEXT { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl ValidationFeatureDisableEXT { + pub const ALL: Self = Self(0); + pub const SHADERS: Self = Self(1); + pub const THREAD_SAFETY: Self = Self(2); + pub const API_PARAMETERS: Self = Self(3); + pub const OBJECT_LIFETIMES: Self = Self(4); + pub const CORE_CHECKS: Self = Self(5); + pub const UNIQUE_HANDLES: Self = Self(6); + pub const SHADER_VALIDATION_CACHE: Self = Self(7); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct IndirectCommandsTokenTypeNV(pub(crate) i32); +impl IndirectCommandsTokenTypeNV { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl IndirectCommandsTokenTypeNV { + pub const SHADER_GROUP: Self = Self(0); + pub const STATE_FLAGS: Self = Self(1); + pub const INDEX_BUFFER: Self = Self(2); + pub const VERTEX_BUFFER: Self = Self(3); + pub const PUSH_CONSTANT: Self = Self(4); + pub const DRAW_INDEXED: Self = Self(5); + pub const DRAW: Self = Self(6); + pub const DRAW_TASKS: Self = Self(7); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct DisplayPowerStateEXT(pub(crate) i32); +impl DisplayPowerStateEXT { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl DisplayPowerStateEXT { + pub const OFF: Self = Self(0); + pub const SUSPEND: Self = Self(1); + pub const ON: Self = Self(2); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct DeviceEventTypeEXT(pub(crate) i32); +impl DeviceEventTypeEXT { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl DeviceEventTypeEXT { + pub const DISPLAY_HOTPLUG: Self = Self(0); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct DisplayEventTypeEXT(pub(crate) i32); +impl DisplayEventTypeEXT { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl DisplayEventTypeEXT { + pub const FIRST_PIXEL_OUT: Self = Self(0); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct ViewportCoordinateSwizzleNV(pub(crate) i32); +impl ViewportCoordinateSwizzleNV { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl ViewportCoordinateSwizzleNV { + pub const POSITIVE_X: Self = Self(0); + pub const NEGATIVE_X: Self = Self(1); + pub const POSITIVE_Y: Self = Self(2); + pub const NEGATIVE_Y: Self = Self(3); + pub const POSITIVE_Z: Self = Self(4); + pub const NEGATIVE_Z: Self = Self(5); + pub const POSITIVE_W: Self = Self(6); + pub const NEGATIVE_W: Self = Self(7); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct DiscardRectangleModeEXT(pub(crate) i32); +impl DiscardRectangleModeEXT { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl DiscardRectangleModeEXT { + pub const INCLUSIVE: Self = Self(0); + pub const EXCLUSIVE: Self = Self(1); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct PointClippingBehavior(pub(crate) i32); +impl PointClippingBehavior { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl PointClippingBehavior { + pub const ALL_CLIP_PLANES: Self = Self(0); + pub const USER_CLIP_PLANES_ONLY: Self = Self(1); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct SamplerReductionMode(pub(crate) i32); +impl SamplerReductionMode { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl SamplerReductionMode { + pub const WEIGHTED_AVERAGE: Self = Self(0); + pub const MIN: Self = Self(1); + pub const MAX: Self = Self(2); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct TessellationDomainOrigin(pub(crate) i32); +impl TessellationDomainOrigin { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl TessellationDomainOrigin { + pub const UPPER_LEFT: Self = Self(0); + pub const LOWER_LEFT: Self = Self(1); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct SamplerYcbcrModelConversion(pub(crate) i32); +impl SamplerYcbcrModelConversion { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl SamplerYcbcrModelConversion { + pub const RGB_IDENTITY: Self = Self(0); + #[doc = "just range expansion"] + pub const YCBCR_IDENTITY: Self = Self(1); + #[doc = "aka HD YUV"] + pub const YCBCR_709: Self = Self(2); + #[doc = "aka SD YUV"] + pub const YCBCR_601: Self = Self(3); + #[doc = "aka UHD YUV"] + pub const YCBCR_2020: Self = Self(4); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct SamplerYcbcrRange(pub(crate) i32); +impl SamplerYcbcrRange { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl SamplerYcbcrRange { + #[doc = "Luma 0..1 maps to 0..255, chroma -0.5..0.5 to 1..255 (clamped)"] + pub const ITU_FULL: Self = Self(0); + #[doc = "Luma 0..1 maps to 16..235, chroma -0.5..0.5 to 16..240"] + pub const ITU_NARROW: Self = Self(1); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct ChromaLocation(pub(crate) i32); +impl ChromaLocation { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl ChromaLocation { + pub const COSITED_EVEN: Self = Self(0); + pub const MIDPOINT: Self = Self(1); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct BlendOverlapEXT(pub(crate) i32); +impl BlendOverlapEXT { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl BlendOverlapEXT { + pub const UNCORRELATED: Self = Self(0); + pub const DISJOINT: Self = Self(1); + pub const CONJOINT: Self = Self(2); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct CoverageModulationModeNV(pub(crate) i32); +impl CoverageModulationModeNV { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl CoverageModulationModeNV { + pub const NONE: Self = Self(0); + pub const RGB: Self = Self(1); + pub const ALPHA: Self = Self(2); + pub const RGBA: Self = Self(3); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct CoverageReductionModeNV(pub(crate) i32); +impl CoverageReductionModeNV { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl CoverageReductionModeNV { + pub const MERGE: Self = Self(0); + pub const TRUNCATE: Self = Self(1); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct ValidationCacheHeaderVersionEXT(pub(crate) i32); +impl ValidationCacheHeaderVersionEXT { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl ValidationCacheHeaderVersionEXT { + pub const ONE: Self = Self(1); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct ShaderInfoTypeAMD(pub(crate) i32); +impl ShaderInfoTypeAMD { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl ShaderInfoTypeAMD { + pub const STATISTICS: Self = Self(0); + pub const BINARY: Self = Self(1); + pub const DISASSEMBLY: Self = Self(2); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct QueueGlobalPriorityKHR(pub(crate) i32); +impl QueueGlobalPriorityKHR { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl QueueGlobalPriorityKHR { + pub const LOW: Self = Self(128); + pub const MEDIUM: Self = Self(256); + pub const HIGH: Self = Self(512); + pub const REALTIME: Self = Self(1_024); + pub const LOW_EXT: Self = Self::LOW; + pub const MEDIUM_EXT: Self = Self::MEDIUM; + pub const HIGH_EXT: Self = Self::HIGH; + pub const REALTIME_EXT: Self = Self::REALTIME; +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct ConservativeRasterizationModeEXT(pub(crate) i32); +impl ConservativeRasterizationModeEXT { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl ConservativeRasterizationModeEXT { + pub const DISABLED: Self = Self(0); + pub const OVERESTIMATE: Self = Self(1); + pub const UNDERESTIMATE: Self = Self(2); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct VendorId(pub(crate) i32); +impl VendorId { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl VendorId { + #[doc = "Vivante vendor ID"] + pub const VIV: Self = Self(0x1_0001); + #[doc = "VeriSilicon vendor ID"] + pub const VSI: Self = Self(0x1_0002); + #[doc = "Kazan Software Renderer"] + pub const KAZAN: Self = Self(0x1_0003); + #[doc = "Codeplay Software Ltd. vendor ID"] + pub const CODEPLAY: Self = Self(0x1_0004); + #[doc = "Mesa vendor ID"] + pub const MESA: Self = Self(0x1_0005); + #[doc = "PoCL vendor ID"] + pub const POCL: Self = Self(0x1_0006); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct DriverId(pub(crate) i32); +impl DriverId { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl DriverId { + #[doc = "Advanced Micro Devices, Inc."] + pub const AMD_PROPRIETARY: Self = Self(1); + #[doc = "Advanced Micro Devices, Inc."] + pub const AMD_OPEN_SOURCE: Self = Self(2); + #[doc = "Mesa open source project"] + pub const MESA_RADV: Self = Self(3); + #[doc = "NVIDIA Corporation"] + pub const NVIDIA_PROPRIETARY: Self = Self(4); + #[doc = "Intel Corporation"] + pub const INTEL_PROPRIETARY_WINDOWS: Self = Self(5); + #[doc = "Intel Corporation"] + pub const INTEL_OPEN_SOURCE_MESA: Self = Self(6); + #[doc = "Imagination Technologies"] + pub const IMAGINATION_PROPRIETARY: Self = Self(7); + #[doc = "Qualcomm Technologies, Inc."] + pub const QUALCOMM_PROPRIETARY: Self = Self(8); + #[doc = "Arm Limited"] + pub const ARM_PROPRIETARY: Self = Self(9); + #[doc = "Google LLC"] + pub const GOOGLE_SWIFTSHADER: Self = Self(10); + #[doc = "Google LLC"] + pub const GGP_PROPRIETARY: Self = Self(11); + #[doc = "Broadcom Inc."] + pub const BROADCOM_PROPRIETARY: Self = Self(12); + #[doc = "Mesa"] + pub const MESA_LLVMPIPE: Self = Self(13); + #[doc = "MoltenVK"] + pub const MOLTENVK: Self = Self(14); + #[doc = "Core Avionics & Industrial Inc."] + pub const COREAVI_PROPRIETARY: Self = Self(15); + #[doc = "Juice Technologies, Inc."] + pub const JUICE_PROPRIETARY: Self = Self(16); + #[doc = "Verisilicon, Inc."] + pub const VERISILICON_PROPRIETARY: Self = Self(17); + #[doc = "Mesa open source project"] + pub const MESA_TURNIP: Self = Self(18); + #[doc = "Mesa open source project"] + pub const MESA_V3DV: Self = Self(19); + #[doc = "Mesa open source project"] + pub const MESA_PANVK: Self = Self(20); + #[doc = "Samsung Electronics Co., Ltd."] + pub const SAMSUNG_PROPRIETARY: Self = Self(21); + #[doc = "Mesa open source project"] + pub const MESA_VENUS: Self = Self(22); + #[doc = "Mesa open source project"] + pub const MESA_DOZEN: Self = Self(23); + #[doc = "Mesa open source project"] + pub const MESA_NVK: Self = Self(24); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct ShadingRatePaletteEntryNV(pub(crate) i32); +impl ShadingRatePaletteEntryNV { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl ShadingRatePaletteEntryNV { + pub const NO_INVOCATIONS: Self = Self(0); + pub const TYPE_16_INVOCATIONS_PER_PIXEL: Self = Self(1); + pub const TYPE_8_INVOCATIONS_PER_PIXEL: Self = Self(2); + pub const TYPE_4_INVOCATIONS_PER_PIXEL: Self = Self(3); + pub const TYPE_2_INVOCATIONS_PER_PIXEL: Self = Self(4); + pub const TYPE_1_INVOCATION_PER_PIXEL: Self = Self(5); + pub const TYPE_1_INVOCATION_PER_2X1_PIXELS: Self = Self(6); + pub const TYPE_1_INVOCATION_PER_1X2_PIXELS: Self = Self(7); + pub const TYPE_1_INVOCATION_PER_2X2_PIXELS: Self = Self(8); + pub const TYPE_1_INVOCATION_PER_4X2_PIXELS: Self = Self(9); + pub const TYPE_1_INVOCATION_PER_2X4_PIXELS: Self = Self(10); + pub const TYPE_1_INVOCATION_PER_4X4_PIXELS: Self = Self(11); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct CoarseSampleOrderTypeNV(pub(crate) i32); +impl CoarseSampleOrderTypeNV { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl CoarseSampleOrderTypeNV { + pub const DEFAULT: Self = Self(0); + pub const CUSTOM: Self = Self(1); + pub const PIXEL_MAJOR: Self = Self(2); + pub const SAMPLE_MAJOR: Self = Self(3); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct CopyAccelerationStructureModeKHR(pub(crate) i32); +impl CopyAccelerationStructureModeKHR { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl CopyAccelerationStructureModeKHR { + pub const CLONE: Self = Self(0); + pub const COMPACT: Self = Self(1); + pub const SERIALIZE: Self = Self(2); + pub const DESERIALIZE: Self = Self(3); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct BuildAccelerationStructureModeKHR(pub(crate) i32); +impl BuildAccelerationStructureModeKHR { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl BuildAccelerationStructureModeKHR { + pub const BUILD: Self = Self(0); + pub const UPDATE: Self = Self(1); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct AccelerationStructureTypeKHR(pub(crate) i32); +impl AccelerationStructureTypeKHR { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl AccelerationStructureTypeKHR { + pub const TOP_LEVEL: Self = Self(0); + pub const BOTTOM_LEVEL: Self = Self(1); + pub const GENERIC: Self = Self(2); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct GeometryTypeKHR(pub(crate) i32); +impl GeometryTypeKHR { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl GeometryTypeKHR { + pub const TRIANGLES: Self = Self(0); + pub const AABBS: Self = Self(1); + pub const INSTANCES: Self = Self(2); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct AccelerationStructureMemoryRequirementsTypeNV(pub(crate) i32); +impl AccelerationStructureMemoryRequirementsTypeNV { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl AccelerationStructureMemoryRequirementsTypeNV { + pub const OBJECT: Self = Self(0); + pub const BUILD_SCRATCH: Self = Self(1); + pub const UPDATE_SCRATCH: Self = Self(2); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct AccelerationStructureBuildTypeKHR(pub(crate) i32); +impl AccelerationStructureBuildTypeKHR { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl AccelerationStructureBuildTypeKHR { + pub const HOST: Self = Self(0); + pub const DEVICE: Self = Self(1); + pub const HOST_OR_DEVICE: Self = Self(2); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct RayTracingShaderGroupTypeKHR(pub(crate) i32); +impl RayTracingShaderGroupTypeKHR { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl RayTracingShaderGroupTypeKHR { + pub const GENERAL: Self = Self(0); + pub const TRIANGLES_HIT_GROUP: Self = Self(1); + pub const PROCEDURAL_HIT_GROUP: Self = Self(2); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct AccelerationStructureCompatibilityKHR(pub(crate) i32); +impl AccelerationStructureCompatibilityKHR { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl AccelerationStructureCompatibilityKHR { + pub const COMPATIBLE: Self = Self(0); + pub const INCOMPATIBLE: Self = Self(1); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct ShaderGroupShaderKHR(pub(crate) i32); +impl ShaderGroupShaderKHR { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl ShaderGroupShaderKHR { + pub const GENERAL: Self = Self(0); + pub const CLOSEST_HIT: Self = Self(1); + pub const ANY_HIT: Self = Self(2); + pub const INTERSECTION: Self = Self(3); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct MemoryOverallocationBehaviorAMD(pub(crate) i32); +impl MemoryOverallocationBehaviorAMD { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl MemoryOverallocationBehaviorAMD { + pub const DEFAULT: Self = Self(0); + pub const ALLOWED: Self = Self(1); + pub const DISALLOWED: Self = Self(2); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct ScopeNV(pub(crate) i32); +impl ScopeNV { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl ScopeNV { + pub const DEVICE: Self = Self(1); + pub const WORKGROUP: Self = Self(2); + pub const SUBGROUP: Self = Self(3); + pub const QUEUE_FAMILY: Self = Self(5); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct ComponentTypeNV(pub(crate) i32); +impl ComponentTypeNV { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl ComponentTypeNV { + pub const FLOAT16: Self = Self(0); + pub const FLOAT32: Self = Self(1); + pub const FLOAT64: Self = Self(2); + pub const SINT8: Self = Self(3); + pub const SINT16: Self = Self(4); + pub const SINT32: Self = Self(5); + pub const SINT64: Self = Self(6); + pub const UINT8: Self = Self(7); + pub const UINT16: Self = Self(8); + pub const UINT32: Self = Self(9); + pub const UINT64: Self = Self(10); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct FullScreenExclusiveEXT(pub(crate) i32); +impl FullScreenExclusiveEXT { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl FullScreenExclusiveEXT { + pub const DEFAULT: Self = Self(0); + pub const ALLOWED: Self = Self(1); + pub const DISALLOWED: Self = Self(2); + pub const APPLICATION_CONTROLLED: Self = Self(3); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct PerformanceCounterScopeKHR(pub(crate) i32); +impl PerformanceCounterScopeKHR { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl PerformanceCounterScopeKHR { + pub const COMMAND_BUFFER: Self = Self(0); + pub const RENDER_PASS: Self = Self(1); + pub const COMMAND: Self = Self(2); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct PerformanceCounterUnitKHR(pub(crate) i32); +impl PerformanceCounterUnitKHR { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl PerformanceCounterUnitKHR { + pub const GENERIC: Self = Self(0); + pub const PERCENTAGE: Self = Self(1); + pub const NANOSECONDS: Self = Self(2); + pub const BYTES: Self = Self(3); + pub const BYTES_PER_SECOND: Self = Self(4); + pub const KELVIN: Self = Self(5); + pub const WATTS: Self = Self(6); + pub const VOLTS: Self = Self(7); + pub const AMPS: Self = Self(8); + pub const HERTZ: Self = Self(9); + pub const CYCLES: Self = Self(10); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct PerformanceCounterStorageKHR(pub(crate) i32); +impl PerformanceCounterStorageKHR { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl PerformanceCounterStorageKHR { + pub const INT32: Self = Self(0); + pub const INT64: Self = Self(1); + pub const UINT32: Self = Self(2); + pub const UINT64: Self = Self(3); + pub const FLOAT32: Self = Self(4); + pub const FLOAT64: Self = Self(5); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct PerformanceConfigurationTypeINTEL(pub(crate) i32); +impl PerformanceConfigurationTypeINTEL { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl PerformanceConfigurationTypeINTEL { + pub const COMMAND_QUEUE_METRICS_DISCOVERY_ACTIVATED: Self = Self(0); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct QueryPoolSamplingModeINTEL(pub(crate) i32); +impl QueryPoolSamplingModeINTEL { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl QueryPoolSamplingModeINTEL { + pub const MANUAL: Self = Self(0); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct PerformanceOverrideTypeINTEL(pub(crate) i32); +impl PerformanceOverrideTypeINTEL { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl PerformanceOverrideTypeINTEL { + pub const NULL_HARDWARE: Self = Self(0); + pub const FLUSH_GPU_CACHES: Self = Self(1); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct PerformanceParameterTypeINTEL(pub(crate) i32); +impl PerformanceParameterTypeINTEL { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl PerformanceParameterTypeINTEL { + pub const HW_COUNTERS_SUPPORTED: Self = Self(0); + pub const STREAM_MARKER_VALIDS: Self = Self(1); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct PerformanceValueTypeINTEL(pub(crate) i32); +impl PerformanceValueTypeINTEL { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl PerformanceValueTypeINTEL { + pub const UINT32: Self = Self(0); + pub const UINT64: Self = Self(1); + pub const FLOAT: Self = Self(2); + pub const BOOL: Self = Self(3); + pub const STRING: Self = Self(4); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct ShaderFloatControlsIndependence(pub(crate) i32); +impl ShaderFloatControlsIndependence { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl ShaderFloatControlsIndependence { + pub const TYPE_32_ONLY: Self = Self(0); + pub const ALL: Self = Self(1); + pub const NONE: Self = Self(2); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct PipelineExecutableStatisticFormatKHR(pub(crate) i32); +impl PipelineExecutableStatisticFormatKHR { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl PipelineExecutableStatisticFormatKHR { + pub const BOOL32: Self = Self(0); + pub const INT64: Self = Self(1); + pub const UINT64: Self = Self(2); + pub const FLOAT64: Self = Self(3); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct LineRasterizationModeEXT(pub(crate) i32); +impl LineRasterizationModeEXT { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl LineRasterizationModeEXT { + pub const DEFAULT: Self = Self(0); + pub const RECTANGULAR: Self = Self(1); + pub const BRESENHAM: Self = Self(2); + pub const RECTANGULAR_SMOOTH: Self = Self(3); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct FragmentShadingRateCombinerOpKHR(pub(crate) i32); +impl FragmentShadingRateCombinerOpKHR { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl FragmentShadingRateCombinerOpKHR { + pub const KEEP: Self = Self(0); + pub const REPLACE: Self = Self(1); + pub const MIN: Self = Self(2); + pub const MAX: Self = Self(3); + pub const MUL: Self = Self(4); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct FragmentShadingRateNV(pub(crate) i32); +impl FragmentShadingRateNV { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl FragmentShadingRateNV { + pub const TYPE_1_INVOCATION_PER_PIXEL: Self = Self(0); + pub const TYPE_1_INVOCATION_PER_1X2_PIXELS: Self = Self(1); + pub const TYPE_1_INVOCATION_PER_2X1_PIXELS: Self = Self(4); + pub const TYPE_1_INVOCATION_PER_2X2_PIXELS: Self = Self(5); + pub const TYPE_1_INVOCATION_PER_2X4_PIXELS: Self = Self(6); + pub const TYPE_1_INVOCATION_PER_4X2_PIXELS: Self = Self(9); + pub const TYPE_1_INVOCATION_PER_4X4_PIXELS: Self = Self(10); + pub const TYPE_2_INVOCATIONS_PER_PIXEL: Self = Self(11); + pub const TYPE_4_INVOCATIONS_PER_PIXEL: Self = Self(12); + pub const TYPE_8_INVOCATIONS_PER_PIXEL: Self = Self(13); + pub const TYPE_16_INVOCATIONS_PER_PIXEL: Self = Self(14); + pub const NO_INVOCATIONS: Self = Self(15); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct FragmentShadingRateTypeNV(pub(crate) i32); +impl FragmentShadingRateTypeNV { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl FragmentShadingRateTypeNV { + pub const FRAGMENT_SIZE: Self = Self(0); + pub const ENUMS: Self = Self(1); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct SubpassMergeStatusEXT(pub(crate) i32); +impl SubpassMergeStatusEXT { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl SubpassMergeStatusEXT { + pub const MERGED: Self = Self(0); + pub const DISALLOWED: Self = Self(1); + pub const NOT_MERGED_SIDE_EFFECTS: Self = Self(2); + pub const NOT_MERGED_SAMPLES_MISMATCH: Self = Self(3); + pub const NOT_MERGED_VIEWS_MISMATCH: Self = Self(4); + pub const NOT_MERGED_ALIASING: Self = Self(5); + pub const NOT_MERGED_DEPENDENCIES: Self = Self(6); + pub const NOT_MERGED_INCOMPATIBLE_INPUT_ATTACHMENT: Self = Self(7); + pub const NOT_MERGED_TOO_MANY_ATTACHMENTS: Self = Self(8); + pub const NOT_MERGED_INSUFFICIENT_STORAGE: Self = Self(9); + pub const NOT_MERGED_DEPTH_STENCIL_COUNT: Self = Self(10); + pub const NOT_MERGED_RESOLVE_ATTACHMENT_REUSE: Self = Self(11); + pub const NOT_MERGED_SINGLE_SUBPASS: Self = Self(12); + pub const NOT_MERGED_UNSPECIFIED: Self = Self(13); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct ProvokingVertexModeEXT(pub(crate) i32); +impl ProvokingVertexModeEXT { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl ProvokingVertexModeEXT { + pub const FIRST_VERTEX: Self = Self(0); + pub const LAST_VERTEX: Self = Self(1); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct AccelerationStructureMotionInstanceTypeNV(pub(crate) i32); +impl AccelerationStructureMotionInstanceTypeNV { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl AccelerationStructureMotionInstanceTypeNV { + pub const STATIC: Self = Self(0); + pub const MATRIX_MOTION: Self = Self(1); + pub const SRT_MOTION: Self = Self(2); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct DeviceAddressBindingTypeEXT(pub(crate) i32); +impl DeviceAddressBindingTypeEXT { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl DeviceAddressBindingTypeEXT { + pub const BIND: Self = Self(0); + pub const UNBIND: Self = Self(1); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct QueryResultStatusKHR(pub(crate) i32); +impl QueryResultStatusKHR { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl QueryResultStatusKHR { + pub const ERROR: Self = Self(-1); + pub const NOT_READY: Self = Self(0); + pub const COMPLETE: Self = Self(1); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct VideoEncodeTuningModeKHR(pub(crate) i32); +impl VideoEncodeTuningModeKHR { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl VideoEncodeTuningModeKHR { + pub const DEFAULT: Self = Self(0); + pub const HIGH_QUALITY: Self = Self(1); + pub const LOW_LATENCY: Self = Self(2); + pub const ULTRA_LOW_LATENCY: Self = Self(3); + pub const LOSSLESS: Self = Self(4); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct VideoEncodeH264RateControlStructureEXT(pub(crate) i32); +impl VideoEncodeH264RateControlStructureEXT { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl VideoEncodeH264RateControlStructureEXT { + pub const UNKNOWN: Self = Self(0); + pub const FLAT: Self = Self(1); + pub const DYADIC: Self = Self(2); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct VideoEncodeH265RateControlStructureEXT(pub(crate) i32); +impl VideoEncodeH265RateControlStructureEXT { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl VideoEncodeH265RateControlStructureEXT { + pub const UNKNOWN: Self = Self(0); + pub const FLAT: Self = Self(1); + pub const DYADIC: Self = Self(2); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct PipelineRobustnessBufferBehaviorEXT(pub(crate) i32); +impl PipelineRobustnessBufferBehaviorEXT { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl PipelineRobustnessBufferBehaviorEXT { + pub const DEVICE_DEFAULT: Self = Self(0); + pub const DISABLED: Self = Self(1); + pub const ROBUST_BUFFER_ACCESS: Self = Self(2); + pub const ROBUST_BUFFER_ACCESS_2: Self = Self(3); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct PipelineRobustnessImageBehaviorEXT(pub(crate) i32); +impl PipelineRobustnessImageBehaviorEXT { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl PipelineRobustnessImageBehaviorEXT { + pub const DEVICE_DEFAULT: Self = Self(0); + pub const DISABLED: Self = Self(1); + pub const ROBUST_IMAGE_ACCESS: Self = Self(2); + pub const ROBUST_IMAGE_ACCESS_2: Self = Self(3); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct OpticalFlowPerformanceLevelNV(pub(crate) i32); +impl OpticalFlowPerformanceLevelNV { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl OpticalFlowPerformanceLevelNV { + pub const UNKNOWN: Self = Self(0); + pub const SLOW: Self = Self(1); + pub const MEDIUM: Self = Self(2); + pub const FAST: Self = Self(3); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct OpticalFlowSessionBindingPointNV(pub(crate) i32); +impl OpticalFlowSessionBindingPointNV { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl OpticalFlowSessionBindingPointNV { + pub const UNKNOWN: Self = Self(0); + pub const INPUT: Self = Self(1); + pub const REFERENCE: Self = Self(2); + pub const HINT: Self = Self(3); + pub const FLOW_VECTOR: Self = Self(4); + pub const BACKWARD_FLOW_VECTOR: Self = Self(5); + pub const COST: Self = Self(6); + pub const BACKWARD_COST: Self = Self(7); + pub const GLOBAL_FLOW: Self = Self(8); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct MicromapTypeEXT(pub(crate) i32); +impl MicromapTypeEXT { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl MicromapTypeEXT { + pub const OPACITY_MICROMAP: Self = Self(0); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct CopyMicromapModeEXT(pub(crate) i32); +impl CopyMicromapModeEXT { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl CopyMicromapModeEXT { + pub const CLONE: Self = Self(0); + pub const SERIALIZE: Self = Self(1); + pub const DESERIALIZE: Self = Self(2); + pub const COMPACT: Self = Self(3); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct BuildMicromapModeEXT(pub(crate) i32); +impl BuildMicromapModeEXT { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl BuildMicromapModeEXT { + pub const BUILD: Self = Self(0); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct OpacityMicromapFormatEXT(pub(crate) i32); +impl OpacityMicromapFormatEXT { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl OpacityMicromapFormatEXT { + pub const TYPE_2_STATE: Self = Self(1); + pub const TYPE_4_STATE: Self = Self(2); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct OpacityMicromapSpecialIndexEXT(pub(crate) i32); +impl OpacityMicromapSpecialIndexEXT { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl OpacityMicromapSpecialIndexEXT { + pub const FULLY_TRANSPARENT: Self = Self(-1); + pub const FULLY_OPAQUE: Self = Self(-2); + pub const FULLY_UNKNOWN_TRANSPARENT: Self = Self(-3); + pub const FULLY_UNKNOWN_OPAQUE: Self = Self(-4); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct DeviceFaultAddressTypeEXT(pub(crate) i32); +impl DeviceFaultAddressTypeEXT { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl DeviceFaultAddressTypeEXT { + #[doc = "Currently unused"] + pub const NONE: Self = Self(0); + pub const READ_INVALID: Self = Self(1); + pub const WRITE_INVALID: Self = Self(2); + pub const EXECUTE_INVALID: Self = Self(3); + pub const INSTRUCTION_POINTER_UNKNOWN: Self = Self(4); + pub const INSTRUCTION_POINTER_INVALID: Self = Self(5); + pub const INSTRUCTION_POINTER_FAULT: Self = Self(6); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct DeviceFaultVendorBinaryHeaderVersionEXT(pub(crate) i32); +impl DeviceFaultVendorBinaryHeaderVersionEXT { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl DeviceFaultVendorBinaryHeaderVersionEXT { + pub const ONE: Self = Self(1); +} +impl fmt::Debug for ObjectType { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UNKNOWN => Some("UNKNOWN"), + Self::INSTANCE => Some("INSTANCE"), + Self::PHYSICAL_DEVICE => Some("PHYSICAL_DEVICE"), + Self::DEVICE => Some("DEVICE"), + Self::QUEUE => Some("QUEUE"), + Self::SEMAPHORE => Some("SEMAPHORE"), + Self::COMMAND_BUFFER => Some("COMMAND_BUFFER"), + Self::FENCE => Some("FENCE"), + Self::DEVICE_MEMORY => Some("DEVICE_MEMORY"), + Self::BUFFER => Some("BUFFER"), + Self::IMAGE => Some("IMAGE"), + Self::EVENT => Some("EVENT"), + Self::QUERY_POOL => Some("QUERY_POOL"), + Self::BUFFER_VIEW => Some("BUFFER_VIEW"), + Self::IMAGE_VIEW => Some("IMAGE_VIEW"), + Self::SHADER_MODULE => Some("SHADER_MODULE"), + Self::PIPELINE_CACHE => Some("PIPELINE_CACHE"), + Self::PIPELINE_LAYOUT => Some("PIPELINE_LAYOUT"), + Self::RENDER_PASS => Some("RENDER_PASS"), + Self::PIPELINE => Some("PIPELINE"), + Self::DESCRIPTOR_SET_LAYOUT => Some("DESCRIPTOR_SET_LAYOUT"), + Self::SAMPLER => Some("SAMPLER"), + Self::DESCRIPTOR_POOL => Some("DESCRIPTOR_POOL"), + Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"), + Self::FRAMEBUFFER => Some("FRAMEBUFFER"), + Self::COMMAND_POOL => Some("COMMAND_POOL"), + Self::SURFACE_KHR => Some("SURFACE_KHR"), + Self::SWAPCHAIN_KHR => Some("SWAPCHAIN_KHR"), + Self::DISPLAY_KHR => Some("DISPLAY_KHR"), + Self::DISPLAY_MODE_KHR => Some("DISPLAY_MODE_KHR"), + Self::DEBUG_REPORT_CALLBACK_EXT => Some("DEBUG_REPORT_CALLBACK_EXT"), + Self::VIDEO_SESSION_KHR => Some("VIDEO_SESSION_KHR"), + Self::VIDEO_SESSION_PARAMETERS_KHR => Some("VIDEO_SESSION_PARAMETERS_KHR"), + Self::CU_MODULE_NVX => Some("CU_MODULE_NVX"), + Self::CU_FUNCTION_NVX => Some("CU_FUNCTION_NVX"), + Self::DEBUG_UTILS_MESSENGER_EXT => Some("DEBUG_UTILS_MESSENGER_EXT"), + Self::ACCELERATION_STRUCTURE_KHR => Some("ACCELERATION_STRUCTURE_KHR"), + Self::VALIDATION_CACHE_EXT => Some("VALIDATION_CACHE_EXT"), + Self::ACCELERATION_STRUCTURE_NV => Some("ACCELERATION_STRUCTURE_NV"), + Self::PERFORMANCE_CONFIGURATION_INTEL => Some("PERFORMANCE_CONFIGURATION_INTEL"), + Self::DEFERRED_OPERATION_KHR => Some("DEFERRED_OPERATION_KHR"), + Self::INDIRECT_COMMANDS_LAYOUT_NV => Some("INDIRECT_COMMANDS_LAYOUT_NV"), + Self::BUFFER_COLLECTION_FUCHSIA => Some("BUFFER_COLLECTION_FUCHSIA"), + Self::MICROMAP_EXT => Some("MICROMAP_EXT"), + Self::OPTICAL_FLOW_SESSION_NV => Some("OPTICAL_FLOW_SESSION_NV"), + Self::SAMPLER_YCBCR_CONVERSION => Some("SAMPLER_YCBCR_CONVERSION"), + Self::DESCRIPTOR_UPDATE_TEMPLATE => Some("DESCRIPTOR_UPDATE_TEMPLATE"), + Self::PRIVATE_DATA_SLOT => Some("PRIVATE_DATA_SLOT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for Result { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::SUCCESS => Some("SUCCESS"), + Self::NOT_READY => Some("NOT_READY"), + Self::TIMEOUT => Some("TIMEOUT"), + Self::EVENT_SET => Some("EVENT_SET"), + Self::EVENT_RESET => Some("EVENT_RESET"), + Self::INCOMPLETE => Some("INCOMPLETE"), + Self::ERROR_OUT_OF_HOST_MEMORY => Some("ERROR_OUT_OF_HOST_MEMORY"), + Self::ERROR_OUT_OF_DEVICE_MEMORY => Some("ERROR_OUT_OF_DEVICE_MEMORY"), + Self::ERROR_INITIALIZATION_FAILED => Some("ERROR_INITIALIZATION_FAILED"), + Self::ERROR_DEVICE_LOST => Some("ERROR_DEVICE_LOST"), + Self::ERROR_MEMORY_MAP_FAILED => Some("ERROR_MEMORY_MAP_FAILED"), + Self::ERROR_LAYER_NOT_PRESENT => Some("ERROR_LAYER_NOT_PRESENT"), + Self::ERROR_EXTENSION_NOT_PRESENT => Some("ERROR_EXTENSION_NOT_PRESENT"), + Self::ERROR_FEATURE_NOT_PRESENT => Some("ERROR_FEATURE_NOT_PRESENT"), + Self::ERROR_INCOMPATIBLE_DRIVER => Some("ERROR_INCOMPATIBLE_DRIVER"), + Self::ERROR_TOO_MANY_OBJECTS => Some("ERROR_TOO_MANY_OBJECTS"), + Self::ERROR_FORMAT_NOT_SUPPORTED => Some("ERROR_FORMAT_NOT_SUPPORTED"), + Self::ERROR_FRAGMENTED_POOL => Some("ERROR_FRAGMENTED_POOL"), + Self::ERROR_UNKNOWN => Some("ERROR_UNKNOWN"), + Self::ERROR_SURFACE_LOST_KHR => Some("ERROR_SURFACE_LOST_KHR"), + Self::ERROR_NATIVE_WINDOW_IN_USE_KHR => Some("ERROR_NATIVE_WINDOW_IN_USE_KHR"), + Self::SUBOPTIMAL_KHR => Some("SUBOPTIMAL_KHR"), + Self::ERROR_OUT_OF_DATE_KHR => Some("ERROR_OUT_OF_DATE_KHR"), + Self::ERROR_INCOMPATIBLE_DISPLAY_KHR => Some("ERROR_INCOMPATIBLE_DISPLAY_KHR"), + Self::ERROR_VALIDATION_FAILED_EXT => Some("ERROR_VALIDATION_FAILED_EXT"), + Self::ERROR_INVALID_SHADER_NV => Some("ERROR_INVALID_SHADER_NV"), + Self::ERROR_IMAGE_USAGE_NOT_SUPPORTED_KHR => { + Some("ERROR_IMAGE_USAGE_NOT_SUPPORTED_KHR") + } + Self::ERROR_VIDEO_PICTURE_LAYOUT_NOT_SUPPORTED_KHR => { + Some("ERROR_VIDEO_PICTURE_LAYOUT_NOT_SUPPORTED_KHR") + } + Self::ERROR_VIDEO_PROFILE_OPERATION_NOT_SUPPORTED_KHR => { + Some("ERROR_VIDEO_PROFILE_OPERATION_NOT_SUPPORTED_KHR") + } + Self::ERROR_VIDEO_PROFILE_FORMAT_NOT_SUPPORTED_KHR => { + Some("ERROR_VIDEO_PROFILE_FORMAT_NOT_SUPPORTED_KHR") + } + Self::ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR => { + Some("ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR") + } + Self::ERROR_VIDEO_STD_VERSION_NOT_SUPPORTED_KHR => { + Some("ERROR_VIDEO_STD_VERSION_NOT_SUPPORTED_KHR") + } + Self::ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT => { + Some("ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT") + } + Self::ERROR_NOT_PERMITTED_KHR => Some("ERROR_NOT_PERMITTED_KHR"), + Self::ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT => { + Some("ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT") + } + Self::THREAD_IDLE_KHR => Some("THREAD_IDLE_KHR"), + Self::THREAD_DONE_KHR => Some("THREAD_DONE_KHR"), + Self::OPERATION_DEFERRED_KHR => Some("OPERATION_DEFERRED_KHR"), + Self::OPERATION_NOT_DEFERRED_KHR => Some("OPERATION_NOT_DEFERRED_KHR"), + Self::ERROR_COMPRESSION_EXHAUSTED_EXT => Some("ERROR_COMPRESSION_EXHAUSTED_EXT"), + Self::ERROR_OUT_OF_POOL_MEMORY => Some("ERROR_OUT_OF_POOL_MEMORY"), + Self::ERROR_INVALID_EXTERNAL_HANDLE => Some("ERROR_INVALID_EXTERNAL_HANDLE"), + Self::ERROR_FRAGMENTATION => Some("ERROR_FRAGMENTATION"), + Self::ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS => { + Some("ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS") + } + Self::PIPELINE_COMPILE_REQUIRED => Some("PIPELINE_COMPILE_REQUIRED"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} diff --git a/third_party/rust/ash/src/vk/extensions.rs b/third_party/rust/ash/src/vk/extensions.rs new file mode 100644 index 0000000000..cf4936d995 --- /dev/null +++ b/third_party/rust/ash/src/vk/extensions.rs @@ -0,0 +1,25322 @@ +use crate::vk::aliases::*; +use crate::vk::bitflags::*; +use crate::vk::definitions::*; +use crate::vk::enums::*; +use crate::vk::platform_types::*; +use std::os::raw::*; +impl KhrSurfaceFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_surface\0") } + } + pub const SPEC_VERSION: u32 = 25u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkDestroySurfaceKHR = unsafe extern "system" fn( + instance: Instance, + surface: SurfaceKHR, + p_allocator: *const AllocationCallbacks, +); +#[allow(non_camel_case_types)] +pub type PFN_vkGetPhysicalDeviceSurfaceSupportKHR = unsafe extern "system" fn( + physical_device: PhysicalDevice, + queue_family_index: u32, + surface: SurfaceKHR, + p_supported: *mut Bool32, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR = unsafe extern "system" fn( + physical_device: PhysicalDevice, + surface: SurfaceKHR, + p_surface_capabilities: *mut SurfaceCapabilitiesKHR, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetPhysicalDeviceSurfaceFormatsKHR = unsafe extern "system" fn( + physical_device: PhysicalDevice, + surface: SurfaceKHR, + p_surface_format_count: *mut u32, + p_surface_formats: *mut SurfaceFormatKHR, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetPhysicalDeviceSurfacePresentModesKHR = unsafe extern "system" fn( + physical_device: PhysicalDevice, + surface: SurfaceKHR, + p_present_mode_count: *mut u32, + p_present_modes: *mut PresentModeKHR, +) -> Result; +#[derive(Clone)] +pub struct KhrSurfaceFn { + pub destroy_surface_khr: PFN_vkDestroySurfaceKHR, + pub get_physical_device_surface_support_khr: PFN_vkGetPhysicalDeviceSurfaceSupportKHR, + pub get_physical_device_surface_capabilities_khr: PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR, + pub get_physical_device_surface_formats_khr: PFN_vkGetPhysicalDeviceSurfaceFormatsKHR, + pub get_physical_device_surface_present_modes_khr: + PFN_vkGetPhysicalDeviceSurfacePresentModesKHR, +} +unsafe impl Send for KhrSurfaceFn {} +unsafe impl Sync for KhrSurfaceFn {} +impl KhrSurfaceFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + destroy_surface_khr: unsafe { + unsafe extern "system" fn destroy_surface_khr( + _instance: Instance, + _surface: SurfaceKHR, + _p_allocator: *const AllocationCallbacks, + ) { + panic!(concat!("Unable to load ", stringify!(destroy_surface_khr))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroySurfaceKHR\0"); + let val = _f(cname); + if val.is_null() { + destroy_surface_khr + } else { + ::std::mem::transmute(val) + } + }, + get_physical_device_surface_support_khr: unsafe { + unsafe extern "system" fn get_physical_device_surface_support_khr( + _physical_device: PhysicalDevice, + _queue_family_index: u32, + _surface: SurfaceKHR, + _p_supported: *mut Bool32, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_surface_support_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPhysicalDeviceSurfaceSupportKHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_physical_device_surface_support_khr + } else { + ::std::mem::transmute(val) + } + }, + get_physical_device_surface_capabilities_khr: unsafe { + unsafe extern "system" fn get_physical_device_surface_capabilities_khr( + _physical_device: PhysicalDevice, + _surface: SurfaceKHR, + _p_surface_capabilities: *mut SurfaceCapabilitiesKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_surface_capabilities_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPhysicalDeviceSurfaceCapabilitiesKHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_physical_device_surface_capabilities_khr + } else { + ::std::mem::transmute(val) + } + }, + get_physical_device_surface_formats_khr: unsafe { + unsafe extern "system" fn get_physical_device_surface_formats_khr( + _physical_device: PhysicalDevice, + _surface: SurfaceKHR, + _p_surface_format_count: *mut u32, + _p_surface_formats: *mut SurfaceFormatKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_surface_formats_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPhysicalDeviceSurfaceFormatsKHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_physical_device_surface_formats_khr + } else { + ::std::mem::transmute(val) + } + }, + get_physical_device_surface_present_modes_khr: unsafe { + unsafe extern "system" fn get_physical_device_surface_present_modes_khr( + _physical_device: PhysicalDevice, + _surface: SurfaceKHR, + _p_present_mode_count: *mut u32, + _p_present_modes: *mut PresentModeKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_surface_present_modes_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPhysicalDeviceSurfacePresentModesKHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_physical_device_surface_present_modes_khr + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_KHR_surface'"] +impl ObjectType { + pub const SURFACE_KHR: Self = Self(1_000_000_000); +} +#[doc = "Generated from 'VK_KHR_surface'"] +impl Result { + pub const ERROR_SURFACE_LOST_KHR: Self = Self(-1_000_000_000); + pub const ERROR_NATIVE_WINDOW_IN_USE_KHR: Self = Self(-1_000_000_001); +} +impl KhrSwapchainFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_swapchain\0") } + } + pub const SPEC_VERSION: u32 = 70u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkCreateSwapchainKHR = unsafe extern "system" fn( + device: Device, + p_create_info: *const SwapchainCreateInfoKHR, + p_allocator: *const AllocationCallbacks, + p_swapchain: *mut SwapchainKHR, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkDestroySwapchainKHR = unsafe extern "system" fn( + device: Device, + swapchain: SwapchainKHR, + p_allocator: *const AllocationCallbacks, +); +#[allow(non_camel_case_types)] +pub type PFN_vkGetSwapchainImagesKHR = unsafe extern "system" fn( + device: Device, + swapchain: SwapchainKHR, + p_swapchain_image_count: *mut u32, + p_swapchain_images: *mut Image, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkAcquireNextImageKHR = unsafe extern "system" fn( + device: Device, + swapchain: SwapchainKHR, + timeout: u64, + semaphore: Semaphore, + fence: Fence, + p_image_index: *mut u32, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkQueuePresentKHR = + unsafe extern "system" fn(queue: Queue, p_present_info: *const PresentInfoKHR) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetDeviceGroupPresentCapabilitiesKHR = unsafe extern "system" fn( + device: Device, + p_device_group_present_capabilities: *mut DeviceGroupPresentCapabilitiesKHR, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetDeviceGroupSurfacePresentModesKHR = unsafe extern "system" fn( + device: Device, + surface: SurfaceKHR, + p_modes: *mut DeviceGroupPresentModeFlagsKHR, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetPhysicalDevicePresentRectanglesKHR = unsafe extern "system" fn( + physical_device: PhysicalDevice, + surface: SurfaceKHR, + p_rect_count: *mut u32, + p_rects: *mut Rect2D, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkAcquireNextImage2KHR = unsafe extern "system" fn( + device: Device, + p_acquire_info: *const AcquireNextImageInfoKHR, + p_image_index: *mut u32, +) -> Result; +#[derive(Clone)] +pub struct KhrSwapchainFn { + pub create_swapchain_khr: PFN_vkCreateSwapchainKHR, + pub destroy_swapchain_khr: PFN_vkDestroySwapchainKHR, + pub get_swapchain_images_khr: PFN_vkGetSwapchainImagesKHR, + pub acquire_next_image_khr: PFN_vkAcquireNextImageKHR, + pub queue_present_khr: PFN_vkQueuePresentKHR, + pub get_device_group_present_capabilities_khr: PFN_vkGetDeviceGroupPresentCapabilitiesKHR, + pub get_device_group_surface_present_modes_khr: PFN_vkGetDeviceGroupSurfacePresentModesKHR, + pub get_physical_device_present_rectangles_khr: PFN_vkGetPhysicalDevicePresentRectanglesKHR, + pub acquire_next_image2_khr: PFN_vkAcquireNextImage2KHR, +} +unsafe impl Send for KhrSwapchainFn {} +unsafe impl Sync for KhrSwapchainFn {} +impl KhrSwapchainFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + create_swapchain_khr: unsafe { + unsafe extern "system" fn create_swapchain_khr( + _device: Device, + _p_create_info: *const SwapchainCreateInfoKHR, + _p_allocator: *const AllocationCallbacks, + _p_swapchain: *mut SwapchainKHR, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(create_swapchain_khr))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateSwapchainKHR\0"); + let val = _f(cname); + if val.is_null() { + create_swapchain_khr + } else { + ::std::mem::transmute(val) + } + }, + destroy_swapchain_khr: unsafe { + unsafe extern "system" fn destroy_swapchain_khr( + _device: Device, + _swapchain: SwapchainKHR, + _p_allocator: *const AllocationCallbacks, + ) { + panic!(concat!( + "Unable to load ", + stringify!(destroy_swapchain_khr) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroySwapchainKHR\0"); + let val = _f(cname); + if val.is_null() { + destroy_swapchain_khr + } else { + ::std::mem::transmute(val) + } + }, + get_swapchain_images_khr: unsafe { + unsafe extern "system" fn get_swapchain_images_khr( + _device: Device, + _swapchain: SwapchainKHR, + _p_swapchain_image_count: *mut u32, + _p_swapchain_images: *mut Image, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_swapchain_images_khr) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetSwapchainImagesKHR\0"); + let val = _f(cname); + if val.is_null() { + get_swapchain_images_khr + } else { + ::std::mem::transmute(val) + } + }, + acquire_next_image_khr: unsafe { + unsafe extern "system" fn acquire_next_image_khr( + _device: Device, + _swapchain: SwapchainKHR, + _timeout: u64, + _semaphore: Semaphore, + _fence: Fence, + _p_image_index: *mut u32, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(acquire_next_image_khr) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkAcquireNextImageKHR\0"); + let val = _f(cname); + if val.is_null() { + acquire_next_image_khr + } else { + ::std::mem::transmute(val) + } + }, + queue_present_khr: unsafe { + unsafe extern "system" fn queue_present_khr( + _queue: Queue, + _p_present_info: *const PresentInfoKHR, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(queue_present_khr))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkQueuePresentKHR\0"); + let val = _f(cname); + if val.is_null() { + queue_present_khr + } else { + ::std::mem::transmute(val) + } + }, + get_device_group_present_capabilities_khr: unsafe { + unsafe extern "system" fn get_device_group_present_capabilities_khr( + _device: Device, + _p_device_group_present_capabilities: *mut DeviceGroupPresentCapabilitiesKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_device_group_present_capabilities_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetDeviceGroupPresentCapabilitiesKHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_device_group_present_capabilities_khr + } else { + ::std::mem::transmute(val) + } + }, + get_device_group_surface_present_modes_khr: unsafe { + unsafe extern "system" fn get_device_group_surface_present_modes_khr( + _device: Device, + _surface: SurfaceKHR, + _p_modes: *mut DeviceGroupPresentModeFlagsKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_device_group_surface_present_modes_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetDeviceGroupSurfacePresentModesKHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_device_group_surface_present_modes_khr + } else { + ::std::mem::transmute(val) + } + }, + get_physical_device_present_rectangles_khr: unsafe { + unsafe extern "system" fn get_physical_device_present_rectangles_khr( + _physical_device: PhysicalDevice, + _surface: SurfaceKHR, + _p_rect_count: *mut u32, + _p_rects: *mut Rect2D, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_present_rectangles_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPhysicalDevicePresentRectanglesKHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_physical_device_present_rectangles_khr + } else { + ::std::mem::transmute(val) + } + }, + acquire_next_image2_khr: unsafe { + unsafe extern "system" fn acquire_next_image2_khr( + _device: Device, + _p_acquire_info: *const AcquireNextImageInfoKHR, + _p_image_index: *mut u32, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(acquire_next_image2_khr) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkAcquireNextImage2KHR\0"); + let val = _f(cname); + if val.is_null() { + acquire_next_image2_khr + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_KHR_swapchain'"] +impl ImageLayout { + pub const PRESENT_SRC_KHR: Self = Self(1_000_001_002); +} +#[doc = "Generated from 'VK_KHR_swapchain'"] +impl ObjectType { + pub const SWAPCHAIN_KHR: Self = Self(1_000_001_000); +} +#[doc = "Generated from 'VK_KHR_swapchain'"] +impl Result { + pub const SUBOPTIMAL_KHR: Self = Self(1_000_001_003); + pub const ERROR_OUT_OF_DATE_KHR: Self = Self(-1_000_001_004); +} +#[doc = "Generated from 'VK_KHR_swapchain'"] +impl StructureType { + pub const SWAPCHAIN_CREATE_INFO_KHR: Self = Self(1_000_001_000); + pub const PRESENT_INFO_KHR: Self = Self(1_000_001_001); + pub const DEVICE_GROUP_PRESENT_CAPABILITIES_KHR: Self = Self(1_000_060_007); + pub const IMAGE_SWAPCHAIN_CREATE_INFO_KHR: Self = Self(1_000_060_008); + pub const BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR: Self = Self(1_000_060_009); + pub const ACQUIRE_NEXT_IMAGE_INFO_KHR: Self = Self(1_000_060_010); + pub const DEVICE_GROUP_PRESENT_INFO_KHR: Self = Self(1_000_060_011); + pub const DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR: Self = Self(1_000_060_012); +} +#[doc = "Generated from 'VK_KHR_swapchain'"] +impl SwapchainCreateFlagsKHR { + #[doc = "Allow images with VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT"] + pub const SPLIT_INSTANCE_BIND_REGIONS: Self = Self(0b1); + #[doc = "Swapchain is protected"] + pub const PROTECTED: Self = Self(0b10); +} +impl KhrDisplayFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_display\0") } + } + pub const SPEC_VERSION: u32 = 23u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkGetPhysicalDeviceDisplayPropertiesKHR = unsafe extern "system" fn( + physical_device: PhysicalDevice, + p_property_count: *mut u32, + p_properties: *mut DisplayPropertiesKHR, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR = unsafe extern "system" fn( + physical_device: PhysicalDevice, + p_property_count: *mut u32, + p_properties: *mut DisplayPlanePropertiesKHR, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetDisplayPlaneSupportedDisplaysKHR = unsafe extern "system" fn( + physical_device: PhysicalDevice, + plane_index: u32, + p_display_count: *mut u32, + p_displays: *mut DisplayKHR, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetDisplayModePropertiesKHR = unsafe extern "system" fn( + physical_device: PhysicalDevice, + display: DisplayKHR, + p_property_count: *mut u32, + p_properties: *mut DisplayModePropertiesKHR, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkCreateDisplayModeKHR = unsafe extern "system" fn( + physical_device: PhysicalDevice, + display: DisplayKHR, + p_create_info: *const DisplayModeCreateInfoKHR, + p_allocator: *const AllocationCallbacks, + p_mode: *mut DisplayModeKHR, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetDisplayPlaneCapabilitiesKHR = unsafe extern "system" fn( + physical_device: PhysicalDevice, + mode: DisplayModeKHR, + plane_index: u32, + p_capabilities: *mut DisplayPlaneCapabilitiesKHR, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkCreateDisplayPlaneSurfaceKHR = unsafe extern "system" fn( + instance: Instance, + p_create_info: *const DisplaySurfaceCreateInfoKHR, + p_allocator: *const AllocationCallbacks, + p_surface: *mut SurfaceKHR, +) -> Result; +#[derive(Clone)] +pub struct KhrDisplayFn { + pub get_physical_device_display_properties_khr: PFN_vkGetPhysicalDeviceDisplayPropertiesKHR, + pub get_physical_device_display_plane_properties_khr: + PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR, + pub get_display_plane_supported_displays_khr: PFN_vkGetDisplayPlaneSupportedDisplaysKHR, + pub get_display_mode_properties_khr: PFN_vkGetDisplayModePropertiesKHR, + pub create_display_mode_khr: PFN_vkCreateDisplayModeKHR, + pub get_display_plane_capabilities_khr: PFN_vkGetDisplayPlaneCapabilitiesKHR, + pub create_display_plane_surface_khr: PFN_vkCreateDisplayPlaneSurfaceKHR, +} +unsafe impl Send for KhrDisplayFn {} +unsafe impl Sync for KhrDisplayFn {} +impl KhrDisplayFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + get_physical_device_display_properties_khr: unsafe { + unsafe extern "system" fn get_physical_device_display_properties_khr( + _physical_device: PhysicalDevice, + _p_property_count: *mut u32, + _p_properties: *mut DisplayPropertiesKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_display_properties_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPhysicalDeviceDisplayPropertiesKHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_physical_device_display_properties_khr + } else { + ::std::mem::transmute(val) + } + }, + get_physical_device_display_plane_properties_khr: unsafe { + unsafe extern "system" fn get_physical_device_display_plane_properties_khr( + _physical_device: PhysicalDevice, + _p_property_count: *mut u32, + _p_properties: *mut DisplayPlanePropertiesKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_display_plane_properties_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPhysicalDeviceDisplayPlanePropertiesKHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_physical_device_display_plane_properties_khr + } else { + ::std::mem::transmute(val) + } + }, + get_display_plane_supported_displays_khr: unsafe { + unsafe extern "system" fn get_display_plane_supported_displays_khr( + _physical_device: PhysicalDevice, + _plane_index: u32, + _p_display_count: *mut u32, + _p_displays: *mut DisplayKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_display_plane_supported_displays_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetDisplayPlaneSupportedDisplaysKHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_display_plane_supported_displays_khr + } else { + ::std::mem::transmute(val) + } + }, + get_display_mode_properties_khr: unsafe { + unsafe extern "system" fn get_display_mode_properties_khr( + _physical_device: PhysicalDevice, + _display: DisplayKHR, + _p_property_count: *mut u32, + _p_properties: *mut DisplayModePropertiesKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_display_mode_properties_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetDisplayModePropertiesKHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_display_mode_properties_khr + } else { + ::std::mem::transmute(val) + } + }, + create_display_mode_khr: unsafe { + unsafe extern "system" fn create_display_mode_khr( + _physical_device: PhysicalDevice, + _display: DisplayKHR, + _p_create_info: *const DisplayModeCreateInfoKHR, + _p_allocator: *const AllocationCallbacks, + _p_mode: *mut DisplayModeKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(create_display_mode_khr) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateDisplayModeKHR\0"); + let val = _f(cname); + if val.is_null() { + create_display_mode_khr + } else { + ::std::mem::transmute(val) + } + }, + get_display_plane_capabilities_khr: unsafe { + unsafe extern "system" fn get_display_plane_capabilities_khr( + _physical_device: PhysicalDevice, + _mode: DisplayModeKHR, + _plane_index: u32, + _p_capabilities: *mut DisplayPlaneCapabilitiesKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_display_plane_capabilities_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetDisplayPlaneCapabilitiesKHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_display_plane_capabilities_khr + } else { + ::std::mem::transmute(val) + } + }, + create_display_plane_surface_khr: unsafe { + unsafe extern "system" fn create_display_plane_surface_khr( + _instance: Instance, + _p_create_info: *const DisplaySurfaceCreateInfoKHR, + _p_allocator: *const AllocationCallbacks, + _p_surface: *mut SurfaceKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(create_display_plane_surface_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCreateDisplayPlaneSurfaceKHR\0", + ); + let val = _f(cname); + if val.is_null() { + create_display_plane_surface_khr + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_KHR_display'"] +impl ObjectType { + pub const DISPLAY_KHR: Self = Self(1_000_002_000); + pub const DISPLAY_MODE_KHR: Self = Self(1_000_002_001); +} +#[doc = "Generated from 'VK_KHR_display'"] +impl StructureType { + pub const DISPLAY_MODE_CREATE_INFO_KHR: Self = Self(1_000_002_000); + pub const DISPLAY_SURFACE_CREATE_INFO_KHR: Self = Self(1_000_002_001); +} +impl KhrDisplaySwapchainFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_display_swapchain\0") } + } + pub const SPEC_VERSION: u32 = 10u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkCreateSharedSwapchainsKHR = unsafe extern "system" fn( + device: Device, + swapchain_count: u32, + p_create_infos: *const SwapchainCreateInfoKHR, + p_allocator: *const AllocationCallbacks, + p_swapchains: *mut SwapchainKHR, +) -> Result; +#[derive(Clone)] +pub struct KhrDisplaySwapchainFn { + pub create_shared_swapchains_khr: PFN_vkCreateSharedSwapchainsKHR, +} +unsafe impl Send for KhrDisplaySwapchainFn {} +unsafe impl Sync for KhrDisplaySwapchainFn {} +impl KhrDisplaySwapchainFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + create_shared_swapchains_khr: unsafe { + unsafe extern "system" fn create_shared_swapchains_khr( + _device: Device, + _swapchain_count: u32, + _p_create_infos: *const SwapchainCreateInfoKHR, + _p_allocator: *const AllocationCallbacks, + _p_swapchains: *mut SwapchainKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(create_shared_swapchains_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCreateSharedSwapchainsKHR\0", + ); + let val = _f(cname); + if val.is_null() { + create_shared_swapchains_khr + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_KHR_display_swapchain'"] +impl Result { + pub const ERROR_INCOMPATIBLE_DISPLAY_KHR: Self = Self(-1_000_003_001); +} +#[doc = "Generated from 'VK_KHR_display_swapchain'"] +impl StructureType { + pub const DISPLAY_PRESENT_INFO_KHR: Self = Self(1_000_003_000); +} +impl KhrXlibSurfaceFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_xlib_surface\0") } + } + pub const SPEC_VERSION: u32 = 6u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkCreateXlibSurfaceKHR = unsafe extern "system" fn( + instance: Instance, + p_create_info: *const XlibSurfaceCreateInfoKHR, + p_allocator: *const AllocationCallbacks, + p_surface: *mut SurfaceKHR, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR = unsafe extern "system" fn( + physical_device: PhysicalDevice, + queue_family_index: u32, + dpy: *mut Display, + visual_id: VisualID, +) -> Bool32; +#[derive(Clone)] +pub struct KhrXlibSurfaceFn { + pub create_xlib_surface_khr: PFN_vkCreateXlibSurfaceKHR, + pub get_physical_device_xlib_presentation_support_khr: + PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR, +} +unsafe impl Send for KhrXlibSurfaceFn {} +unsafe impl Sync for KhrXlibSurfaceFn {} +impl KhrXlibSurfaceFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + create_xlib_surface_khr: unsafe { + unsafe extern "system" fn create_xlib_surface_khr( + _instance: Instance, + _p_create_info: *const XlibSurfaceCreateInfoKHR, + _p_allocator: *const AllocationCallbacks, + _p_surface: *mut SurfaceKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(create_xlib_surface_khr) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateXlibSurfaceKHR\0"); + let val = _f(cname); + if val.is_null() { + create_xlib_surface_khr + } else { + ::std::mem::transmute(val) + } + }, + get_physical_device_xlib_presentation_support_khr: unsafe { + unsafe extern "system" fn get_physical_device_xlib_presentation_support_khr( + _physical_device: PhysicalDevice, + _queue_family_index: u32, + _dpy: *mut Display, + _visual_id: VisualID, + ) -> Bool32 { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_xlib_presentation_support_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPhysicalDeviceXlibPresentationSupportKHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_physical_device_xlib_presentation_support_khr + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_KHR_xlib_surface'"] +impl StructureType { + pub const XLIB_SURFACE_CREATE_INFO_KHR: Self = Self(1_000_004_000); +} +impl KhrXcbSurfaceFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_xcb_surface\0") } + } + pub const SPEC_VERSION: u32 = 6u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkCreateXcbSurfaceKHR = unsafe extern "system" fn( + instance: Instance, + p_create_info: *const XcbSurfaceCreateInfoKHR, + p_allocator: *const AllocationCallbacks, + p_surface: *mut SurfaceKHR, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR = unsafe extern "system" fn( + physical_device: PhysicalDevice, + queue_family_index: u32, + connection: *mut xcb_connection_t, + visual_id: xcb_visualid_t, +) -> Bool32; +#[derive(Clone)] +pub struct KhrXcbSurfaceFn { + pub create_xcb_surface_khr: PFN_vkCreateXcbSurfaceKHR, + pub get_physical_device_xcb_presentation_support_khr: + PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR, +} +unsafe impl Send for KhrXcbSurfaceFn {} +unsafe impl Sync for KhrXcbSurfaceFn {} +impl KhrXcbSurfaceFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + create_xcb_surface_khr: unsafe { + unsafe extern "system" fn create_xcb_surface_khr( + _instance: Instance, + _p_create_info: *const XcbSurfaceCreateInfoKHR, + _p_allocator: *const AllocationCallbacks, + _p_surface: *mut SurfaceKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(create_xcb_surface_khr) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateXcbSurfaceKHR\0"); + let val = _f(cname); + if val.is_null() { + create_xcb_surface_khr + } else { + ::std::mem::transmute(val) + } + }, + get_physical_device_xcb_presentation_support_khr: unsafe { + unsafe extern "system" fn get_physical_device_xcb_presentation_support_khr( + _physical_device: PhysicalDevice, + _queue_family_index: u32, + _connection: *mut xcb_connection_t, + _visual_id: xcb_visualid_t, + ) -> Bool32 { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_xcb_presentation_support_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPhysicalDeviceXcbPresentationSupportKHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_physical_device_xcb_presentation_support_khr + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_KHR_xcb_surface'"] +impl StructureType { + pub const XCB_SURFACE_CREATE_INFO_KHR: Self = Self(1_000_005_000); +} +impl KhrWaylandSurfaceFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_wayland_surface\0") } + } + pub const SPEC_VERSION: u32 = 6u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkCreateWaylandSurfaceKHR = unsafe extern "system" fn( + instance: Instance, + p_create_info: *const WaylandSurfaceCreateInfoKHR, + p_allocator: *const AllocationCallbacks, + p_surface: *mut SurfaceKHR, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR = unsafe extern "system" fn( + physical_device: PhysicalDevice, + queue_family_index: u32, + display: *mut wl_display, +) + -> Bool32; +#[derive(Clone)] +pub struct KhrWaylandSurfaceFn { + pub create_wayland_surface_khr: PFN_vkCreateWaylandSurfaceKHR, + pub get_physical_device_wayland_presentation_support_khr: + PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR, +} +unsafe impl Send for KhrWaylandSurfaceFn {} +unsafe impl Sync for KhrWaylandSurfaceFn {} +impl KhrWaylandSurfaceFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + create_wayland_surface_khr: unsafe { + unsafe extern "system" fn create_wayland_surface_khr( + _instance: Instance, + _p_create_info: *const WaylandSurfaceCreateInfoKHR, + _p_allocator: *const AllocationCallbacks, + _p_surface: *mut SurfaceKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(create_wayland_surface_khr) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateWaylandSurfaceKHR\0"); + let val = _f(cname); + if val.is_null() { + create_wayland_surface_khr + } else { + ::std::mem::transmute(val) + } + }, + get_physical_device_wayland_presentation_support_khr: unsafe { + unsafe extern "system" fn get_physical_device_wayland_presentation_support_khr( + _physical_device: PhysicalDevice, + _queue_family_index: u32, + _display: *mut wl_display, + ) -> Bool32 { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_wayland_presentation_support_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPhysicalDeviceWaylandPresentationSupportKHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_physical_device_wayland_presentation_support_khr + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_KHR_wayland_surface'"] +impl StructureType { + pub const WAYLAND_SURFACE_CREATE_INFO_KHR: Self = Self(1_000_006_000); +} +impl KhrMirSurfaceFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_mir_surface\0") } + } + pub const SPEC_VERSION: u32 = 4u32; +} +#[derive(Clone)] +pub struct KhrMirSurfaceFn {} +unsafe impl Send for KhrMirSurfaceFn {} +unsafe impl Sync for KhrMirSurfaceFn {} +impl KhrMirSurfaceFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl KhrAndroidSurfaceFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_android_surface\0") } + } + pub const SPEC_VERSION: u32 = 6u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkCreateAndroidSurfaceKHR = unsafe extern "system" fn( + instance: Instance, + p_create_info: *const AndroidSurfaceCreateInfoKHR, + p_allocator: *const AllocationCallbacks, + p_surface: *mut SurfaceKHR, +) -> Result; +#[derive(Clone)] +pub struct KhrAndroidSurfaceFn { + pub create_android_surface_khr: PFN_vkCreateAndroidSurfaceKHR, +} +unsafe impl Send for KhrAndroidSurfaceFn {} +unsafe impl Sync for KhrAndroidSurfaceFn {} +impl KhrAndroidSurfaceFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + create_android_surface_khr: unsafe { + unsafe extern "system" fn create_android_surface_khr( + _instance: Instance, + _p_create_info: *const AndroidSurfaceCreateInfoKHR, + _p_allocator: *const AllocationCallbacks, + _p_surface: *mut SurfaceKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(create_android_surface_khr) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateAndroidSurfaceKHR\0"); + let val = _f(cname); + if val.is_null() { + create_android_surface_khr + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_KHR_android_surface'"] +impl StructureType { + pub const ANDROID_SURFACE_CREATE_INFO_KHR: Self = Self(1_000_008_000); +} +impl KhrWin32SurfaceFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_win32_surface\0") } + } + pub const SPEC_VERSION: u32 = 6u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkCreateWin32SurfaceKHR = unsafe extern "system" fn( + instance: Instance, + p_create_info: *const Win32SurfaceCreateInfoKHR, + p_allocator: *const AllocationCallbacks, + p_surface: *mut SurfaceKHR, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR = + unsafe extern "system" fn(physical_device: PhysicalDevice, queue_family_index: u32) -> Bool32; +#[derive(Clone)] +pub struct KhrWin32SurfaceFn { + pub create_win32_surface_khr: PFN_vkCreateWin32SurfaceKHR, + pub get_physical_device_win32_presentation_support_khr: + PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR, +} +unsafe impl Send for KhrWin32SurfaceFn {} +unsafe impl Sync for KhrWin32SurfaceFn {} +impl KhrWin32SurfaceFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + create_win32_surface_khr: unsafe { + unsafe extern "system" fn create_win32_surface_khr( + _instance: Instance, + _p_create_info: *const Win32SurfaceCreateInfoKHR, + _p_allocator: *const AllocationCallbacks, + _p_surface: *mut SurfaceKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(create_win32_surface_khr) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateWin32SurfaceKHR\0"); + let val = _f(cname); + if val.is_null() { + create_win32_surface_khr + } else { + ::std::mem::transmute(val) + } + }, + get_physical_device_win32_presentation_support_khr: unsafe { + unsafe extern "system" fn get_physical_device_win32_presentation_support_khr( + _physical_device: PhysicalDevice, + _queue_family_index: u32, + ) -> Bool32 { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_win32_presentation_support_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPhysicalDeviceWin32PresentationSupportKHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_physical_device_win32_presentation_support_khr + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_KHR_win32_surface'"] +impl StructureType { + pub const WIN32_SURFACE_CREATE_INFO_KHR: Self = Self(1_000_009_000); +} +impl AndroidNativeBufferFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_ANDROID_native_buffer\0") } + } + pub const SPEC_VERSION: u32 = 8u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkGetSwapchainGrallocUsageANDROID = unsafe extern "system" fn( + device: Device, + format: Format, + image_usage: ImageUsageFlags, + gralloc_usage: *mut c_int, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkAcquireImageANDROID = unsafe extern "system" fn( + device: Device, + image: Image, + native_fence_fd: c_int, + semaphore: Semaphore, + fence: Fence, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkQueueSignalReleaseImageANDROID = unsafe extern "system" fn( + queue: Queue, + wait_semaphore_count: u32, + p_wait_semaphores: *const Semaphore, + image: Image, + p_native_fence_fd: *mut c_int, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetSwapchainGrallocUsage2ANDROID = unsafe extern "system" fn( + device: Device, + format: Format, + image_usage: ImageUsageFlags, + swapchain_image_usage: SwapchainImageUsageFlagsANDROID, + gralloc_consumer_usage: *mut u64, + gralloc_producer_usage: *mut u64, +) -> Result; +#[derive(Clone)] +pub struct AndroidNativeBufferFn { + pub get_swapchain_gralloc_usage_android: PFN_vkGetSwapchainGrallocUsageANDROID, + pub acquire_image_android: PFN_vkAcquireImageANDROID, + pub queue_signal_release_image_android: PFN_vkQueueSignalReleaseImageANDROID, + pub get_swapchain_gralloc_usage2_android: PFN_vkGetSwapchainGrallocUsage2ANDROID, +} +unsafe impl Send for AndroidNativeBufferFn {} +unsafe impl Sync for AndroidNativeBufferFn {} +impl AndroidNativeBufferFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + get_swapchain_gralloc_usage_android: unsafe { + unsafe extern "system" fn get_swapchain_gralloc_usage_android( + _device: Device, + _format: Format, + _image_usage: ImageUsageFlags, + _gralloc_usage: *mut c_int, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_swapchain_gralloc_usage_android) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetSwapchainGrallocUsageANDROID\0", + ); + let val = _f(cname); + if val.is_null() { + get_swapchain_gralloc_usage_android + } else { + ::std::mem::transmute(val) + } + }, + acquire_image_android: unsafe { + unsafe extern "system" fn acquire_image_android( + _device: Device, + _image: Image, + _native_fence_fd: c_int, + _semaphore: Semaphore, + _fence: Fence, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(acquire_image_android) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkAcquireImageANDROID\0"); + let val = _f(cname); + if val.is_null() { + acquire_image_android + } else { + ::std::mem::transmute(val) + } + }, + queue_signal_release_image_android: unsafe { + unsafe extern "system" fn queue_signal_release_image_android( + _queue: Queue, + _wait_semaphore_count: u32, + _p_wait_semaphores: *const Semaphore, + _image: Image, + _p_native_fence_fd: *mut c_int, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(queue_signal_release_image_android) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkQueueSignalReleaseImageANDROID\0", + ); + let val = _f(cname); + if val.is_null() { + queue_signal_release_image_android + } else { + ::std::mem::transmute(val) + } + }, + get_swapchain_gralloc_usage2_android: unsafe { + unsafe extern "system" fn get_swapchain_gralloc_usage2_android( + _device: Device, + _format: Format, + _image_usage: ImageUsageFlags, + _swapchain_image_usage: SwapchainImageUsageFlagsANDROID, + _gralloc_consumer_usage: *mut u64, + _gralloc_producer_usage: *mut u64, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_swapchain_gralloc_usage2_android) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetSwapchainGrallocUsage2ANDROID\0", + ); + let val = _f(cname); + if val.is_null() { + get_swapchain_gralloc_usage2_android + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_ANDROID_native_buffer'"] +impl StructureType { + pub const NATIVE_BUFFER_ANDROID: Self = Self(1_000_010_000); + pub const SWAPCHAIN_IMAGE_CREATE_INFO_ANDROID: Self = Self(1_000_010_001); + pub const PHYSICAL_DEVICE_PRESENTATION_PROPERTIES_ANDROID: Self = Self(1_000_010_002); +} +impl ExtDebugReportFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_debug_report\0") } + } + pub const SPEC_VERSION: u32 = 10u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkCreateDebugReportCallbackEXT = unsafe extern "system" fn( + instance: Instance, + p_create_info: *const DebugReportCallbackCreateInfoEXT, + p_allocator: *const AllocationCallbacks, + p_callback: *mut DebugReportCallbackEXT, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkDestroyDebugReportCallbackEXT = unsafe extern "system" fn( + instance: Instance, + callback: DebugReportCallbackEXT, + p_allocator: *const AllocationCallbacks, +); +#[allow(non_camel_case_types)] +pub type PFN_vkDebugReportMessageEXT = unsafe extern "system" fn( + instance: Instance, + flags: DebugReportFlagsEXT, + object_type: DebugReportObjectTypeEXT, + object: u64, + location: usize, + message_code: i32, + p_layer_prefix: *const c_char, + p_message: *const c_char, +); +#[derive(Clone)] +pub struct ExtDebugReportFn { + pub create_debug_report_callback_ext: PFN_vkCreateDebugReportCallbackEXT, + pub destroy_debug_report_callback_ext: PFN_vkDestroyDebugReportCallbackEXT, + pub debug_report_message_ext: PFN_vkDebugReportMessageEXT, +} +unsafe impl Send for ExtDebugReportFn {} +unsafe impl Sync for ExtDebugReportFn {} +impl ExtDebugReportFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + create_debug_report_callback_ext: unsafe { + unsafe extern "system" fn create_debug_report_callback_ext( + _instance: Instance, + _p_create_info: *const DebugReportCallbackCreateInfoEXT, + _p_allocator: *const AllocationCallbacks, + _p_callback: *mut DebugReportCallbackEXT, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(create_debug_report_callback_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCreateDebugReportCallbackEXT\0", + ); + let val = _f(cname); + if val.is_null() { + create_debug_report_callback_ext + } else { + ::std::mem::transmute(val) + } + }, + destroy_debug_report_callback_ext: unsafe { + unsafe extern "system" fn destroy_debug_report_callback_ext( + _instance: Instance, + _callback: DebugReportCallbackEXT, + _p_allocator: *const AllocationCallbacks, + ) { + panic!(concat!( + "Unable to load ", + stringify!(destroy_debug_report_callback_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkDestroyDebugReportCallbackEXT\0", + ); + let val = _f(cname); + if val.is_null() { + destroy_debug_report_callback_ext + } else { + ::std::mem::transmute(val) + } + }, + debug_report_message_ext: unsafe { + unsafe extern "system" fn debug_report_message_ext( + _instance: Instance, + _flags: DebugReportFlagsEXT, + _object_type: DebugReportObjectTypeEXT, + _object: u64, + _location: usize, + _message_code: i32, + _p_layer_prefix: *const c_char, + _p_message: *const c_char, + ) { + panic!(concat!( + "Unable to load ", + stringify!(debug_report_message_ext) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDebugReportMessageEXT\0"); + let val = _f(cname); + if val.is_null() { + debug_report_message_ext + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_EXT_debug_report'"] +impl DebugReportObjectTypeEXT { + pub const SAMPLER_YCBCR_CONVERSION: Self = Self(1_000_156_000); + pub const DESCRIPTOR_UPDATE_TEMPLATE: Self = Self(1_000_085_000); +} +#[doc = "Generated from 'VK_EXT_debug_report'"] +impl ObjectType { + pub const DEBUG_REPORT_CALLBACK_EXT: Self = Self(1_000_011_000); +} +#[doc = "Generated from 'VK_EXT_debug_report'"] +impl Result { + pub const ERROR_VALIDATION_FAILED_EXT: Self = Self(-1_000_011_001); +} +#[doc = "Generated from 'VK_EXT_debug_report'"] +impl StructureType { + pub const DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT: Self = Self(1_000_011_000); +} +impl NvGlslShaderFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_glsl_shader\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct NvGlslShaderFn {} +unsafe impl Send for NvGlslShaderFn {} +unsafe impl Sync for NvGlslShaderFn {} +impl NvGlslShaderFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_NV_glsl_shader'"] +impl Result { + pub const ERROR_INVALID_SHADER_NV: Self = Self(-1_000_012_000); +} +impl ExtDepthRangeUnrestrictedFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_depth_range_unrestricted\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct ExtDepthRangeUnrestrictedFn {} +unsafe impl Send for ExtDepthRangeUnrestrictedFn {} +unsafe impl Sync for ExtDepthRangeUnrestrictedFn {} +impl ExtDepthRangeUnrestrictedFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl KhrSamplerMirrorClampToEdgeFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"VK_KHR_sampler_mirror_clamp_to_edge\0", + ) + } + } + pub const SPEC_VERSION: u32 = 3u32; +} +#[derive(Clone)] +pub struct KhrSamplerMirrorClampToEdgeFn {} +unsafe impl Send for KhrSamplerMirrorClampToEdgeFn {} +unsafe impl Sync for KhrSamplerMirrorClampToEdgeFn {} +impl KhrSamplerMirrorClampToEdgeFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_KHR_sampler_mirror_clamp_to_edge'"] +impl SamplerAddressMode { + #[doc = "Note that this defines what was previously a core enum, and so uses the 'value' attribute rather than 'offset', and does not have a suffix. This is a special case, and should not be repeated"] + pub const MIRROR_CLAMP_TO_EDGE: Self = Self(4); + #[deprecated = "Alias introduced for consistency with extension suffixing rules"] + pub const MIRROR_CLAMP_TO_EDGE_KHR: Self = Self::MIRROR_CLAMP_TO_EDGE; +} +impl ImgFilterCubicFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_IMG_filter_cubic\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct ImgFilterCubicFn {} +unsafe impl Send for ImgFilterCubicFn {} +unsafe impl Sync for ImgFilterCubicFn {} +impl ImgFilterCubicFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_IMG_filter_cubic'"] +impl Filter { + pub const CUBIC_IMG: Self = Self::CUBIC_EXT; +} +#[doc = "Generated from 'VK_IMG_filter_cubic'"] +impl FormatFeatureFlags { + #[doc = "Format can be filtered with VK_FILTER_CUBIC_IMG when being sampled"] + pub const SAMPLED_IMAGE_FILTER_CUBIC_IMG: Self = Self::SAMPLED_IMAGE_FILTER_CUBIC_EXT; +} +impl AmdExtension17Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_17\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct AmdExtension17Fn {} +unsafe impl Send for AmdExtension17Fn {} +unsafe impl Sync for AmdExtension17Fn {} +impl AmdExtension17Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl AmdExtension18Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_18\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct AmdExtension18Fn {} +unsafe impl Send for AmdExtension18Fn {} +unsafe impl Sync for AmdExtension18Fn {} +impl AmdExtension18Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl AmdRasterizationOrderFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_rasterization_order\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct AmdRasterizationOrderFn {} +unsafe impl Send for AmdRasterizationOrderFn {} +unsafe impl Sync for AmdRasterizationOrderFn {} +impl AmdRasterizationOrderFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_AMD_rasterization_order'"] +impl StructureType { + pub const PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD: Self = Self(1_000_018_000); +} +impl AmdExtension20Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_20\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct AmdExtension20Fn {} +unsafe impl Send for AmdExtension20Fn {} +unsafe impl Sync for AmdExtension20Fn {} +impl AmdExtension20Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl AmdShaderTrinaryMinmaxFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_shader_trinary_minmax\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct AmdShaderTrinaryMinmaxFn {} +unsafe impl Send for AmdShaderTrinaryMinmaxFn {} +unsafe impl Sync for AmdShaderTrinaryMinmaxFn {} +impl AmdShaderTrinaryMinmaxFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl AmdShaderExplicitVertexParameterFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"VK_AMD_shader_explicit_vertex_parameter\0", + ) + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct AmdShaderExplicitVertexParameterFn {} +unsafe impl Send for AmdShaderExplicitVertexParameterFn {} +unsafe impl Sync for AmdShaderExplicitVertexParameterFn {} +impl AmdShaderExplicitVertexParameterFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtDebugMarkerFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_debug_marker\0") } + } + pub const SPEC_VERSION: u32 = 4u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkDebugMarkerSetObjectTagEXT = unsafe extern "system" fn( + device: Device, + p_tag_info: *const DebugMarkerObjectTagInfoEXT, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkDebugMarkerSetObjectNameEXT = unsafe extern "system" fn( + device: Device, + p_name_info: *const DebugMarkerObjectNameInfoEXT, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkCmdDebugMarkerBeginEXT = unsafe extern "system" fn( + command_buffer: CommandBuffer, + p_marker_info: *const DebugMarkerMarkerInfoEXT, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdDebugMarkerEndEXT = unsafe extern "system" fn(command_buffer: CommandBuffer); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdDebugMarkerInsertEXT = unsafe extern "system" fn( + command_buffer: CommandBuffer, + p_marker_info: *const DebugMarkerMarkerInfoEXT, +); +#[derive(Clone)] +pub struct ExtDebugMarkerFn { + pub debug_marker_set_object_tag_ext: PFN_vkDebugMarkerSetObjectTagEXT, + pub debug_marker_set_object_name_ext: PFN_vkDebugMarkerSetObjectNameEXT, + pub cmd_debug_marker_begin_ext: PFN_vkCmdDebugMarkerBeginEXT, + pub cmd_debug_marker_end_ext: PFN_vkCmdDebugMarkerEndEXT, + pub cmd_debug_marker_insert_ext: PFN_vkCmdDebugMarkerInsertEXT, +} +unsafe impl Send for ExtDebugMarkerFn {} +unsafe impl Sync for ExtDebugMarkerFn {} +impl ExtDebugMarkerFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + debug_marker_set_object_tag_ext: unsafe { + unsafe extern "system" fn debug_marker_set_object_tag_ext( + _device: Device, + _p_tag_info: *const DebugMarkerObjectTagInfoEXT, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(debug_marker_set_object_tag_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkDebugMarkerSetObjectTagEXT\0", + ); + let val = _f(cname); + if val.is_null() { + debug_marker_set_object_tag_ext + } else { + ::std::mem::transmute(val) + } + }, + debug_marker_set_object_name_ext: unsafe { + unsafe extern "system" fn debug_marker_set_object_name_ext( + _device: Device, + _p_name_info: *const DebugMarkerObjectNameInfoEXT, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(debug_marker_set_object_name_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkDebugMarkerSetObjectNameEXT\0", + ); + let val = _f(cname); + if val.is_null() { + debug_marker_set_object_name_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_debug_marker_begin_ext: unsafe { + unsafe extern "system" fn cmd_debug_marker_begin_ext( + _command_buffer: CommandBuffer, + _p_marker_info: *const DebugMarkerMarkerInfoEXT, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_debug_marker_begin_ext) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdDebugMarkerBeginEXT\0"); + let val = _f(cname); + if val.is_null() { + cmd_debug_marker_begin_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_debug_marker_end_ext: unsafe { + unsafe extern "system" fn cmd_debug_marker_end_ext(_command_buffer: CommandBuffer) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_debug_marker_end_ext) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdDebugMarkerEndEXT\0"); + let val = _f(cname); + if val.is_null() { + cmd_debug_marker_end_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_debug_marker_insert_ext: unsafe { + unsafe extern "system" fn cmd_debug_marker_insert_ext( + _command_buffer: CommandBuffer, + _p_marker_info: *const DebugMarkerMarkerInfoEXT, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_debug_marker_insert_ext) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdDebugMarkerInsertEXT\0"); + let val = _f(cname); + if val.is_null() { + cmd_debug_marker_insert_ext + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_EXT_debug_marker'"] +impl StructureType { + pub const DEBUG_MARKER_OBJECT_NAME_INFO_EXT: Self = Self(1_000_022_000); + pub const DEBUG_MARKER_OBJECT_TAG_INFO_EXT: Self = Self(1_000_022_001); + pub const DEBUG_MARKER_MARKER_INFO_EXT: Self = Self(1_000_022_002); +} +impl KhrVideoQueueFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_video_queue\0") } + } + pub const SPEC_VERSION: u32 = 8u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkGetPhysicalDeviceVideoCapabilitiesKHR = unsafe extern "system" fn( + physical_device: PhysicalDevice, + p_video_profile: *const VideoProfileInfoKHR, + p_capabilities: *mut VideoCapabilitiesKHR, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetPhysicalDeviceVideoFormatPropertiesKHR = unsafe extern "system" fn( + physical_device: PhysicalDevice, + p_video_format_info: *const PhysicalDeviceVideoFormatInfoKHR, + p_video_format_property_count: *mut u32, + p_video_format_properties: *mut VideoFormatPropertiesKHR, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkCreateVideoSessionKHR = unsafe extern "system" fn( + device: Device, + p_create_info: *const VideoSessionCreateInfoKHR, + p_allocator: *const AllocationCallbacks, + p_video_session: *mut VideoSessionKHR, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkDestroyVideoSessionKHR = unsafe extern "system" fn( + device: Device, + video_session: VideoSessionKHR, + p_allocator: *const AllocationCallbacks, +); +#[allow(non_camel_case_types)] +pub type PFN_vkGetVideoSessionMemoryRequirementsKHR = unsafe extern "system" fn( + device: Device, + video_session: VideoSessionKHR, + p_memory_requirements_count: *mut u32, + p_memory_requirements: *mut VideoSessionMemoryRequirementsKHR, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkBindVideoSessionMemoryKHR = unsafe extern "system" fn( + device: Device, + video_session: VideoSessionKHR, + bind_session_memory_info_count: u32, + p_bind_session_memory_infos: *const BindVideoSessionMemoryInfoKHR, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkCreateVideoSessionParametersKHR = unsafe extern "system" fn( + device: Device, + p_create_info: *const VideoSessionParametersCreateInfoKHR, + p_allocator: *const AllocationCallbacks, + p_video_session_parameters: *mut VideoSessionParametersKHR, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkUpdateVideoSessionParametersKHR = unsafe extern "system" fn( + device: Device, + video_session_parameters: VideoSessionParametersKHR, + p_update_info: *const VideoSessionParametersUpdateInfoKHR, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkDestroyVideoSessionParametersKHR = unsafe extern "system" fn( + device: Device, + video_session_parameters: VideoSessionParametersKHR, + p_allocator: *const AllocationCallbacks, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdBeginVideoCodingKHR = unsafe extern "system" fn( + command_buffer: CommandBuffer, + p_begin_info: *const VideoBeginCodingInfoKHR, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdEndVideoCodingKHR = unsafe extern "system" fn( + command_buffer: CommandBuffer, + p_end_coding_info: *const VideoEndCodingInfoKHR, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdControlVideoCodingKHR = unsafe extern "system" fn( + command_buffer: CommandBuffer, + p_coding_control_info: *const VideoCodingControlInfoKHR, +); +#[derive(Clone)] +pub struct KhrVideoQueueFn { + pub get_physical_device_video_capabilities_khr: PFN_vkGetPhysicalDeviceVideoCapabilitiesKHR, + pub get_physical_device_video_format_properties_khr: + PFN_vkGetPhysicalDeviceVideoFormatPropertiesKHR, + pub create_video_session_khr: PFN_vkCreateVideoSessionKHR, + pub destroy_video_session_khr: PFN_vkDestroyVideoSessionKHR, + pub get_video_session_memory_requirements_khr: PFN_vkGetVideoSessionMemoryRequirementsKHR, + pub bind_video_session_memory_khr: PFN_vkBindVideoSessionMemoryKHR, + pub create_video_session_parameters_khr: PFN_vkCreateVideoSessionParametersKHR, + pub update_video_session_parameters_khr: PFN_vkUpdateVideoSessionParametersKHR, + pub destroy_video_session_parameters_khr: PFN_vkDestroyVideoSessionParametersKHR, + pub cmd_begin_video_coding_khr: PFN_vkCmdBeginVideoCodingKHR, + pub cmd_end_video_coding_khr: PFN_vkCmdEndVideoCodingKHR, + pub cmd_control_video_coding_khr: PFN_vkCmdControlVideoCodingKHR, +} +unsafe impl Send for KhrVideoQueueFn {} +unsafe impl Sync for KhrVideoQueueFn {} +impl KhrVideoQueueFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + get_physical_device_video_capabilities_khr: unsafe { + unsafe extern "system" fn get_physical_device_video_capabilities_khr( + _physical_device: PhysicalDevice, + _p_video_profile: *const VideoProfileInfoKHR, + _p_capabilities: *mut VideoCapabilitiesKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_video_capabilities_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPhysicalDeviceVideoCapabilitiesKHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_physical_device_video_capabilities_khr + } else { + ::std::mem::transmute(val) + } + }, + get_physical_device_video_format_properties_khr: unsafe { + unsafe extern "system" fn get_physical_device_video_format_properties_khr( + _physical_device: PhysicalDevice, + _p_video_format_info: *const PhysicalDeviceVideoFormatInfoKHR, + _p_video_format_property_count: *mut u32, + _p_video_format_properties: *mut VideoFormatPropertiesKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_video_format_properties_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPhysicalDeviceVideoFormatPropertiesKHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_physical_device_video_format_properties_khr + } else { + ::std::mem::transmute(val) + } + }, + create_video_session_khr: unsafe { + unsafe extern "system" fn create_video_session_khr( + _device: Device, + _p_create_info: *const VideoSessionCreateInfoKHR, + _p_allocator: *const AllocationCallbacks, + _p_video_session: *mut VideoSessionKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(create_video_session_khr) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateVideoSessionKHR\0"); + let val = _f(cname); + if val.is_null() { + create_video_session_khr + } else { + ::std::mem::transmute(val) + } + }, + destroy_video_session_khr: unsafe { + unsafe extern "system" fn destroy_video_session_khr( + _device: Device, + _video_session: VideoSessionKHR, + _p_allocator: *const AllocationCallbacks, + ) { + panic!(concat!( + "Unable to load ", + stringify!(destroy_video_session_khr) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyVideoSessionKHR\0"); + let val = _f(cname); + if val.is_null() { + destroy_video_session_khr + } else { + ::std::mem::transmute(val) + } + }, + get_video_session_memory_requirements_khr: unsafe { + unsafe extern "system" fn get_video_session_memory_requirements_khr( + _device: Device, + _video_session: VideoSessionKHR, + _p_memory_requirements_count: *mut u32, + _p_memory_requirements: *mut VideoSessionMemoryRequirementsKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_video_session_memory_requirements_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetVideoSessionMemoryRequirementsKHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_video_session_memory_requirements_khr + } else { + ::std::mem::transmute(val) + } + }, + bind_video_session_memory_khr: unsafe { + unsafe extern "system" fn bind_video_session_memory_khr( + _device: Device, + _video_session: VideoSessionKHR, + _bind_session_memory_info_count: u32, + _p_bind_session_memory_infos: *const BindVideoSessionMemoryInfoKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(bind_video_session_memory_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkBindVideoSessionMemoryKHR\0", + ); + let val = _f(cname); + if val.is_null() { + bind_video_session_memory_khr + } else { + ::std::mem::transmute(val) + } + }, + create_video_session_parameters_khr: unsafe { + unsafe extern "system" fn create_video_session_parameters_khr( + _device: Device, + _p_create_info: *const VideoSessionParametersCreateInfoKHR, + _p_allocator: *const AllocationCallbacks, + _p_video_session_parameters: *mut VideoSessionParametersKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(create_video_session_parameters_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCreateVideoSessionParametersKHR\0", + ); + let val = _f(cname); + if val.is_null() { + create_video_session_parameters_khr + } else { + ::std::mem::transmute(val) + } + }, + update_video_session_parameters_khr: unsafe { + unsafe extern "system" fn update_video_session_parameters_khr( + _device: Device, + _video_session_parameters: VideoSessionParametersKHR, + _p_update_info: *const VideoSessionParametersUpdateInfoKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(update_video_session_parameters_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkUpdateVideoSessionParametersKHR\0", + ); + let val = _f(cname); + if val.is_null() { + update_video_session_parameters_khr + } else { + ::std::mem::transmute(val) + } + }, + destroy_video_session_parameters_khr: unsafe { + unsafe extern "system" fn destroy_video_session_parameters_khr( + _device: Device, + _video_session_parameters: VideoSessionParametersKHR, + _p_allocator: *const AllocationCallbacks, + ) { + panic!(concat!( + "Unable to load ", + stringify!(destroy_video_session_parameters_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkDestroyVideoSessionParametersKHR\0", + ); + let val = _f(cname); + if val.is_null() { + destroy_video_session_parameters_khr + } else { + ::std::mem::transmute(val) + } + }, + cmd_begin_video_coding_khr: unsafe { + unsafe extern "system" fn cmd_begin_video_coding_khr( + _command_buffer: CommandBuffer, + _p_begin_info: *const VideoBeginCodingInfoKHR, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_begin_video_coding_khr) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdBeginVideoCodingKHR\0"); + let val = _f(cname); + if val.is_null() { + cmd_begin_video_coding_khr + } else { + ::std::mem::transmute(val) + } + }, + cmd_end_video_coding_khr: unsafe { + unsafe extern "system" fn cmd_end_video_coding_khr( + _command_buffer: CommandBuffer, + _p_end_coding_info: *const VideoEndCodingInfoKHR, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_end_video_coding_khr) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdEndVideoCodingKHR\0"); + let val = _f(cname); + if val.is_null() { + cmd_end_video_coding_khr + } else { + ::std::mem::transmute(val) + } + }, + cmd_control_video_coding_khr: unsafe { + unsafe extern "system" fn cmd_control_video_coding_khr( + _command_buffer: CommandBuffer, + _p_coding_control_info: *const VideoCodingControlInfoKHR, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_control_video_coding_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdControlVideoCodingKHR\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_control_video_coding_khr + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_KHR_video_queue'"] +impl ObjectType { + #[doc = "VkVideoSessionKHR"] + pub const VIDEO_SESSION_KHR: Self = Self(1_000_023_000); + #[doc = "VkVideoSessionParametersKHR"] + pub const VIDEO_SESSION_PARAMETERS_KHR: Self = Self(1_000_023_001); +} +#[doc = "Generated from 'VK_KHR_video_queue'"] +impl QueryResultFlags { + pub const WITH_STATUS_KHR: Self = Self(0b1_0000); +} +#[doc = "Generated from 'VK_KHR_video_queue'"] +impl QueryType { + pub const RESULT_STATUS_ONLY_KHR: Self = Self(1_000_023_000); +} +#[doc = "Generated from 'VK_KHR_video_queue'"] +impl Result { + pub const ERROR_IMAGE_USAGE_NOT_SUPPORTED_KHR: Self = Self(-1_000_023_000); + pub const ERROR_VIDEO_PICTURE_LAYOUT_NOT_SUPPORTED_KHR: Self = Self(-1_000_023_001); + pub const ERROR_VIDEO_PROFILE_OPERATION_NOT_SUPPORTED_KHR: Self = Self(-1_000_023_002); + pub const ERROR_VIDEO_PROFILE_FORMAT_NOT_SUPPORTED_KHR: Self = Self(-1_000_023_003); + pub const ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR: Self = Self(-1_000_023_004); + pub const ERROR_VIDEO_STD_VERSION_NOT_SUPPORTED_KHR: Self = Self(-1_000_023_005); +} +#[doc = "Generated from 'VK_KHR_video_queue'"] +impl StructureType { + pub const VIDEO_PROFILE_INFO_KHR: Self = Self(1_000_023_000); + pub const VIDEO_CAPABILITIES_KHR: Self = Self(1_000_023_001); + pub const VIDEO_PICTURE_RESOURCE_INFO_KHR: Self = Self(1_000_023_002); + pub const VIDEO_SESSION_MEMORY_REQUIREMENTS_KHR: Self = Self(1_000_023_003); + pub const BIND_VIDEO_SESSION_MEMORY_INFO_KHR: Self = Self(1_000_023_004); + pub const VIDEO_SESSION_CREATE_INFO_KHR: Self = Self(1_000_023_005); + pub const VIDEO_SESSION_PARAMETERS_CREATE_INFO_KHR: Self = Self(1_000_023_006); + pub const VIDEO_SESSION_PARAMETERS_UPDATE_INFO_KHR: Self = Self(1_000_023_007); + pub const VIDEO_BEGIN_CODING_INFO_KHR: Self = Self(1_000_023_008); + pub const VIDEO_END_CODING_INFO_KHR: Self = Self(1_000_023_009); + pub const VIDEO_CODING_CONTROL_INFO_KHR: Self = Self(1_000_023_010); + pub const VIDEO_REFERENCE_SLOT_INFO_KHR: Self = Self(1_000_023_011); + pub const QUEUE_FAMILY_VIDEO_PROPERTIES_KHR: Self = Self(1_000_023_012); + pub const VIDEO_PROFILE_LIST_INFO_KHR: Self = Self(1_000_023_013); + pub const PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR: Self = Self(1_000_023_014); + pub const VIDEO_FORMAT_PROPERTIES_KHR: Self = Self(1_000_023_015); + pub const QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_KHR: Self = Self(1_000_023_016); +} +impl KhrVideoDecodeQueueFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_video_decode_queue\0") } + } + pub const SPEC_VERSION: u32 = 7u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkCmdDecodeVideoKHR = unsafe extern "system" fn( + command_buffer: CommandBuffer, + p_decode_info: *const VideoDecodeInfoKHR, +); +#[derive(Clone)] +pub struct KhrVideoDecodeQueueFn { + pub cmd_decode_video_khr: PFN_vkCmdDecodeVideoKHR, +} +unsafe impl Send for KhrVideoDecodeQueueFn {} +unsafe impl Sync for KhrVideoDecodeQueueFn {} +impl KhrVideoDecodeQueueFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + cmd_decode_video_khr: unsafe { + unsafe extern "system" fn cmd_decode_video_khr( + _command_buffer: CommandBuffer, + _p_decode_info: *const VideoDecodeInfoKHR, + ) { + panic!(concat!("Unable to load ", stringify!(cmd_decode_video_khr))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdDecodeVideoKHR\0"); + let val = _f(cname); + if val.is_null() { + cmd_decode_video_khr + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_KHR_video_decode_queue'"] +impl AccessFlags2 { + pub const VIDEO_DECODE_READ_KHR: Self = Self(0b1000_0000_0000_0000_0000_0000_0000_0000_0000); + pub const VIDEO_DECODE_WRITE_KHR: Self = Self(0b1_0000_0000_0000_0000_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_KHR_video_decode_queue'"] +impl BufferUsageFlags { + pub const VIDEO_DECODE_SRC_KHR: Self = Self(0b10_0000_0000_0000); + pub const VIDEO_DECODE_DST_KHR: Self = Self(0b100_0000_0000_0000); +} +#[doc = "Generated from 'VK_KHR_video_decode_queue'"] +impl FormatFeatureFlags { + pub const VIDEO_DECODE_OUTPUT_KHR: Self = Self(0b10_0000_0000_0000_0000_0000_0000); + pub const VIDEO_DECODE_DPB_KHR: Self = Self(0b100_0000_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_KHR_video_decode_queue'"] +impl FormatFeatureFlags2 { + pub const VIDEO_DECODE_OUTPUT_KHR: Self = Self(0b10_0000_0000_0000_0000_0000_0000); + pub const VIDEO_DECODE_DPB_KHR: Self = Self(0b100_0000_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_KHR_video_decode_queue'"] +impl ImageLayout { + pub const VIDEO_DECODE_DST_KHR: Self = Self(1_000_024_000); + pub const VIDEO_DECODE_SRC_KHR: Self = Self(1_000_024_001); + pub const VIDEO_DECODE_DPB_KHR: Self = Self(1_000_024_002); +} +#[doc = "Generated from 'VK_KHR_video_decode_queue'"] +impl ImageUsageFlags { + pub const VIDEO_DECODE_DST_KHR: Self = Self(0b100_0000_0000); + pub const VIDEO_DECODE_SRC_KHR: Self = Self(0b1000_0000_0000); + pub const VIDEO_DECODE_DPB_KHR: Self = Self(0b1_0000_0000_0000); +} +#[doc = "Generated from 'VK_KHR_video_decode_queue'"] +impl PipelineStageFlags2 { + pub const VIDEO_DECODE_KHR: Self = Self(0b100_0000_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_KHR_video_decode_queue'"] +impl QueueFlags { + pub const VIDEO_DECODE_KHR: Self = Self(0b10_0000); +} +#[doc = "Generated from 'VK_KHR_video_decode_queue'"] +impl StructureType { + pub const VIDEO_DECODE_INFO_KHR: Self = Self(1_000_024_000); + pub const VIDEO_DECODE_CAPABILITIES_KHR: Self = Self(1_000_024_001); + pub const VIDEO_DECODE_USAGE_INFO_KHR: Self = Self(1_000_024_002); +} +impl AmdGcnShaderFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_gcn_shader\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct AmdGcnShaderFn {} +unsafe impl Send for AmdGcnShaderFn {} +unsafe impl Sync for AmdGcnShaderFn {} +impl AmdGcnShaderFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl NvDedicatedAllocationFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_dedicated_allocation\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct NvDedicatedAllocationFn {} +unsafe impl Send for NvDedicatedAllocationFn {} +unsafe impl Sync for NvDedicatedAllocationFn {} +impl NvDedicatedAllocationFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_NV_dedicated_allocation'"] +impl StructureType { + pub const DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV: Self = Self(1_000_026_000); + pub const DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV: Self = Self(1_000_026_001); + pub const DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV: Self = Self(1_000_026_002); +} +impl ExtExtension28Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_28\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct ExtExtension28Fn {} +unsafe impl Send for ExtExtension28Fn {} +unsafe impl Sync for ExtExtension28Fn {} +impl ExtExtension28Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtTransformFeedbackFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_transform_feedback\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkCmdBindTransformFeedbackBuffersEXT = unsafe extern "system" fn( + command_buffer: CommandBuffer, + first_binding: u32, + binding_count: u32, + p_buffers: *const Buffer, + p_offsets: *const DeviceSize, + p_sizes: *const DeviceSize, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdBeginTransformFeedbackEXT = unsafe extern "system" fn( + command_buffer: CommandBuffer, + first_counter_buffer: u32, + counter_buffer_count: u32, + p_counter_buffers: *const Buffer, + p_counter_buffer_offsets: *const DeviceSize, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdEndTransformFeedbackEXT = unsafe extern "system" fn( + command_buffer: CommandBuffer, + first_counter_buffer: u32, + counter_buffer_count: u32, + p_counter_buffers: *const Buffer, + p_counter_buffer_offsets: *const DeviceSize, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdBeginQueryIndexedEXT = unsafe extern "system" fn( + command_buffer: CommandBuffer, + query_pool: QueryPool, + query: u32, + flags: QueryControlFlags, + index: u32, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdEndQueryIndexedEXT = unsafe extern "system" fn( + command_buffer: CommandBuffer, + query_pool: QueryPool, + query: u32, + index: u32, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdDrawIndirectByteCountEXT = unsafe extern "system" fn( + command_buffer: CommandBuffer, + instance_count: u32, + first_instance: u32, + counter_buffer: Buffer, + counter_buffer_offset: DeviceSize, + counter_offset: u32, + vertex_stride: u32, +); +#[derive(Clone)] +pub struct ExtTransformFeedbackFn { + pub cmd_bind_transform_feedback_buffers_ext: PFN_vkCmdBindTransformFeedbackBuffersEXT, + pub cmd_begin_transform_feedback_ext: PFN_vkCmdBeginTransformFeedbackEXT, + pub cmd_end_transform_feedback_ext: PFN_vkCmdEndTransformFeedbackEXT, + pub cmd_begin_query_indexed_ext: PFN_vkCmdBeginQueryIndexedEXT, + pub cmd_end_query_indexed_ext: PFN_vkCmdEndQueryIndexedEXT, + pub cmd_draw_indirect_byte_count_ext: PFN_vkCmdDrawIndirectByteCountEXT, +} +unsafe impl Send for ExtTransformFeedbackFn {} +unsafe impl Sync for ExtTransformFeedbackFn {} +impl ExtTransformFeedbackFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + cmd_bind_transform_feedback_buffers_ext: unsafe { + unsafe extern "system" fn cmd_bind_transform_feedback_buffers_ext( + _command_buffer: CommandBuffer, + _first_binding: u32, + _binding_count: u32, + _p_buffers: *const Buffer, + _p_offsets: *const DeviceSize, + _p_sizes: *const DeviceSize, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_bind_transform_feedback_buffers_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdBindTransformFeedbackBuffersEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_bind_transform_feedback_buffers_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_begin_transform_feedback_ext: unsafe { + unsafe extern "system" fn cmd_begin_transform_feedback_ext( + _command_buffer: CommandBuffer, + _first_counter_buffer: u32, + _counter_buffer_count: u32, + _p_counter_buffers: *const Buffer, + _p_counter_buffer_offsets: *const DeviceSize, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_begin_transform_feedback_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdBeginTransformFeedbackEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_begin_transform_feedback_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_end_transform_feedback_ext: unsafe { + unsafe extern "system" fn cmd_end_transform_feedback_ext( + _command_buffer: CommandBuffer, + _first_counter_buffer: u32, + _counter_buffer_count: u32, + _p_counter_buffers: *const Buffer, + _p_counter_buffer_offsets: *const DeviceSize, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_end_transform_feedback_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdEndTransformFeedbackEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_end_transform_feedback_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_begin_query_indexed_ext: unsafe { + unsafe extern "system" fn cmd_begin_query_indexed_ext( + _command_buffer: CommandBuffer, + _query_pool: QueryPool, + _query: u32, + _flags: QueryControlFlags, + _index: u32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_begin_query_indexed_ext) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdBeginQueryIndexedEXT\0"); + let val = _f(cname); + if val.is_null() { + cmd_begin_query_indexed_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_end_query_indexed_ext: unsafe { + unsafe extern "system" fn cmd_end_query_indexed_ext( + _command_buffer: CommandBuffer, + _query_pool: QueryPool, + _query: u32, + _index: u32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_end_query_indexed_ext) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdEndQueryIndexedEXT\0"); + let val = _f(cname); + if val.is_null() { + cmd_end_query_indexed_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_draw_indirect_byte_count_ext: unsafe { + unsafe extern "system" fn cmd_draw_indirect_byte_count_ext( + _command_buffer: CommandBuffer, + _instance_count: u32, + _first_instance: u32, + _counter_buffer: Buffer, + _counter_buffer_offset: DeviceSize, + _counter_offset: u32, + _vertex_stride: u32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_draw_indirect_byte_count_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdDrawIndirectByteCountEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_draw_indirect_byte_count_ext + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_EXT_transform_feedback'"] +impl AccessFlags { + pub const TRANSFORM_FEEDBACK_WRITE_EXT: Self = Self(0b10_0000_0000_0000_0000_0000_0000); + pub const TRANSFORM_FEEDBACK_COUNTER_READ_EXT: Self = Self(0b100_0000_0000_0000_0000_0000_0000); + pub const TRANSFORM_FEEDBACK_COUNTER_WRITE_EXT: Self = + Self(0b1000_0000_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_EXT_transform_feedback'"] +impl BufferUsageFlags { + pub const TRANSFORM_FEEDBACK_BUFFER_EXT: Self = Self(0b1000_0000_0000); + pub const TRANSFORM_FEEDBACK_COUNTER_BUFFER_EXT: Self = Self(0b1_0000_0000_0000); +} +#[doc = "Generated from 'VK_EXT_transform_feedback'"] +impl PipelineStageFlags { + pub const TRANSFORM_FEEDBACK_EXT: Self = Self(0b1_0000_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_EXT_transform_feedback'"] +impl QueryType { + pub const TRANSFORM_FEEDBACK_STREAM_EXT: Self = Self(1_000_028_004); +} +#[doc = "Generated from 'VK_EXT_transform_feedback'"] +impl StructureType { + pub const PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT: Self = Self(1_000_028_000); + pub const PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT: Self = Self(1_000_028_001); + pub const PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT: Self = Self(1_000_028_002); +} +impl NvxBinaryImportFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NVX_binary_import\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkCreateCuModuleNVX = unsafe extern "system" fn( + device: Device, + p_create_info: *const CuModuleCreateInfoNVX, + p_allocator: *const AllocationCallbacks, + p_module: *mut CuModuleNVX, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkCreateCuFunctionNVX = unsafe extern "system" fn( + device: Device, + p_create_info: *const CuFunctionCreateInfoNVX, + p_allocator: *const AllocationCallbacks, + p_function: *mut CuFunctionNVX, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkDestroyCuModuleNVX = unsafe extern "system" fn( + device: Device, + module: CuModuleNVX, + p_allocator: *const AllocationCallbacks, +); +#[allow(non_camel_case_types)] +pub type PFN_vkDestroyCuFunctionNVX = unsafe extern "system" fn( + device: Device, + function: CuFunctionNVX, + p_allocator: *const AllocationCallbacks, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdCuLaunchKernelNVX = + unsafe extern "system" fn(command_buffer: CommandBuffer, p_launch_info: *const CuLaunchInfoNVX); +#[derive(Clone)] +pub struct NvxBinaryImportFn { + pub create_cu_module_nvx: PFN_vkCreateCuModuleNVX, + pub create_cu_function_nvx: PFN_vkCreateCuFunctionNVX, + pub destroy_cu_module_nvx: PFN_vkDestroyCuModuleNVX, + pub destroy_cu_function_nvx: PFN_vkDestroyCuFunctionNVX, + pub cmd_cu_launch_kernel_nvx: PFN_vkCmdCuLaunchKernelNVX, +} +unsafe impl Send for NvxBinaryImportFn {} +unsafe impl Sync for NvxBinaryImportFn {} +impl NvxBinaryImportFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + create_cu_module_nvx: unsafe { + unsafe extern "system" fn create_cu_module_nvx( + _device: Device, + _p_create_info: *const CuModuleCreateInfoNVX, + _p_allocator: *const AllocationCallbacks, + _p_module: *mut CuModuleNVX, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(create_cu_module_nvx))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateCuModuleNVX\0"); + let val = _f(cname); + if val.is_null() { + create_cu_module_nvx + } else { + ::std::mem::transmute(val) + } + }, + create_cu_function_nvx: unsafe { + unsafe extern "system" fn create_cu_function_nvx( + _device: Device, + _p_create_info: *const CuFunctionCreateInfoNVX, + _p_allocator: *const AllocationCallbacks, + _p_function: *mut CuFunctionNVX, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(create_cu_function_nvx) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateCuFunctionNVX\0"); + let val = _f(cname); + if val.is_null() { + create_cu_function_nvx + } else { + ::std::mem::transmute(val) + } + }, + destroy_cu_module_nvx: unsafe { + unsafe extern "system" fn destroy_cu_module_nvx( + _device: Device, + _module: CuModuleNVX, + _p_allocator: *const AllocationCallbacks, + ) { + panic!(concat!( + "Unable to load ", + stringify!(destroy_cu_module_nvx) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyCuModuleNVX\0"); + let val = _f(cname); + if val.is_null() { + destroy_cu_module_nvx + } else { + ::std::mem::transmute(val) + } + }, + destroy_cu_function_nvx: unsafe { + unsafe extern "system" fn destroy_cu_function_nvx( + _device: Device, + _function: CuFunctionNVX, + _p_allocator: *const AllocationCallbacks, + ) { + panic!(concat!( + "Unable to load ", + stringify!(destroy_cu_function_nvx) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyCuFunctionNVX\0"); + let val = _f(cname); + if val.is_null() { + destroy_cu_function_nvx + } else { + ::std::mem::transmute(val) + } + }, + cmd_cu_launch_kernel_nvx: unsafe { + unsafe extern "system" fn cmd_cu_launch_kernel_nvx( + _command_buffer: CommandBuffer, + _p_launch_info: *const CuLaunchInfoNVX, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_cu_launch_kernel_nvx) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdCuLaunchKernelNVX\0"); + let val = _f(cname); + if val.is_null() { + cmd_cu_launch_kernel_nvx + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_NVX_binary_import'"] +impl DebugReportObjectTypeEXT { + pub const CU_MODULE_NVX: Self = Self(1_000_029_000); + pub const CU_FUNCTION_NVX: Self = Self(1_000_029_001); +} +#[doc = "Generated from 'VK_NVX_binary_import'"] +impl ObjectType { + pub const CU_MODULE_NVX: Self = Self(1_000_029_000); + pub const CU_FUNCTION_NVX: Self = Self(1_000_029_001); +} +#[doc = "Generated from 'VK_NVX_binary_import'"] +impl StructureType { + pub const CU_MODULE_CREATE_INFO_NVX: Self = Self(1_000_029_000); + pub const CU_FUNCTION_CREATE_INFO_NVX: Self = Self(1_000_029_001); + pub const CU_LAUNCH_INFO_NVX: Self = Self(1_000_029_002); +} +impl NvxImageViewHandleFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NVX_image_view_handle\0") } + } + pub const SPEC_VERSION: u32 = 2u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkGetImageViewHandleNVX = + unsafe extern "system" fn(device: Device, p_info: *const ImageViewHandleInfoNVX) -> u32; +#[allow(non_camel_case_types)] +pub type PFN_vkGetImageViewAddressNVX = unsafe extern "system" fn( + device: Device, + image_view: ImageView, + p_properties: *mut ImageViewAddressPropertiesNVX, +) -> Result; +#[derive(Clone)] +pub struct NvxImageViewHandleFn { + pub get_image_view_handle_nvx: PFN_vkGetImageViewHandleNVX, + pub get_image_view_address_nvx: PFN_vkGetImageViewAddressNVX, +} +unsafe impl Send for NvxImageViewHandleFn {} +unsafe impl Sync for NvxImageViewHandleFn {} +impl NvxImageViewHandleFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + get_image_view_handle_nvx: unsafe { + unsafe extern "system" fn get_image_view_handle_nvx( + _device: Device, + _p_info: *const ImageViewHandleInfoNVX, + ) -> u32 { + panic!(concat!( + "Unable to load ", + stringify!(get_image_view_handle_nvx) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetImageViewHandleNVX\0"); + let val = _f(cname); + if val.is_null() { + get_image_view_handle_nvx + } else { + ::std::mem::transmute(val) + } + }, + get_image_view_address_nvx: unsafe { + unsafe extern "system" fn get_image_view_address_nvx( + _device: Device, + _image_view: ImageView, + _p_properties: *mut ImageViewAddressPropertiesNVX, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_image_view_address_nvx) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetImageViewAddressNVX\0"); + let val = _f(cname); + if val.is_null() { + get_image_view_address_nvx + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_NVX_image_view_handle'"] +impl StructureType { + pub const IMAGE_VIEW_HANDLE_INFO_NVX: Self = Self(1_000_030_000); + pub const IMAGE_VIEW_ADDRESS_PROPERTIES_NVX: Self = Self(1_000_030_001); +} +impl AmdExtension32Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_32\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct AmdExtension32Fn {} +unsafe impl Send for AmdExtension32Fn {} +unsafe impl Sync for AmdExtension32Fn {} +impl AmdExtension32Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl AmdExtension33Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_33\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct AmdExtension33Fn {} +unsafe impl Send for AmdExtension33Fn {} +unsafe impl Sync for AmdExtension33Fn {} +impl AmdExtension33Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl AmdDrawIndirectCountFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_draw_indirect_count\0") } + } + pub const SPEC_VERSION: u32 = 2u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkCmdDrawIndirectCount = unsafe extern "system" fn( + command_buffer: CommandBuffer, + buffer: Buffer, + offset: DeviceSize, + count_buffer: Buffer, + count_buffer_offset: DeviceSize, + max_draw_count: u32, + stride: u32, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdDrawIndexedIndirectCount = unsafe extern "system" fn( + command_buffer: CommandBuffer, + buffer: Buffer, + offset: DeviceSize, + count_buffer: Buffer, + count_buffer_offset: DeviceSize, + max_draw_count: u32, + stride: u32, +); +#[derive(Clone)] +pub struct AmdDrawIndirectCountFn { + pub cmd_draw_indirect_count_amd: PFN_vkCmdDrawIndirectCount, + pub cmd_draw_indexed_indirect_count_amd: PFN_vkCmdDrawIndexedIndirectCount, +} +unsafe impl Send for AmdDrawIndirectCountFn {} +unsafe impl Sync for AmdDrawIndirectCountFn {} +impl AmdDrawIndirectCountFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + cmd_draw_indirect_count_amd: unsafe { + unsafe extern "system" fn cmd_draw_indirect_count_amd( + _command_buffer: CommandBuffer, + _buffer: Buffer, + _offset: DeviceSize, + _count_buffer: Buffer, + _count_buffer_offset: DeviceSize, + _max_draw_count: u32, + _stride: u32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_draw_indirect_count_amd) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdDrawIndirectCountAMD\0"); + let val = _f(cname); + if val.is_null() { + cmd_draw_indirect_count_amd + } else { + ::std::mem::transmute(val) + } + }, + cmd_draw_indexed_indirect_count_amd: unsafe { + unsafe extern "system" fn cmd_draw_indexed_indirect_count_amd( + _command_buffer: CommandBuffer, + _buffer: Buffer, + _offset: DeviceSize, + _count_buffer: Buffer, + _count_buffer_offset: DeviceSize, + _max_draw_count: u32, + _stride: u32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_draw_indexed_indirect_count_amd) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdDrawIndexedIndirectCountAMD\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_draw_indexed_indirect_count_amd + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +impl AmdExtension35Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_35\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct AmdExtension35Fn {} +unsafe impl Send for AmdExtension35Fn {} +unsafe impl Sync for AmdExtension35Fn {} +impl AmdExtension35Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl AmdNegativeViewportHeightFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_negative_viewport_height\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct AmdNegativeViewportHeightFn {} +unsafe impl Send for AmdNegativeViewportHeightFn {} +unsafe impl Sync for AmdNegativeViewportHeightFn {} +impl AmdNegativeViewportHeightFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl AmdGpuShaderHalfFloatFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_gpu_shader_half_float\0") + } + } + pub const SPEC_VERSION: u32 = 2u32; +} +#[derive(Clone)] +pub struct AmdGpuShaderHalfFloatFn {} +unsafe impl Send for AmdGpuShaderHalfFloatFn {} +unsafe impl Sync for AmdGpuShaderHalfFloatFn {} +impl AmdGpuShaderHalfFloatFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl AmdShaderBallotFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_shader_ballot\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct AmdShaderBallotFn {} +unsafe impl Send for AmdShaderBallotFn {} +unsafe impl Sync for AmdShaderBallotFn {} +impl AmdShaderBallotFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtVideoEncodeH264Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_video_encode_h264\0") } + } + pub const SPEC_VERSION: u32 = 9u32; +} +#[derive(Clone)] +pub struct ExtVideoEncodeH264Fn {} +unsafe impl Send for ExtVideoEncodeH264Fn {} +unsafe impl Sync for ExtVideoEncodeH264Fn {} +impl ExtVideoEncodeH264Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_video_encode_h264'"] +impl StructureType { + pub const VIDEO_ENCODE_H264_CAPABILITIES_EXT: Self = Self(1_000_038_000); + pub const VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT: Self = Self(1_000_038_001); + pub const VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT: Self = Self(1_000_038_002); + pub const VIDEO_ENCODE_H264_VCL_FRAME_INFO_EXT: Self = Self(1_000_038_003); + pub const VIDEO_ENCODE_H264_DPB_SLOT_INFO_EXT: Self = Self(1_000_038_004); + pub const VIDEO_ENCODE_H264_NALU_SLICE_INFO_EXT: Self = Self(1_000_038_005); + pub const VIDEO_ENCODE_H264_EMIT_PICTURE_PARAMETERS_INFO_EXT: Self = Self(1_000_038_006); + pub const VIDEO_ENCODE_H264_PROFILE_INFO_EXT: Self = Self(1_000_038_007); + pub const VIDEO_ENCODE_H264_RATE_CONTROL_INFO_EXT: Self = Self(1_000_038_008); + pub const VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_EXT: Self = Self(1_000_038_009); + pub const VIDEO_ENCODE_H264_REFERENCE_LISTS_INFO_EXT: Self = Self(1_000_038_010); +} +#[doc = "Generated from 'VK_EXT_video_encode_h264'"] +impl VideoCodecOperationFlagsKHR { + pub const ENCODE_H264_EXT: Self = Self(0b1_0000_0000_0000_0000); +} +impl ExtVideoEncodeH265Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_video_encode_h265\0") } + } + pub const SPEC_VERSION: u32 = 9u32; +} +#[derive(Clone)] +pub struct ExtVideoEncodeH265Fn {} +unsafe impl Send for ExtVideoEncodeH265Fn {} +unsafe impl Sync for ExtVideoEncodeH265Fn {} +impl ExtVideoEncodeH265Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_video_encode_h265'"] +impl StructureType { + pub const VIDEO_ENCODE_H265_CAPABILITIES_EXT: Self = Self(1_000_039_000); + pub const VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT: Self = Self(1_000_039_001); + pub const VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT: Self = Self(1_000_039_002); + pub const VIDEO_ENCODE_H265_VCL_FRAME_INFO_EXT: Self = Self(1_000_039_003); + pub const VIDEO_ENCODE_H265_DPB_SLOT_INFO_EXT: Self = Self(1_000_039_004); + pub const VIDEO_ENCODE_H265_NALU_SLICE_SEGMENT_INFO_EXT: Self = Self(1_000_039_005); + pub const VIDEO_ENCODE_H265_EMIT_PICTURE_PARAMETERS_INFO_EXT: Self = Self(1_000_039_006); + pub const VIDEO_ENCODE_H265_PROFILE_INFO_EXT: Self = Self(1_000_039_007); + pub const VIDEO_ENCODE_H265_REFERENCE_LISTS_INFO_EXT: Self = Self(1_000_039_008); + pub const VIDEO_ENCODE_H265_RATE_CONTROL_INFO_EXT: Self = Self(1_000_039_009); + pub const VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_EXT: Self = Self(1_000_039_010); +} +#[doc = "Generated from 'VK_EXT_video_encode_h265'"] +impl VideoCodecOperationFlagsKHR { + pub const ENCODE_H265_EXT: Self = Self(0b10_0000_0000_0000_0000); +} +impl KhrVideoDecodeH264Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_video_decode_h264\0") } + } + pub const SPEC_VERSION: u32 = 8u32; +} +#[derive(Clone)] +pub struct KhrVideoDecodeH264Fn {} +unsafe impl Send for KhrVideoDecodeH264Fn {} +unsafe impl Sync for KhrVideoDecodeH264Fn {} +impl KhrVideoDecodeH264Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_KHR_video_decode_h264'"] +impl StructureType { + pub const VIDEO_DECODE_H264_CAPABILITIES_KHR: Self = Self(1_000_040_000); + pub const VIDEO_DECODE_H264_PICTURE_INFO_KHR: Self = Self(1_000_040_001); + pub const VIDEO_DECODE_H264_PROFILE_INFO_KHR: Self = Self(1_000_040_003); + pub const VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR: Self = Self(1_000_040_004); + pub const VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR: Self = Self(1_000_040_005); + pub const VIDEO_DECODE_H264_DPB_SLOT_INFO_KHR: Self = Self(1_000_040_006); +} +#[doc = "Generated from 'VK_KHR_video_decode_h264'"] +impl VideoCodecOperationFlagsKHR { + pub const DECODE_H264: Self = Self(0b1); +} +impl AmdTextureGatherBiasLodFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_texture_gather_bias_lod\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct AmdTextureGatherBiasLodFn {} +unsafe impl Send for AmdTextureGatherBiasLodFn {} +unsafe impl Sync for AmdTextureGatherBiasLodFn {} +impl AmdTextureGatherBiasLodFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_AMD_texture_gather_bias_lod'"] +impl StructureType { + pub const TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD: Self = Self(1_000_041_000); +} +impl AmdShaderInfoFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_shader_info\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkGetShaderInfoAMD = unsafe extern "system" fn( + device: Device, + pipeline: Pipeline, + shader_stage: ShaderStageFlags, + info_type: ShaderInfoTypeAMD, + p_info_size: *mut usize, + p_info: *mut c_void, +) -> Result; +#[derive(Clone)] +pub struct AmdShaderInfoFn { + pub get_shader_info_amd: PFN_vkGetShaderInfoAMD, +} +unsafe impl Send for AmdShaderInfoFn {} +unsafe impl Sync for AmdShaderInfoFn {} +impl AmdShaderInfoFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + get_shader_info_amd: unsafe { + unsafe extern "system" fn get_shader_info_amd( + _device: Device, + _pipeline: Pipeline, + _shader_stage: ShaderStageFlags, + _info_type: ShaderInfoTypeAMD, + _p_info_size: *mut usize, + _p_info: *mut c_void, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(get_shader_info_amd))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetShaderInfoAMD\0"); + let val = _f(cname); + if val.is_null() { + get_shader_info_amd + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +impl AmdExtension44Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_44\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct AmdExtension44Fn {} +unsafe impl Send for AmdExtension44Fn {} +unsafe impl Sync for AmdExtension44Fn {} +impl AmdExtension44Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl KhrDynamicRenderingFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_dynamic_rendering\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkCmdBeginRendering = unsafe extern "system" fn( + command_buffer: CommandBuffer, + p_rendering_info: *const RenderingInfo, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdEndRendering = unsafe extern "system" fn(command_buffer: CommandBuffer); +#[derive(Clone)] +pub struct KhrDynamicRenderingFn { + pub cmd_begin_rendering_khr: PFN_vkCmdBeginRendering, + pub cmd_end_rendering_khr: PFN_vkCmdEndRendering, +} +unsafe impl Send for KhrDynamicRenderingFn {} +unsafe impl Sync for KhrDynamicRenderingFn {} +impl KhrDynamicRenderingFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + cmd_begin_rendering_khr: unsafe { + unsafe extern "system" fn cmd_begin_rendering_khr( + _command_buffer: CommandBuffer, + _p_rendering_info: *const RenderingInfo, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_begin_rendering_khr) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdBeginRenderingKHR\0"); + let val = _f(cname); + if val.is_null() { + cmd_begin_rendering_khr + } else { + ::std::mem::transmute(val) + } + }, + cmd_end_rendering_khr: unsafe { + unsafe extern "system" fn cmd_end_rendering_khr(_command_buffer: CommandBuffer) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_end_rendering_khr) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdEndRenderingKHR\0"); + let val = _f(cname); + if val.is_null() { + cmd_end_rendering_khr + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_KHR_dynamic_rendering'"] +impl AttachmentStoreOp { + pub const NONE_KHR: Self = Self::NONE; +} +#[doc = "Generated from 'VK_KHR_dynamic_rendering'"] +impl PipelineCreateFlags { + pub const RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_KHR: Self = + Self(0b10_0000_0000_0000_0000_0000); + pub const RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_EXT: Self = + Self(0b100_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_KHR_dynamic_rendering'"] +impl StructureType { + pub const RENDERING_INFO_KHR: Self = Self::RENDERING_INFO; + pub const RENDERING_ATTACHMENT_INFO_KHR: Self = Self::RENDERING_ATTACHMENT_INFO; + pub const PIPELINE_RENDERING_CREATE_INFO_KHR: Self = Self::PIPELINE_RENDERING_CREATE_INFO; + pub const PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES_KHR: Self = + Self::PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES; + pub const COMMAND_BUFFER_INHERITANCE_RENDERING_INFO_KHR: Self = + Self::COMMAND_BUFFER_INHERITANCE_RENDERING_INFO; + pub const RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR: Self = Self(1_000_044_006); + pub const RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT: Self = Self(1_000_044_007); + pub const ATTACHMENT_SAMPLE_COUNT_INFO_AMD: Self = Self(1_000_044_008); + pub const ATTACHMENT_SAMPLE_COUNT_INFO_NV: Self = Self::ATTACHMENT_SAMPLE_COUNT_INFO_AMD; + pub const MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX: Self = Self(1_000_044_009); +} +impl AmdExtension46Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_46\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct AmdExtension46Fn {} +unsafe impl Send for AmdExtension46Fn {} +unsafe impl Sync for AmdExtension46Fn {} +impl AmdExtension46Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl AmdShaderImageLoadStoreLodFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_shader_image_load_store_lod\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct AmdShaderImageLoadStoreLodFn {} +unsafe impl Send for AmdShaderImageLoadStoreLodFn {} +unsafe impl Sync for AmdShaderImageLoadStoreLodFn {} +impl AmdShaderImageLoadStoreLodFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl NvxExtension48Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NVX_extension_48\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct NvxExtension48Fn {} +unsafe impl Send for NvxExtension48Fn {} +unsafe impl Sync for NvxExtension48Fn {} +impl NvxExtension48Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl GoogleExtension49Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_GOOGLE_extension_49\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct GoogleExtension49Fn {} +unsafe impl Send for GoogleExtension49Fn {} +unsafe impl Sync for GoogleExtension49Fn {} +impl GoogleExtension49Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl GgpStreamDescriptorSurfaceFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_GGP_stream_descriptor_surface\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkCreateStreamDescriptorSurfaceGGP = unsafe extern "system" fn( + instance: Instance, + p_create_info: *const StreamDescriptorSurfaceCreateInfoGGP, + p_allocator: *const AllocationCallbacks, + p_surface: *mut SurfaceKHR, +) -> Result; +#[derive(Clone)] +pub struct GgpStreamDescriptorSurfaceFn { + pub create_stream_descriptor_surface_ggp: PFN_vkCreateStreamDescriptorSurfaceGGP, +} +unsafe impl Send for GgpStreamDescriptorSurfaceFn {} +unsafe impl Sync for GgpStreamDescriptorSurfaceFn {} +impl GgpStreamDescriptorSurfaceFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + create_stream_descriptor_surface_ggp: unsafe { + unsafe extern "system" fn create_stream_descriptor_surface_ggp( + _instance: Instance, + _p_create_info: *const StreamDescriptorSurfaceCreateInfoGGP, + _p_allocator: *const AllocationCallbacks, + _p_surface: *mut SurfaceKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(create_stream_descriptor_surface_ggp) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCreateStreamDescriptorSurfaceGGP\0", + ); + let val = _f(cname); + if val.is_null() { + create_stream_descriptor_surface_ggp + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_GGP_stream_descriptor_surface'"] +impl StructureType { + pub const STREAM_DESCRIPTOR_SURFACE_CREATE_INFO_GGP: Self = Self(1_000_049_000); +} +impl NvCornerSampledImageFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_corner_sampled_image\0") } + } + pub const SPEC_VERSION: u32 = 2u32; +} +#[derive(Clone)] +pub struct NvCornerSampledImageFn {} +unsafe impl Send for NvCornerSampledImageFn {} +unsafe impl Sync for NvCornerSampledImageFn {} +impl NvCornerSampledImageFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_NV_corner_sampled_image'"] +impl ImageCreateFlags { + pub const CORNER_SAMPLED_NV: Self = Self(0b10_0000_0000_0000); +} +#[doc = "Generated from 'VK_NV_corner_sampled_image'"] +impl StructureType { + pub const PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV: Self = Self(1_000_050_000); +} +impl NvExtension52Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_52\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct NvExtension52Fn {} +unsafe impl Send for NvExtension52Fn {} +unsafe impl Sync for NvExtension52Fn {} +impl NvExtension52Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl NvExtension53Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_53\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct NvExtension53Fn {} +unsafe impl Send for NvExtension53Fn {} +unsafe impl Sync for NvExtension53Fn {} +impl NvExtension53Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl KhrMultiviewFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_multiview\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct KhrMultiviewFn {} +unsafe impl Send for KhrMultiviewFn {} +unsafe impl Sync for KhrMultiviewFn {} +impl KhrMultiviewFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_KHR_multiview'"] +impl DependencyFlags { + pub const VIEW_LOCAL_KHR: Self = Self::VIEW_LOCAL; +} +#[doc = "Generated from 'VK_KHR_multiview'"] +impl StructureType { + pub const RENDER_PASS_MULTIVIEW_CREATE_INFO_KHR: Self = Self::RENDER_PASS_MULTIVIEW_CREATE_INFO; + pub const PHYSICAL_DEVICE_MULTIVIEW_FEATURES_KHR: Self = + Self::PHYSICAL_DEVICE_MULTIVIEW_FEATURES; + pub const PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES_KHR: Self = + Self::PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES; +} +impl ImgFormatPvrtcFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_IMG_format_pvrtc\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct ImgFormatPvrtcFn {} +unsafe impl Send for ImgFormatPvrtcFn {} +unsafe impl Sync for ImgFormatPvrtcFn {} +impl ImgFormatPvrtcFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_IMG_format_pvrtc'"] +impl Format { + pub const PVRTC1_2BPP_UNORM_BLOCK_IMG: Self = Self(1_000_054_000); + pub const PVRTC1_4BPP_UNORM_BLOCK_IMG: Self = Self(1_000_054_001); + pub const PVRTC2_2BPP_UNORM_BLOCK_IMG: Self = Self(1_000_054_002); + pub const PVRTC2_4BPP_UNORM_BLOCK_IMG: Self = Self(1_000_054_003); + pub const PVRTC1_2BPP_SRGB_BLOCK_IMG: Self = Self(1_000_054_004); + pub const PVRTC1_4BPP_SRGB_BLOCK_IMG: Self = Self(1_000_054_005); + pub const PVRTC2_2BPP_SRGB_BLOCK_IMG: Self = Self(1_000_054_006); + pub const PVRTC2_4BPP_SRGB_BLOCK_IMG: Self = Self(1_000_054_007); +} +impl NvExternalMemoryCapabilitiesFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_external_memory_capabilities\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV = + unsafe extern "system" fn( + physical_device: PhysicalDevice, + format: Format, + ty: ImageType, + tiling: ImageTiling, + usage: ImageUsageFlags, + flags: ImageCreateFlags, + external_handle_type: ExternalMemoryHandleTypeFlagsNV, + p_external_image_format_properties: *mut ExternalImageFormatPropertiesNV, + ) -> Result; +#[derive(Clone)] +pub struct NvExternalMemoryCapabilitiesFn { + pub get_physical_device_external_image_format_properties_nv: + PFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV, +} +unsafe impl Send for NvExternalMemoryCapabilitiesFn {} +unsafe impl Sync for NvExternalMemoryCapabilitiesFn {} +impl NvExternalMemoryCapabilitiesFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + get_physical_device_external_image_format_properties_nv: unsafe { + unsafe extern "system" fn get_physical_device_external_image_format_properties_nv( + _physical_device: PhysicalDevice, + _format: Format, + _ty: ImageType, + _tiling: ImageTiling, + _usage: ImageUsageFlags, + _flags: ImageCreateFlags, + _external_handle_type: ExternalMemoryHandleTypeFlagsNV, + _p_external_image_format_properties: *mut ExternalImageFormatPropertiesNV, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_external_image_format_properties_nv) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPhysicalDeviceExternalImageFormatPropertiesNV\0", + ); + let val = _f(cname); + if val.is_null() { + get_physical_device_external_image_format_properties_nv + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +impl NvExternalMemoryFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_external_memory\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct NvExternalMemoryFn {} +unsafe impl Send for NvExternalMemoryFn {} +unsafe impl Sync for NvExternalMemoryFn {} +impl NvExternalMemoryFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_NV_external_memory'"] +impl StructureType { + pub const EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV: Self = Self(1_000_056_000); + pub const EXPORT_MEMORY_ALLOCATE_INFO_NV: Self = Self(1_000_056_001); +} +impl NvExternalMemoryWin32Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_external_memory_win32\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkGetMemoryWin32HandleNV = unsafe extern "system" fn( + device: Device, + memory: DeviceMemory, + handle_type: ExternalMemoryHandleTypeFlagsNV, + p_handle: *mut HANDLE, +) -> Result; +#[derive(Clone)] +pub struct NvExternalMemoryWin32Fn { + pub get_memory_win32_handle_nv: PFN_vkGetMemoryWin32HandleNV, +} +unsafe impl Send for NvExternalMemoryWin32Fn {} +unsafe impl Sync for NvExternalMemoryWin32Fn {} +impl NvExternalMemoryWin32Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + get_memory_win32_handle_nv: unsafe { + unsafe extern "system" fn get_memory_win32_handle_nv( + _device: Device, + _memory: DeviceMemory, + _handle_type: ExternalMemoryHandleTypeFlagsNV, + _p_handle: *mut HANDLE, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_memory_win32_handle_nv) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetMemoryWin32HandleNV\0"); + let val = _f(cname); + if val.is_null() { + get_memory_win32_handle_nv + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_NV_external_memory_win32'"] +impl StructureType { + pub const IMPORT_MEMORY_WIN32_HANDLE_INFO_NV: Self = Self(1_000_057_000); + pub const EXPORT_MEMORY_WIN32_HANDLE_INFO_NV: Self = Self(1_000_057_001); +} +impl NvWin32KeyedMutexFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_win32_keyed_mutex\0") } + } + pub const SPEC_VERSION: u32 = 2u32; +} +#[derive(Clone)] +pub struct NvWin32KeyedMutexFn {} +unsafe impl Send for NvWin32KeyedMutexFn {} +unsafe impl Sync for NvWin32KeyedMutexFn {} +impl NvWin32KeyedMutexFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_NV_win32_keyed_mutex'"] +impl StructureType { + pub const WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV: Self = Self(1_000_058_000); +} +impl KhrGetPhysicalDeviceProperties2Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"VK_KHR_get_physical_device_properties2\0", + ) + } + } + pub const SPEC_VERSION: u32 = 2u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkGetPhysicalDeviceFeatures2 = unsafe extern "system" fn( + physical_device: PhysicalDevice, + p_features: *mut PhysicalDeviceFeatures2, +); +#[allow(non_camel_case_types)] +pub type PFN_vkGetPhysicalDeviceProperties2 = unsafe extern "system" fn( + physical_device: PhysicalDevice, + p_properties: *mut PhysicalDeviceProperties2, +); +#[allow(non_camel_case_types)] +pub type PFN_vkGetPhysicalDeviceFormatProperties2 = unsafe extern "system" fn( + physical_device: PhysicalDevice, + format: Format, + p_format_properties: *mut FormatProperties2, +); +#[allow(non_camel_case_types)] +pub type PFN_vkGetPhysicalDeviceImageFormatProperties2 = unsafe extern "system" fn( + physical_device: PhysicalDevice, + p_image_format_info: *const PhysicalDeviceImageFormatInfo2, + p_image_format_properties: *mut ImageFormatProperties2, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetPhysicalDeviceQueueFamilyProperties2 = unsafe extern "system" fn( + physical_device: PhysicalDevice, + p_queue_family_property_count: *mut u32, + p_queue_family_properties: *mut QueueFamilyProperties2, +); +#[allow(non_camel_case_types)] +pub type PFN_vkGetPhysicalDeviceMemoryProperties2 = unsafe extern "system" fn( + physical_device: PhysicalDevice, + p_memory_properties: *mut PhysicalDeviceMemoryProperties2, +); +#[allow(non_camel_case_types)] +pub type PFN_vkGetPhysicalDeviceSparseImageFormatProperties2 = unsafe extern "system" fn( + physical_device: PhysicalDevice, + p_format_info: *const PhysicalDeviceSparseImageFormatInfo2, + p_property_count: *mut u32, + p_properties: *mut SparseImageFormatProperties2, +); +#[derive(Clone)] +pub struct KhrGetPhysicalDeviceProperties2Fn { + pub get_physical_device_features2_khr: PFN_vkGetPhysicalDeviceFeatures2, + pub get_physical_device_properties2_khr: PFN_vkGetPhysicalDeviceProperties2, + pub get_physical_device_format_properties2_khr: PFN_vkGetPhysicalDeviceFormatProperties2, + pub get_physical_device_image_format_properties2_khr: + PFN_vkGetPhysicalDeviceImageFormatProperties2, + pub get_physical_device_queue_family_properties2_khr: + PFN_vkGetPhysicalDeviceQueueFamilyProperties2, + pub get_physical_device_memory_properties2_khr: PFN_vkGetPhysicalDeviceMemoryProperties2, + pub get_physical_device_sparse_image_format_properties2_khr: + PFN_vkGetPhysicalDeviceSparseImageFormatProperties2, +} +unsafe impl Send for KhrGetPhysicalDeviceProperties2Fn {} +unsafe impl Sync for KhrGetPhysicalDeviceProperties2Fn {} +impl KhrGetPhysicalDeviceProperties2Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + get_physical_device_features2_khr: unsafe { + unsafe extern "system" fn get_physical_device_features2_khr( + _physical_device: PhysicalDevice, + _p_features: *mut PhysicalDeviceFeatures2, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_features2_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPhysicalDeviceFeatures2KHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_physical_device_features2_khr + } else { + ::std::mem::transmute(val) + } + }, + get_physical_device_properties2_khr: unsafe { + unsafe extern "system" fn get_physical_device_properties2_khr( + _physical_device: PhysicalDevice, + _p_properties: *mut PhysicalDeviceProperties2, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_properties2_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPhysicalDeviceProperties2KHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_physical_device_properties2_khr + } else { + ::std::mem::transmute(val) + } + }, + get_physical_device_format_properties2_khr: unsafe { + unsafe extern "system" fn get_physical_device_format_properties2_khr( + _physical_device: PhysicalDevice, + _format: Format, + _p_format_properties: *mut FormatProperties2, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_format_properties2_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPhysicalDeviceFormatProperties2KHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_physical_device_format_properties2_khr + } else { + ::std::mem::transmute(val) + } + }, + get_physical_device_image_format_properties2_khr: unsafe { + unsafe extern "system" fn get_physical_device_image_format_properties2_khr( + _physical_device: PhysicalDevice, + _p_image_format_info: *const PhysicalDeviceImageFormatInfo2, + _p_image_format_properties: *mut ImageFormatProperties2, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_image_format_properties2_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPhysicalDeviceImageFormatProperties2KHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_physical_device_image_format_properties2_khr + } else { + ::std::mem::transmute(val) + } + }, + get_physical_device_queue_family_properties2_khr: unsafe { + unsafe extern "system" fn get_physical_device_queue_family_properties2_khr( + _physical_device: PhysicalDevice, + _p_queue_family_property_count: *mut u32, + _p_queue_family_properties: *mut QueueFamilyProperties2, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_queue_family_properties2_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPhysicalDeviceQueueFamilyProperties2KHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_physical_device_queue_family_properties2_khr + } else { + ::std::mem::transmute(val) + } + }, + get_physical_device_memory_properties2_khr: unsafe { + unsafe extern "system" fn get_physical_device_memory_properties2_khr( + _physical_device: PhysicalDevice, + _p_memory_properties: *mut PhysicalDeviceMemoryProperties2, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_memory_properties2_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPhysicalDeviceMemoryProperties2KHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_physical_device_memory_properties2_khr + } else { + ::std::mem::transmute(val) + } + }, + get_physical_device_sparse_image_format_properties2_khr: unsafe { + unsafe extern "system" fn get_physical_device_sparse_image_format_properties2_khr( + _physical_device: PhysicalDevice, + _p_format_info: *const PhysicalDeviceSparseImageFormatInfo2, + _p_property_count: *mut u32, + _p_properties: *mut SparseImageFormatProperties2, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_sparse_image_format_properties2_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPhysicalDeviceSparseImageFormatProperties2KHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_physical_device_sparse_image_format_properties2_khr + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_KHR_get_physical_device_properties2'"] +impl StructureType { + pub const PHYSICAL_DEVICE_FEATURES_2_KHR: Self = Self::PHYSICAL_DEVICE_FEATURES_2; + pub const PHYSICAL_DEVICE_PROPERTIES_2_KHR: Self = Self::PHYSICAL_DEVICE_PROPERTIES_2; + pub const FORMAT_PROPERTIES_2_KHR: Self = Self::FORMAT_PROPERTIES_2; + pub const IMAGE_FORMAT_PROPERTIES_2_KHR: Self = Self::IMAGE_FORMAT_PROPERTIES_2; + pub const PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2_KHR: Self = + Self::PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2; + pub const QUEUE_FAMILY_PROPERTIES_2_KHR: Self = Self::QUEUE_FAMILY_PROPERTIES_2; + pub const PHYSICAL_DEVICE_MEMORY_PROPERTIES_2_KHR: Self = + Self::PHYSICAL_DEVICE_MEMORY_PROPERTIES_2; + pub const SPARSE_IMAGE_FORMAT_PROPERTIES_2_KHR: Self = Self::SPARSE_IMAGE_FORMAT_PROPERTIES_2; + pub const PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2_KHR: Self = + Self::PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2; +} +impl KhrDeviceGroupFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_device_group\0") } + } + pub const SPEC_VERSION: u32 = 4u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkGetDeviceGroupPeerMemoryFeatures = unsafe extern "system" fn( + device: Device, + heap_index: u32, + local_device_index: u32, + remote_device_index: u32, + p_peer_memory_features: *mut PeerMemoryFeatureFlags, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetDeviceMask = + unsafe extern "system" fn(command_buffer: CommandBuffer, device_mask: u32); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdDispatchBase = unsafe extern "system" fn( + command_buffer: CommandBuffer, + base_group_x: u32, + base_group_y: u32, + base_group_z: u32, + group_count_x: u32, + group_count_y: u32, + group_count_z: u32, +); +#[derive(Clone)] +pub struct KhrDeviceGroupFn { + pub get_device_group_peer_memory_features_khr: PFN_vkGetDeviceGroupPeerMemoryFeatures, + pub cmd_set_device_mask_khr: PFN_vkCmdSetDeviceMask, + pub cmd_dispatch_base_khr: PFN_vkCmdDispatchBase, + pub get_device_group_present_capabilities_khr: + crate::vk::PFN_vkGetDeviceGroupPresentCapabilitiesKHR, + pub get_device_group_surface_present_modes_khr: + crate::vk::PFN_vkGetDeviceGroupSurfacePresentModesKHR, + pub get_physical_device_present_rectangles_khr: + crate::vk::PFN_vkGetPhysicalDevicePresentRectanglesKHR, + pub acquire_next_image2_khr: crate::vk::PFN_vkAcquireNextImage2KHR, +} +unsafe impl Send for KhrDeviceGroupFn {} +unsafe impl Sync for KhrDeviceGroupFn {} +impl KhrDeviceGroupFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + get_device_group_peer_memory_features_khr: unsafe { + unsafe extern "system" fn get_device_group_peer_memory_features_khr( + _device: Device, + _heap_index: u32, + _local_device_index: u32, + _remote_device_index: u32, + _p_peer_memory_features: *mut PeerMemoryFeatureFlags, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_device_group_peer_memory_features_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetDeviceGroupPeerMemoryFeaturesKHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_device_group_peer_memory_features_khr + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_device_mask_khr: unsafe { + unsafe extern "system" fn cmd_set_device_mask_khr( + _command_buffer: CommandBuffer, + _device_mask: u32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_device_mask_khr) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetDeviceMaskKHR\0"); + let val = _f(cname); + if val.is_null() { + cmd_set_device_mask_khr + } else { + ::std::mem::transmute(val) + } + }, + cmd_dispatch_base_khr: unsafe { + unsafe extern "system" fn cmd_dispatch_base_khr( + _command_buffer: CommandBuffer, + _base_group_x: u32, + _base_group_y: u32, + _base_group_z: u32, + _group_count_x: u32, + _group_count_y: u32, + _group_count_z: u32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_dispatch_base_khr) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdDispatchBaseKHR\0"); + let val = _f(cname); + if val.is_null() { + cmd_dispatch_base_khr + } else { + ::std::mem::transmute(val) + } + }, + get_device_group_present_capabilities_khr: unsafe { + unsafe extern "system" fn get_device_group_present_capabilities_khr( + _device: Device, + _p_device_group_present_capabilities: *mut DeviceGroupPresentCapabilitiesKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_device_group_present_capabilities_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetDeviceGroupPresentCapabilitiesKHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_device_group_present_capabilities_khr + } else { + ::std::mem::transmute(val) + } + }, + get_device_group_surface_present_modes_khr: unsafe { + unsafe extern "system" fn get_device_group_surface_present_modes_khr( + _device: Device, + _surface: SurfaceKHR, + _p_modes: *mut DeviceGroupPresentModeFlagsKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_device_group_surface_present_modes_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetDeviceGroupSurfacePresentModesKHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_device_group_surface_present_modes_khr + } else { + ::std::mem::transmute(val) + } + }, + get_physical_device_present_rectangles_khr: unsafe { + unsafe extern "system" fn get_physical_device_present_rectangles_khr( + _physical_device: PhysicalDevice, + _surface: SurfaceKHR, + _p_rect_count: *mut u32, + _p_rects: *mut Rect2D, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_present_rectangles_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPhysicalDevicePresentRectanglesKHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_physical_device_present_rectangles_khr + } else { + ::std::mem::transmute(val) + } + }, + acquire_next_image2_khr: unsafe { + unsafe extern "system" fn acquire_next_image2_khr( + _device: Device, + _p_acquire_info: *const AcquireNextImageInfoKHR, + _p_image_index: *mut u32, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(acquire_next_image2_khr) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkAcquireNextImage2KHR\0"); + let val = _f(cname); + if val.is_null() { + acquire_next_image2_khr + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_KHR_device_group'"] +impl DependencyFlags { + pub const DEVICE_GROUP_KHR: Self = Self::DEVICE_GROUP; +} +#[doc = "Generated from 'VK_KHR_device_group'"] +impl ImageCreateFlags { + pub const SPLIT_INSTANCE_BIND_REGIONS_KHR: Self = Self::SPLIT_INSTANCE_BIND_REGIONS; +} +#[doc = "Generated from 'VK_KHR_device_group'"] +impl MemoryAllocateFlags { + pub const DEVICE_MASK_KHR: Self = Self::DEVICE_MASK; +} +#[doc = "Generated from 'VK_KHR_device_group'"] +impl PeerMemoryFeatureFlags { + pub const COPY_SRC_KHR: Self = Self::COPY_SRC; + pub const COPY_DST_KHR: Self = Self::COPY_DST; + pub const GENERIC_SRC_KHR: Self = Self::GENERIC_SRC; + pub const GENERIC_DST_KHR: Self = Self::GENERIC_DST; +} +#[doc = "Generated from 'VK_KHR_device_group'"] +impl PipelineCreateFlags { + pub const VIEW_INDEX_FROM_DEVICE_INDEX_KHR: Self = Self::VIEW_INDEX_FROM_DEVICE_INDEX; +} +#[doc = "Generated from 'VK_KHR_device_group'"] +impl StructureType { + pub const MEMORY_ALLOCATE_FLAGS_INFO_KHR: Self = Self::MEMORY_ALLOCATE_FLAGS_INFO; + pub const DEVICE_GROUP_RENDER_PASS_BEGIN_INFO_KHR: Self = + Self::DEVICE_GROUP_RENDER_PASS_BEGIN_INFO; + pub const DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO_KHR: Self = + Self::DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO; + pub const DEVICE_GROUP_SUBMIT_INFO_KHR: Self = Self::DEVICE_GROUP_SUBMIT_INFO; + pub const DEVICE_GROUP_BIND_SPARSE_INFO_KHR: Self = Self::DEVICE_GROUP_BIND_SPARSE_INFO; + pub const BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO_KHR: Self = + Self::BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO; + pub const BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO_KHR: Self = + Self::BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO; +} +impl ExtValidationFlagsFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_validation_flags\0") } + } + pub const SPEC_VERSION: u32 = 2u32; +} +#[derive(Clone)] +pub struct ExtValidationFlagsFn {} +unsafe impl Send for ExtValidationFlagsFn {} +unsafe impl Sync for ExtValidationFlagsFn {} +impl ExtValidationFlagsFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_validation_flags'"] +impl StructureType { + pub const VALIDATION_FLAGS_EXT: Self = Self(1_000_061_000); +} +impl NnViSurfaceFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NN_vi_surface\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkCreateViSurfaceNN = unsafe extern "system" fn( + instance: Instance, + p_create_info: *const ViSurfaceCreateInfoNN, + p_allocator: *const AllocationCallbacks, + p_surface: *mut SurfaceKHR, +) -> Result; +#[derive(Clone)] +pub struct NnViSurfaceFn { + pub create_vi_surface_nn: PFN_vkCreateViSurfaceNN, +} +unsafe impl Send for NnViSurfaceFn {} +unsafe impl Sync for NnViSurfaceFn {} +impl NnViSurfaceFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + create_vi_surface_nn: unsafe { + unsafe extern "system" fn create_vi_surface_nn( + _instance: Instance, + _p_create_info: *const ViSurfaceCreateInfoNN, + _p_allocator: *const AllocationCallbacks, + _p_surface: *mut SurfaceKHR, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(create_vi_surface_nn))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateViSurfaceNN\0"); + let val = _f(cname); + if val.is_null() { + create_vi_surface_nn + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_NN_vi_surface'"] +impl StructureType { + pub const VI_SURFACE_CREATE_INFO_NN: Self = Self(1_000_062_000); +} +impl KhrShaderDrawParametersFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_shader_draw_parameters\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct KhrShaderDrawParametersFn {} +unsafe impl Send for KhrShaderDrawParametersFn {} +unsafe impl Sync for KhrShaderDrawParametersFn {} +impl KhrShaderDrawParametersFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtShaderSubgroupBallotFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_shader_subgroup_ballot\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct ExtShaderSubgroupBallotFn {} +unsafe impl Send for ExtShaderSubgroupBallotFn {} +unsafe impl Sync for ExtShaderSubgroupBallotFn {} +impl ExtShaderSubgroupBallotFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtShaderSubgroupVoteFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_shader_subgroup_vote\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct ExtShaderSubgroupVoteFn {} +unsafe impl Send for ExtShaderSubgroupVoteFn {} +unsafe impl Sync for ExtShaderSubgroupVoteFn {} +impl ExtShaderSubgroupVoteFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtTextureCompressionAstcHdrFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"VK_EXT_texture_compression_astc_hdr\0", + ) + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct ExtTextureCompressionAstcHdrFn {} +unsafe impl Send for ExtTextureCompressionAstcHdrFn {} +unsafe impl Sync for ExtTextureCompressionAstcHdrFn {} +impl ExtTextureCompressionAstcHdrFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_texture_compression_astc_hdr'"] +impl Format { + pub const ASTC_4X4_SFLOAT_BLOCK_EXT: Self = Self::ASTC_4X4_SFLOAT_BLOCK; + pub const ASTC_5X4_SFLOAT_BLOCK_EXT: Self = Self::ASTC_5X4_SFLOAT_BLOCK; + pub const ASTC_5X5_SFLOAT_BLOCK_EXT: Self = Self::ASTC_5X5_SFLOAT_BLOCK; + pub const ASTC_6X5_SFLOAT_BLOCK_EXT: Self = Self::ASTC_6X5_SFLOAT_BLOCK; + pub const ASTC_6X6_SFLOAT_BLOCK_EXT: Self = Self::ASTC_6X6_SFLOAT_BLOCK; + pub const ASTC_8X5_SFLOAT_BLOCK_EXT: Self = Self::ASTC_8X5_SFLOAT_BLOCK; + pub const ASTC_8X6_SFLOAT_BLOCK_EXT: Self = Self::ASTC_8X6_SFLOAT_BLOCK; + pub const ASTC_8X8_SFLOAT_BLOCK_EXT: Self = Self::ASTC_8X8_SFLOAT_BLOCK; + pub const ASTC_10X5_SFLOAT_BLOCK_EXT: Self = Self::ASTC_10X5_SFLOAT_BLOCK; + pub const ASTC_10X6_SFLOAT_BLOCK_EXT: Self = Self::ASTC_10X6_SFLOAT_BLOCK; + pub const ASTC_10X8_SFLOAT_BLOCK_EXT: Self = Self::ASTC_10X8_SFLOAT_BLOCK; + pub const ASTC_10X10_SFLOAT_BLOCK_EXT: Self = Self::ASTC_10X10_SFLOAT_BLOCK; + pub const ASTC_12X10_SFLOAT_BLOCK_EXT: Self = Self::ASTC_12X10_SFLOAT_BLOCK; + pub const ASTC_12X12_SFLOAT_BLOCK_EXT: Self = Self::ASTC_12X12_SFLOAT_BLOCK; +} +#[doc = "Generated from 'VK_EXT_texture_compression_astc_hdr'"] +impl StructureType { + pub const PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT: Self = + Self::PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES; +} +impl ExtAstcDecodeModeFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_astc_decode_mode\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct ExtAstcDecodeModeFn {} +unsafe impl Send for ExtAstcDecodeModeFn {} +unsafe impl Sync for ExtAstcDecodeModeFn {} +impl ExtAstcDecodeModeFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_astc_decode_mode'"] +impl StructureType { + pub const IMAGE_VIEW_ASTC_DECODE_MODE_EXT: Self = Self(1_000_067_000); + pub const PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT: Self = Self(1_000_067_001); +} +impl ExtPipelineRobustnessFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_pipeline_robustness\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct ExtPipelineRobustnessFn {} +unsafe impl Send for ExtPipelineRobustnessFn {} +unsafe impl Sync for ExtPipelineRobustnessFn {} +impl ExtPipelineRobustnessFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_pipeline_robustness'"] +impl StructureType { + pub const PIPELINE_ROBUSTNESS_CREATE_INFO_EXT: Self = Self(1_000_068_000); + pub const PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT: Self = Self(1_000_068_001); + pub const PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES_EXT: Self = Self(1_000_068_002); +} +impl KhrMaintenance1Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_maintenance1\0") } + } + pub const SPEC_VERSION: u32 = 2u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkTrimCommandPool = unsafe extern "system" fn( + device: Device, + command_pool: CommandPool, + flags: CommandPoolTrimFlags, +); +#[derive(Clone)] +pub struct KhrMaintenance1Fn { + pub trim_command_pool_khr: PFN_vkTrimCommandPool, +} +unsafe impl Send for KhrMaintenance1Fn {} +unsafe impl Sync for KhrMaintenance1Fn {} +impl KhrMaintenance1Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + trim_command_pool_khr: unsafe { + unsafe extern "system" fn trim_command_pool_khr( + _device: Device, + _command_pool: CommandPool, + _flags: CommandPoolTrimFlags, + ) { + panic!(concat!( + "Unable to load ", + stringify!(trim_command_pool_khr) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkTrimCommandPoolKHR\0"); + let val = _f(cname); + if val.is_null() { + trim_command_pool_khr + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_KHR_maintenance1'"] +impl FormatFeatureFlags { + pub const TRANSFER_SRC_KHR: Self = Self::TRANSFER_SRC; + pub const TRANSFER_DST_KHR: Self = Self::TRANSFER_DST; +} +#[doc = "Generated from 'VK_KHR_maintenance1'"] +impl ImageCreateFlags { + pub const TYPE_2D_ARRAY_COMPATIBLE_KHR: Self = Self::TYPE_2D_ARRAY_COMPATIBLE; +} +#[doc = "Generated from 'VK_KHR_maintenance1'"] +impl Result { + pub const ERROR_OUT_OF_POOL_MEMORY_KHR: Self = Self::ERROR_OUT_OF_POOL_MEMORY; +} +impl KhrDeviceGroupCreationFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_device_group_creation\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkEnumeratePhysicalDeviceGroups = unsafe extern "system" fn( + instance: Instance, + p_physical_device_group_count: *mut u32, + p_physical_device_group_properties: *mut PhysicalDeviceGroupProperties, +) -> Result; +#[derive(Clone)] +pub struct KhrDeviceGroupCreationFn { + pub enumerate_physical_device_groups_khr: PFN_vkEnumeratePhysicalDeviceGroups, +} +unsafe impl Send for KhrDeviceGroupCreationFn {} +unsafe impl Sync for KhrDeviceGroupCreationFn {} +impl KhrDeviceGroupCreationFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + enumerate_physical_device_groups_khr: unsafe { + unsafe extern "system" fn enumerate_physical_device_groups_khr( + _instance: Instance, + _p_physical_device_group_count: *mut u32, + _p_physical_device_group_properties: *mut PhysicalDeviceGroupProperties, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(enumerate_physical_device_groups_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkEnumeratePhysicalDeviceGroupsKHR\0", + ); + let val = _f(cname); + if val.is_null() { + enumerate_physical_device_groups_khr + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_KHR_device_group_creation'"] +impl MemoryHeapFlags { + pub const MULTI_INSTANCE_KHR: Self = Self::MULTI_INSTANCE; +} +#[doc = "Generated from 'VK_KHR_device_group_creation'"] +impl StructureType { + pub const PHYSICAL_DEVICE_GROUP_PROPERTIES_KHR: Self = Self::PHYSICAL_DEVICE_GROUP_PROPERTIES; + pub const DEVICE_GROUP_DEVICE_CREATE_INFO_KHR: Self = Self::DEVICE_GROUP_DEVICE_CREATE_INFO; +} +impl KhrExternalMemoryCapabilitiesFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"VK_KHR_external_memory_capabilities\0", + ) + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkGetPhysicalDeviceExternalBufferProperties = unsafe extern "system" fn( + physical_device: PhysicalDevice, + p_external_buffer_info: *const PhysicalDeviceExternalBufferInfo, + p_external_buffer_properties: *mut ExternalBufferProperties, +); +#[derive(Clone)] +pub struct KhrExternalMemoryCapabilitiesFn { + pub get_physical_device_external_buffer_properties_khr: + PFN_vkGetPhysicalDeviceExternalBufferProperties, +} +unsafe impl Send for KhrExternalMemoryCapabilitiesFn {} +unsafe impl Sync for KhrExternalMemoryCapabilitiesFn {} +impl KhrExternalMemoryCapabilitiesFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + get_physical_device_external_buffer_properties_khr: unsafe { + unsafe extern "system" fn get_physical_device_external_buffer_properties_khr( + _physical_device: PhysicalDevice, + _p_external_buffer_info: *const PhysicalDeviceExternalBufferInfo, + _p_external_buffer_properties: *mut ExternalBufferProperties, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_external_buffer_properties_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPhysicalDeviceExternalBufferPropertiesKHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_physical_device_external_buffer_properties_khr + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_KHR_external_memory_capabilities'"] +impl ExternalMemoryFeatureFlags { + pub const DEDICATED_ONLY_KHR: Self = Self::DEDICATED_ONLY; + pub const EXPORTABLE_KHR: Self = Self::EXPORTABLE; + pub const IMPORTABLE_KHR: Self = Self::IMPORTABLE; +} +#[doc = "Generated from 'VK_KHR_external_memory_capabilities'"] +impl ExternalMemoryHandleTypeFlags { + pub const OPAQUE_FD_KHR: Self = Self::OPAQUE_FD; + pub const OPAQUE_WIN32_KHR: Self = Self::OPAQUE_WIN32; + pub const OPAQUE_WIN32_KMT_KHR: Self = Self::OPAQUE_WIN32_KMT; + pub const D3D11_TEXTURE_KHR: Self = Self::D3D11_TEXTURE; + pub const D3D11_TEXTURE_KMT_KHR: Self = Self::D3D11_TEXTURE_KMT; + pub const D3D12_HEAP_KHR: Self = Self::D3D12_HEAP; + pub const D3D12_RESOURCE_KHR: Self = Self::D3D12_RESOURCE; +} +#[doc = "Generated from 'VK_KHR_external_memory_capabilities'"] +impl StructureType { + pub const PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO_KHR: Self = + Self::PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO; + pub const EXTERNAL_IMAGE_FORMAT_PROPERTIES_KHR: Self = Self::EXTERNAL_IMAGE_FORMAT_PROPERTIES; + pub const PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO_KHR: Self = + Self::PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO; + pub const EXTERNAL_BUFFER_PROPERTIES_KHR: Self = Self::EXTERNAL_BUFFER_PROPERTIES; + pub const PHYSICAL_DEVICE_ID_PROPERTIES_KHR: Self = Self::PHYSICAL_DEVICE_ID_PROPERTIES; +} +impl KhrExternalMemoryFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_external_memory\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct KhrExternalMemoryFn {} +unsafe impl Send for KhrExternalMemoryFn {} +unsafe impl Sync for KhrExternalMemoryFn {} +impl KhrExternalMemoryFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_KHR_external_memory'"] +impl Result { + pub const ERROR_INVALID_EXTERNAL_HANDLE_KHR: Self = Self::ERROR_INVALID_EXTERNAL_HANDLE; +} +#[doc = "Generated from 'VK_KHR_external_memory'"] +impl StructureType { + pub const EXTERNAL_MEMORY_BUFFER_CREATE_INFO_KHR: Self = + Self::EXTERNAL_MEMORY_BUFFER_CREATE_INFO; + pub const EXTERNAL_MEMORY_IMAGE_CREATE_INFO_KHR: Self = Self::EXTERNAL_MEMORY_IMAGE_CREATE_INFO; + pub const EXPORT_MEMORY_ALLOCATE_INFO_KHR: Self = Self::EXPORT_MEMORY_ALLOCATE_INFO; +} +impl KhrExternalMemoryWin32Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_external_memory_win32\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkGetMemoryWin32HandleKHR = unsafe extern "system" fn( + device: Device, + p_get_win32_handle_info: *const MemoryGetWin32HandleInfoKHR, + p_handle: *mut HANDLE, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetMemoryWin32HandlePropertiesKHR = unsafe extern "system" fn( + device: Device, + handle_type: ExternalMemoryHandleTypeFlags, + handle: HANDLE, + p_memory_win32_handle_properties: *mut MemoryWin32HandlePropertiesKHR, +) -> Result; +#[derive(Clone)] +pub struct KhrExternalMemoryWin32Fn { + pub get_memory_win32_handle_khr: PFN_vkGetMemoryWin32HandleKHR, + pub get_memory_win32_handle_properties_khr: PFN_vkGetMemoryWin32HandlePropertiesKHR, +} +unsafe impl Send for KhrExternalMemoryWin32Fn {} +unsafe impl Sync for KhrExternalMemoryWin32Fn {} +impl KhrExternalMemoryWin32Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + get_memory_win32_handle_khr: unsafe { + unsafe extern "system" fn get_memory_win32_handle_khr( + _device: Device, + _p_get_win32_handle_info: *const MemoryGetWin32HandleInfoKHR, + _p_handle: *mut HANDLE, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_memory_win32_handle_khr) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetMemoryWin32HandleKHR\0"); + let val = _f(cname); + if val.is_null() { + get_memory_win32_handle_khr + } else { + ::std::mem::transmute(val) + } + }, + get_memory_win32_handle_properties_khr: unsafe { + unsafe extern "system" fn get_memory_win32_handle_properties_khr( + _device: Device, + _handle_type: ExternalMemoryHandleTypeFlags, + _handle: HANDLE, + _p_memory_win32_handle_properties: *mut MemoryWin32HandlePropertiesKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_memory_win32_handle_properties_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetMemoryWin32HandlePropertiesKHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_memory_win32_handle_properties_khr + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_KHR_external_memory_win32'"] +impl StructureType { + pub const IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR: Self = Self(1_000_073_000); + pub const EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR: Self = Self(1_000_073_001); + pub const MEMORY_WIN32_HANDLE_PROPERTIES_KHR: Self = Self(1_000_073_002); + pub const MEMORY_GET_WIN32_HANDLE_INFO_KHR: Self = Self(1_000_073_003); +} +impl KhrExternalMemoryFdFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_external_memory_fd\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkGetMemoryFdKHR = unsafe extern "system" fn( + device: Device, + p_get_fd_info: *const MemoryGetFdInfoKHR, + p_fd: *mut c_int, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetMemoryFdPropertiesKHR = unsafe extern "system" fn( + device: Device, + handle_type: ExternalMemoryHandleTypeFlags, + fd: c_int, + p_memory_fd_properties: *mut MemoryFdPropertiesKHR, +) -> Result; +#[derive(Clone)] +pub struct KhrExternalMemoryFdFn { + pub get_memory_fd_khr: PFN_vkGetMemoryFdKHR, + pub get_memory_fd_properties_khr: PFN_vkGetMemoryFdPropertiesKHR, +} +unsafe impl Send for KhrExternalMemoryFdFn {} +unsafe impl Sync for KhrExternalMemoryFdFn {} +impl KhrExternalMemoryFdFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + get_memory_fd_khr: unsafe { + unsafe extern "system" fn get_memory_fd_khr( + _device: Device, + _p_get_fd_info: *const MemoryGetFdInfoKHR, + _p_fd: *mut c_int, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(get_memory_fd_khr))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetMemoryFdKHR\0"); + let val = _f(cname); + if val.is_null() { + get_memory_fd_khr + } else { + ::std::mem::transmute(val) + } + }, + get_memory_fd_properties_khr: unsafe { + unsafe extern "system" fn get_memory_fd_properties_khr( + _device: Device, + _handle_type: ExternalMemoryHandleTypeFlags, + _fd: c_int, + _p_memory_fd_properties: *mut MemoryFdPropertiesKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_memory_fd_properties_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetMemoryFdPropertiesKHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_memory_fd_properties_khr + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_KHR_external_memory_fd'"] +impl StructureType { + pub const IMPORT_MEMORY_FD_INFO_KHR: Self = Self(1_000_074_000); + pub const MEMORY_FD_PROPERTIES_KHR: Self = Self(1_000_074_001); + pub const MEMORY_GET_FD_INFO_KHR: Self = Self(1_000_074_002); +} +impl KhrWin32KeyedMutexFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_win32_keyed_mutex\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct KhrWin32KeyedMutexFn {} +unsafe impl Send for KhrWin32KeyedMutexFn {} +unsafe impl Sync for KhrWin32KeyedMutexFn {} +impl KhrWin32KeyedMutexFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_KHR_win32_keyed_mutex'"] +impl StructureType { + pub const WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR: Self = Self(1_000_075_000); +} +impl KhrExternalSemaphoreCapabilitiesFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"VK_KHR_external_semaphore_capabilities\0", + ) + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkGetPhysicalDeviceExternalSemaphoreProperties = unsafe extern "system" fn( + physical_device: PhysicalDevice, + p_external_semaphore_info: *const PhysicalDeviceExternalSemaphoreInfo, + p_external_semaphore_properties: *mut ExternalSemaphoreProperties, +); +#[derive(Clone)] +pub struct KhrExternalSemaphoreCapabilitiesFn { + pub get_physical_device_external_semaphore_properties_khr: + PFN_vkGetPhysicalDeviceExternalSemaphoreProperties, +} +unsafe impl Send for KhrExternalSemaphoreCapabilitiesFn {} +unsafe impl Sync for KhrExternalSemaphoreCapabilitiesFn {} +impl KhrExternalSemaphoreCapabilitiesFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + get_physical_device_external_semaphore_properties_khr: unsafe { + unsafe extern "system" fn get_physical_device_external_semaphore_properties_khr( + _physical_device: PhysicalDevice, + _p_external_semaphore_info: *const PhysicalDeviceExternalSemaphoreInfo, + _p_external_semaphore_properties: *mut ExternalSemaphoreProperties, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_external_semaphore_properties_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPhysicalDeviceExternalSemaphorePropertiesKHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_physical_device_external_semaphore_properties_khr + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_KHR_external_semaphore_capabilities'"] +impl ExternalSemaphoreFeatureFlags { + pub const EXPORTABLE_KHR: Self = Self::EXPORTABLE; + pub const IMPORTABLE_KHR: Self = Self::IMPORTABLE; +} +#[doc = "Generated from 'VK_KHR_external_semaphore_capabilities'"] +impl ExternalSemaphoreHandleTypeFlags { + pub const OPAQUE_FD_KHR: Self = Self::OPAQUE_FD; + pub const OPAQUE_WIN32_KHR: Self = Self::OPAQUE_WIN32; + pub const OPAQUE_WIN32_KMT_KHR: Self = Self::OPAQUE_WIN32_KMT; + pub const D3D12_FENCE_KHR: Self = Self::D3D12_FENCE; + pub const SYNC_FD_KHR: Self = Self::SYNC_FD; +} +#[doc = "Generated from 'VK_KHR_external_semaphore_capabilities'"] +impl StructureType { + pub const PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO_KHR: Self = + Self::PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO; + pub const EXTERNAL_SEMAPHORE_PROPERTIES_KHR: Self = Self::EXTERNAL_SEMAPHORE_PROPERTIES; +} +impl KhrExternalSemaphoreFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_external_semaphore\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct KhrExternalSemaphoreFn {} +unsafe impl Send for KhrExternalSemaphoreFn {} +unsafe impl Sync for KhrExternalSemaphoreFn {} +impl KhrExternalSemaphoreFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_KHR_external_semaphore'"] +impl SemaphoreImportFlags { + pub const TEMPORARY_KHR: Self = Self::TEMPORARY; +} +#[doc = "Generated from 'VK_KHR_external_semaphore'"] +impl StructureType { + pub const EXPORT_SEMAPHORE_CREATE_INFO_KHR: Self = Self::EXPORT_SEMAPHORE_CREATE_INFO; +} +impl KhrExternalSemaphoreWin32Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_external_semaphore_win32\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkImportSemaphoreWin32HandleKHR = unsafe extern "system" fn( + device: Device, + p_import_semaphore_win32_handle_info: *const ImportSemaphoreWin32HandleInfoKHR, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetSemaphoreWin32HandleKHR = unsafe extern "system" fn( + device: Device, + p_get_win32_handle_info: *const SemaphoreGetWin32HandleInfoKHR, + p_handle: *mut HANDLE, +) -> Result; +#[derive(Clone)] +pub struct KhrExternalSemaphoreWin32Fn { + pub import_semaphore_win32_handle_khr: PFN_vkImportSemaphoreWin32HandleKHR, + pub get_semaphore_win32_handle_khr: PFN_vkGetSemaphoreWin32HandleKHR, +} +unsafe impl Send for KhrExternalSemaphoreWin32Fn {} +unsafe impl Sync for KhrExternalSemaphoreWin32Fn {} +impl KhrExternalSemaphoreWin32Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + import_semaphore_win32_handle_khr: unsafe { + unsafe extern "system" fn import_semaphore_win32_handle_khr( + _device: Device, + _p_import_semaphore_win32_handle_info: *const ImportSemaphoreWin32HandleInfoKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(import_semaphore_win32_handle_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkImportSemaphoreWin32HandleKHR\0", + ); + let val = _f(cname); + if val.is_null() { + import_semaphore_win32_handle_khr + } else { + ::std::mem::transmute(val) + } + }, + get_semaphore_win32_handle_khr: unsafe { + unsafe extern "system" fn get_semaphore_win32_handle_khr( + _device: Device, + _p_get_win32_handle_info: *const SemaphoreGetWin32HandleInfoKHR, + _p_handle: *mut HANDLE, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_semaphore_win32_handle_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetSemaphoreWin32HandleKHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_semaphore_win32_handle_khr + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_KHR_external_semaphore_win32'"] +impl StructureType { + pub const IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR: Self = Self(1_000_078_000); + pub const EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR: Self = Self(1_000_078_001); + pub const D3D12_FENCE_SUBMIT_INFO_KHR: Self = Self(1_000_078_002); + pub const SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR: Self = Self(1_000_078_003); +} +impl KhrExternalSemaphoreFdFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_external_semaphore_fd\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkImportSemaphoreFdKHR = unsafe extern "system" fn( + device: Device, + p_import_semaphore_fd_info: *const ImportSemaphoreFdInfoKHR, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetSemaphoreFdKHR = unsafe extern "system" fn( + device: Device, + p_get_fd_info: *const SemaphoreGetFdInfoKHR, + p_fd: *mut c_int, +) -> Result; +#[derive(Clone)] +pub struct KhrExternalSemaphoreFdFn { + pub import_semaphore_fd_khr: PFN_vkImportSemaphoreFdKHR, + pub get_semaphore_fd_khr: PFN_vkGetSemaphoreFdKHR, +} +unsafe impl Send for KhrExternalSemaphoreFdFn {} +unsafe impl Sync for KhrExternalSemaphoreFdFn {} +impl KhrExternalSemaphoreFdFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + import_semaphore_fd_khr: unsafe { + unsafe extern "system" fn import_semaphore_fd_khr( + _device: Device, + _p_import_semaphore_fd_info: *const ImportSemaphoreFdInfoKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(import_semaphore_fd_khr) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkImportSemaphoreFdKHR\0"); + let val = _f(cname); + if val.is_null() { + import_semaphore_fd_khr + } else { + ::std::mem::transmute(val) + } + }, + get_semaphore_fd_khr: unsafe { + unsafe extern "system" fn get_semaphore_fd_khr( + _device: Device, + _p_get_fd_info: *const SemaphoreGetFdInfoKHR, + _p_fd: *mut c_int, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(get_semaphore_fd_khr))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetSemaphoreFdKHR\0"); + let val = _f(cname); + if val.is_null() { + get_semaphore_fd_khr + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_KHR_external_semaphore_fd'"] +impl StructureType { + pub const IMPORT_SEMAPHORE_FD_INFO_KHR: Self = Self(1_000_079_000); + pub const SEMAPHORE_GET_FD_INFO_KHR: Self = Self(1_000_079_001); +} +impl KhrPushDescriptorFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_push_descriptor\0") } + } + pub const SPEC_VERSION: u32 = 2u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkCmdPushDescriptorSetKHR = unsafe extern "system" fn( + command_buffer: CommandBuffer, + pipeline_bind_point: PipelineBindPoint, + layout: PipelineLayout, + set: u32, + descriptor_write_count: u32, + p_descriptor_writes: *const WriteDescriptorSet, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdPushDescriptorSetWithTemplateKHR = unsafe extern "system" fn( + command_buffer: CommandBuffer, + descriptor_update_template: DescriptorUpdateTemplate, + layout: PipelineLayout, + set: u32, + p_data: *const c_void, +); +#[derive(Clone)] +pub struct KhrPushDescriptorFn { + pub cmd_push_descriptor_set_khr: PFN_vkCmdPushDescriptorSetKHR, + pub cmd_push_descriptor_set_with_template_khr: PFN_vkCmdPushDescriptorSetWithTemplateKHR, +} +unsafe impl Send for KhrPushDescriptorFn {} +unsafe impl Sync for KhrPushDescriptorFn {} +impl KhrPushDescriptorFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + cmd_push_descriptor_set_khr: unsafe { + unsafe extern "system" fn cmd_push_descriptor_set_khr( + _command_buffer: CommandBuffer, + _pipeline_bind_point: PipelineBindPoint, + _layout: PipelineLayout, + _set: u32, + _descriptor_write_count: u32, + _p_descriptor_writes: *const WriteDescriptorSet, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_push_descriptor_set_khr) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdPushDescriptorSetKHR\0"); + let val = _f(cname); + if val.is_null() { + cmd_push_descriptor_set_khr + } else { + ::std::mem::transmute(val) + } + }, + cmd_push_descriptor_set_with_template_khr: unsafe { + unsafe extern "system" fn cmd_push_descriptor_set_with_template_khr( + _command_buffer: CommandBuffer, + _descriptor_update_template: DescriptorUpdateTemplate, + _layout: PipelineLayout, + _set: u32, + _p_data: *const c_void, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_push_descriptor_set_with_template_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdPushDescriptorSetWithTemplateKHR\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_push_descriptor_set_with_template_khr + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_KHR_push_descriptor'"] +impl DescriptorSetLayoutCreateFlags { + #[doc = "Descriptors are pushed via flink:vkCmdPushDescriptorSetKHR"] + pub const PUSH_DESCRIPTOR_KHR: Self = Self(0b1); +} +#[doc = "Generated from 'VK_KHR_push_descriptor'"] +impl DescriptorUpdateTemplateType { + #[doc = "Create descriptor update template for pushed descriptor updates"] + pub const PUSH_DESCRIPTORS_KHR: Self = Self(1); +} +#[doc = "Generated from 'VK_KHR_push_descriptor'"] +impl StructureType { + pub const PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR: Self = Self(1_000_080_000); +} +impl ExtConditionalRenderingFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_conditional_rendering\0") + } + } + pub const SPEC_VERSION: u32 = 2u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkCmdBeginConditionalRenderingEXT = unsafe extern "system" fn( + command_buffer: CommandBuffer, + p_conditional_rendering_begin: *const ConditionalRenderingBeginInfoEXT, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdEndConditionalRenderingEXT = + unsafe extern "system" fn(command_buffer: CommandBuffer); +#[derive(Clone)] +pub struct ExtConditionalRenderingFn { + pub cmd_begin_conditional_rendering_ext: PFN_vkCmdBeginConditionalRenderingEXT, + pub cmd_end_conditional_rendering_ext: PFN_vkCmdEndConditionalRenderingEXT, +} +unsafe impl Send for ExtConditionalRenderingFn {} +unsafe impl Sync for ExtConditionalRenderingFn {} +impl ExtConditionalRenderingFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + cmd_begin_conditional_rendering_ext: unsafe { + unsafe extern "system" fn cmd_begin_conditional_rendering_ext( + _command_buffer: CommandBuffer, + _p_conditional_rendering_begin: *const ConditionalRenderingBeginInfoEXT, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_begin_conditional_rendering_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdBeginConditionalRenderingEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_begin_conditional_rendering_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_end_conditional_rendering_ext: unsafe { + unsafe extern "system" fn cmd_end_conditional_rendering_ext( + _command_buffer: CommandBuffer, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_end_conditional_rendering_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdEndConditionalRenderingEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_end_conditional_rendering_ext + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_EXT_conditional_rendering'"] +impl AccessFlags { + #[doc = "read access flag for reading conditional rendering predicate"] + pub const CONDITIONAL_RENDERING_READ_EXT: Self = Self(0b1_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_EXT_conditional_rendering'"] +impl BufferUsageFlags { + #[doc = "Specifies the buffer can be used as predicate in conditional rendering"] + pub const CONDITIONAL_RENDERING_EXT: Self = Self(0b10_0000_0000); +} +#[doc = "Generated from 'VK_EXT_conditional_rendering'"] +impl PipelineStageFlags { + #[doc = "A pipeline stage for conditional rendering predicate fetch"] + pub const CONDITIONAL_RENDERING_EXT: Self = Self(0b100_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_EXT_conditional_rendering'"] +impl StructureType { + pub const COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT: Self = Self(1_000_081_000); + pub const PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT: Self = Self(1_000_081_001); + pub const CONDITIONAL_RENDERING_BEGIN_INFO_EXT: Self = Self(1_000_081_002); +} +impl KhrShaderFloat16Int8Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_shader_float16_int8\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct KhrShaderFloat16Int8Fn {} +unsafe impl Send for KhrShaderFloat16Int8Fn {} +unsafe impl Sync for KhrShaderFloat16Int8Fn {} +impl KhrShaderFloat16Int8Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_KHR_shader_float16_int8'"] +impl StructureType { + pub const PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES_KHR: Self = + Self::PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES; + pub const PHYSICAL_DEVICE_FLOAT16_INT8_FEATURES_KHR: Self = + Self::PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES; +} +impl Khr16bitStorageFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_16bit_storage\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct Khr16bitStorageFn {} +unsafe impl Send for Khr16bitStorageFn {} +unsafe impl Sync for Khr16bitStorageFn {} +impl Khr16bitStorageFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_KHR_16bit_storage'"] +impl StructureType { + pub const PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES_KHR: Self = + Self::PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES; +} +impl KhrIncrementalPresentFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_incremental_present\0") } + } + pub const SPEC_VERSION: u32 = 2u32; +} +#[derive(Clone)] +pub struct KhrIncrementalPresentFn {} +unsafe impl Send for KhrIncrementalPresentFn {} +unsafe impl Sync for KhrIncrementalPresentFn {} +impl KhrIncrementalPresentFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_KHR_incremental_present'"] +impl StructureType { + pub const PRESENT_REGIONS_KHR: Self = Self(1_000_084_000); +} +impl KhrDescriptorUpdateTemplateFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_descriptor_update_template\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkCreateDescriptorUpdateTemplate = unsafe extern "system" fn( + device: Device, + p_create_info: *const DescriptorUpdateTemplateCreateInfo, + p_allocator: *const AllocationCallbacks, + p_descriptor_update_template: *mut DescriptorUpdateTemplate, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkDestroyDescriptorUpdateTemplate = unsafe extern "system" fn( + device: Device, + descriptor_update_template: DescriptorUpdateTemplate, + p_allocator: *const AllocationCallbacks, +); +#[allow(non_camel_case_types)] +pub type PFN_vkUpdateDescriptorSetWithTemplate = unsafe extern "system" fn( + device: Device, + descriptor_set: DescriptorSet, + descriptor_update_template: DescriptorUpdateTemplate, + p_data: *const c_void, +); +#[derive(Clone)] +pub struct KhrDescriptorUpdateTemplateFn { + pub create_descriptor_update_template_khr: PFN_vkCreateDescriptorUpdateTemplate, + pub destroy_descriptor_update_template_khr: PFN_vkDestroyDescriptorUpdateTemplate, + pub update_descriptor_set_with_template_khr: PFN_vkUpdateDescriptorSetWithTemplate, + pub cmd_push_descriptor_set_with_template_khr: + crate::vk::PFN_vkCmdPushDescriptorSetWithTemplateKHR, +} +unsafe impl Send for KhrDescriptorUpdateTemplateFn {} +unsafe impl Sync for KhrDescriptorUpdateTemplateFn {} +impl KhrDescriptorUpdateTemplateFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + create_descriptor_update_template_khr: unsafe { + unsafe extern "system" fn create_descriptor_update_template_khr( + _device: Device, + _p_create_info: *const DescriptorUpdateTemplateCreateInfo, + _p_allocator: *const AllocationCallbacks, + _p_descriptor_update_template: *mut DescriptorUpdateTemplate, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(create_descriptor_update_template_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCreateDescriptorUpdateTemplateKHR\0", + ); + let val = _f(cname); + if val.is_null() { + create_descriptor_update_template_khr + } else { + ::std::mem::transmute(val) + } + }, + destroy_descriptor_update_template_khr: unsafe { + unsafe extern "system" fn destroy_descriptor_update_template_khr( + _device: Device, + _descriptor_update_template: DescriptorUpdateTemplate, + _p_allocator: *const AllocationCallbacks, + ) { + panic!(concat!( + "Unable to load ", + stringify!(destroy_descriptor_update_template_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkDestroyDescriptorUpdateTemplateKHR\0", + ); + let val = _f(cname); + if val.is_null() { + destroy_descriptor_update_template_khr + } else { + ::std::mem::transmute(val) + } + }, + update_descriptor_set_with_template_khr: unsafe { + unsafe extern "system" fn update_descriptor_set_with_template_khr( + _device: Device, + _descriptor_set: DescriptorSet, + _descriptor_update_template: DescriptorUpdateTemplate, + _p_data: *const c_void, + ) { + panic!(concat!( + "Unable to load ", + stringify!(update_descriptor_set_with_template_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkUpdateDescriptorSetWithTemplateKHR\0", + ); + let val = _f(cname); + if val.is_null() { + update_descriptor_set_with_template_khr + } else { + ::std::mem::transmute(val) + } + }, + cmd_push_descriptor_set_with_template_khr: unsafe { + unsafe extern "system" fn cmd_push_descriptor_set_with_template_khr( + _command_buffer: CommandBuffer, + _descriptor_update_template: DescriptorUpdateTemplate, + _layout: PipelineLayout, + _set: u32, + _p_data: *const c_void, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_push_descriptor_set_with_template_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdPushDescriptorSetWithTemplateKHR\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_push_descriptor_set_with_template_khr + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_KHR_descriptor_update_template'"] +impl DebugReportObjectTypeEXT { + pub const DESCRIPTOR_UPDATE_TEMPLATE_KHR: Self = Self::DESCRIPTOR_UPDATE_TEMPLATE; +} +#[doc = "Generated from 'VK_KHR_descriptor_update_template'"] +impl DescriptorUpdateTemplateType { + pub const DESCRIPTOR_SET_KHR: Self = Self::DESCRIPTOR_SET; +} +#[doc = "Generated from 'VK_KHR_descriptor_update_template'"] +impl ObjectType { + pub const DESCRIPTOR_UPDATE_TEMPLATE_KHR: Self = Self::DESCRIPTOR_UPDATE_TEMPLATE; +} +#[doc = "Generated from 'VK_KHR_descriptor_update_template'"] +impl StructureType { + pub const DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO_KHR: Self = + Self::DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO; +} +impl NvxDeviceGeneratedCommandsFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NVX_device_generated_commands\0") + } + } + pub const SPEC_VERSION: u32 = 3u32; +} +#[derive(Clone)] +pub struct NvxDeviceGeneratedCommandsFn {} +unsafe impl Send for NvxDeviceGeneratedCommandsFn {} +unsafe impl Sync for NvxDeviceGeneratedCommandsFn {} +impl NvxDeviceGeneratedCommandsFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl NvClipSpaceWScalingFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_clip_space_w_scaling\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetViewportWScalingNV = unsafe extern "system" fn( + command_buffer: CommandBuffer, + first_viewport: u32, + viewport_count: u32, + p_viewport_w_scalings: *const ViewportWScalingNV, +); +#[derive(Clone)] +pub struct NvClipSpaceWScalingFn { + pub cmd_set_viewport_w_scaling_nv: PFN_vkCmdSetViewportWScalingNV, +} +unsafe impl Send for NvClipSpaceWScalingFn {} +unsafe impl Sync for NvClipSpaceWScalingFn {} +impl NvClipSpaceWScalingFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + cmd_set_viewport_w_scaling_nv: unsafe { + unsafe extern "system" fn cmd_set_viewport_w_scaling_nv( + _command_buffer: CommandBuffer, + _first_viewport: u32, + _viewport_count: u32, + _p_viewport_w_scalings: *const ViewportWScalingNV, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_viewport_w_scaling_nv) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetViewportWScalingNV\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_viewport_w_scaling_nv + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_NV_clip_space_w_scaling'"] +impl DynamicState { + pub const VIEWPORT_W_SCALING_NV: Self = Self(1_000_087_000); +} +#[doc = "Generated from 'VK_NV_clip_space_w_scaling'"] +impl StructureType { + pub const PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV: Self = Self(1_000_087_000); +} +impl ExtDirectModeDisplayFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_direct_mode_display\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkReleaseDisplayEXT = + unsafe extern "system" fn(physical_device: PhysicalDevice, display: DisplayKHR) -> Result; +#[derive(Clone)] +pub struct ExtDirectModeDisplayFn { + pub release_display_ext: PFN_vkReleaseDisplayEXT, +} +unsafe impl Send for ExtDirectModeDisplayFn {} +unsafe impl Sync for ExtDirectModeDisplayFn {} +impl ExtDirectModeDisplayFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + release_display_ext: unsafe { + unsafe extern "system" fn release_display_ext( + _physical_device: PhysicalDevice, + _display: DisplayKHR, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(release_display_ext))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkReleaseDisplayEXT\0"); + let val = _f(cname); + if val.is_null() { + release_display_ext + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +impl ExtAcquireXlibDisplayFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_acquire_xlib_display\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkAcquireXlibDisplayEXT = unsafe extern "system" fn( + physical_device: PhysicalDevice, + dpy: *mut Display, + display: DisplayKHR, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetRandROutputDisplayEXT = unsafe extern "system" fn( + physical_device: PhysicalDevice, + dpy: *mut Display, + rr_output: RROutput, + p_display: *mut DisplayKHR, +) -> Result; +#[derive(Clone)] +pub struct ExtAcquireXlibDisplayFn { + pub acquire_xlib_display_ext: PFN_vkAcquireXlibDisplayEXT, + pub get_rand_r_output_display_ext: PFN_vkGetRandROutputDisplayEXT, +} +unsafe impl Send for ExtAcquireXlibDisplayFn {} +unsafe impl Sync for ExtAcquireXlibDisplayFn {} +impl ExtAcquireXlibDisplayFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + acquire_xlib_display_ext: unsafe { + unsafe extern "system" fn acquire_xlib_display_ext( + _physical_device: PhysicalDevice, + _dpy: *mut Display, + _display: DisplayKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(acquire_xlib_display_ext) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkAcquireXlibDisplayEXT\0"); + let val = _f(cname); + if val.is_null() { + acquire_xlib_display_ext + } else { + ::std::mem::transmute(val) + } + }, + get_rand_r_output_display_ext: unsafe { + unsafe extern "system" fn get_rand_r_output_display_ext( + _physical_device: PhysicalDevice, + _dpy: *mut Display, + _rr_output: RROutput, + _p_display: *mut DisplayKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_rand_r_output_display_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetRandROutputDisplayEXT\0", + ); + let val = _f(cname); + if val.is_null() { + get_rand_r_output_display_ext + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +impl ExtDisplaySurfaceCounterFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_display_surface_counter\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT = unsafe extern "system" fn( + physical_device: PhysicalDevice, + surface: SurfaceKHR, + p_surface_capabilities: *mut SurfaceCapabilities2EXT, +) -> Result; +#[derive(Clone)] +pub struct ExtDisplaySurfaceCounterFn { + pub get_physical_device_surface_capabilities2_ext: + PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT, +} +unsafe impl Send for ExtDisplaySurfaceCounterFn {} +unsafe impl Sync for ExtDisplaySurfaceCounterFn {} +impl ExtDisplaySurfaceCounterFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + get_physical_device_surface_capabilities2_ext: unsafe { + unsafe extern "system" fn get_physical_device_surface_capabilities2_ext( + _physical_device: PhysicalDevice, + _surface: SurfaceKHR, + _p_surface_capabilities: *mut SurfaceCapabilities2EXT, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_surface_capabilities2_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPhysicalDeviceSurfaceCapabilities2EXT\0", + ); + let val = _f(cname); + if val.is_null() { + get_physical_device_surface_capabilities2_ext + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_EXT_display_surface_counter'"] +impl StructureType { + pub const SURFACE_CAPABILITIES_2_EXT: Self = Self(1_000_090_000); +} +impl ExtDisplayControlFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_display_control\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkDisplayPowerControlEXT = unsafe extern "system" fn( + device: Device, + display: DisplayKHR, + p_display_power_info: *const DisplayPowerInfoEXT, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkRegisterDeviceEventEXT = unsafe extern "system" fn( + device: Device, + p_device_event_info: *const DeviceEventInfoEXT, + p_allocator: *const AllocationCallbacks, + p_fence: *mut Fence, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkRegisterDisplayEventEXT = unsafe extern "system" fn( + device: Device, + display: DisplayKHR, + p_display_event_info: *const DisplayEventInfoEXT, + p_allocator: *const AllocationCallbacks, + p_fence: *mut Fence, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetSwapchainCounterEXT = unsafe extern "system" fn( + device: Device, + swapchain: SwapchainKHR, + counter: SurfaceCounterFlagsEXT, + p_counter_value: *mut u64, +) -> Result; +#[derive(Clone)] +pub struct ExtDisplayControlFn { + pub display_power_control_ext: PFN_vkDisplayPowerControlEXT, + pub register_device_event_ext: PFN_vkRegisterDeviceEventEXT, + pub register_display_event_ext: PFN_vkRegisterDisplayEventEXT, + pub get_swapchain_counter_ext: PFN_vkGetSwapchainCounterEXT, +} +unsafe impl Send for ExtDisplayControlFn {} +unsafe impl Sync for ExtDisplayControlFn {} +impl ExtDisplayControlFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + display_power_control_ext: unsafe { + unsafe extern "system" fn display_power_control_ext( + _device: Device, + _display: DisplayKHR, + _p_display_power_info: *const DisplayPowerInfoEXT, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(display_power_control_ext) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDisplayPowerControlEXT\0"); + let val = _f(cname); + if val.is_null() { + display_power_control_ext + } else { + ::std::mem::transmute(val) + } + }, + register_device_event_ext: unsafe { + unsafe extern "system" fn register_device_event_ext( + _device: Device, + _p_device_event_info: *const DeviceEventInfoEXT, + _p_allocator: *const AllocationCallbacks, + _p_fence: *mut Fence, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(register_device_event_ext) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkRegisterDeviceEventEXT\0"); + let val = _f(cname); + if val.is_null() { + register_device_event_ext + } else { + ::std::mem::transmute(val) + } + }, + register_display_event_ext: unsafe { + unsafe extern "system" fn register_display_event_ext( + _device: Device, + _display: DisplayKHR, + _p_display_event_info: *const DisplayEventInfoEXT, + _p_allocator: *const AllocationCallbacks, + _p_fence: *mut Fence, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(register_display_event_ext) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkRegisterDisplayEventEXT\0"); + let val = _f(cname); + if val.is_null() { + register_display_event_ext + } else { + ::std::mem::transmute(val) + } + }, + get_swapchain_counter_ext: unsafe { + unsafe extern "system" fn get_swapchain_counter_ext( + _device: Device, + _swapchain: SwapchainKHR, + _counter: SurfaceCounterFlagsEXT, + _p_counter_value: *mut u64, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_swapchain_counter_ext) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetSwapchainCounterEXT\0"); + let val = _f(cname); + if val.is_null() { + get_swapchain_counter_ext + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_EXT_display_control'"] +impl StructureType { + pub const DISPLAY_POWER_INFO_EXT: Self = Self(1_000_091_000); + pub const DEVICE_EVENT_INFO_EXT: Self = Self(1_000_091_001); + pub const DISPLAY_EVENT_INFO_EXT: Self = Self(1_000_091_002); + pub const SWAPCHAIN_COUNTER_CREATE_INFO_EXT: Self = Self(1_000_091_003); +} +impl GoogleDisplayTimingFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_GOOGLE_display_timing\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkGetRefreshCycleDurationGOOGLE = unsafe extern "system" fn( + device: Device, + swapchain: SwapchainKHR, + p_display_timing_properties: *mut RefreshCycleDurationGOOGLE, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetPastPresentationTimingGOOGLE = unsafe extern "system" fn( + device: Device, + swapchain: SwapchainKHR, + p_presentation_timing_count: *mut u32, + p_presentation_timings: *mut PastPresentationTimingGOOGLE, +) -> Result; +#[derive(Clone)] +pub struct GoogleDisplayTimingFn { + pub get_refresh_cycle_duration_google: PFN_vkGetRefreshCycleDurationGOOGLE, + pub get_past_presentation_timing_google: PFN_vkGetPastPresentationTimingGOOGLE, +} +unsafe impl Send for GoogleDisplayTimingFn {} +unsafe impl Sync for GoogleDisplayTimingFn {} +impl GoogleDisplayTimingFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + get_refresh_cycle_duration_google: unsafe { + unsafe extern "system" fn get_refresh_cycle_duration_google( + _device: Device, + _swapchain: SwapchainKHR, + _p_display_timing_properties: *mut RefreshCycleDurationGOOGLE, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_refresh_cycle_duration_google) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetRefreshCycleDurationGOOGLE\0", + ); + let val = _f(cname); + if val.is_null() { + get_refresh_cycle_duration_google + } else { + ::std::mem::transmute(val) + } + }, + get_past_presentation_timing_google: unsafe { + unsafe extern "system" fn get_past_presentation_timing_google( + _device: Device, + _swapchain: SwapchainKHR, + _p_presentation_timing_count: *mut u32, + _p_presentation_timings: *mut PastPresentationTimingGOOGLE, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_past_presentation_timing_google) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPastPresentationTimingGOOGLE\0", + ); + let val = _f(cname); + if val.is_null() { + get_past_presentation_timing_google + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_GOOGLE_display_timing'"] +impl StructureType { + pub const PRESENT_TIMES_INFO_GOOGLE: Self = Self(1_000_092_000); +} +impl NvSampleMaskOverrideCoverageFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"VK_NV_sample_mask_override_coverage\0", + ) + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct NvSampleMaskOverrideCoverageFn {} +unsafe impl Send for NvSampleMaskOverrideCoverageFn {} +unsafe impl Sync for NvSampleMaskOverrideCoverageFn {} +impl NvSampleMaskOverrideCoverageFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl NvGeometryShaderPassthroughFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_geometry_shader_passthrough\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct NvGeometryShaderPassthroughFn {} +unsafe impl Send for NvGeometryShaderPassthroughFn {} +unsafe impl Sync for NvGeometryShaderPassthroughFn {} +impl NvGeometryShaderPassthroughFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl NvViewportArray2Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_viewport_array2\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct NvViewportArray2Fn {} +unsafe impl Send for NvViewportArray2Fn {} +unsafe impl Sync for NvViewportArray2Fn {} +impl NvViewportArray2Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl NvxMultiviewPerViewAttributesFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"VK_NVX_multiview_per_view_attributes\0", + ) + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct NvxMultiviewPerViewAttributesFn {} +unsafe impl Send for NvxMultiviewPerViewAttributesFn {} +unsafe impl Sync for NvxMultiviewPerViewAttributesFn {} +impl NvxMultiviewPerViewAttributesFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_NVX_multiview_per_view_attributes'"] +impl StructureType { + pub const PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX: Self = + Self(1_000_097_000); +} +#[doc = "Generated from 'VK_NVX_multiview_per_view_attributes'"] +impl SubpassDescriptionFlags { + pub const PER_VIEW_ATTRIBUTES_NVX: Self = Self(0b1); + pub const PER_VIEW_POSITION_X_ONLY_NVX: Self = Self(0b10); +} +impl NvViewportSwizzleFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_viewport_swizzle\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct NvViewportSwizzleFn {} +unsafe impl Send for NvViewportSwizzleFn {} +unsafe impl Sync for NvViewportSwizzleFn {} +impl NvViewportSwizzleFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_NV_viewport_swizzle'"] +impl StructureType { + pub const PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV: Self = Self(1_000_098_000); +} +impl ExtDiscardRectanglesFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_discard_rectangles\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetDiscardRectangleEXT = unsafe extern "system" fn( + command_buffer: CommandBuffer, + first_discard_rectangle: u32, + discard_rectangle_count: u32, + p_discard_rectangles: *const Rect2D, +); +#[derive(Clone)] +pub struct ExtDiscardRectanglesFn { + pub cmd_set_discard_rectangle_ext: PFN_vkCmdSetDiscardRectangleEXT, +} +unsafe impl Send for ExtDiscardRectanglesFn {} +unsafe impl Sync for ExtDiscardRectanglesFn {} +impl ExtDiscardRectanglesFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + cmd_set_discard_rectangle_ext: unsafe { + unsafe extern "system" fn cmd_set_discard_rectangle_ext( + _command_buffer: CommandBuffer, + _first_discard_rectangle: u32, + _discard_rectangle_count: u32, + _p_discard_rectangles: *const Rect2D, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_discard_rectangle_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetDiscardRectangleEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_discard_rectangle_ext + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_EXT_discard_rectangles'"] +impl DynamicState { + pub const DISCARD_RECTANGLE_EXT: Self = Self(1_000_099_000); +} +#[doc = "Generated from 'VK_EXT_discard_rectangles'"] +impl StructureType { + pub const PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT: Self = Self(1_000_099_000); + pub const PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT: Self = Self(1_000_099_001); +} +impl NvExtension101Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_101\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct NvExtension101Fn {} +unsafe impl Send for NvExtension101Fn {} +unsafe impl Sync for NvExtension101Fn {} +impl NvExtension101Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtConservativeRasterizationFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_conservative_rasterization\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct ExtConservativeRasterizationFn {} +unsafe impl Send for ExtConservativeRasterizationFn {} +unsafe impl Sync for ExtConservativeRasterizationFn {} +impl ExtConservativeRasterizationFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_conservative_rasterization'"] +impl StructureType { + pub const PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT: Self = Self(1_000_101_000); + pub const PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT: Self = Self(1_000_101_001); +} +impl ExtDepthClipEnableFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_depth_clip_enable\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct ExtDepthClipEnableFn {} +unsafe impl Send for ExtDepthClipEnableFn {} +unsafe impl Sync for ExtDepthClipEnableFn {} +impl ExtDepthClipEnableFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_depth_clip_enable'"] +impl StructureType { + pub const PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT: Self = Self(1_000_102_000); + pub const PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT: Self = Self(1_000_102_001); +} +impl NvExtension104Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_104\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct NvExtension104Fn {} +unsafe impl Send for NvExtension104Fn {} +unsafe impl Sync for NvExtension104Fn {} +impl NvExtension104Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtSwapchainColorspaceFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_swapchain_colorspace\0") } + } + pub const SPEC_VERSION: u32 = 4u32; +} +#[derive(Clone)] +pub struct ExtSwapchainColorspaceFn {} +unsafe impl Send for ExtSwapchainColorspaceFn {} +unsafe impl Sync for ExtSwapchainColorspaceFn {} +impl ExtSwapchainColorspaceFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_swapchain_colorspace'"] +impl ColorSpaceKHR { + pub const DISPLAY_P3_NONLINEAR_EXT: Self = Self(1_000_104_001); + pub const EXTENDED_SRGB_LINEAR_EXT: Self = Self(1_000_104_002); + pub const DISPLAY_P3_LINEAR_EXT: Self = Self(1_000_104_003); + pub const DCI_P3_NONLINEAR_EXT: Self = Self(1_000_104_004); + pub const BT709_LINEAR_EXT: Self = Self(1_000_104_005); + pub const BT709_NONLINEAR_EXT: Self = Self(1_000_104_006); + pub const BT2020_LINEAR_EXT: Self = Self(1_000_104_007); + pub const HDR10_ST2084_EXT: Self = Self(1_000_104_008); + pub const DOLBYVISION_EXT: Self = Self(1_000_104_009); + pub const HDR10_HLG_EXT: Self = Self(1_000_104_010); + pub const ADOBERGB_LINEAR_EXT: Self = Self(1_000_104_011); + pub const ADOBERGB_NONLINEAR_EXT: Self = Self(1_000_104_012); + pub const PASS_THROUGH_EXT: Self = Self(1_000_104_013); + pub const EXTENDED_SRGB_NONLINEAR_EXT: Self = Self(1_000_104_014); +} +impl ExtHdrMetadataFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_hdr_metadata\0") } + } + pub const SPEC_VERSION: u32 = 2u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkSetHdrMetadataEXT = unsafe extern "system" fn( + device: Device, + swapchain_count: u32, + p_swapchains: *const SwapchainKHR, + p_metadata: *const HdrMetadataEXT, +); +#[derive(Clone)] +pub struct ExtHdrMetadataFn { + pub set_hdr_metadata_ext: PFN_vkSetHdrMetadataEXT, +} +unsafe impl Send for ExtHdrMetadataFn {} +unsafe impl Sync for ExtHdrMetadataFn {} +impl ExtHdrMetadataFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + set_hdr_metadata_ext: unsafe { + unsafe extern "system" fn set_hdr_metadata_ext( + _device: Device, + _swapchain_count: u32, + _p_swapchains: *const SwapchainKHR, + _p_metadata: *const HdrMetadataEXT, + ) { + panic!(concat!("Unable to load ", stringify!(set_hdr_metadata_ext))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkSetHdrMetadataEXT\0"); + let val = _f(cname); + if val.is_null() { + set_hdr_metadata_ext + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_EXT_hdr_metadata'"] +impl StructureType { + pub const HDR_METADATA_EXT: Self = Self(1_000_105_000); +} +impl ImgExtension107Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_IMG_extension_107\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct ImgExtension107Fn {} +unsafe impl Send for ImgExtension107Fn {} +unsafe impl Sync for ImgExtension107Fn {} +impl ImgExtension107Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ImgExtension108Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_IMG_extension_108\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct ImgExtension108Fn {} +unsafe impl Send for ImgExtension108Fn {} +unsafe impl Sync for ImgExtension108Fn {} +impl ImgExtension108Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl KhrImagelessFramebufferFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_imageless_framebuffer\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct KhrImagelessFramebufferFn {} +unsafe impl Send for KhrImagelessFramebufferFn {} +unsafe impl Sync for KhrImagelessFramebufferFn {} +impl KhrImagelessFramebufferFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_KHR_imageless_framebuffer'"] +impl FramebufferCreateFlags { + pub const IMAGELESS_KHR: Self = Self::IMAGELESS; +} +#[doc = "Generated from 'VK_KHR_imageless_framebuffer'"] +impl StructureType { + pub const PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES_KHR: Self = + Self::PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES; + pub const FRAMEBUFFER_ATTACHMENTS_CREATE_INFO_KHR: Self = + Self::FRAMEBUFFER_ATTACHMENTS_CREATE_INFO; + pub const FRAMEBUFFER_ATTACHMENT_IMAGE_INFO_KHR: Self = Self::FRAMEBUFFER_ATTACHMENT_IMAGE_INFO; + pub const RENDER_PASS_ATTACHMENT_BEGIN_INFO_KHR: Self = Self::RENDER_PASS_ATTACHMENT_BEGIN_INFO; +} +impl KhrCreateRenderpass2Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_create_renderpass2\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkCreateRenderPass2 = unsafe extern "system" fn( + device: Device, + p_create_info: *const RenderPassCreateInfo2, + p_allocator: *const AllocationCallbacks, + p_render_pass: *mut RenderPass, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkCmdBeginRenderPass2 = unsafe extern "system" fn( + command_buffer: CommandBuffer, + p_render_pass_begin: *const RenderPassBeginInfo, + p_subpass_begin_info: *const SubpassBeginInfo, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdNextSubpass2 = unsafe extern "system" fn( + command_buffer: CommandBuffer, + p_subpass_begin_info: *const SubpassBeginInfo, + p_subpass_end_info: *const SubpassEndInfo, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdEndRenderPass2 = unsafe extern "system" fn( + command_buffer: CommandBuffer, + p_subpass_end_info: *const SubpassEndInfo, +); +#[derive(Clone)] +pub struct KhrCreateRenderpass2Fn { + pub create_render_pass2_khr: PFN_vkCreateRenderPass2, + pub cmd_begin_render_pass2_khr: PFN_vkCmdBeginRenderPass2, + pub cmd_next_subpass2_khr: PFN_vkCmdNextSubpass2, + pub cmd_end_render_pass2_khr: PFN_vkCmdEndRenderPass2, +} +unsafe impl Send for KhrCreateRenderpass2Fn {} +unsafe impl Sync for KhrCreateRenderpass2Fn {} +impl KhrCreateRenderpass2Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + create_render_pass2_khr: unsafe { + unsafe extern "system" fn create_render_pass2_khr( + _device: Device, + _p_create_info: *const RenderPassCreateInfo2, + _p_allocator: *const AllocationCallbacks, + _p_render_pass: *mut RenderPass, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(create_render_pass2_khr) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateRenderPass2KHR\0"); + let val = _f(cname); + if val.is_null() { + create_render_pass2_khr + } else { + ::std::mem::transmute(val) + } + }, + cmd_begin_render_pass2_khr: unsafe { + unsafe extern "system" fn cmd_begin_render_pass2_khr( + _command_buffer: CommandBuffer, + _p_render_pass_begin: *const RenderPassBeginInfo, + _p_subpass_begin_info: *const SubpassBeginInfo, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_begin_render_pass2_khr) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdBeginRenderPass2KHR\0"); + let val = _f(cname); + if val.is_null() { + cmd_begin_render_pass2_khr + } else { + ::std::mem::transmute(val) + } + }, + cmd_next_subpass2_khr: unsafe { + unsafe extern "system" fn cmd_next_subpass2_khr( + _command_buffer: CommandBuffer, + _p_subpass_begin_info: *const SubpassBeginInfo, + _p_subpass_end_info: *const SubpassEndInfo, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_next_subpass2_khr) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdNextSubpass2KHR\0"); + let val = _f(cname); + if val.is_null() { + cmd_next_subpass2_khr + } else { + ::std::mem::transmute(val) + } + }, + cmd_end_render_pass2_khr: unsafe { + unsafe extern "system" fn cmd_end_render_pass2_khr( + _command_buffer: CommandBuffer, + _p_subpass_end_info: *const SubpassEndInfo, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_end_render_pass2_khr) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdEndRenderPass2KHR\0"); + let val = _f(cname); + if val.is_null() { + cmd_end_render_pass2_khr + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_KHR_create_renderpass2'"] +impl StructureType { + pub const ATTACHMENT_DESCRIPTION_2_KHR: Self = Self::ATTACHMENT_DESCRIPTION_2; + pub const ATTACHMENT_REFERENCE_2_KHR: Self = Self::ATTACHMENT_REFERENCE_2; + pub const SUBPASS_DESCRIPTION_2_KHR: Self = Self::SUBPASS_DESCRIPTION_2; + pub const SUBPASS_DEPENDENCY_2_KHR: Self = Self::SUBPASS_DEPENDENCY_2; + pub const RENDER_PASS_CREATE_INFO_2_KHR: Self = Self::RENDER_PASS_CREATE_INFO_2; + pub const SUBPASS_BEGIN_INFO_KHR: Self = Self::SUBPASS_BEGIN_INFO; + pub const SUBPASS_END_INFO_KHR: Self = Self::SUBPASS_END_INFO; +} +impl ImgExtension111Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_IMG_extension_111\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct ImgExtension111Fn {} +unsafe impl Send for ImgExtension111Fn {} +unsafe impl Sync for ImgExtension111Fn {} +impl ImgExtension111Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl KhrSharedPresentableImageFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_shared_presentable_image\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkGetSwapchainStatusKHR = + unsafe extern "system" fn(device: Device, swapchain: SwapchainKHR) -> Result; +#[derive(Clone)] +pub struct KhrSharedPresentableImageFn { + pub get_swapchain_status_khr: PFN_vkGetSwapchainStatusKHR, +} +unsafe impl Send for KhrSharedPresentableImageFn {} +unsafe impl Sync for KhrSharedPresentableImageFn {} +impl KhrSharedPresentableImageFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + get_swapchain_status_khr: unsafe { + unsafe extern "system" fn get_swapchain_status_khr( + _device: Device, + _swapchain: SwapchainKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_swapchain_status_khr) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetSwapchainStatusKHR\0"); + let val = _f(cname); + if val.is_null() { + get_swapchain_status_khr + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_KHR_shared_presentable_image'"] +impl ImageLayout { + pub const SHARED_PRESENT_KHR: Self = Self(1_000_111_000); +} +#[doc = "Generated from 'VK_KHR_shared_presentable_image'"] +impl PresentModeKHR { + pub const SHARED_DEMAND_REFRESH: Self = Self(1_000_111_000); + pub const SHARED_CONTINUOUS_REFRESH: Self = Self(1_000_111_001); +} +#[doc = "Generated from 'VK_KHR_shared_presentable_image'"] +impl StructureType { + pub const SHARED_PRESENT_SURFACE_CAPABILITIES_KHR: Self = Self(1_000_111_000); +} +impl KhrExternalFenceCapabilitiesFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_external_fence_capabilities\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkGetPhysicalDeviceExternalFenceProperties = unsafe extern "system" fn( + physical_device: PhysicalDevice, + p_external_fence_info: *const PhysicalDeviceExternalFenceInfo, + p_external_fence_properties: *mut ExternalFenceProperties, +); +#[derive(Clone)] +pub struct KhrExternalFenceCapabilitiesFn { + pub get_physical_device_external_fence_properties_khr: + PFN_vkGetPhysicalDeviceExternalFenceProperties, +} +unsafe impl Send for KhrExternalFenceCapabilitiesFn {} +unsafe impl Sync for KhrExternalFenceCapabilitiesFn {} +impl KhrExternalFenceCapabilitiesFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + get_physical_device_external_fence_properties_khr: unsafe { + unsafe extern "system" fn get_physical_device_external_fence_properties_khr( + _physical_device: PhysicalDevice, + _p_external_fence_info: *const PhysicalDeviceExternalFenceInfo, + _p_external_fence_properties: *mut ExternalFenceProperties, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_external_fence_properties_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPhysicalDeviceExternalFencePropertiesKHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_physical_device_external_fence_properties_khr + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_KHR_external_fence_capabilities'"] +impl ExternalFenceFeatureFlags { + pub const EXPORTABLE_KHR: Self = Self::EXPORTABLE; + pub const IMPORTABLE_KHR: Self = Self::IMPORTABLE; +} +#[doc = "Generated from 'VK_KHR_external_fence_capabilities'"] +impl ExternalFenceHandleTypeFlags { + pub const OPAQUE_FD_KHR: Self = Self::OPAQUE_FD; + pub const OPAQUE_WIN32_KHR: Self = Self::OPAQUE_WIN32; + pub const OPAQUE_WIN32_KMT_KHR: Self = Self::OPAQUE_WIN32_KMT; + pub const SYNC_FD_KHR: Self = Self::SYNC_FD; +} +#[doc = "Generated from 'VK_KHR_external_fence_capabilities'"] +impl StructureType { + pub const PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO_KHR: Self = + Self::PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO; + pub const EXTERNAL_FENCE_PROPERTIES_KHR: Self = Self::EXTERNAL_FENCE_PROPERTIES; +} +impl KhrExternalFenceFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_external_fence\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct KhrExternalFenceFn {} +unsafe impl Send for KhrExternalFenceFn {} +unsafe impl Sync for KhrExternalFenceFn {} +impl KhrExternalFenceFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_KHR_external_fence'"] +impl FenceImportFlags { + pub const TEMPORARY_KHR: Self = Self::TEMPORARY; +} +#[doc = "Generated from 'VK_KHR_external_fence'"] +impl StructureType { + pub const EXPORT_FENCE_CREATE_INFO_KHR: Self = Self::EXPORT_FENCE_CREATE_INFO; +} +impl KhrExternalFenceWin32Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_external_fence_win32\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkImportFenceWin32HandleKHR = unsafe extern "system" fn( + device: Device, + p_import_fence_win32_handle_info: *const ImportFenceWin32HandleInfoKHR, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetFenceWin32HandleKHR = unsafe extern "system" fn( + device: Device, + p_get_win32_handle_info: *const FenceGetWin32HandleInfoKHR, + p_handle: *mut HANDLE, +) -> Result; +#[derive(Clone)] +pub struct KhrExternalFenceWin32Fn { + pub import_fence_win32_handle_khr: PFN_vkImportFenceWin32HandleKHR, + pub get_fence_win32_handle_khr: PFN_vkGetFenceWin32HandleKHR, +} +unsafe impl Send for KhrExternalFenceWin32Fn {} +unsafe impl Sync for KhrExternalFenceWin32Fn {} +impl KhrExternalFenceWin32Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + import_fence_win32_handle_khr: unsafe { + unsafe extern "system" fn import_fence_win32_handle_khr( + _device: Device, + _p_import_fence_win32_handle_info: *const ImportFenceWin32HandleInfoKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(import_fence_win32_handle_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkImportFenceWin32HandleKHR\0", + ); + let val = _f(cname); + if val.is_null() { + import_fence_win32_handle_khr + } else { + ::std::mem::transmute(val) + } + }, + get_fence_win32_handle_khr: unsafe { + unsafe extern "system" fn get_fence_win32_handle_khr( + _device: Device, + _p_get_win32_handle_info: *const FenceGetWin32HandleInfoKHR, + _p_handle: *mut HANDLE, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_fence_win32_handle_khr) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetFenceWin32HandleKHR\0"); + let val = _f(cname); + if val.is_null() { + get_fence_win32_handle_khr + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_KHR_external_fence_win32'"] +impl StructureType { + pub const IMPORT_FENCE_WIN32_HANDLE_INFO_KHR: Self = Self(1_000_114_000); + pub const EXPORT_FENCE_WIN32_HANDLE_INFO_KHR: Self = Self(1_000_114_001); + pub const FENCE_GET_WIN32_HANDLE_INFO_KHR: Self = Self(1_000_114_002); +} +impl KhrExternalFenceFdFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_external_fence_fd\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkImportFenceFdKHR = unsafe extern "system" fn( + device: Device, + p_import_fence_fd_info: *const ImportFenceFdInfoKHR, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetFenceFdKHR = unsafe extern "system" fn( + device: Device, + p_get_fd_info: *const FenceGetFdInfoKHR, + p_fd: *mut c_int, +) -> Result; +#[derive(Clone)] +pub struct KhrExternalFenceFdFn { + pub import_fence_fd_khr: PFN_vkImportFenceFdKHR, + pub get_fence_fd_khr: PFN_vkGetFenceFdKHR, +} +unsafe impl Send for KhrExternalFenceFdFn {} +unsafe impl Sync for KhrExternalFenceFdFn {} +impl KhrExternalFenceFdFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + import_fence_fd_khr: unsafe { + unsafe extern "system" fn import_fence_fd_khr( + _device: Device, + _p_import_fence_fd_info: *const ImportFenceFdInfoKHR, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(import_fence_fd_khr))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkImportFenceFdKHR\0"); + let val = _f(cname); + if val.is_null() { + import_fence_fd_khr + } else { + ::std::mem::transmute(val) + } + }, + get_fence_fd_khr: unsafe { + unsafe extern "system" fn get_fence_fd_khr( + _device: Device, + _p_get_fd_info: *const FenceGetFdInfoKHR, + _p_fd: *mut c_int, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(get_fence_fd_khr))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetFenceFdKHR\0"); + let val = _f(cname); + if val.is_null() { + get_fence_fd_khr + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_KHR_external_fence_fd'"] +impl StructureType { + pub const IMPORT_FENCE_FD_INFO_KHR: Self = Self(1_000_115_000); + pub const FENCE_GET_FD_INFO_KHR: Self = Self(1_000_115_001); +} +impl KhrPerformanceQueryFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_performance_query\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR = + unsafe extern "system" fn( + physical_device: PhysicalDevice, + queue_family_index: u32, + p_counter_count: *mut u32, + p_counters: *mut PerformanceCounterKHR, + p_counter_descriptions: *mut PerformanceCounterDescriptionKHR, + ) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR = + unsafe extern "system" fn( + physical_device: PhysicalDevice, + p_performance_query_create_info: *const QueryPoolPerformanceCreateInfoKHR, + p_num_passes: *mut u32, + ); +#[allow(non_camel_case_types)] +pub type PFN_vkAcquireProfilingLockKHR = + unsafe extern "system" fn(device: Device, p_info: *const AcquireProfilingLockInfoKHR) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkReleaseProfilingLockKHR = unsafe extern "system" fn(device: Device); +#[derive(Clone)] +pub struct KhrPerformanceQueryFn { + pub enumerate_physical_device_queue_family_performance_query_counters_khr: + PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR, + pub get_physical_device_queue_family_performance_query_passes_khr: + PFN_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR, + pub acquire_profiling_lock_khr: PFN_vkAcquireProfilingLockKHR, + pub release_profiling_lock_khr: PFN_vkReleaseProfilingLockKHR, +} +unsafe impl Send for KhrPerformanceQueryFn {} +unsafe impl Sync for KhrPerformanceQueryFn {} +impl KhrPerformanceQueryFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + enumerate_physical_device_queue_family_performance_query_counters_khr: unsafe { + unsafe extern "system" fn enumerate_physical_device_queue_family_performance_query_counters_khr( + _physical_device: PhysicalDevice, + _queue_family_index: u32, + _p_counter_count: *mut u32, + _p_counters: *mut PerformanceCounterKHR, + _p_counter_descriptions: *mut PerformanceCounterDescriptionKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!( + enumerate_physical_device_queue_family_performance_query_counters_khr + ) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR\0", + ); + let val = _f(cname); + if val.is_null() { + enumerate_physical_device_queue_family_performance_query_counters_khr + } else { + ::std::mem::transmute(val) + } + }, + get_physical_device_queue_family_performance_query_passes_khr: unsafe { + unsafe extern "system" fn get_physical_device_queue_family_performance_query_passes_khr( + _physical_device: PhysicalDevice, + _p_performance_query_create_info: *const QueryPoolPerformanceCreateInfoKHR, + _p_num_passes: *mut u32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_queue_family_performance_query_passes_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_physical_device_queue_family_performance_query_passes_khr + } else { + ::std::mem::transmute(val) + } + }, + acquire_profiling_lock_khr: unsafe { + unsafe extern "system" fn acquire_profiling_lock_khr( + _device: Device, + _p_info: *const AcquireProfilingLockInfoKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(acquire_profiling_lock_khr) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkAcquireProfilingLockKHR\0"); + let val = _f(cname); + if val.is_null() { + acquire_profiling_lock_khr + } else { + ::std::mem::transmute(val) + } + }, + release_profiling_lock_khr: unsafe { + unsafe extern "system" fn release_profiling_lock_khr(_device: Device) { + panic!(concat!( + "Unable to load ", + stringify!(release_profiling_lock_khr) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkReleaseProfilingLockKHR\0"); + let val = _f(cname); + if val.is_null() { + release_profiling_lock_khr + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_KHR_performance_query'"] +impl QueryType { + pub const PERFORMANCE_QUERY_KHR: Self = Self(1_000_116_000); +} +#[doc = "Generated from 'VK_KHR_performance_query'"] +impl StructureType { + pub const PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR: Self = Self(1_000_116_000); + pub const PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR: Self = Self(1_000_116_001); + pub const QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR: Self = Self(1_000_116_002); + pub const PERFORMANCE_QUERY_SUBMIT_INFO_KHR: Self = Self(1_000_116_003); + pub const ACQUIRE_PROFILING_LOCK_INFO_KHR: Self = Self(1_000_116_004); + pub const PERFORMANCE_COUNTER_KHR: Self = Self(1_000_116_005); + pub const PERFORMANCE_COUNTER_DESCRIPTION_KHR: Self = Self(1_000_116_006); +} +impl KhrMaintenance2Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_maintenance2\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct KhrMaintenance2Fn {} +unsafe impl Send for KhrMaintenance2Fn {} +unsafe impl Sync for KhrMaintenance2Fn {} +impl KhrMaintenance2Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_KHR_maintenance2'"] +impl ImageCreateFlags { + pub const BLOCK_TEXEL_VIEW_COMPATIBLE_KHR: Self = Self::BLOCK_TEXEL_VIEW_COMPATIBLE; + pub const EXTENDED_USAGE_KHR: Self = Self::EXTENDED_USAGE; +} +#[doc = "Generated from 'VK_KHR_maintenance2'"] +impl ImageLayout { + pub const DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL_KHR: Self = + Self::DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL; + pub const DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL_KHR: Self = + Self::DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL; +} +#[doc = "Generated from 'VK_KHR_maintenance2'"] +impl PointClippingBehavior { + pub const ALL_CLIP_PLANES_KHR: Self = Self::ALL_CLIP_PLANES; + pub const USER_CLIP_PLANES_ONLY_KHR: Self = Self::USER_CLIP_PLANES_ONLY; +} +#[doc = "Generated from 'VK_KHR_maintenance2'"] +impl StructureType { + pub const PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES_KHR: Self = + Self::PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES; + pub const RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO_KHR: Self = + Self::RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO; + pub const IMAGE_VIEW_USAGE_CREATE_INFO_KHR: Self = Self::IMAGE_VIEW_USAGE_CREATE_INFO; + pub const PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO_KHR: Self = + Self::PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO; +} +#[doc = "Generated from 'VK_KHR_maintenance2'"] +impl TessellationDomainOrigin { + pub const UPPER_LEFT_KHR: Self = Self::UPPER_LEFT; + pub const LOWER_LEFT_KHR: Self = Self::LOWER_LEFT; +} +impl KhrExtension119Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_extension_119\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct KhrExtension119Fn {} +unsafe impl Send for KhrExtension119Fn {} +unsafe impl Sync for KhrExtension119Fn {} +impl KhrExtension119Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl KhrGetSurfaceCapabilities2Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_get_surface_capabilities2\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR = unsafe extern "system" fn( + physical_device: PhysicalDevice, + p_surface_info: *const PhysicalDeviceSurfaceInfo2KHR, + p_surface_capabilities: *mut SurfaceCapabilities2KHR, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetPhysicalDeviceSurfaceFormats2KHR = unsafe extern "system" fn( + physical_device: PhysicalDevice, + p_surface_info: *const PhysicalDeviceSurfaceInfo2KHR, + p_surface_format_count: *mut u32, + p_surface_formats: *mut SurfaceFormat2KHR, +) -> Result; +#[derive(Clone)] +pub struct KhrGetSurfaceCapabilities2Fn { + pub get_physical_device_surface_capabilities2_khr: + PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR, + pub get_physical_device_surface_formats2_khr: PFN_vkGetPhysicalDeviceSurfaceFormats2KHR, +} +unsafe impl Send for KhrGetSurfaceCapabilities2Fn {} +unsafe impl Sync for KhrGetSurfaceCapabilities2Fn {} +impl KhrGetSurfaceCapabilities2Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + get_physical_device_surface_capabilities2_khr: unsafe { + unsafe extern "system" fn get_physical_device_surface_capabilities2_khr( + _physical_device: PhysicalDevice, + _p_surface_info: *const PhysicalDeviceSurfaceInfo2KHR, + _p_surface_capabilities: *mut SurfaceCapabilities2KHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_surface_capabilities2_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPhysicalDeviceSurfaceCapabilities2KHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_physical_device_surface_capabilities2_khr + } else { + ::std::mem::transmute(val) + } + }, + get_physical_device_surface_formats2_khr: unsafe { + unsafe extern "system" fn get_physical_device_surface_formats2_khr( + _physical_device: PhysicalDevice, + _p_surface_info: *const PhysicalDeviceSurfaceInfo2KHR, + _p_surface_format_count: *mut u32, + _p_surface_formats: *mut SurfaceFormat2KHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_surface_formats2_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPhysicalDeviceSurfaceFormats2KHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_physical_device_surface_formats2_khr + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_KHR_get_surface_capabilities2'"] +impl StructureType { + pub const PHYSICAL_DEVICE_SURFACE_INFO_2_KHR: Self = Self(1_000_119_000); + pub const SURFACE_CAPABILITIES_2_KHR: Self = Self(1_000_119_001); + pub const SURFACE_FORMAT_2_KHR: Self = Self(1_000_119_002); +} +impl KhrVariablePointersFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_variable_pointers\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct KhrVariablePointersFn {} +unsafe impl Send for KhrVariablePointersFn {} +unsafe impl Sync for KhrVariablePointersFn {} +impl KhrVariablePointersFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_KHR_variable_pointers'"] +impl StructureType { + pub const PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES_KHR: Self = + Self::PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES; + pub const PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES_KHR: Self = + Self::PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES_KHR; +} +impl KhrGetDisplayProperties2Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_get_display_properties2\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkGetPhysicalDeviceDisplayProperties2KHR = unsafe extern "system" fn( + physical_device: PhysicalDevice, + p_property_count: *mut u32, + p_properties: *mut DisplayProperties2KHR, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetPhysicalDeviceDisplayPlaneProperties2KHR = unsafe extern "system" fn( + physical_device: PhysicalDevice, + p_property_count: *mut u32, + p_properties: *mut DisplayPlaneProperties2KHR, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetDisplayModeProperties2KHR = unsafe extern "system" fn( + physical_device: PhysicalDevice, + display: DisplayKHR, + p_property_count: *mut u32, + p_properties: *mut DisplayModeProperties2KHR, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetDisplayPlaneCapabilities2KHR = unsafe extern "system" fn( + physical_device: PhysicalDevice, + p_display_plane_info: *const DisplayPlaneInfo2KHR, + p_capabilities: *mut DisplayPlaneCapabilities2KHR, +) -> Result; +#[derive(Clone)] +pub struct KhrGetDisplayProperties2Fn { + pub get_physical_device_display_properties2_khr: PFN_vkGetPhysicalDeviceDisplayProperties2KHR, + pub get_physical_device_display_plane_properties2_khr: + PFN_vkGetPhysicalDeviceDisplayPlaneProperties2KHR, + pub get_display_mode_properties2_khr: PFN_vkGetDisplayModeProperties2KHR, + pub get_display_plane_capabilities2_khr: PFN_vkGetDisplayPlaneCapabilities2KHR, +} +unsafe impl Send for KhrGetDisplayProperties2Fn {} +unsafe impl Sync for KhrGetDisplayProperties2Fn {} +impl KhrGetDisplayProperties2Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + get_physical_device_display_properties2_khr: unsafe { + unsafe extern "system" fn get_physical_device_display_properties2_khr( + _physical_device: PhysicalDevice, + _p_property_count: *mut u32, + _p_properties: *mut DisplayProperties2KHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_display_properties2_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPhysicalDeviceDisplayProperties2KHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_physical_device_display_properties2_khr + } else { + ::std::mem::transmute(val) + } + }, + get_physical_device_display_plane_properties2_khr: unsafe { + unsafe extern "system" fn get_physical_device_display_plane_properties2_khr( + _physical_device: PhysicalDevice, + _p_property_count: *mut u32, + _p_properties: *mut DisplayPlaneProperties2KHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_display_plane_properties2_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPhysicalDeviceDisplayPlaneProperties2KHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_physical_device_display_plane_properties2_khr + } else { + ::std::mem::transmute(val) + } + }, + get_display_mode_properties2_khr: unsafe { + unsafe extern "system" fn get_display_mode_properties2_khr( + _physical_device: PhysicalDevice, + _display: DisplayKHR, + _p_property_count: *mut u32, + _p_properties: *mut DisplayModeProperties2KHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_display_mode_properties2_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetDisplayModeProperties2KHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_display_mode_properties2_khr + } else { + ::std::mem::transmute(val) + } + }, + get_display_plane_capabilities2_khr: unsafe { + unsafe extern "system" fn get_display_plane_capabilities2_khr( + _physical_device: PhysicalDevice, + _p_display_plane_info: *const DisplayPlaneInfo2KHR, + _p_capabilities: *mut DisplayPlaneCapabilities2KHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_display_plane_capabilities2_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetDisplayPlaneCapabilities2KHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_display_plane_capabilities2_khr + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_KHR_get_display_properties2'"] +impl StructureType { + pub const DISPLAY_PROPERTIES_2_KHR: Self = Self(1_000_121_000); + pub const DISPLAY_PLANE_PROPERTIES_2_KHR: Self = Self(1_000_121_001); + pub const DISPLAY_MODE_PROPERTIES_2_KHR: Self = Self(1_000_121_002); + pub const DISPLAY_PLANE_INFO_2_KHR: Self = Self(1_000_121_003); + pub const DISPLAY_PLANE_CAPABILITIES_2_KHR: Self = Self(1_000_121_004); +} +impl MvkIosSurfaceFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_MVK_ios_surface\0") } + } + pub const SPEC_VERSION: u32 = 3u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkCreateIOSSurfaceMVK = unsafe extern "system" fn( + instance: Instance, + p_create_info: *const IOSSurfaceCreateInfoMVK, + p_allocator: *const AllocationCallbacks, + p_surface: *mut SurfaceKHR, +) -> Result; +#[derive(Clone)] +pub struct MvkIosSurfaceFn { + pub create_ios_surface_mvk: PFN_vkCreateIOSSurfaceMVK, +} +unsafe impl Send for MvkIosSurfaceFn {} +unsafe impl Sync for MvkIosSurfaceFn {} +impl MvkIosSurfaceFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + create_ios_surface_mvk: unsafe { + unsafe extern "system" fn create_ios_surface_mvk( + _instance: Instance, + _p_create_info: *const IOSSurfaceCreateInfoMVK, + _p_allocator: *const AllocationCallbacks, + _p_surface: *mut SurfaceKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(create_ios_surface_mvk) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateIOSSurfaceMVK\0"); + let val = _f(cname); + if val.is_null() { + create_ios_surface_mvk + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_MVK_ios_surface'"] +impl StructureType { + pub const IOS_SURFACE_CREATE_INFO_MVK: Self = Self(1_000_122_000); +} +impl MvkMacosSurfaceFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_MVK_macos_surface\0") } + } + pub const SPEC_VERSION: u32 = 3u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkCreateMacOSSurfaceMVK = unsafe extern "system" fn( + instance: Instance, + p_create_info: *const MacOSSurfaceCreateInfoMVK, + p_allocator: *const AllocationCallbacks, + p_surface: *mut SurfaceKHR, +) -> Result; +#[derive(Clone)] +pub struct MvkMacosSurfaceFn { + pub create_mac_os_surface_mvk: PFN_vkCreateMacOSSurfaceMVK, +} +unsafe impl Send for MvkMacosSurfaceFn {} +unsafe impl Sync for MvkMacosSurfaceFn {} +impl MvkMacosSurfaceFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + create_mac_os_surface_mvk: unsafe { + unsafe extern "system" fn create_mac_os_surface_mvk( + _instance: Instance, + _p_create_info: *const MacOSSurfaceCreateInfoMVK, + _p_allocator: *const AllocationCallbacks, + _p_surface: *mut SurfaceKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(create_mac_os_surface_mvk) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateMacOSSurfaceMVK\0"); + let val = _f(cname); + if val.is_null() { + create_mac_os_surface_mvk + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_MVK_macos_surface'"] +impl StructureType { + pub const MACOS_SURFACE_CREATE_INFO_MVK: Self = Self(1_000_123_000); +} +impl MvkMoltenvkFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_MVK_moltenvk\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct MvkMoltenvkFn {} +unsafe impl Send for MvkMoltenvkFn {} +unsafe impl Sync for MvkMoltenvkFn {} +impl MvkMoltenvkFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtExternalMemoryDmaBufFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_external_memory_dma_buf\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct ExtExternalMemoryDmaBufFn {} +unsafe impl Send for ExtExternalMemoryDmaBufFn {} +unsafe impl Sync for ExtExternalMemoryDmaBufFn {} +impl ExtExternalMemoryDmaBufFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_external_memory_dma_buf'"] +impl ExternalMemoryHandleTypeFlags { + pub const DMA_BUF_EXT: Self = Self(0b10_0000_0000); +} +impl ExtQueueFamilyForeignFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_queue_family_foreign\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct ExtQueueFamilyForeignFn {} +unsafe impl Send for ExtQueueFamilyForeignFn {} +unsafe impl Sync for ExtQueueFamilyForeignFn {} +impl ExtQueueFamilyForeignFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl KhrDedicatedAllocationFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_dedicated_allocation\0") } + } + pub const SPEC_VERSION: u32 = 3u32; +} +#[derive(Clone)] +pub struct KhrDedicatedAllocationFn {} +unsafe impl Send for KhrDedicatedAllocationFn {} +unsafe impl Sync for KhrDedicatedAllocationFn {} +impl KhrDedicatedAllocationFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_KHR_dedicated_allocation'"] +impl StructureType { + pub const MEMORY_DEDICATED_REQUIREMENTS_KHR: Self = Self::MEMORY_DEDICATED_REQUIREMENTS; + pub const MEMORY_DEDICATED_ALLOCATE_INFO_KHR: Self = Self::MEMORY_DEDICATED_ALLOCATE_INFO; +} +impl ExtDebugUtilsFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_debug_utils\0") } + } + pub const SPEC_VERSION: u32 = 2u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkSetDebugUtilsObjectNameEXT = unsafe extern "system" fn( + device: Device, + p_name_info: *const DebugUtilsObjectNameInfoEXT, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkSetDebugUtilsObjectTagEXT = unsafe extern "system" fn( + device: Device, + p_tag_info: *const DebugUtilsObjectTagInfoEXT, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkQueueBeginDebugUtilsLabelEXT = + unsafe extern "system" fn(queue: Queue, p_label_info: *const DebugUtilsLabelEXT); +#[allow(non_camel_case_types)] +pub type PFN_vkQueueEndDebugUtilsLabelEXT = unsafe extern "system" fn(queue: Queue); +#[allow(non_camel_case_types)] +pub type PFN_vkQueueInsertDebugUtilsLabelEXT = + unsafe extern "system" fn(queue: Queue, p_label_info: *const DebugUtilsLabelEXT); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdBeginDebugUtilsLabelEXT = unsafe extern "system" fn( + command_buffer: CommandBuffer, + p_label_info: *const DebugUtilsLabelEXT, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdEndDebugUtilsLabelEXT = unsafe extern "system" fn(command_buffer: CommandBuffer); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdInsertDebugUtilsLabelEXT = unsafe extern "system" fn( + command_buffer: CommandBuffer, + p_label_info: *const DebugUtilsLabelEXT, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCreateDebugUtilsMessengerEXT = unsafe extern "system" fn( + instance: Instance, + p_create_info: *const DebugUtilsMessengerCreateInfoEXT, + p_allocator: *const AllocationCallbacks, + p_messenger: *mut DebugUtilsMessengerEXT, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkDestroyDebugUtilsMessengerEXT = unsafe extern "system" fn( + instance: Instance, + messenger: DebugUtilsMessengerEXT, + p_allocator: *const AllocationCallbacks, +); +#[allow(non_camel_case_types)] +pub type PFN_vkSubmitDebugUtilsMessageEXT = unsafe extern "system" fn( + instance: Instance, + message_severity: DebugUtilsMessageSeverityFlagsEXT, + message_types: DebugUtilsMessageTypeFlagsEXT, + p_callback_data: *const DebugUtilsMessengerCallbackDataEXT, +); +#[derive(Clone)] +pub struct ExtDebugUtilsFn { + pub set_debug_utils_object_name_ext: PFN_vkSetDebugUtilsObjectNameEXT, + pub set_debug_utils_object_tag_ext: PFN_vkSetDebugUtilsObjectTagEXT, + pub queue_begin_debug_utils_label_ext: PFN_vkQueueBeginDebugUtilsLabelEXT, + pub queue_end_debug_utils_label_ext: PFN_vkQueueEndDebugUtilsLabelEXT, + pub queue_insert_debug_utils_label_ext: PFN_vkQueueInsertDebugUtilsLabelEXT, + pub cmd_begin_debug_utils_label_ext: PFN_vkCmdBeginDebugUtilsLabelEXT, + pub cmd_end_debug_utils_label_ext: PFN_vkCmdEndDebugUtilsLabelEXT, + pub cmd_insert_debug_utils_label_ext: PFN_vkCmdInsertDebugUtilsLabelEXT, + pub create_debug_utils_messenger_ext: PFN_vkCreateDebugUtilsMessengerEXT, + pub destroy_debug_utils_messenger_ext: PFN_vkDestroyDebugUtilsMessengerEXT, + pub submit_debug_utils_message_ext: PFN_vkSubmitDebugUtilsMessageEXT, +} +unsafe impl Send for ExtDebugUtilsFn {} +unsafe impl Sync for ExtDebugUtilsFn {} +impl ExtDebugUtilsFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + set_debug_utils_object_name_ext: unsafe { + unsafe extern "system" fn set_debug_utils_object_name_ext( + _device: Device, + _p_name_info: *const DebugUtilsObjectNameInfoEXT, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(set_debug_utils_object_name_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkSetDebugUtilsObjectNameEXT\0", + ); + let val = _f(cname); + if val.is_null() { + set_debug_utils_object_name_ext + } else { + ::std::mem::transmute(val) + } + }, + set_debug_utils_object_tag_ext: unsafe { + unsafe extern "system" fn set_debug_utils_object_tag_ext( + _device: Device, + _p_tag_info: *const DebugUtilsObjectTagInfoEXT, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(set_debug_utils_object_tag_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkSetDebugUtilsObjectTagEXT\0", + ); + let val = _f(cname); + if val.is_null() { + set_debug_utils_object_tag_ext + } else { + ::std::mem::transmute(val) + } + }, + queue_begin_debug_utils_label_ext: unsafe { + unsafe extern "system" fn queue_begin_debug_utils_label_ext( + _queue: Queue, + _p_label_info: *const DebugUtilsLabelEXT, + ) { + panic!(concat!( + "Unable to load ", + stringify!(queue_begin_debug_utils_label_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkQueueBeginDebugUtilsLabelEXT\0", + ); + let val = _f(cname); + if val.is_null() { + queue_begin_debug_utils_label_ext + } else { + ::std::mem::transmute(val) + } + }, + queue_end_debug_utils_label_ext: unsafe { + unsafe extern "system" fn queue_end_debug_utils_label_ext(_queue: Queue) { + panic!(concat!( + "Unable to load ", + stringify!(queue_end_debug_utils_label_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkQueueEndDebugUtilsLabelEXT\0", + ); + let val = _f(cname); + if val.is_null() { + queue_end_debug_utils_label_ext + } else { + ::std::mem::transmute(val) + } + }, + queue_insert_debug_utils_label_ext: unsafe { + unsafe extern "system" fn queue_insert_debug_utils_label_ext( + _queue: Queue, + _p_label_info: *const DebugUtilsLabelEXT, + ) { + panic!(concat!( + "Unable to load ", + stringify!(queue_insert_debug_utils_label_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkQueueInsertDebugUtilsLabelEXT\0", + ); + let val = _f(cname); + if val.is_null() { + queue_insert_debug_utils_label_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_begin_debug_utils_label_ext: unsafe { + unsafe extern "system" fn cmd_begin_debug_utils_label_ext( + _command_buffer: CommandBuffer, + _p_label_info: *const DebugUtilsLabelEXT, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_begin_debug_utils_label_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdBeginDebugUtilsLabelEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_begin_debug_utils_label_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_end_debug_utils_label_ext: unsafe { + unsafe extern "system" fn cmd_end_debug_utils_label_ext( + _command_buffer: CommandBuffer, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_end_debug_utils_label_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdEndDebugUtilsLabelEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_end_debug_utils_label_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_insert_debug_utils_label_ext: unsafe { + unsafe extern "system" fn cmd_insert_debug_utils_label_ext( + _command_buffer: CommandBuffer, + _p_label_info: *const DebugUtilsLabelEXT, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_insert_debug_utils_label_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdInsertDebugUtilsLabelEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_insert_debug_utils_label_ext + } else { + ::std::mem::transmute(val) + } + }, + create_debug_utils_messenger_ext: unsafe { + unsafe extern "system" fn create_debug_utils_messenger_ext( + _instance: Instance, + _p_create_info: *const DebugUtilsMessengerCreateInfoEXT, + _p_allocator: *const AllocationCallbacks, + _p_messenger: *mut DebugUtilsMessengerEXT, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(create_debug_utils_messenger_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCreateDebugUtilsMessengerEXT\0", + ); + let val = _f(cname); + if val.is_null() { + create_debug_utils_messenger_ext + } else { + ::std::mem::transmute(val) + } + }, + destroy_debug_utils_messenger_ext: unsafe { + unsafe extern "system" fn destroy_debug_utils_messenger_ext( + _instance: Instance, + _messenger: DebugUtilsMessengerEXT, + _p_allocator: *const AllocationCallbacks, + ) { + panic!(concat!( + "Unable to load ", + stringify!(destroy_debug_utils_messenger_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkDestroyDebugUtilsMessengerEXT\0", + ); + let val = _f(cname); + if val.is_null() { + destroy_debug_utils_messenger_ext + } else { + ::std::mem::transmute(val) + } + }, + submit_debug_utils_message_ext: unsafe { + unsafe extern "system" fn submit_debug_utils_message_ext( + _instance: Instance, + _message_severity: DebugUtilsMessageSeverityFlagsEXT, + _message_types: DebugUtilsMessageTypeFlagsEXT, + _p_callback_data: *const DebugUtilsMessengerCallbackDataEXT, + ) { + panic!(concat!( + "Unable to load ", + stringify!(submit_debug_utils_message_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkSubmitDebugUtilsMessageEXT\0", + ); + let val = _f(cname); + if val.is_null() { + submit_debug_utils_message_ext + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_EXT_debug_utils'"] +impl ObjectType { + pub const DEBUG_UTILS_MESSENGER_EXT: Self = Self(1_000_128_000); +} +#[doc = "Generated from 'VK_EXT_debug_utils'"] +impl StructureType { + pub const DEBUG_UTILS_OBJECT_NAME_INFO_EXT: Self = Self(1_000_128_000); + pub const DEBUG_UTILS_OBJECT_TAG_INFO_EXT: Self = Self(1_000_128_001); + pub const DEBUG_UTILS_LABEL_EXT: Self = Self(1_000_128_002); + pub const DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT: Self = Self(1_000_128_003); + pub const DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT: Self = Self(1_000_128_004); +} +impl AndroidExternalMemoryAndroidHardwareBufferFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"VK_ANDROID_external_memory_android_hardware_buffer\0", + ) + } + } + pub const SPEC_VERSION: u32 = 5u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkGetAndroidHardwareBufferPropertiesANDROID = unsafe extern "system" fn( + device: Device, + buffer: *const AHardwareBuffer, + p_properties: *mut AndroidHardwareBufferPropertiesANDROID, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetMemoryAndroidHardwareBufferANDROID = unsafe extern "system" fn( + device: Device, + p_info: *const MemoryGetAndroidHardwareBufferInfoANDROID, + p_buffer: *mut *mut AHardwareBuffer, +) -> Result; +#[derive(Clone)] +pub struct AndroidExternalMemoryAndroidHardwareBufferFn { + pub get_android_hardware_buffer_properties_android: + PFN_vkGetAndroidHardwareBufferPropertiesANDROID, + pub get_memory_android_hardware_buffer_android: PFN_vkGetMemoryAndroidHardwareBufferANDROID, +} +unsafe impl Send for AndroidExternalMemoryAndroidHardwareBufferFn {} +unsafe impl Sync for AndroidExternalMemoryAndroidHardwareBufferFn {} +impl AndroidExternalMemoryAndroidHardwareBufferFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + get_android_hardware_buffer_properties_android: unsafe { + unsafe extern "system" fn get_android_hardware_buffer_properties_android( + _device: Device, + _buffer: *const AHardwareBuffer, + _p_properties: *mut AndroidHardwareBufferPropertiesANDROID, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_android_hardware_buffer_properties_android) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetAndroidHardwareBufferPropertiesANDROID\0", + ); + let val = _f(cname); + if val.is_null() { + get_android_hardware_buffer_properties_android + } else { + ::std::mem::transmute(val) + } + }, + get_memory_android_hardware_buffer_android: unsafe { + unsafe extern "system" fn get_memory_android_hardware_buffer_android( + _device: Device, + _p_info: *const MemoryGetAndroidHardwareBufferInfoANDROID, + _p_buffer: *mut *mut AHardwareBuffer, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_memory_android_hardware_buffer_android) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetMemoryAndroidHardwareBufferANDROID\0", + ); + let val = _f(cname); + if val.is_null() { + get_memory_android_hardware_buffer_android + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_ANDROID_external_memory_android_hardware_buffer'"] +impl ExternalMemoryHandleTypeFlags { + pub const ANDROID_HARDWARE_BUFFER_ANDROID: Self = Self(0b100_0000_0000); +} +#[doc = "Generated from 'VK_ANDROID_external_memory_android_hardware_buffer'"] +impl StructureType { + pub const ANDROID_HARDWARE_BUFFER_USAGE_ANDROID: Self = Self(1_000_129_000); + pub const ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID: Self = Self(1_000_129_001); + pub const ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID: Self = Self(1_000_129_002); + pub const IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID: Self = Self(1_000_129_003); + pub const MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID: Self = Self(1_000_129_004); + pub const EXTERNAL_FORMAT_ANDROID: Self = Self(1_000_129_005); + pub const ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID: Self = Self(1_000_129_006); +} +impl ExtSamplerFilterMinmaxFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_sampler_filter_minmax\0") + } + } + pub const SPEC_VERSION: u32 = 2u32; +} +#[derive(Clone)] +pub struct ExtSamplerFilterMinmaxFn {} +unsafe impl Send for ExtSamplerFilterMinmaxFn {} +unsafe impl Sync for ExtSamplerFilterMinmaxFn {} +impl ExtSamplerFilterMinmaxFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_sampler_filter_minmax'"] +impl FormatFeatureFlags { + pub const SAMPLED_IMAGE_FILTER_MINMAX_EXT: Self = Self::SAMPLED_IMAGE_FILTER_MINMAX; +} +#[doc = "Generated from 'VK_EXT_sampler_filter_minmax'"] +impl SamplerReductionMode { + pub const WEIGHTED_AVERAGE_EXT: Self = Self::WEIGHTED_AVERAGE; + pub const MIN_EXT: Self = Self::MIN; + pub const MAX_EXT: Self = Self::MAX; +} +#[doc = "Generated from 'VK_EXT_sampler_filter_minmax'"] +impl StructureType { + pub const PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES_EXT: Self = + Self::PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES; + pub const SAMPLER_REDUCTION_MODE_CREATE_INFO_EXT: Self = + Self::SAMPLER_REDUCTION_MODE_CREATE_INFO; +} +impl KhrStorageBufferStorageClassFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"VK_KHR_storage_buffer_storage_class\0", + ) + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct KhrStorageBufferStorageClassFn {} +unsafe impl Send for KhrStorageBufferStorageClassFn {} +unsafe impl Sync for KhrStorageBufferStorageClassFn {} +impl KhrStorageBufferStorageClassFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl AmdGpuShaderInt16Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_gpu_shader_int16\0") } + } + pub const SPEC_VERSION: u32 = 2u32; +} +#[derive(Clone)] +pub struct AmdGpuShaderInt16Fn {} +unsafe impl Send for AmdGpuShaderInt16Fn {} +unsafe impl Sync for AmdGpuShaderInt16Fn {} +impl AmdGpuShaderInt16Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl AmdExtension134Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_134\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct AmdExtension134Fn {} +unsafe impl Send for AmdExtension134Fn {} +unsafe impl Sync for AmdExtension134Fn {} +impl AmdExtension134Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl AmdExtension135Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_135\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct AmdExtension135Fn {} +unsafe impl Send for AmdExtension135Fn {} +unsafe impl Sync for AmdExtension135Fn {} +impl AmdExtension135Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_AMD_extension_135'"] +impl BufferUsageFlags { + pub const RESERVED_25_AMD: Self = Self(0b10_0000_0000_0000_0000_0000_0000); +} +impl AmdExtension136Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_136\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct AmdExtension136Fn {} +unsafe impl Send for AmdExtension136Fn {} +unsafe impl Sync for AmdExtension136Fn {} +impl AmdExtension136Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl AmdMixedAttachmentSamplesFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_mixed_attachment_samples\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct AmdMixedAttachmentSamplesFn {} +unsafe impl Send for AmdMixedAttachmentSamplesFn {} +unsafe impl Sync for AmdMixedAttachmentSamplesFn {} +impl AmdMixedAttachmentSamplesFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl AmdShaderFragmentMaskFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_shader_fragment_mask\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct AmdShaderFragmentMaskFn {} +unsafe impl Send for AmdShaderFragmentMaskFn {} +unsafe impl Sync for AmdShaderFragmentMaskFn {} +impl AmdShaderFragmentMaskFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtInlineUniformBlockFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_inline_uniform_block\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct ExtInlineUniformBlockFn {} +unsafe impl Send for ExtInlineUniformBlockFn {} +unsafe impl Sync for ExtInlineUniformBlockFn {} +impl ExtInlineUniformBlockFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_inline_uniform_block'"] +impl DescriptorType { + pub const INLINE_UNIFORM_BLOCK_EXT: Self = Self::INLINE_UNIFORM_BLOCK; +} +#[doc = "Generated from 'VK_EXT_inline_uniform_block'"] +impl StructureType { + pub const PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT: Self = + Self::PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES; + pub const PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES_EXT: Self = + Self::PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES; + pub const WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK_EXT: Self = + Self::WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK; + pub const DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO_EXT: Self = + Self::DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO; +} +impl AmdExtension140Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_140\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct AmdExtension140Fn {} +unsafe impl Send for AmdExtension140Fn {} +unsafe impl Sync for AmdExtension140Fn {} +impl AmdExtension140Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtShaderStencilExportFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_shader_stencil_export\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct ExtShaderStencilExportFn {} +unsafe impl Send for ExtShaderStencilExportFn {} +unsafe impl Sync for ExtShaderStencilExportFn {} +impl ExtShaderStencilExportFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl AmdExtension142Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_142\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct AmdExtension142Fn {} +unsafe impl Send for AmdExtension142Fn {} +unsafe impl Sync for AmdExtension142Fn {} +impl AmdExtension142Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl AmdExtension143Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_143\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct AmdExtension143Fn {} +unsafe impl Send for AmdExtension143Fn {} +unsafe impl Sync for AmdExtension143Fn {} +impl AmdExtension143Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtSampleLocationsFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_sample_locations\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetSampleLocationsEXT = unsafe extern "system" fn( + command_buffer: CommandBuffer, + p_sample_locations_info: *const SampleLocationsInfoEXT, +); +#[allow(non_camel_case_types)] +pub type PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT = unsafe extern "system" fn( + physical_device: PhysicalDevice, + samples: SampleCountFlags, + p_multisample_properties: *mut MultisamplePropertiesEXT, +); +#[derive(Clone)] +pub struct ExtSampleLocationsFn { + pub cmd_set_sample_locations_ext: PFN_vkCmdSetSampleLocationsEXT, + pub get_physical_device_multisample_properties_ext: + PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT, +} +unsafe impl Send for ExtSampleLocationsFn {} +unsafe impl Sync for ExtSampleLocationsFn {} +impl ExtSampleLocationsFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + cmd_set_sample_locations_ext: unsafe { + unsafe extern "system" fn cmd_set_sample_locations_ext( + _command_buffer: CommandBuffer, + _p_sample_locations_info: *const SampleLocationsInfoEXT, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_sample_locations_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetSampleLocationsEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_sample_locations_ext + } else { + ::std::mem::transmute(val) + } + }, + get_physical_device_multisample_properties_ext: unsafe { + unsafe extern "system" fn get_physical_device_multisample_properties_ext( + _physical_device: PhysicalDevice, + _samples: SampleCountFlags, + _p_multisample_properties: *mut MultisamplePropertiesEXT, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_multisample_properties_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPhysicalDeviceMultisamplePropertiesEXT\0", + ); + let val = _f(cname); + if val.is_null() { + get_physical_device_multisample_properties_ext + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_EXT_sample_locations'"] +impl DynamicState { + pub const SAMPLE_LOCATIONS_EXT: Self = Self(1_000_143_000); +} +#[doc = "Generated from 'VK_EXT_sample_locations'"] +impl ImageCreateFlags { + pub const SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_EXT: Self = Self(0b1_0000_0000_0000); +} +#[doc = "Generated from 'VK_EXT_sample_locations'"] +impl StructureType { + pub const SAMPLE_LOCATIONS_INFO_EXT: Self = Self(1_000_143_000); + pub const RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT: Self = Self(1_000_143_001); + pub const PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT: Self = Self(1_000_143_002); + pub const PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT: Self = Self(1_000_143_003); + pub const MULTISAMPLE_PROPERTIES_EXT: Self = Self(1_000_143_004); +} +impl KhrRelaxedBlockLayoutFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_relaxed_block_layout\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct KhrRelaxedBlockLayoutFn {} +unsafe impl Send for KhrRelaxedBlockLayoutFn {} +unsafe impl Sync for KhrRelaxedBlockLayoutFn {} +impl KhrRelaxedBlockLayoutFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl KhrGetMemoryRequirements2Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_get_memory_requirements2\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkGetImageMemoryRequirements2 = unsafe extern "system" fn( + device: Device, + p_info: *const ImageMemoryRequirementsInfo2, + p_memory_requirements: *mut MemoryRequirements2, +); +#[allow(non_camel_case_types)] +pub type PFN_vkGetBufferMemoryRequirements2 = unsafe extern "system" fn( + device: Device, + p_info: *const BufferMemoryRequirementsInfo2, + p_memory_requirements: *mut MemoryRequirements2, +); +#[allow(non_camel_case_types)] +pub type PFN_vkGetImageSparseMemoryRequirements2 = unsafe extern "system" fn( + device: Device, + p_info: *const ImageSparseMemoryRequirementsInfo2, + p_sparse_memory_requirement_count: *mut u32, + p_sparse_memory_requirements: *mut SparseImageMemoryRequirements2, +); +#[derive(Clone)] +pub struct KhrGetMemoryRequirements2Fn { + pub get_image_memory_requirements2_khr: PFN_vkGetImageMemoryRequirements2, + pub get_buffer_memory_requirements2_khr: PFN_vkGetBufferMemoryRequirements2, + pub get_image_sparse_memory_requirements2_khr: PFN_vkGetImageSparseMemoryRequirements2, +} +unsafe impl Send for KhrGetMemoryRequirements2Fn {} +unsafe impl Sync for KhrGetMemoryRequirements2Fn {} +impl KhrGetMemoryRequirements2Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + get_image_memory_requirements2_khr: unsafe { + unsafe extern "system" fn get_image_memory_requirements2_khr( + _device: Device, + _p_info: *const ImageMemoryRequirementsInfo2, + _p_memory_requirements: *mut MemoryRequirements2, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_image_memory_requirements2_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetImageMemoryRequirements2KHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_image_memory_requirements2_khr + } else { + ::std::mem::transmute(val) + } + }, + get_buffer_memory_requirements2_khr: unsafe { + unsafe extern "system" fn get_buffer_memory_requirements2_khr( + _device: Device, + _p_info: *const BufferMemoryRequirementsInfo2, + _p_memory_requirements: *mut MemoryRequirements2, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_buffer_memory_requirements2_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetBufferMemoryRequirements2KHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_buffer_memory_requirements2_khr + } else { + ::std::mem::transmute(val) + } + }, + get_image_sparse_memory_requirements2_khr: unsafe { + unsafe extern "system" fn get_image_sparse_memory_requirements2_khr( + _device: Device, + _p_info: *const ImageSparseMemoryRequirementsInfo2, + _p_sparse_memory_requirement_count: *mut u32, + _p_sparse_memory_requirements: *mut SparseImageMemoryRequirements2, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_image_sparse_memory_requirements2_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetImageSparseMemoryRequirements2KHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_image_sparse_memory_requirements2_khr + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_KHR_get_memory_requirements2'"] +impl StructureType { + pub const BUFFER_MEMORY_REQUIREMENTS_INFO_2_KHR: Self = Self::BUFFER_MEMORY_REQUIREMENTS_INFO_2; + pub const IMAGE_MEMORY_REQUIREMENTS_INFO_2_KHR: Self = Self::IMAGE_MEMORY_REQUIREMENTS_INFO_2; + pub const IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2_KHR: Self = + Self::IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2; + pub const MEMORY_REQUIREMENTS_2_KHR: Self = Self::MEMORY_REQUIREMENTS_2; + pub const SPARSE_IMAGE_MEMORY_REQUIREMENTS_2_KHR: Self = + Self::SPARSE_IMAGE_MEMORY_REQUIREMENTS_2; +} +impl KhrImageFormatListFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_image_format_list\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct KhrImageFormatListFn {} +unsafe impl Send for KhrImageFormatListFn {} +unsafe impl Sync for KhrImageFormatListFn {} +impl KhrImageFormatListFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_KHR_image_format_list'"] +impl StructureType { + pub const IMAGE_FORMAT_LIST_CREATE_INFO_KHR: Self = Self::IMAGE_FORMAT_LIST_CREATE_INFO; +} +impl ExtBlendOperationAdvancedFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_blend_operation_advanced\0") + } + } + pub const SPEC_VERSION: u32 = 2u32; +} +#[derive(Clone)] +pub struct ExtBlendOperationAdvancedFn {} +unsafe impl Send for ExtBlendOperationAdvancedFn {} +unsafe impl Sync for ExtBlendOperationAdvancedFn {} +impl ExtBlendOperationAdvancedFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_blend_operation_advanced'"] +impl AccessFlags { + pub const COLOR_ATTACHMENT_READ_NONCOHERENT_EXT: Self = Self(0b1000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_EXT_blend_operation_advanced'"] +impl BlendOp { + pub const ZERO_EXT: Self = Self(1_000_148_000); + pub const SRC_EXT: Self = Self(1_000_148_001); + pub const DST_EXT: Self = Self(1_000_148_002); + pub const SRC_OVER_EXT: Self = Self(1_000_148_003); + pub const DST_OVER_EXT: Self = Self(1_000_148_004); + pub const SRC_IN_EXT: Self = Self(1_000_148_005); + pub const DST_IN_EXT: Self = Self(1_000_148_006); + pub const SRC_OUT_EXT: Self = Self(1_000_148_007); + pub const DST_OUT_EXT: Self = Self(1_000_148_008); + pub const SRC_ATOP_EXT: Self = Self(1_000_148_009); + pub const DST_ATOP_EXT: Self = Self(1_000_148_010); + pub const XOR_EXT: Self = Self(1_000_148_011); + pub const MULTIPLY_EXT: Self = Self(1_000_148_012); + pub const SCREEN_EXT: Self = Self(1_000_148_013); + pub const OVERLAY_EXT: Self = Self(1_000_148_014); + pub const DARKEN_EXT: Self = Self(1_000_148_015); + pub const LIGHTEN_EXT: Self = Self(1_000_148_016); + pub const COLORDODGE_EXT: Self = Self(1_000_148_017); + pub const COLORBURN_EXT: Self = Self(1_000_148_018); + pub const HARDLIGHT_EXT: Self = Self(1_000_148_019); + pub const SOFTLIGHT_EXT: Self = Self(1_000_148_020); + pub const DIFFERENCE_EXT: Self = Self(1_000_148_021); + pub const EXCLUSION_EXT: Self = Self(1_000_148_022); + pub const INVERT_EXT: Self = Self(1_000_148_023); + pub const INVERT_RGB_EXT: Self = Self(1_000_148_024); + pub const LINEARDODGE_EXT: Self = Self(1_000_148_025); + pub const LINEARBURN_EXT: Self = Self(1_000_148_026); + pub const VIVIDLIGHT_EXT: Self = Self(1_000_148_027); + pub const LINEARLIGHT_EXT: Self = Self(1_000_148_028); + pub const PINLIGHT_EXT: Self = Self(1_000_148_029); + pub const HARDMIX_EXT: Self = Self(1_000_148_030); + pub const HSL_HUE_EXT: Self = Self(1_000_148_031); + pub const HSL_SATURATION_EXT: Self = Self(1_000_148_032); + pub const HSL_COLOR_EXT: Self = Self(1_000_148_033); + pub const HSL_LUMINOSITY_EXT: Self = Self(1_000_148_034); + pub const PLUS_EXT: Self = Self(1_000_148_035); + pub const PLUS_CLAMPED_EXT: Self = Self(1_000_148_036); + pub const PLUS_CLAMPED_ALPHA_EXT: Self = Self(1_000_148_037); + pub const PLUS_DARKER_EXT: Self = Self(1_000_148_038); + pub const MINUS_EXT: Self = Self(1_000_148_039); + pub const MINUS_CLAMPED_EXT: Self = Self(1_000_148_040); + pub const CONTRAST_EXT: Self = Self(1_000_148_041); + pub const INVERT_OVG_EXT: Self = Self(1_000_148_042); + pub const RED_EXT: Self = Self(1_000_148_043); + pub const GREEN_EXT: Self = Self(1_000_148_044); + pub const BLUE_EXT: Self = Self(1_000_148_045); +} +#[doc = "Generated from 'VK_EXT_blend_operation_advanced'"] +impl StructureType { + pub const PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT: Self = Self(1_000_148_000); + pub const PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT: Self = Self(1_000_148_001); + pub const PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT: Self = Self(1_000_148_002); +} +impl NvFragmentCoverageToColorFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_fragment_coverage_to_color\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct NvFragmentCoverageToColorFn {} +unsafe impl Send for NvFragmentCoverageToColorFn {} +unsafe impl Sync for NvFragmentCoverageToColorFn {} +impl NvFragmentCoverageToColorFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_NV_fragment_coverage_to_color'"] +impl StructureType { + pub const PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV: Self = Self(1_000_149_000); +} +impl KhrAccelerationStructureFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_acceleration_structure\0") + } + } + pub const SPEC_VERSION: u32 = 13u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkCreateAccelerationStructureKHR = unsafe extern "system" fn( + device: Device, + p_create_info: *const AccelerationStructureCreateInfoKHR, + p_allocator: *const AllocationCallbacks, + p_acceleration_structure: *mut AccelerationStructureKHR, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkDestroyAccelerationStructureKHR = unsafe extern "system" fn( + device: Device, + acceleration_structure: AccelerationStructureKHR, + p_allocator: *const AllocationCallbacks, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdBuildAccelerationStructuresKHR = unsafe extern "system" fn( + command_buffer: CommandBuffer, + info_count: u32, + p_infos: *const AccelerationStructureBuildGeometryInfoKHR, + pp_build_range_infos: *const *const AccelerationStructureBuildRangeInfoKHR, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdBuildAccelerationStructuresIndirectKHR = unsafe extern "system" fn( + command_buffer: CommandBuffer, + info_count: u32, + p_infos: *const AccelerationStructureBuildGeometryInfoKHR, + p_indirect_device_addresses: *const DeviceAddress, + p_indirect_strides: *const u32, + pp_max_primitive_counts: *const *const u32, +); +#[allow(non_camel_case_types)] +pub type PFN_vkBuildAccelerationStructuresKHR = unsafe extern "system" fn( + device: Device, + deferred_operation: DeferredOperationKHR, + info_count: u32, + p_infos: *const AccelerationStructureBuildGeometryInfoKHR, + pp_build_range_infos: *const *const AccelerationStructureBuildRangeInfoKHR, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkCopyAccelerationStructureKHR = unsafe extern "system" fn( + device: Device, + deferred_operation: DeferredOperationKHR, + p_info: *const CopyAccelerationStructureInfoKHR, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkCopyAccelerationStructureToMemoryKHR = unsafe extern "system" fn( + device: Device, + deferred_operation: DeferredOperationKHR, + p_info: *const CopyAccelerationStructureToMemoryInfoKHR, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkCopyMemoryToAccelerationStructureKHR = unsafe extern "system" fn( + device: Device, + deferred_operation: DeferredOperationKHR, + p_info: *const CopyMemoryToAccelerationStructureInfoKHR, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkWriteAccelerationStructuresPropertiesKHR = unsafe extern "system" fn( + device: Device, + acceleration_structure_count: u32, + p_acceleration_structures: *const AccelerationStructureKHR, + query_type: QueryType, + data_size: usize, + p_data: *mut c_void, + stride: usize, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkCmdCopyAccelerationStructureKHR = unsafe extern "system" fn( + command_buffer: CommandBuffer, + p_info: *const CopyAccelerationStructureInfoKHR, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdCopyAccelerationStructureToMemoryKHR = unsafe extern "system" fn( + command_buffer: CommandBuffer, + p_info: *const CopyAccelerationStructureToMemoryInfoKHR, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdCopyMemoryToAccelerationStructureKHR = unsafe extern "system" fn( + command_buffer: CommandBuffer, + p_info: *const CopyMemoryToAccelerationStructureInfoKHR, +); +#[allow(non_camel_case_types)] +pub type PFN_vkGetAccelerationStructureDeviceAddressKHR = + unsafe extern "system" fn( + device: Device, + p_info: *const AccelerationStructureDeviceAddressInfoKHR, + ) -> DeviceAddress; +#[allow(non_camel_case_types)] +pub type PFN_vkCmdWriteAccelerationStructuresPropertiesKHR = unsafe extern "system" fn( + command_buffer: CommandBuffer, + acceleration_structure_count: u32, + p_acceleration_structures: *const AccelerationStructureKHR, + query_type: QueryType, + query_pool: QueryPool, + first_query: u32, +); +#[allow(non_camel_case_types)] +pub type PFN_vkGetDeviceAccelerationStructureCompatibilityKHR = unsafe extern "system" fn( + device: Device, + p_version_info: *const AccelerationStructureVersionInfoKHR, + p_compatibility: *mut AccelerationStructureCompatibilityKHR, +); +#[allow(non_camel_case_types)] +pub type PFN_vkGetAccelerationStructureBuildSizesKHR = unsafe extern "system" fn( + device: Device, + build_type: AccelerationStructureBuildTypeKHR, + p_build_info: *const AccelerationStructureBuildGeometryInfoKHR, + p_max_primitive_counts: *const u32, + p_size_info: *mut AccelerationStructureBuildSizesInfoKHR, +); +#[derive(Clone)] +pub struct KhrAccelerationStructureFn { + pub create_acceleration_structure_khr: PFN_vkCreateAccelerationStructureKHR, + pub destroy_acceleration_structure_khr: PFN_vkDestroyAccelerationStructureKHR, + pub cmd_build_acceleration_structures_khr: PFN_vkCmdBuildAccelerationStructuresKHR, + pub cmd_build_acceleration_structures_indirect_khr: + PFN_vkCmdBuildAccelerationStructuresIndirectKHR, + pub build_acceleration_structures_khr: PFN_vkBuildAccelerationStructuresKHR, + pub copy_acceleration_structure_khr: PFN_vkCopyAccelerationStructureKHR, + pub copy_acceleration_structure_to_memory_khr: PFN_vkCopyAccelerationStructureToMemoryKHR, + pub copy_memory_to_acceleration_structure_khr: PFN_vkCopyMemoryToAccelerationStructureKHR, + pub write_acceleration_structures_properties_khr: + PFN_vkWriteAccelerationStructuresPropertiesKHR, + pub cmd_copy_acceleration_structure_khr: PFN_vkCmdCopyAccelerationStructureKHR, + pub cmd_copy_acceleration_structure_to_memory_khr: + PFN_vkCmdCopyAccelerationStructureToMemoryKHR, + pub cmd_copy_memory_to_acceleration_structure_khr: + PFN_vkCmdCopyMemoryToAccelerationStructureKHR, + pub get_acceleration_structure_device_address_khr: + PFN_vkGetAccelerationStructureDeviceAddressKHR, + pub cmd_write_acceleration_structures_properties_khr: + PFN_vkCmdWriteAccelerationStructuresPropertiesKHR, + pub get_device_acceleration_structure_compatibility_khr: + PFN_vkGetDeviceAccelerationStructureCompatibilityKHR, + pub get_acceleration_structure_build_sizes_khr: PFN_vkGetAccelerationStructureBuildSizesKHR, +} +unsafe impl Send for KhrAccelerationStructureFn {} +unsafe impl Sync for KhrAccelerationStructureFn {} +impl KhrAccelerationStructureFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + create_acceleration_structure_khr: unsafe { + unsafe extern "system" fn create_acceleration_structure_khr( + _device: Device, + _p_create_info: *const AccelerationStructureCreateInfoKHR, + _p_allocator: *const AllocationCallbacks, + _p_acceleration_structure: *mut AccelerationStructureKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(create_acceleration_structure_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCreateAccelerationStructureKHR\0", + ); + let val = _f(cname); + if val.is_null() { + create_acceleration_structure_khr + } else { + ::std::mem::transmute(val) + } + }, + destroy_acceleration_structure_khr: unsafe { + unsafe extern "system" fn destroy_acceleration_structure_khr( + _device: Device, + _acceleration_structure: AccelerationStructureKHR, + _p_allocator: *const AllocationCallbacks, + ) { + panic!(concat!( + "Unable to load ", + stringify!(destroy_acceleration_structure_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkDestroyAccelerationStructureKHR\0", + ); + let val = _f(cname); + if val.is_null() { + destroy_acceleration_structure_khr + } else { + ::std::mem::transmute(val) + } + }, + cmd_build_acceleration_structures_khr: unsafe { + unsafe extern "system" fn cmd_build_acceleration_structures_khr( + _command_buffer: CommandBuffer, + _info_count: u32, + _p_infos: *const AccelerationStructureBuildGeometryInfoKHR, + _pp_build_range_infos: *const *const AccelerationStructureBuildRangeInfoKHR, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_build_acceleration_structures_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdBuildAccelerationStructuresKHR\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_build_acceleration_structures_khr + } else { + ::std::mem::transmute(val) + } + }, + cmd_build_acceleration_structures_indirect_khr: unsafe { + unsafe extern "system" fn cmd_build_acceleration_structures_indirect_khr( + _command_buffer: CommandBuffer, + _info_count: u32, + _p_infos: *const AccelerationStructureBuildGeometryInfoKHR, + _p_indirect_device_addresses: *const DeviceAddress, + _p_indirect_strides: *const u32, + _pp_max_primitive_counts: *const *const u32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_build_acceleration_structures_indirect_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdBuildAccelerationStructuresIndirectKHR\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_build_acceleration_structures_indirect_khr + } else { + ::std::mem::transmute(val) + } + }, + build_acceleration_structures_khr: unsafe { + unsafe extern "system" fn build_acceleration_structures_khr( + _device: Device, + _deferred_operation: DeferredOperationKHR, + _info_count: u32, + _p_infos: *const AccelerationStructureBuildGeometryInfoKHR, + _pp_build_range_infos: *const *const AccelerationStructureBuildRangeInfoKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(build_acceleration_structures_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkBuildAccelerationStructuresKHR\0", + ); + let val = _f(cname); + if val.is_null() { + build_acceleration_structures_khr + } else { + ::std::mem::transmute(val) + } + }, + copy_acceleration_structure_khr: unsafe { + unsafe extern "system" fn copy_acceleration_structure_khr( + _device: Device, + _deferred_operation: DeferredOperationKHR, + _p_info: *const CopyAccelerationStructureInfoKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(copy_acceleration_structure_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCopyAccelerationStructureKHR\0", + ); + let val = _f(cname); + if val.is_null() { + copy_acceleration_structure_khr + } else { + ::std::mem::transmute(val) + } + }, + copy_acceleration_structure_to_memory_khr: unsafe { + unsafe extern "system" fn copy_acceleration_structure_to_memory_khr( + _device: Device, + _deferred_operation: DeferredOperationKHR, + _p_info: *const CopyAccelerationStructureToMemoryInfoKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(copy_acceleration_structure_to_memory_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCopyAccelerationStructureToMemoryKHR\0", + ); + let val = _f(cname); + if val.is_null() { + copy_acceleration_structure_to_memory_khr + } else { + ::std::mem::transmute(val) + } + }, + copy_memory_to_acceleration_structure_khr: unsafe { + unsafe extern "system" fn copy_memory_to_acceleration_structure_khr( + _device: Device, + _deferred_operation: DeferredOperationKHR, + _p_info: *const CopyMemoryToAccelerationStructureInfoKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(copy_memory_to_acceleration_structure_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCopyMemoryToAccelerationStructureKHR\0", + ); + let val = _f(cname); + if val.is_null() { + copy_memory_to_acceleration_structure_khr + } else { + ::std::mem::transmute(val) + } + }, + write_acceleration_structures_properties_khr: unsafe { + unsafe extern "system" fn write_acceleration_structures_properties_khr( + _device: Device, + _acceleration_structure_count: u32, + _p_acceleration_structures: *const AccelerationStructureKHR, + _query_type: QueryType, + _data_size: usize, + _p_data: *mut c_void, + _stride: usize, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(write_acceleration_structures_properties_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkWriteAccelerationStructuresPropertiesKHR\0", + ); + let val = _f(cname); + if val.is_null() { + write_acceleration_structures_properties_khr + } else { + ::std::mem::transmute(val) + } + }, + cmd_copy_acceleration_structure_khr: unsafe { + unsafe extern "system" fn cmd_copy_acceleration_structure_khr( + _command_buffer: CommandBuffer, + _p_info: *const CopyAccelerationStructureInfoKHR, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_copy_acceleration_structure_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdCopyAccelerationStructureKHR\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_copy_acceleration_structure_khr + } else { + ::std::mem::transmute(val) + } + }, + cmd_copy_acceleration_structure_to_memory_khr: unsafe { + unsafe extern "system" fn cmd_copy_acceleration_structure_to_memory_khr( + _command_buffer: CommandBuffer, + _p_info: *const CopyAccelerationStructureToMemoryInfoKHR, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_copy_acceleration_structure_to_memory_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdCopyAccelerationStructureToMemoryKHR\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_copy_acceleration_structure_to_memory_khr + } else { + ::std::mem::transmute(val) + } + }, + cmd_copy_memory_to_acceleration_structure_khr: unsafe { + unsafe extern "system" fn cmd_copy_memory_to_acceleration_structure_khr( + _command_buffer: CommandBuffer, + _p_info: *const CopyMemoryToAccelerationStructureInfoKHR, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_copy_memory_to_acceleration_structure_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdCopyMemoryToAccelerationStructureKHR\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_copy_memory_to_acceleration_structure_khr + } else { + ::std::mem::transmute(val) + } + }, + get_acceleration_structure_device_address_khr: unsafe { + unsafe extern "system" fn get_acceleration_structure_device_address_khr( + _device: Device, + _p_info: *const AccelerationStructureDeviceAddressInfoKHR, + ) -> DeviceAddress { + panic!(concat!( + "Unable to load ", + stringify!(get_acceleration_structure_device_address_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetAccelerationStructureDeviceAddressKHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_acceleration_structure_device_address_khr + } else { + ::std::mem::transmute(val) + } + }, + cmd_write_acceleration_structures_properties_khr: unsafe { + unsafe extern "system" fn cmd_write_acceleration_structures_properties_khr( + _command_buffer: CommandBuffer, + _acceleration_structure_count: u32, + _p_acceleration_structures: *const AccelerationStructureKHR, + _query_type: QueryType, + _query_pool: QueryPool, + _first_query: u32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_write_acceleration_structures_properties_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdWriteAccelerationStructuresPropertiesKHR\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_write_acceleration_structures_properties_khr + } else { + ::std::mem::transmute(val) + } + }, + get_device_acceleration_structure_compatibility_khr: unsafe { + unsafe extern "system" fn get_device_acceleration_structure_compatibility_khr( + _device: Device, + _p_version_info: *const AccelerationStructureVersionInfoKHR, + _p_compatibility: *mut AccelerationStructureCompatibilityKHR, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_device_acceleration_structure_compatibility_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetDeviceAccelerationStructureCompatibilityKHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_device_acceleration_structure_compatibility_khr + } else { + ::std::mem::transmute(val) + } + }, + get_acceleration_structure_build_sizes_khr: unsafe { + unsafe extern "system" fn get_acceleration_structure_build_sizes_khr( + _device: Device, + _build_type: AccelerationStructureBuildTypeKHR, + _p_build_info: *const AccelerationStructureBuildGeometryInfoKHR, + _p_max_primitive_counts: *const u32, + _p_size_info: *mut AccelerationStructureBuildSizesInfoKHR, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_acceleration_structure_build_sizes_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetAccelerationStructureBuildSizesKHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_acceleration_structure_build_sizes_khr + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_KHR_acceleration_structure'"] +impl AccessFlags { + pub const ACCELERATION_STRUCTURE_READ_KHR: Self = Self(0b10_0000_0000_0000_0000_0000); + pub const ACCELERATION_STRUCTURE_WRITE_KHR: Self = Self(0b100_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_KHR_acceleration_structure'"] +impl BufferUsageFlags { + pub const ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_KHR: Self = + Self(0b1000_0000_0000_0000_0000); + pub const ACCELERATION_STRUCTURE_STORAGE_KHR: Self = Self(0b1_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_KHR_acceleration_structure'"] +impl DebugReportObjectTypeEXT { + pub const ACCELERATION_STRUCTURE_KHR: Self = Self(1_000_150_000); +} +#[doc = "Generated from 'VK_KHR_acceleration_structure'"] +impl DescriptorType { + pub const ACCELERATION_STRUCTURE_KHR: Self = Self(1_000_150_000); +} +#[doc = "Generated from 'VK_KHR_acceleration_structure'"] +impl FormatFeatureFlags { + pub const ACCELERATION_STRUCTURE_VERTEX_BUFFER_KHR: Self = + Self(0b10_0000_0000_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_KHR_acceleration_structure'"] +impl FormatFeatureFlags2 { + pub const ACCELERATION_STRUCTURE_VERTEX_BUFFER_KHR: Self = + Self(0b10_0000_0000_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_KHR_acceleration_structure'"] +impl IndexType { + pub const NONE_KHR: Self = Self(1_000_165_000); +} +#[doc = "Generated from 'VK_KHR_acceleration_structure'"] +impl ObjectType { + pub const ACCELERATION_STRUCTURE_KHR: Self = Self(1_000_150_000); +} +#[doc = "Generated from 'VK_KHR_acceleration_structure'"] +impl PipelineStageFlags { + pub const ACCELERATION_STRUCTURE_BUILD_KHR: Self = Self(0b10_0000_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_KHR_acceleration_structure'"] +impl QueryType { + pub const ACCELERATION_STRUCTURE_COMPACTED_SIZE_KHR: Self = Self(1_000_150_000); + pub const ACCELERATION_STRUCTURE_SERIALIZATION_SIZE_KHR: Self = Self(1_000_150_001); +} +#[doc = "Generated from 'VK_KHR_acceleration_structure'"] +impl StructureType { + pub const WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR: Self = Self(1_000_150_007); + pub const ACCELERATION_STRUCTURE_BUILD_GEOMETRY_INFO_KHR: Self = Self(1_000_150_000); + pub const ACCELERATION_STRUCTURE_DEVICE_ADDRESS_INFO_KHR: Self = Self(1_000_150_002); + pub const ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA_KHR: Self = Self(1_000_150_003); + pub const ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR: Self = Self(1_000_150_004); + pub const ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR: Self = Self(1_000_150_005); + pub const ACCELERATION_STRUCTURE_GEOMETRY_KHR: Self = Self(1_000_150_006); + pub const ACCELERATION_STRUCTURE_VERSION_INFO_KHR: Self = Self(1_000_150_009); + pub const COPY_ACCELERATION_STRUCTURE_INFO_KHR: Self = Self(1_000_150_010); + pub const COPY_ACCELERATION_STRUCTURE_TO_MEMORY_INFO_KHR: Self = Self(1_000_150_011); + pub const COPY_MEMORY_TO_ACCELERATION_STRUCTURE_INFO_KHR: Self = Self(1_000_150_012); + pub const PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR: Self = Self(1_000_150_013); + pub const PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR: Self = Self(1_000_150_014); + pub const ACCELERATION_STRUCTURE_CREATE_INFO_KHR: Self = Self(1_000_150_017); + pub const ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR: Self = Self(1_000_150_020); +} +impl KhrRayTracingPipelineFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_ray_tracing_pipeline\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkCmdTraceRaysKHR = unsafe extern "system" fn( + command_buffer: CommandBuffer, + p_raygen_shader_binding_table: *const StridedDeviceAddressRegionKHR, + p_miss_shader_binding_table: *const StridedDeviceAddressRegionKHR, + p_hit_shader_binding_table: *const StridedDeviceAddressRegionKHR, + p_callable_shader_binding_table: *const StridedDeviceAddressRegionKHR, + width: u32, + height: u32, + depth: u32, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCreateRayTracingPipelinesKHR = unsafe extern "system" fn( + device: Device, + deferred_operation: DeferredOperationKHR, + pipeline_cache: PipelineCache, + create_info_count: u32, + p_create_infos: *const RayTracingPipelineCreateInfoKHR, + p_allocator: *const AllocationCallbacks, + p_pipelines: *mut Pipeline, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetRayTracingShaderGroupHandlesKHR = unsafe extern "system" fn( + device: Device, + pipeline: Pipeline, + first_group: u32, + group_count: u32, + data_size: usize, + p_data: *mut c_void, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR = + unsafe extern "system" fn( + device: Device, + pipeline: Pipeline, + first_group: u32, + group_count: u32, + data_size: usize, + p_data: *mut c_void, + ) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkCmdTraceRaysIndirectKHR = unsafe extern "system" fn( + command_buffer: CommandBuffer, + p_raygen_shader_binding_table: *const StridedDeviceAddressRegionKHR, + p_miss_shader_binding_table: *const StridedDeviceAddressRegionKHR, + p_hit_shader_binding_table: *const StridedDeviceAddressRegionKHR, + p_callable_shader_binding_table: *const StridedDeviceAddressRegionKHR, + indirect_device_address: DeviceAddress, +); +#[allow(non_camel_case_types)] +pub type PFN_vkGetRayTracingShaderGroupStackSizeKHR = unsafe extern "system" fn( + device: Device, + pipeline: Pipeline, + group: u32, + group_shader: ShaderGroupShaderKHR, +) -> DeviceSize; +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetRayTracingPipelineStackSizeKHR = + unsafe extern "system" fn(command_buffer: CommandBuffer, pipeline_stack_size: u32); +#[derive(Clone)] +pub struct KhrRayTracingPipelineFn { + pub cmd_trace_rays_khr: PFN_vkCmdTraceRaysKHR, + pub create_ray_tracing_pipelines_khr: PFN_vkCreateRayTracingPipelinesKHR, + pub get_ray_tracing_shader_group_handles_khr: PFN_vkGetRayTracingShaderGroupHandlesKHR, + pub get_ray_tracing_capture_replay_shader_group_handles_khr: + PFN_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR, + pub cmd_trace_rays_indirect_khr: PFN_vkCmdTraceRaysIndirectKHR, + pub get_ray_tracing_shader_group_stack_size_khr: PFN_vkGetRayTracingShaderGroupStackSizeKHR, + pub cmd_set_ray_tracing_pipeline_stack_size_khr: PFN_vkCmdSetRayTracingPipelineStackSizeKHR, +} +unsafe impl Send for KhrRayTracingPipelineFn {} +unsafe impl Sync for KhrRayTracingPipelineFn {} +impl KhrRayTracingPipelineFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + cmd_trace_rays_khr: unsafe { + unsafe extern "system" fn cmd_trace_rays_khr( + _command_buffer: CommandBuffer, + _p_raygen_shader_binding_table: *const StridedDeviceAddressRegionKHR, + _p_miss_shader_binding_table: *const StridedDeviceAddressRegionKHR, + _p_hit_shader_binding_table: *const StridedDeviceAddressRegionKHR, + _p_callable_shader_binding_table: *const StridedDeviceAddressRegionKHR, + _width: u32, + _height: u32, + _depth: u32, + ) { + panic!(concat!("Unable to load ", stringify!(cmd_trace_rays_khr))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdTraceRaysKHR\0"); + let val = _f(cname); + if val.is_null() { + cmd_trace_rays_khr + } else { + ::std::mem::transmute(val) + } + }, + create_ray_tracing_pipelines_khr: unsafe { + unsafe extern "system" fn create_ray_tracing_pipelines_khr( + _device: Device, + _deferred_operation: DeferredOperationKHR, + _pipeline_cache: PipelineCache, + _create_info_count: u32, + _p_create_infos: *const RayTracingPipelineCreateInfoKHR, + _p_allocator: *const AllocationCallbacks, + _p_pipelines: *mut Pipeline, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(create_ray_tracing_pipelines_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCreateRayTracingPipelinesKHR\0", + ); + let val = _f(cname); + if val.is_null() { + create_ray_tracing_pipelines_khr + } else { + ::std::mem::transmute(val) + } + }, + get_ray_tracing_shader_group_handles_khr: unsafe { + unsafe extern "system" fn get_ray_tracing_shader_group_handles_khr( + _device: Device, + _pipeline: Pipeline, + _first_group: u32, + _group_count: u32, + _data_size: usize, + _p_data: *mut c_void, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_ray_tracing_shader_group_handles_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetRayTracingShaderGroupHandlesKHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_ray_tracing_shader_group_handles_khr + } else { + ::std::mem::transmute(val) + } + }, + get_ray_tracing_capture_replay_shader_group_handles_khr: unsafe { + unsafe extern "system" fn get_ray_tracing_capture_replay_shader_group_handles_khr( + _device: Device, + _pipeline: Pipeline, + _first_group: u32, + _group_count: u32, + _data_size: usize, + _p_data: *mut c_void, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_ray_tracing_capture_replay_shader_group_handles_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetRayTracingCaptureReplayShaderGroupHandlesKHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_ray_tracing_capture_replay_shader_group_handles_khr + } else { + ::std::mem::transmute(val) + } + }, + cmd_trace_rays_indirect_khr: unsafe { + unsafe extern "system" fn cmd_trace_rays_indirect_khr( + _command_buffer: CommandBuffer, + _p_raygen_shader_binding_table: *const StridedDeviceAddressRegionKHR, + _p_miss_shader_binding_table: *const StridedDeviceAddressRegionKHR, + _p_hit_shader_binding_table: *const StridedDeviceAddressRegionKHR, + _p_callable_shader_binding_table: *const StridedDeviceAddressRegionKHR, + _indirect_device_address: DeviceAddress, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_trace_rays_indirect_khr) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdTraceRaysIndirectKHR\0"); + let val = _f(cname); + if val.is_null() { + cmd_trace_rays_indirect_khr + } else { + ::std::mem::transmute(val) + } + }, + get_ray_tracing_shader_group_stack_size_khr: unsafe { + unsafe extern "system" fn get_ray_tracing_shader_group_stack_size_khr( + _device: Device, + _pipeline: Pipeline, + _group: u32, + _group_shader: ShaderGroupShaderKHR, + ) -> DeviceSize { + panic!(concat!( + "Unable to load ", + stringify!(get_ray_tracing_shader_group_stack_size_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetRayTracingShaderGroupStackSizeKHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_ray_tracing_shader_group_stack_size_khr + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_ray_tracing_pipeline_stack_size_khr: unsafe { + unsafe extern "system" fn cmd_set_ray_tracing_pipeline_stack_size_khr( + _command_buffer: CommandBuffer, + _pipeline_stack_size: u32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_ray_tracing_pipeline_stack_size_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetRayTracingPipelineStackSizeKHR\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_ray_tracing_pipeline_stack_size_khr + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_KHR_ray_tracing_pipeline'"] +impl BufferUsageFlags { + pub const SHADER_BINDING_TABLE_KHR: Self = Self(0b100_0000_0000); +} +#[doc = "Generated from 'VK_KHR_ray_tracing_pipeline'"] +impl DynamicState { + pub const RAY_TRACING_PIPELINE_STACK_SIZE_KHR: Self = Self(1_000_347_000); +} +#[doc = "Generated from 'VK_KHR_ray_tracing_pipeline'"] +impl PipelineBindPoint { + pub const RAY_TRACING_KHR: Self = Self(1_000_165_000); +} +#[doc = "Generated from 'VK_KHR_ray_tracing_pipeline'"] +impl PipelineCreateFlags { + pub const RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_KHR: Self = Self(0b100_0000_0000_0000); + pub const RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS_KHR: Self = Self(0b1000_0000_0000_0000); + pub const RAY_TRACING_NO_NULL_MISS_SHADERS_KHR: Self = Self(0b1_0000_0000_0000_0000); + pub const RAY_TRACING_NO_NULL_INTERSECTION_SHADERS_KHR: Self = Self(0b10_0000_0000_0000_0000); + pub const RAY_TRACING_SKIP_TRIANGLES_KHR: Self = Self(0b1_0000_0000_0000); + pub const RAY_TRACING_SKIP_AABBS_KHR: Self = Self(0b10_0000_0000_0000); + pub const RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY_KHR: Self = + Self(0b1000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_KHR_ray_tracing_pipeline'"] +impl PipelineStageFlags { + pub const RAY_TRACING_SHADER_KHR: Self = Self(0b10_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_KHR_ray_tracing_pipeline'"] +impl ShaderStageFlags { + pub const RAYGEN_KHR: Self = Self(0b1_0000_0000); + pub const ANY_HIT_KHR: Self = Self(0b10_0000_0000); + pub const CLOSEST_HIT_KHR: Self = Self(0b100_0000_0000); + pub const MISS_KHR: Self = Self(0b1000_0000_0000); + pub const INTERSECTION_KHR: Self = Self(0b1_0000_0000_0000); + pub const CALLABLE_KHR: Self = Self(0b10_0000_0000_0000); +} +#[doc = "Generated from 'VK_KHR_ray_tracing_pipeline'"] +impl StructureType { + pub const PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR: Self = Self(1_000_347_000); + pub const PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR: Self = Self(1_000_347_001); + pub const RAY_TRACING_PIPELINE_CREATE_INFO_KHR: Self = Self(1_000_150_015); + pub const RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR: Self = Self(1_000_150_016); + pub const RAY_TRACING_PIPELINE_INTERFACE_CREATE_INFO_KHR: Self = Self(1_000_150_018); +} +impl KhrRayQueryFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_ray_query\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct KhrRayQueryFn {} +unsafe impl Send for KhrRayQueryFn {} +unsafe impl Sync for KhrRayQueryFn {} +impl KhrRayQueryFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_KHR_ray_query'"] +impl StructureType { + pub const PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR: Self = Self(1_000_348_013); +} +impl NvExtension152Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_152\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct NvExtension152Fn {} +unsafe impl Send for NvExtension152Fn {} +unsafe impl Sync for NvExtension152Fn {} +impl NvExtension152Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl NvFramebufferMixedSamplesFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_framebuffer_mixed_samples\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct NvFramebufferMixedSamplesFn {} +unsafe impl Send for NvFramebufferMixedSamplesFn {} +unsafe impl Sync for NvFramebufferMixedSamplesFn {} +impl NvFramebufferMixedSamplesFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_NV_framebuffer_mixed_samples'"] +impl StructureType { + pub const PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV: Self = Self(1_000_152_000); +} +impl NvFillRectangleFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_fill_rectangle\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct NvFillRectangleFn {} +unsafe impl Send for NvFillRectangleFn {} +unsafe impl Sync for NvFillRectangleFn {} +impl NvFillRectangleFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_NV_fill_rectangle'"] +impl PolygonMode { + pub const FILL_RECTANGLE_NV: Self = Self(1_000_153_000); +} +impl NvShaderSmBuiltinsFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_shader_sm_builtins\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct NvShaderSmBuiltinsFn {} +unsafe impl Send for NvShaderSmBuiltinsFn {} +unsafe impl Sync for NvShaderSmBuiltinsFn {} +impl NvShaderSmBuiltinsFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_NV_shader_sm_builtins'"] +impl StructureType { + pub const PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV: Self = Self(1_000_154_000); + pub const PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV: Self = Self(1_000_154_001); +} +impl ExtPostDepthCoverageFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_post_depth_coverage\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct ExtPostDepthCoverageFn {} +unsafe impl Send for ExtPostDepthCoverageFn {} +unsafe impl Sync for ExtPostDepthCoverageFn {} +impl ExtPostDepthCoverageFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl KhrSamplerYcbcrConversionFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_sampler_ycbcr_conversion\0") + } + } + pub const SPEC_VERSION: u32 = 14u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkCreateSamplerYcbcrConversion = unsafe extern "system" fn( + device: Device, + p_create_info: *const SamplerYcbcrConversionCreateInfo, + p_allocator: *const AllocationCallbacks, + p_ycbcr_conversion: *mut SamplerYcbcrConversion, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkDestroySamplerYcbcrConversion = unsafe extern "system" fn( + device: Device, + ycbcr_conversion: SamplerYcbcrConversion, + p_allocator: *const AllocationCallbacks, +); +#[derive(Clone)] +pub struct KhrSamplerYcbcrConversionFn { + pub create_sampler_ycbcr_conversion_khr: PFN_vkCreateSamplerYcbcrConversion, + pub destroy_sampler_ycbcr_conversion_khr: PFN_vkDestroySamplerYcbcrConversion, +} +unsafe impl Send for KhrSamplerYcbcrConversionFn {} +unsafe impl Sync for KhrSamplerYcbcrConversionFn {} +impl KhrSamplerYcbcrConversionFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + create_sampler_ycbcr_conversion_khr: unsafe { + unsafe extern "system" fn create_sampler_ycbcr_conversion_khr( + _device: Device, + _p_create_info: *const SamplerYcbcrConversionCreateInfo, + _p_allocator: *const AllocationCallbacks, + _p_ycbcr_conversion: *mut SamplerYcbcrConversion, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(create_sampler_ycbcr_conversion_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCreateSamplerYcbcrConversionKHR\0", + ); + let val = _f(cname); + if val.is_null() { + create_sampler_ycbcr_conversion_khr + } else { + ::std::mem::transmute(val) + } + }, + destroy_sampler_ycbcr_conversion_khr: unsafe { + unsafe extern "system" fn destroy_sampler_ycbcr_conversion_khr( + _device: Device, + _ycbcr_conversion: SamplerYcbcrConversion, + _p_allocator: *const AllocationCallbacks, + ) { + panic!(concat!( + "Unable to load ", + stringify!(destroy_sampler_ycbcr_conversion_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkDestroySamplerYcbcrConversionKHR\0", + ); + let val = _f(cname); + if val.is_null() { + destroy_sampler_ycbcr_conversion_khr + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_KHR_sampler_ycbcr_conversion'"] +impl ChromaLocation { + pub const COSITED_EVEN_KHR: Self = Self::COSITED_EVEN; + pub const MIDPOINT_KHR: Self = Self::MIDPOINT; +} +#[doc = "Generated from 'VK_KHR_sampler_ycbcr_conversion'"] +impl DebugReportObjectTypeEXT { + pub const SAMPLER_YCBCR_CONVERSION_KHR: Self = Self::SAMPLER_YCBCR_CONVERSION; +} +#[doc = "Generated from 'VK_KHR_sampler_ycbcr_conversion'"] +impl Format { + pub const G8B8G8R8_422_UNORM_KHR: Self = Self::G8B8G8R8_422_UNORM; + pub const B8G8R8G8_422_UNORM_KHR: Self = Self::B8G8R8G8_422_UNORM; + pub const G8_B8_R8_3PLANE_420_UNORM_KHR: Self = Self::G8_B8_R8_3PLANE_420_UNORM; + pub const G8_B8R8_2PLANE_420_UNORM_KHR: Self = Self::G8_B8R8_2PLANE_420_UNORM; + pub const G8_B8_R8_3PLANE_422_UNORM_KHR: Self = Self::G8_B8_R8_3PLANE_422_UNORM; + pub const G8_B8R8_2PLANE_422_UNORM_KHR: Self = Self::G8_B8R8_2PLANE_422_UNORM; + pub const G8_B8_R8_3PLANE_444_UNORM_KHR: Self = Self::G8_B8_R8_3PLANE_444_UNORM; + pub const R10X6_UNORM_PACK16_KHR: Self = Self::R10X6_UNORM_PACK16; + pub const R10X6G10X6_UNORM_2PACK16_KHR: Self = Self::R10X6G10X6_UNORM_2PACK16; + pub const R10X6G10X6B10X6A10X6_UNORM_4PACK16_KHR: Self = + Self::R10X6G10X6B10X6A10X6_UNORM_4PACK16; + pub const G10X6B10X6G10X6R10X6_422_UNORM_4PACK16_KHR: Self = + Self::G10X6B10X6G10X6R10X6_422_UNORM_4PACK16; + pub const B10X6G10X6R10X6G10X6_422_UNORM_4PACK16_KHR: Self = + Self::B10X6G10X6R10X6G10X6_422_UNORM_4PACK16; + pub const G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16_KHR: Self = + Self::G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16; + pub const G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16_KHR: Self = + Self::G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16; + pub const G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16_KHR: Self = + Self::G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16; + pub const G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16_KHR: Self = + Self::G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16; + pub const G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16_KHR: Self = + Self::G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16; + pub const R12X4_UNORM_PACK16_KHR: Self = Self::R12X4_UNORM_PACK16; + pub const R12X4G12X4_UNORM_2PACK16_KHR: Self = Self::R12X4G12X4_UNORM_2PACK16; + pub const R12X4G12X4B12X4A12X4_UNORM_4PACK16_KHR: Self = + Self::R12X4G12X4B12X4A12X4_UNORM_4PACK16; + pub const G12X4B12X4G12X4R12X4_422_UNORM_4PACK16_KHR: Self = + Self::G12X4B12X4G12X4R12X4_422_UNORM_4PACK16; + pub const B12X4G12X4R12X4G12X4_422_UNORM_4PACK16_KHR: Self = + Self::B12X4G12X4R12X4G12X4_422_UNORM_4PACK16; + pub const G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16_KHR: Self = + Self::G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16; + pub const G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16_KHR: Self = + Self::G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16; + pub const G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16_KHR: Self = + Self::G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16; + pub const G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16_KHR: Self = + Self::G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16; + pub const G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16_KHR: Self = + Self::G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16; + pub const G16B16G16R16_422_UNORM_KHR: Self = Self::G16B16G16R16_422_UNORM; + pub const B16G16R16G16_422_UNORM_KHR: Self = Self::B16G16R16G16_422_UNORM; + pub const G16_B16_R16_3PLANE_420_UNORM_KHR: Self = Self::G16_B16_R16_3PLANE_420_UNORM; + pub const G16_B16R16_2PLANE_420_UNORM_KHR: Self = Self::G16_B16R16_2PLANE_420_UNORM; + pub const G16_B16_R16_3PLANE_422_UNORM_KHR: Self = Self::G16_B16_R16_3PLANE_422_UNORM; + pub const G16_B16R16_2PLANE_422_UNORM_KHR: Self = Self::G16_B16R16_2PLANE_422_UNORM; + pub const G16_B16_R16_3PLANE_444_UNORM_KHR: Self = Self::G16_B16_R16_3PLANE_444_UNORM; +} +#[doc = "Generated from 'VK_KHR_sampler_ycbcr_conversion'"] +impl FormatFeatureFlags { + pub const MIDPOINT_CHROMA_SAMPLES_KHR: Self = Self::MIDPOINT_CHROMA_SAMPLES; + pub const SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_KHR: Self = + Self::SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER; + pub const SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_KHR: Self = + Self::SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER; + pub const SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_KHR: Self = + Self::SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT; + pub const SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_KHR: Self = + Self::SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE; + pub const DISJOINT_KHR: Self = Self::DISJOINT; + pub const COSITED_CHROMA_SAMPLES_KHR: Self = Self::COSITED_CHROMA_SAMPLES; +} +#[doc = "Generated from 'VK_KHR_sampler_ycbcr_conversion'"] +impl ImageAspectFlags { + pub const PLANE_0_KHR: Self = Self::PLANE_0; + pub const PLANE_1_KHR: Self = Self::PLANE_1; + pub const PLANE_2_KHR: Self = Self::PLANE_2; +} +#[doc = "Generated from 'VK_KHR_sampler_ycbcr_conversion'"] +impl ImageCreateFlags { + pub const DISJOINT_KHR: Self = Self::DISJOINT; +} +#[doc = "Generated from 'VK_KHR_sampler_ycbcr_conversion'"] +impl ObjectType { + pub const SAMPLER_YCBCR_CONVERSION_KHR: Self = Self::SAMPLER_YCBCR_CONVERSION; +} +#[doc = "Generated from 'VK_KHR_sampler_ycbcr_conversion'"] +impl SamplerYcbcrModelConversion { + pub const RGB_IDENTITY_KHR: Self = Self::RGB_IDENTITY; + pub const YCBCR_IDENTITY_KHR: Self = Self::YCBCR_IDENTITY; + pub const YCBCR_709_KHR: Self = Self::YCBCR_709; + pub const YCBCR_601_KHR: Self = Self::YCBCR_601; + pub const YCBCR_2020_KHR: Self = Self::YCBCR_2020; +} +#[doc = "Generated from 'VK_KHR_sampler_ycbcr_conversion'"] +impl SamplerYcbcrRange { + pub const ITU_FULL_KHR: Self = Self::ITU_FULL; + pub const ITU_NARROW_KHR: Self = Self::ITU_NARROW; +} +#[doc = "Generated from 'VK_KHR_sampler_ycbcr_conversion'"] +impl StructureType { + pub const SAMPLER_YCBCR_CONVERSION_CREATE_INFO_KHR: Self = + Self::SAMPLER_YCBCR_CONVERSION_CREATE_INFO; + pub const SAMPLER_YCBCR_CONVERSION_INFO_KHR: Self = Self::SAMPLER_YCBCR_CONVERSION_INFO; + pub const BIND_IMAGE_PLANE_MEMORY_INFO_KHR: Self = Self::BIND_IMAGE_PLANE_MEMORY_INFO; + pub const IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO_KHR: Self = + Self::IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO; + pub const PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES_KHR: Self = + Self::PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES; + pub const SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES_KHR: Self = + Self::SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES; +} +impl KhrBindMemory2Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_bind_memory2\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkBindBufferMemory2 = unsafe extern "system" fn( + device: Device, + bind_info_count: u32, + p_bind_infos: *const BindBufferMemoryInfo, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkBindImageMemory2 = unsafe extern "system" fn( + device: Device, + bind_info_count: u32, + p_bind_infos: *const BindImageMemoryInfo, +) -> Result; +#[derive(Clone)] +pub struct KhrBindMemory2Fn { + pub bind_buffer_memory2_khr: PFN_vkBindBufferMemory2, + pub bind_image_memory2_khr: PFN_vkBindImageMemory2, +} +unsafe impl Send for KhrBindMemory2Fn {} +unsafe impl Sync for KhrBindMemory2Fn {} +impl KhrBindMemory2Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + bind_buffer_memory2_khr: unsafe { + unsafe extern "system" fn bind_buffer_memory2_khr( + _device: Device, + _bind_info_count: u32, + _p_bind_infos: *const BindBufferMemoryInfo, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(bind_buffer_memory2_khr) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkBindBufferMemory2KHR\0"); + let val = _f(cname); + if val.is_null() { + bind_buffer_memory2_khr + } else { + ::std::mem::transmute(val) + } + }, + bind_image_memory2_khr: unsafe { + unsafe extern "system" fn bind_image_memory2_khr( + _device: Device, + _bind_info_count: u32, + _p_bind_infos: *const BindImageMemoryInfo, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(bind_image_memory2_khr) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkBindImageMemory2KHR\0"); + let val = _f(cname); + if val.is_null() { + bind_image_memory2_khr + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_KHR_bind_memory2'"] +impl ImageCreateFlags { + pub const ALIAS_KHR: Self = Self::ALIAS; +} +#[doc = "Generated from 'VK_KHR_bind_memory2'"] +impl StructureType { + pub const BIND_BUFFER_MEMORY_INFO_KHR: Self = Self::BIND_BUFFER_MEMORY_INFO; + pub const BIND_IMAGE_MEMORY_INFO_KHR: Self = Self::BIND_IMAGE_MEMORY_INFO; +} +impl ExtImageDrmFormatModifierFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_image_drm_format_modifier\0") + } + } + pub const SPEC_VERSION: u32 = 2u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkGetImageDrmFormatModifierPropertiesEXT = unsafe extern "system" fn( + device: Device, + image: Image, + p_properties: *mut ImageDrmFormatModifierPropertiesEXT, +) -> Result; +#[derive(Clone)] +pub struct ExtImageDrmFormatModifierFn { + pub get_image_drm_format_modifier_properties_ext: PFN_vkGetImageDrmFormatModifierPropertiesEXT, +} +unsafe impl Send for ExtImageDrmFormatModifierFn {} +unsafe impl Sync for ExtImageDrmFormatModifierFn {} +impl ExtImageDrmFormatModifierFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + get_image_drm_format_modifier_properties_ext: unsafe { + unsafe extern "system" fn get_image_drm_format_modifier_properties_ext( + _device: Device, + _image: Image, + _p_properties: *mut ImageDrmFormatModifierPropertiesEXT, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_image_drm_format_modifier_properties_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetImageDrmFormatModifierPropertiesEXT\0", + ); + let val = _f(cname); + if val.is_null() { + get_image_drm_format_modifier_properties_ext + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_EXT_image_drm_format_modifier'"] +impl ImageAspectFlags { + pub const MEMORY_PLANE_0_EXT: Self = Self(0b1000_0000); + pub const MEMORY_PLANE_1_EXT: Self = Self(0b1_0000_0000); + pub const MEMORY_PLANE_2_EXT: Self = Self(0b10_0000_0000); + pub const MEMORY_PLANE_3_EXT: Self = Self(0b100_0000_0000); +} +#[doc = "Generated from 'VK_EXT_image_drm_format_modifier'"] +impl ImageTiling { + pub const DRM_FORMAT_MODIFIER_EXT: Self = Self(1_000_158_000); +} +#[doc = "Generated from 'VK_EXT_image_drm_format_modifier'"] +impl Result { + pub const ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT: Self = Self(-1_000_158_000); +} +#[doc = "Generated from 'VK_EXT_image_drm_format_modifier'"] +impl StructureType { + pub const DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT: Self = Self(1_000_158_000); + pub const PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT: Self = Self(1_000_158_002); + pub const IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT: Self = Self(1_000_158_003); + pub const IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT: Self = Self(1_000_158_004); + pub const IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT: Self = Self(1_000_158_005); + pub const DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT: Self = Self(1_000_158_006); +} +impl ExtExtension160Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_160\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct ExtExtension160Fn {} +unsafe impl Send for ExtExtension160Fn {} +unsafe impl Sync for ExtExtension160Fn {} +impl ExtExtension160Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtValidationCacheFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_validation_cache\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkCreateValidationCacheEXT = unsafe extern "system" fn( + device: Device, + p_create_info: *const ValidationCacheCreateInfoEXT, + p_allocator: *const AllocationCallbacks, + p_validation_cache: *mut ValidationCacheEXT, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkDestroyValidationCacheEXT = unsafe extern "system" fn( + device: Device, + validation_cache: ValidationCacheEXT, + p_allocator: *const AllocationCallbacks, +); +#[allow(non_camel_case_types)] +pub type PFN_vkMergeValidationCachesEXT = unsafe extern "system" fn( + device: Device, + dst_cache: ValidationCacheEXT, + src_cache_count: u32, + p_src_caches: *const ValidationCacheEXT, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetValidationCacheDataEXT = unsafe extern "system" fn( + device: Device, + validation_cache: ValidationCacheEXT, + p_data_size: *mut usize, + p_data: *mut c_void, +) -> Result; +#[derive(Clone)] +pub struct ExtValidationCacheFn { + pub create_validation_cache_ext: PFN_vkCreateValidationCacheEXT, + pub destroy_validation_cache_ext: PFN_vkDestroyValidationCacheEXT, + pub merge_validation_caches_ext: PFN_vkMergeValidationCachesEXT, + pub get_validation_cache_data_ext: PFN_vkGetValidationCacheDataEXT, +} +unsafe impl Send for ExtValidationCacheFn {} +unsafe impl Sync for ExtValidationCacheFn {} +impl ExtValidationCacheFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + create_validation_cache_ext: unsafe { + unsafe extern "system" fn create_validation_cache_ext( + _device: Device, + _p_create_info: *const ValidationCacheCreateInfoEXT, + _p_allocator: *const AllocationCallbacks, + _p_validation_cache: *mut ValidationCacheEXT, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(create_validation_cache_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCreateValidationCacheEXT\0", + ); + let val = _f(cname); + if val.is_null() { + create_validation_cache_ext + } else { + ::std::mem::transmute(val) + } + }, + destroy_validation_cache_ext: unsafe { + unsafe extern "system" fn destroy_validation_cache_ext( + _device: Device, + _validation_cache: ValidationCacheEXT, + _p_allocator: *const AllocationCallbacks, + ) { + panic!(concat!( + "Unable to load ", + stringify!(destroy_validation_cache_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkDestroyValidationCacheEXT\0", + ); + let val = _f(cname); + if val.is_null() { + destroy_validation_cache_ext + } else { + ::std::mem::transmute(val) + } + }, + merge_validation_caches_ext: unsafe { + unsafe extern "system" fn merge_validation_caches_ext( + _device: Device, + _dst_cache: ValidationCacheEXT, + _src_cache_count: u32, + _p_src_caches: *const ValidationCacheEXT, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(merge_validation_caches_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkMergeValidationCachesEXT\0", + ); + let val = _f(cname); + if val.is_null() { + merge_validation_caches_ext + } else { + ::std::mem::transmute(val) + } + }, + get_validation_cache_data_ext: unsafe { + unsafe extern "system" fn get_validation_cache_data_ext( + _device: Device, + _validation_cache: ValidationCacheEXT, + _p_data_size: *mut usize, + _p_data: *mut c_void, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_validation_cache_data_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetValidationCacheDataEXT\0", + ); + let val = _f(cname); + if val.is_null() { + get_validation_cache_data_ext + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_EXT_validation_cache'"] +impl ObjectType { + pub const VALIDATION_CACHE_EXT: Self = Self(1_000_160_000); +} +#[doc = "Generated from 'VK_EXT_validation_cache'"] +impl StructureType { + pub const VALIDATION_CACHE_CREATE_INFO_EXT: Self = Self(1_000_160_000); + pub const SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT: Self = Self(1_000_160_001); +} +impl ExtDescriptorIndexingFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_descriptor_indexing\0") } + } + pub const SPEC_VERSION: u32 = 2u32; +} +#[derive(Clone)] +pub struct ExtDescriptorIndexingFn {} +unsafe impl Send for ExtDescriptorIndexingFn {} +unsafe impl Sync for ExtDescriptorIndexingFn {} +impl ExtDescriptorIndexingFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_descriptor_indexing'"] +impl DescriptorBindingFlags { + pub const UPDATE_AFTER_BIND_EXT: Self = Self::UPDATE_AFTER_BIND; + pub const UPDATE_UNUSED_WHILE_PENDING_EXT: Self = Self::UPDATE_UNUSED_WHILE_PENDING; + pub const PARTIALLY_BOUND_EXT: Self = Self::PARTIALLY_BOUND; + pub const VARIABLE_DESCRIPTOR_COUNT_EXT: Self = Self::VARIABLE_DESCRIPTOR_COUNT; +} +#[doc = "Generated from 'VK_EXT_descriptor_indexing'"] +impl DescriptorPoolCreateFlags { + pub const UPDATE_AFTER_BIND_EXT: Self = Self::UPDATE_AFTER_BIND; +} +#[doc = "Generated from 'VK_EXT_descriptor_indexing'"] +impl DescriptorSetLayoutCreateFlags { + pub const UPDATE_AFTER_BIND_POOL_EXT: Self = Self::UPDATE_AFTER_BIND_POOL; +} +#[doc = "Generated from 'VK_EXT_descriptor_indexing'"] +impl Result { + pub const ERROR_FRAGMENTATION_EXT: Self = Self::ERROR_FRAGMENTATION; +} +#[doc = "Generated from 'VK_EXT_descriptor_indexing'"] +impl StructureType { + pub const DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO_EXT: Self = + Self::DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO; + pub const PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES_EXT: Self = + Self::PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES; + pub const PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES_EXT: Self = + Self::PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES; + pub const DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO_EXT: Self = + Self::DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO; + pub const DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT_EXT: Self = + Self::DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT; +} +impl ExtShaderViewportIndexLayerFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_shader_viewport_index_layer\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct ExtShaderViewportIndexLayerFn {} +unsafe impl Send for ExtShaderViewportIndexLayerFn {} +unsafe impl Sync for ExtShaderViewportIndexLayerFn {} +impl ExtShaderViewportIndexLayerFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl KhrPortabilitySubsetFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_portability_subset\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct KhrPortabilitySubsetFn {} +unsafe impl Send for KhrPortabilitySubsetFn {} +unsafe impl Sync for KhrPortabilitySubsetFn {} +impl KhrPortabilitySubsetFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_KHR_portability_subset'"] +impl StructureType { + pub const PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR: Self = Self(1_000_163_000); + pub const PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR: Self = Self(1_000_163_001); +} +impl NvShadingRateImageFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_shading_rate_image\0") } + } + pub const SPEC_VERSION: u32 = 3u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkCmdBindShadingRateImageNV = unsafe extern "system" fn( + command_buffer: CommandBuffer, + image_view: ImageView, + image_layout: ImageLayout, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetViewportShadingRatePaletteNV = unsafe extern "system" fn( + command_buffer: CommandBuffer, + first_viewport: u32, + viewport_count: u32, + p_shading_rate_palettes: *const ShadingRatePaletteNV, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetCoarseSampleOrderNV = unsafe extern "system" fn( + command_buffer: CommandBuffer, + sample_order_type: CoarseSampleOrderTypeNV, + custom_sample_order_count: u32, + p_custom_sample_orders: *const CoarseSampleOrderCustomNV, +); +#[derive(Clone)] +pub struct NvShadingRateImageFn { + pub cmd_bind_shading_rate_image_nv: PFN_vkCmdBindShadingRateImageNV, + pub cmd_set_viewport_shading_rate_palette_nv: PFN_vkCmdSetViewportShadingRatePaletteNV, + pub cmd_set_coarse_sample_order_nv: PFN_vkCmdSetCoarseSampleOrderNV, +} +unsafe impl Send for NvShadingRateImageFn {} +unsafe impl Sync for NvShadingRateImageFn {} +impl NvShadingRateImageFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + cmd_bind_shading_rate_image_nv: unsafe { + unsafe extern "system" fn cmd_bind_shading_rate_image_nv( + _command_buffer: CommandBuffer, + _image_view: ImageView, + _image_layout: ImageLayout, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_bind_shading_rate_image_nv) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdBindShadingRateImageNV\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_bind_shading_rate_image_nv + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_viewport_shading_rate_palette_nv: unsafe { + unsafe extern "system" fn cmd_set_viewport_shading_rate_palette_nv( + _command_buffer: CommandBuffer, + _first_viewport: u32, + _viewport_count: u32, + _p_shading_rate_palettes: *const ShadingRatePaletteNV, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_viewport_shading_rate_palette_nv) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetViewportShadingRatePaletteNV\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_viewport_shading_rate_palette_nv + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_coarse_sample_order_nv: unsafe { + unsafe extern "system" fn cmd_set_coarse_sample_order_nv( + _command_buffer: CommandBuffer, + _sample_order_type: CoarseSampleOrderTypeNV, + _custom_sample_order_count: u32, + _p_custom_sample_orders: *const CoarseSampleOrderCustomNV, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_coarse_sample_order_nv) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetCoarseSampleOrderNV\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_coarse_sample_order_nv + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_NV_shading_rate_image'"] +impl AccessFlags { + pub const SHADING_RATE_IMAGE_READ_NV: Self = Self::FRAGMENT_SHADING_RATE_ATTACHMENT_READ_KHR; +} +#[doc = "Generated from 'VK_NV_shading_rate_image'"] +impl DynamicState { + pub const VIEWPORT_SHADING_RATE_PALETTE_NV: Self = Self(1_000_164_004); + pub const VIEWPORT_COARSE_SAMPLE_ORDER_NV: Self = Self(1_000_164_006); +} +#[doc = "Generated from 'VK_NV_shading_rate_image'"] +impl ImageLayout { + pub const SHADING_RATE_OPTIMAL_NV: Self = Self::FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR; +} +#[doc = "Generated from 'VK_NV_shading_rate_image'"] +impl ImageUsageFlags { + pub const SHADING_RATE_IMAGE_NV: Self = Self::FRAGMENT_SHADING_RATE_ATTACHMENT_KHR; +} +#[doc = "Generated from 'VK_NV_shading_rate_image'"] +impl PipelineStageFlags { + pub const SHADING_RATE_IMAGE_NV: Self = Self::FRAGMENT_SHADING_RATE_ATTACHMENT_KHR; +} +#[doc = "Generated from 'VK_NV_shading_rate_image'"] +impl StructureType { + pub const PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV: Self = Self(1_000_164_000); + pub const PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV: Self = Self(1_000_164_001); + pub const PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV: Self = Self(1_000_164_002); + pub const PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV: Self = + Self(1_000_164_005); +} +impl NvRayTracingFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_ray_tracing\0") } + } + pub const SPEC_VERSION: u32 = 3u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkCreateAccelerationStructureNV = unsafe extern "system" fn( + device: Device, + p_create_info: *const AccelerationStructureCreateInfoNV, + p_allocator: *const AllocationCallbacks, + p_acceleration_structure: *mut AccelerationStructureNV, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkDestroyAccelerationStructureNV = unsafe extern "system" fn( + device: Device, + acceleration_structure: AccelerationStructureNV, + p_allocator: *const AllocationCallbacks, +); +#[allow(non_camel_case_types)] +pub type PFN_vkGetAccelerationStructureMemoryRequirementsNV = unsafe extern "system" fn( + device: Device, + p_info: *const AccelerationStructureMemoryRequirementsInfoNV, + p_memory_requirements: *mut MemoryRequirements2KHR, +); +#[allow(non_camel_case_types)] +pub type PFN_vkBindAccelerationStructureMemoryNV = unsafe extern "system" fn( + device: Device, + bind_info_count: u32, + p_bind_infos: *const BindAccelerationStructureMemoryInfoNV, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkCmdBuildAccelerationStructureNV = unsafe extern "system" fn( + command_buffer: CommandBuffer, + p_info: *const AccelerationStructureInfoNV, + instance_data: Buffer, + instance_offset: DeviceSize, + update: Bool32, + dst: AccelerationStructureNV, + src: AccelerationStructureNV, + scratch: Buffer, + scratch_offset: DeviceSize, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdCopyAccelerationStructureNV = unsafe extern "system" fn( + command_buffer: CommandBuffer, + dst: AccelerationStructureNV, + src: AccelerationStructureNV, + mode: CopyAccelerationStructureModeKHR, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdTraceRaysNV = unsafe extern "system" fn( + command_buffer: CommandBuffer, + raygen_shader_binding_table_buffer: Buffer, + raygen_shader_binding_offset: DeviceSize, + miss_shader_binding_table_buffer: Buffer, + miss_shader_binding_offset: DeviceSize, + miss_shader_binding_stride: DeviceSize, + hit_shader_binding_table_buffer: Buffer, + hit_shader_binding_offset: DeviceSize, + hit_shader_binding_stride: DeviceSize, + callable_shader_binding_table_buffer: Buffer, + callable_shader_binding_offset: DeviceSize, + callable_shader_binding_stride: DeviceSize, + width: u32, + height: u32, + depth: u32, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCreateRayTracingPipelinesNV = unsafe extern "system" fn( + device: Device, + pipeline_cache: PipelineCache, + create_info_count: u32, + p_create_infos: *const RayTracingPipelineCreateInfoNV, + p_allocator: *const AllocationCallbacks, + p_pipelines: *mut Pipeline, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetAccelerationStructureHandleNV = unsafe extern "system" fn( + device: Device, + acceleration_structure: AccelerationStructureNV, + data_size: usize, + p_data: *mut c_void, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkCmdWriteAccelerationStructuresPropertiesNV = unsafe extern "system" fn( + command_buffer: CommandBuffer, + acceleration_structure_count: u32, + p_acceleration_structures: *const AccelerationStructureNV, + query_type: QueryType, + query_pool: QueryPool, + first_query: u32, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCompileDeferredNV = + unsafe extern "system" fn(device: Device, pipeline: Pipeline, shader: u32) -> Result; +#[derive(Clone)] +pub struct NvRayTracingFn { + pub create_acceleration_structure_nv: PFN_vkCreateAccelerationStructureNV, + pub destroy_acceleration_structure_nv: PFN_vkDestroyAccelerationStructureNV, + pub get_acceleration_structure_memory_requirements_nv: + PFN_vkGetAccelerationStructureMemoryRequirementsNV, + pub bind_acceleration_structure_memory_nv: PFN_vkBindAccelerationStructureMemoryNV, + pub cmd_build_acceleration_structure_nv: PFN_vkCmdBuildAccelerationStructureNV, + pub cmd_copy_acceleration_structure_nv: PFN_vkCmdCopyAccelerationStructureNV, + pub cmd_trace_rays_nv: PFN_vkCmdTraceRaysNV, + pub create_ray_tracing_pipelines_nv: PFN_vkCreateRayTracingPipelinesNV, + pub get_ray_tracing_shader_group_handles_nv: + crate::vk::PFN_vkGetRayTracingShaderGroupHandlesKHR, + pub get_acceleration_structure_handle_nv: PFN_vkGetAccelerationStructureHandleNV, + pub cmd_write_acceleration_structures_properties_nv: + PFN_vkCmdWriteAccelerationStructuresPropertiesNV, + pub compile_deferred_nv: PFN_vkCompileDeferredNV, +} +unsafe impl Send for NvRayTracingFn {} +unsafe impl Sync for NvRayTracingFn {} +impl NvRayTracingFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + create_acceleration_structure_nv: unsafe { + unsafe extern "system" fn create_acceleration_structure_nv( + _device: Device, + _p_create_info: *const AccelerationStructureCreateInfoNV, + _p_allocator: *const AllocationCallbacks, + _p_acceleration_structure: *mut AccelerationStructureNV, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(create_acceleration_structure_nv) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCreateAccelerationStructureNV\0", + ); + let val = _f(cname); + if val.is_null() { + create_acceleration_structure_nv + } else { + ::std::mem::transmute(val) + } + }, + destroy_acceleration_structure_nv: unsafe { + unsafe extern "system" fn destroy_acceleration_structure_nv( + _device: Device, + _acceleration_structure: AccelerationStructureNV, + _p_allocator: *const AllocationCallbacks, + ) { + panic!(concat!( + "Unable to load ", + stringify!(destroy_acceleration_structure_nv) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkDestroyAccelerationStructureNV\0", + ); + let val = _f(cname); + if val.is_null() { + destroy_acceleration_structure_nv + } else { + ::std::mem::transmute(val) + } + }, + get_acceleration_structure_memory_requirements_nv: unsafe { + unsafe extern "system" fn get_acceleration_structure_memory_requirements_nv( + _device: Device, + _p_info: *const AccelerationStructureMemoryRequirementsInfoNV, + _p_memory_requirements: *mut MemoryRequirements2KHR, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_acceleration_structure_memory_requirements_nv) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetAccelerationStructureMemoryRequirementsNV\0", + ); + let val = _f(cname); + if val.is_null() { + get_acceleration_structure_memory_requirements_nv + } else { + ::std::mem::transmute(val) + } + }, + bind_acceleration_structure_memory_nv: unsafe { + unsafe extern "system" fn bind_acceleration_structure_memory_nv( + _device: Device, + _bind_info_count: u32, + _p_bind_infos: *const BindAccelerationStructureMemoryInfoNV, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(bind_acceleration_structure_memory_nv) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkBindAccelerationStructureMemoryNV\0", + ); + let val = _f(cname); + if val.is_null() { + bind_acceleration_structure_memory_nv + } else { + ::std::mem::transmute(val) + } + }, + cmd_build_acceleration_structure_nv: unsafe { + unsafe extern "system" fn cmd_build_acceleration_structure_nv( + _command_buffer: CommandBuffer, + _p_info: *const AccelerationStructureInfoNV, + _instance_data: Buffer, + _instance_offset: DeviceSize, + _update: Bool32, + _dst: AccelerationStructureNV, + _src: AccelerationStructureNV, + _scratch: Buffer, + _scratch_offset: DeviceSize, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_build_acceleration_structure_nv) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdBuildAccelerationStructureNV\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_build_acceleration_structure_nv + } else { + ::std::mem::transmute(val) + } + }, + cmd_copy_acceleration_structure_nv: unsafe { + unsafe extern "system" fn cmd_copy_acceleration_structure_nv( + _command_buffer: CommandBuffer, + _dst: AccelerationStructureNV, + _src: AccelerationStructureNV, + _mode: CopyAccelerationStructureModeKHR, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_copy_acceleration_structure_nv) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdCopyAccelerationStructureNV\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_copy_acceleration_structure_nv + } else { + ::std::mem::transmute(val) + } + }, + cmd_trace_rays_nv: unsafe { + unsafe extern "system" fn cmd_trace_rays_nv( + _command_buffer: CommandBuffer, + _raygen_shader_binding_table_buffer: Buffer, + _raygen_shader_binding_offset: DeviceSize, + _miss_shader_binding_table_buffer: Buffer, + _miss_shader_binding_offset: DeviceSize, + _miss_shader_binding_stride: DeviceSize, + _hit_shader_binding_table_buffer: Buffer, + _hit_shader_binding_offset: DeviceSize, + _hit_shader_binding_stride: DeviceSize, + _callable_shader_binding_table_buffer: Buffer, + _callable_shader_binding_offset: DeviceSize, + _callable_shader_binding_stride: DeviceSize, + _width: u32, + _height: u32, + _depth: u32, + ) { + panic!(concat!("Unable to load ", stringify!(cmd_trace_rays_nv))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdTraceRaysNV\0"); + let val = _f(cname); + if val.is_null() { + cmd_trace_rays_nv + } else { + ::std::mem::transmute(val) + } + }, + create_ray_tracing_pipelines_nv: unsafe { + unsafe extern "system" fn create_ray_tracing_pipelines_nv( + _device: Device, + _pipeline_cache: PipelineCache, + _create_info_count: u32, + _p_create_infos: *const RayTracingPipelineCreateInfoNV, + _p_allocator: *const AllocationCallbacks, + _p_pipelines: *mut Pipeline, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(create_ray_tracing_pipelines_nv) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCreateRayTracingPipelinesNV\0", + ); + let val = _f(cname); + if val.is_null() { + create_ray_tracing_pipelines_nv + } else { + ::std::mem::transmute(val) + } + }, + get_ray_tracing_shader_group_handles_nv: unsafe { + unsafe extern "system" fn get_ray_tracing_shader_group_handles_nv( + _device: Device, + _pipeline: Pipeline, + _first_group: u32, + _group_count: u32, + _data_size: usize, + _p_data: *mut c_void, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_ray_tracing_shader_group_handles_nv) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetRayTracingShaderGroupHandlesNV\0", + ); + let val = _f(cname); + if val.is_null() { + get_ray_tracing_shader_group_handles_nv + } else { + ::std::mem::transmute(val) + } + }, + get_acceleration_structure_handle_nv: unsafe { + unsafe extern "system" fn get_acceleration_structure_handle_nv( + _device: Device, + _acceleration_structure: AccelerationStructureNV, + _data_size: usize, + _p_data: *mut c_void, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_acceleration_structure_handle_nv) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetAccelerationStructureHandleNV\0", + ); + let val = _f(cname); + if val.is_null() { + get_acceleration_structure_handle_nv + } else { + ::std::mem::transmute(val) + } + }, + cmd_write_acceleration_structures_properties_nv: unsafe { + unsafe extern "system" fn cmd_write_acceleration_structures_properties_nv( + _command_buffer: CommandBuffer, + _acceleration_structure_count: u32, + _p_acceleration_structures: *const AccelerationStructureNV, + _query_type: QueryType, + _query_pool: QueryPool, + _first_query: u32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_write_acceleration_structures_properties_nv) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdWriteAccelerationStructuresPropertiesNV\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_write_acceleration_structures_properties_nv + } else { + ::std::mem::transmute(val) + } + }, + compile_deferred_nv: unsafe { + unsafe extern "system" fn compile_deferred_nv( + _device: Device, + _pipeline: Pipeline, + _shader: u32, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(compile_deferred_nv))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCompileDeferredNV\0"); + let val = _f(cname); + if val.is_null() { + compile_deferred_nv + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_NV_ray_tracing'"] +impl AccelerationStructureTypeKHR { + pub const TOP_LEVEL_NV: Self = Self::TOP_LEVEL; + pub const BOTTOM_LEVEL_NV: Self = Self::BOTTOM_LEVEL; +} +#[doc = "Generated from 'VK_NV_ray_tracing'"] +impl AccessFlags { + pub const ACCELERATION_STRUCTURE_READ_NV: Self = Self::ACCELERATION_STRUCTURE_READ_KHR; + pub const ACCELERATION_STRUCTURE_WRITE_NV: Self = Self::ACCELERATION_STRUCTURE_WRITE_KHR; +} +#[doc = "Generated from 'VK_NV_ray_tracing'"] +impl BufferUsageFlags { + pub const RAY_TRACING_NV: Self = Self::SHADER_BINDING_TABLE_KHR; +} +#[doc = "Generated from 'VK_NV_ray_tracing'"] +impl BuildAccelerationStructureFlagsKHR { + pub const ALLOW_UPDATE_NV: Self = Self::ALLOW_UPDATE; + pub const ALLOW_COMPACTION_NV: Self = Self::ALLOW_COMPACTION; + pub const PREFER_FAST_TRACE_NV: Self = Self::PREFER_FAST_TRACE; + pub const PREFER_FAST_BUILD_NV: Self = Self::PREFER_FAST_BUILD; + pub const LOW_MEMORY_NV: Self = Self::LOW_MEMORY; +} +#[doc = "Generated from 'VK_NV_ray_tracing'"] +impl CopyAccelerationStructureModeKHR { + pub const CLONE_NV: Self = Self::CLONE; + pub const COMPACT_NV: Self = Self::COMPACT; +} +#[doc = "Generated from 'VK_NV_ray_tracing'"] +impl DebugReportObjectTypeEXT { + pub const ACCELERATION_STRUCTURE_NV: Self = Self(1_000_165_000); +} +#[doc = "Generated from 'VK_NV_ray_tracing'"] +impl DescriptorType { + pub const ACCELERATION_STRUCTURE_NV: Self = Self(1_000_165_000); +} +#[doc = "Generated from 'VK_NV_ray_tracing'"] +impl GeometryFlagsKHR { + pub const OPAQUE_NV: Self = Self::OPAQUE; + pub const NO_DUPLICATE_ANY_HIT_INVOCATION_NV: Self = Self::NO_DUPLICATE_ANY_HIT_INVOCATION; +} +#[doc = "Generated from 'VK_NV_ray_tracing'"] +impl GeometryInstanceFlagsKHR { + pub const TRIANGLE_CULL_DISABLE_NV: Self = Self::TRIANGLE_FACING_CULL_DISABLE; + pub const TRIANGLE_FRONT_COUNTERCLOCKWISE_NV: Self = Self::TRIANGLE_FRONT_COUNTERCLOCKWISE; + pub const FORCE_OPAQUE_NV: Self = Self::FORCE_OPAQUE; + pub const FORCE_NO_OPAQUE_NV: Self = Self::FORCE_NO_OPAQUE; +} +#[doc = "Generated from 'VK_NV_ray_tracing'"] +impl GeometryTypeKHR { + pub const TRIANGLES_NV: Self = Self::TRIANGLES; + pub const AABBS_NV: Self = Self::AABBS; +} +#[doc = "Generated from 'VK_NV_ray_tracing'"] +impl IndexType { + pub const NONE_NV: Self = Self::NONE_KHR; +} +#[doc = "Generated from 'VK_NV_ray_tracing'"] +impl ObjectType { + pub const ACCELERATION_STRUCTURE_NV: Self = Self(1_000_165_000); +} +#[doc = "Generated from 'VK_NV_ray_tracing'"] +impl PipelineBindPoint { + pub const RAY_TRACING_NV: Self = Self::RAY_TRACING_KHR; +} +#[doc = "Generated from 'VK_NV_ray_tracing'"] +impl PipelineCreateFlags { + pub const DEFER_COMPILE_NV: Self = Self(0b10_0000); +} +#[doc = "Generated from 'VK_NV_ray_tracing'"] +impl PipelineStageFlags { + pub const RAY_TRACING_SHADER_NV: Self = Self::RAY_TRACING_SHADER_KHR; + pub const ACCELERATION_STRUCTURE_BUILD_NV: Self = Self::ACCELERATION_STRUCTURE_BUILD_KHR; +} +#[doc = "Generated from 'VK_NV_ray_tracing'"] +impl QueryType { + pub const ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV: Self = Self(1_000_165_000); +} +#[doc = "Generated from 'VK_NV_ray_tracing'"] +impl RayTracingShaderGroupTypeKHR { + pub const GENERAL_NV: Self = Self::GENERAL; + pub const TRIANGLES_HIT_GROUP_NV: Self = Self::TRIANGLES_HIT_GROUP; + pub const PROCEDURAL_HIT_GROUP_NV: Self = Self::PROCEDURAL_HIT_GROUP; +} +#[doc = "Generated from 'VK_NV_ray_tracing'"] +impl ShaderStageFlags { + pub const RAYGEN_NV: Self = Self::RAYGEN_KHR; + pub const ANY_HIT_NV: Self = Self::ANY_HIT_KHR; + pub const CLOSEST_HIT_NV: Self = Self::CLOSEST_HIT_KHR; + pub const MISS_NV: Self = Self::MISS_KHR; + pub const INTERSECTION_NV: Self = Self::INTERSECTION_KHR; + pub const CALLABLE_NV: Self = Self::CALLABLE_KHR; +} +#[doc = "Generated from 'VK_NV_ray_tracing'"] +impl StructureType { + pub const RAY_TRACING_PIPELINE_CREATE_INFO_NV: Self = Self(1_000_165_000); + pub const ACCELERATION_STRUCTURE_CREATE_INFO_NV: Self = Self(1_000_165_001); + pub const GEOMETRY_NV: Self = Self(1_000_165_003); + pub const GEOMETRY_TRIANGLES_NV: Self = Self(1_000_165_004); + pub const GEOMETRY_AABB_NV: Self = Self(1_000_165_005); + pub const BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NV: Self = Self(1_000_165_006); + pub const WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV: Self = Self(1_000_165_007); + pub const ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV: Self = Self(1_000_165_008); + pub const PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV: Self = Self(1_000_165_009); + pub const RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV: Self = Self(1_000_165_011); + pub const ACCELERATION_STRUCTURE_INFO_NV: Self = Self(1_000_165_012); +} +impl NvRepresentativeFragmentTestFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_representative_fragment_test\0") + } + } + pub const SPEC_VERSION: u32 = 2u32; +} +#[derive(Clone)] +pub struct NvRepresentativeFragmentTestFn {} +unsafe impl Send for NvRepresentativeFragmentTestFn {} +unsafe impl Sync for NvRepresentativeFragmentTestFn {} +impl NvRepresentativeFragmentTestFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_NV_representative_fragment_test'"] +impl StructureType { + pub const PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV: Self = Self(1_000_166_000); + pub const PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV: Self = + Self(1_000_166_001); +} +impl NvExtension168Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_168\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct NvExtension168Fn {} +unsafe impl Send for NvExtension168Fn {} +unsafe impl Sync for NvExtension168Fn {} +impl NvExtension168Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl KhrMaintenance3Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_maintenance3\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkGetDescriptorSetLayoutSupport = unsafe extern "system" fn( + device: Device, + p_create_info: *const DescriptorSetLayoutCreateInfo, + p_support: *mut DescriptorSetLayoutSupport, +); +#[derive(Clone)] +pub struct KhrMaintenance3Fn { + pub get_descriptor_set_layout_support_khr: PFN_vkGetDescriptorSetLayoutSupport, +} +unsafe impl Send for KhrMaintenance3Fn {} +unsafe impl Sync for KhrMaintenance3Fn {} +impl KhrMaintenance3Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + get_descriptor_set_layout_support_khr: unsafe { + unsafe extern "system" fn get_descriptor_set_layout_support_khr( + _device: Device, + _p_create_info: *const DescriptorSetLayoutCreateInfo, + _p_support: *mut DescriptorSetLayoutSupport, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_descriptor_set_layout_support_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetDescriptorSetLayoutSupportKHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_descriptor_set_layout_support_khr + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_KHR_maintenance3'"] +impl StructureType { + pub const PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES_KHR: Self = + Self::PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES; + pub const DESCRIPTOR_SET_LAYOUT_SUPPORT_KHR: Self = Self::DESCRIPTOR_SET_LAYOUT_SUPPORT; +} +impl KhrDrawIndirectCountFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_draw_indirect_count\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct KhrDrawIndirectCountFn { + pub cmd_draw_indirect_count_khr: crate::vk::PFN_vkCmdDrawIndirectCount, + pub cmd_draw_indexed_indirect_count_khr: crate::vk::PFN_vkCmdDrawIndexedIndirectCount, +} +unsafe impl Send for KhrDrawIndirectCountFn {} +unsafe impl Sync for KhrDrawIndirectCountFn {} +impl KhrDrawIndirectCountFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + cmd_draw_indirect_count_khr: unsafe { + unsafe extern "system" fn cmd_draw_indirect_count_khr( + _command_buffer: CommandBuffer, + _buffer: Buffer, + _offset: DeviceSize, + _count_buffer: Buffer, + _count_buffer_offset: DeviceSize, + _max_draw_count: u32, + _stride: u32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_draw_indirect_count_khr) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdDrawIndirectCountKHR\0"); + let val = _f(cname); + if val.is_null() { + cmd_draw_indirect_count_khr + } else { + ::std::mem::transmute(val) + } + }, + cmd_draw_indexed_indirect_count_khr: unsafe { + unsafe extern "system" fn cmd_draw_indexed_indirect_count_khr( + _command_buffer: CommandBuffer, + _buffer: Buffer, + _offset: DeviceSize, + _count_buffer: Buffer, + _count_buffer_offset: DeviceSize, + _max_draw_count: u32, + _stride: u32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_draw_indexed_indirect_count_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdDrawIndexedIndirectCountKHR\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_draw_indexed_indirect_count_khr + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +impl ExtFilterCubicFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_filter_cubic\0") } + } + pub const SPEC_VERSION: u32 = 3u32; +} +#[derive(Clone)] +pub struct ExtFilterCubicFn {} +unsafe impl Send for ExtFilterCubicFn {} +unsafe impl Sync for ExtFilterCubicFn {} +impl ExtFilterCubicFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_filter_cubic'"] +impl Filter { + pub const CUBIC_EXT: Self = Self(1_000_015_000); +} +#[doc = "Generated from 'VK_EXT_filter_cubic'"] +impl FormatFeatureFlags { + pub const SAMPLED_IMAGE_FILTER_CUBIC_EXT: Self = Self(0b10_0000_0000_0000); +} +#[doc = "Generated from 'VK_EXT_filter_cubic'"] +impl StructureType { + pub const PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT: Self = Self(1_000_170_000); + pub const FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT: Self = Self(1_000_170_001); +} +impl QcomRenderPassShaderResolveFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_QCOM_render_pass_shader_resolve\0") + } + } + pub const SPEC_VERSION: u32 = 4u32; +} +#[derive(Clone)] +pub struct QcomRenderPassShaderResolveFn {} +unsafe impl Send for QcomRenderPassShaderResolveFn {} +unsafe impl Sync for QcomRenderPassShaderResolveFn {} +impl QcomRenderPassShaderResolveFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_QCOM_render_pass_shader_resolve'"] +impl SubpassDescriptionFlags { + pub const FRAGMENT_REGION_QCOM: Self = Self(0b100); + pub const SHADER_RESOLVE_QCOM: Self = Self(0b1000); +} +impl QcomExtension173Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_QCOM_extension_173\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct QcomExtension173Fn {} +unsafe impl Send for QcomExtension173Fn {} +unsafe impl Sync for QcomExtension173Fn {} +impl QcomExtension173Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_QCOM_extension_173'"] +impl BufferUsageFlags { + pub const RESERVED_18_QCOM: Self = Self(0b100_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_QCOM_extension_173'"] +impl ImageUsageFlags { + pub const RESERVED_16_QCOM: Self = Self(0b1_0000_0000_0000_0000); + pub const RESERVED_17_QCOM: Self = Self(0b10_0000_0000_0000_0000); +} +impl QcomExtension174Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_QCOM_extension_174\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct QcomExtension174Fn {} +unsafe impl Send for QcomExtension174Fn {} +unsafe impl Sync for QcomExtension174Fn {} +impl QcomExtension174Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtGlobalPriorityFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_global_priority\0") } + } + pub const SPEC_VERSION: u32 = 2u32; +} +#[derive(Clone)] +pub struct ExtGlobalPriorityFn {} +unsafe impl Send for ExtGlobalPriorityFn {} +unsafe impl Sync for ExtGlobalPriorityFn {} +impl ExtGlobalPriorityFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_global_priority'"] +impl Result { + pub const ERROR_NOT_PERMITTED_EXT: Self = Self::ERROR_NOT_PERMITTED_KHR; +} +#[doc = "Generated from 'VK_EXT_global_priority'"] +impl StructureType { + pub const DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT: Self = + Self::DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_KHR; +} +impl KhrShaderSubgroupExtendedTypesFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"VK_KHR_shader_subgroup_extended_types\0", + ) + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct KhrShaderSubgroupExtendedTypesFn {} +unsafe impl Send for KhrShaderSubgroupExtendedTypesFn {} +unsafe impl Sync for KhrShaderSubgroupExtendedTypesFn {} +impl KhrShaderSubgroupExtendedTypesFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_KHR_shader_subgroup_extended_types'"] +impl StructureType { + pub const PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES_KHR: Self = + Self::PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES; +} +impl ExtExtension177Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_177\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct ExtExtension177Fn {} +unsafe impl Send for ExtExtension177Fn {} +unsafe impl Sync for ExtExtension177Fn {} +impl ExtExtension177Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl Khr8bitStorageFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_8bit_storage\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct Khr8bitStorageFn {} +unsafe impl Send for Khr8bitStorageFn {} +unsafe impl Sync for Khr8bitStorageFn {} +impl Khr8bitStorageFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_KHR_8bit_storage'"] +impl StructureType { + pub const PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES_KHR: Self = + Self::PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES; +} +impl ExtExternalMemoryHostFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_external_memory_host\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkGetMemoryHostPointerPropertiesEXT = unsafe extern "system" fn( + device: Device, + handle_type: ExternalMemoryHandleTypeFlags, + p_host_pointer: *const c_void, + p_memory_host_pointer_properties: *mut MemoryHostPointerPropertiesEXT, +) -> Result; +#[derive(Clone)] +pub struct ExtExternalMemoryHostFn { + pub get_memory_host_pointer_properties_ext: PFN_vkGetMemoryHostPointerPropertiesEXT, +} +unsafe impl Send for ExtExternalMemoryHostFn {} +unsafe impl Sync for ExtExternalMemoryHostFn {} +impl ExtExternalMemoryHostFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + get_memory_host_pointer_properties_ext: unsafe { + unsafe extern "system" fn get_memory_host_pointer_properties_ext( + _device: Device, + _handle_type: ExternalMemoryHandleTypeFlags, + _p_host_pointer: *const c_void, + _p_memory_host_pointer_properties: *mut MemoryHostPointerPropertiesEXT, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_memory_host_pointer_properties_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetMemoryHostPointerPropertiesEXT\0", + ); + let val = _f(cname); + if val.is_null() { + get_memory_host_pointer_properties_ext + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_EXT_external_memory_host'"] +impl ExternalMemoryHandleTypeFlags { + pub const HOST_ALLOCATION_EXT: Self = Self(0b1000_0000); + pub const HOST_MAPPED_FOREIGN_MEMORY_EXT: Self = Self(0b1_0000_0000); +} +#[doc = "Generated from 'VK_EXT_external_memory_host'"] +impl StructureType { + pub const IMPORT_MEMORY_HOST_POINTER_INFO_EXT: Self = Self(1_000_178_000); + pub const MEMORY_HOST_POINTER_PROPERTIES_EXT: Self = Self(1_000_178_001); + pub const PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT: Self = Self(1_000_178_002); +} +impl AmdBufferMarkerFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_buffer_marker\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkCmdWriteBufferMarkerAMD = unsafe extern "system" fn( + command_buffer: CommandBuffer, + pipeline_stage: PipelineStageFlags, + dst_buffer: Buffer, + dst_offset: DeviceSize, + marker: u32, +); +#[derive(Clone)] +pub struct AmdBufferMarkerFn { + pub cmd_write_buffer_marker_amd: PFN_vkCmdWriteBufferMarkerAMD, +} +unsafe impl Send for AmdBufferMarkerFn {} +unsafe impl Sync for AmdBufferMarkerFn {} +impl AmdBufferMarkerFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + cmd_write_buffer_marker_amd: unsafe { + unsafe extern "system" fn cmd_write_buffer_marker_amd( + _command_buffer: CommandBuffer, + _pipeline_stage: PipelineStageFlags, + _dst_buffer: Buffer, + _dst_offset: DeviceSize, + _marker: u32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_write_buffer_marker_amd) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdWriteBufferMarkerAMD\0"); + let val = _f(cname); + if val.is_null() { + cmd_write_buffer_marker_amd + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +impl KhrShaderAtomicInt64Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_shader_atomic_int64\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct KhrShaderAtomicInt64Fn {} +unsafe impl Send for KhrShaderAtomicInt64Fn {} +unsafe impl Sync for KhrShaderAtomicInt64Fn {} +impl KhrShaderAtomicInt64Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_KHR_shader_atomic_int64'"] +impl StructureType { + pub const PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES_KHR: Self = + Self::PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES; +} +impl KhrShaderClockFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_shader_clock\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct KhrShaderClockFn {} +unsafe impl Send for KhrShaderClockFn {} +unsafe impl Sync for KhrShaderClockFn {} +impl KhrShaderClockFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_KHR_shader_clock'"] +impl StructureType { + pub const PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR: Self = Self(1_000_181_000); +} +impl AmdExtension183Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_183\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct AmdExtension183Fn {} +unsafe impl Send for AmdExtension183Fn {} +unsafe impl Sync for AmdExtension183Fn {} +impl AmdExtension183Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl AmdPipelineCompilerControlFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_pipeline_compiler_control\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct AmdPipelineCompilerControlFn {} +unsafe impl Send for AmdPipelineCompilerControlFn {} +unsafe impl Sync for AmdPipelineCompilerControlFn {} +impl AmdPipelineCompilerControlFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_AMD_pipeline_compiler_control'"] +impl StructureType { + pub const PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD: Self = Self(1_000_183_000); +} +impl ExtCalibratedTimestampsFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_calibrated_timestamps\0") + } + } + pub const SPEC_VERSION: u32 = 2u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT = unsafe extern "system" fn( + physical_device: PhysicalDevice, + p_time_domain_count: *mut u32, + p_time_domains: *mut TimeDomainEXT, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetCalibratedTimestampsEXT = unsafe extern "system" fn( + device: Device, + timestamp_count: u32, + p_timestamp_infos: *const CalibratedTimestampInfoEXT, + p_timestamps: *mut u64, + p_max_deviation: *mut u64, +) -> Result; +#[derive(Clone)] +pub struct ExtCalibratedTimestampsFn { + pub get_physical_device_calibrateable_time_domains_ext: + PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT, + pub get_calibrated_timestamps_ext: PFN_vkGetCalibratedTimestampsEXT, +} +unsafe impl Send for ExtCalibratedTimestampsFn {} +unsafe impl Sync for ExtCalibratedTimestampsFn {} +impl ExtCalibratedTimestampsFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + get_physical_device_calibrateable_time_domains_ext: unsafe { + unsafe extern "system" fn get_physical_device_calibrateable_time_domains_ext( + _physical_device: PhysicalDevice, + _p_time_domain_count: *mut u32, + _p_time_domains: *mut TimeDomainEXT, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_calibrateable_time_domains_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPhysicalDeviceCalibrateableTimeDomainsEXT\0", + ); + let val = _f(cname); + if val.is_null() { + get_physical_device_calibrateable_time_domains_ext + } else { + ::std::mem::transmute(val) + } + }, + get_calibrated_timestamps_ext: unsafe { + unsafe extern "system" fn get_calibrated_timestamps_ext( + _device: Device, + _timestamp_count: u32, + _p_timestamp_infos: *const CalibratedTimestampInfoEXT, + _p_timestamps: *mut u64, + _p_max_deviation: *mut u64, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_calibrated_timestamps_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetCalibratedTimestampsEXT\0", + ); + let val = _f(cname); + if val.is_null() { + get_calibrated_timestamps_ext + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_EXT_calibrated_timestamps'"] +impl StructureType { + pub const CALIBRATED_TIMESTAMP_INFO_EXT: Self = Self(1_000_184_000); +} +impl AmdShaderCorePropertiesFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_shader_core_properties\0") + } + } + pub const SPEC_VERSION: u32 = 2u32; +} +#[derive(Clone)] +pub struct AmdShaderCorePropertiesFn {} +unsafe impl Send for AmdShaderCorePropertiesFn {} +unsafe impl Sync for AmdShaderCorePropertiesFn {} +impl AmdShaderCorePropertiesFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_AMD_shader_core_properties'"] +impl StructureType { + pub const PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD: Self = Self(1_000_185_000); +} +impl AmdExtension187Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_187\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct AmdExtension187Fn {} +unsafe impl Send for AmdExtension187Fn {} +unsafe impl Sync for AmdExtension187Fn {} +impl AmdExtension187Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl KhrVideoDecodeH265Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_video_decode_h265\0") } + } + pub const SPEC_VERSION: u32 = 7u32; +} +#[derive(Clone)] +pub struct KhrVideoDecodeH265Fn {} +unsafe impl Send for KhrVideoDecodeH265Fn {} +unsafe impl Sync for KhrVideoDecodeH265Fn {} +impl KhrVideoDecodeH265Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_KHR_video_decode_h265'"] +impl StructureType { + pub const VIDEO_DECODE_H265_CAPABILITIES_KHR: Self = Self(1_000_187_000); + pub const VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR: Self = Self(1_000_187_001); + pub const VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR: Self = Self(1_000_187_002); + pub const VIDEO_DECODE_H265_PROFILE_INFO_KHR: Self = Self(1_000_187_003); + pub const VIDEO_DECODE_H265_PICTURE_INFO_KHR: Self = Self(1_000_187_004); + pub const VIDEO_DECODE_H265_DPB_SLOT_INFO_KHR: Self = Self(1_000_187_005); +} +#[doc = "Generated from 'VK_KHR_video_decode_h265'"] +impl VideoCodecOperationFlagsKHR { + pub const DECODE_H265: Self = Self(0b10); +} +impl KhrGlobalPriorityFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_global_priority\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct KhrGlobalPriorityFn {} +unsafe impl Send for KhrGlobalPriorityFn {} +unsafe impl Sync for KhrGlobalPriorityFn {} +impl KhrGlobalPriorityFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_KHR_global_priority'"] +impl Result { + pub const ERROR_NOT_PERMITTED_KHR: Self = Self(-1_000_174_001); +} +#[doc = "Generated from 'VK_KHR_global_priority'"] +impl StructureType { + pub const DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_KHR: Self = Self(1_000_174_000); + pub const PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR: Self = Self(1_000_388_000); + pub const QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR: Self = Self(1_000_388_001); +} +impl AmdMemoryOverallocationBehaviorFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"VK_AMD_memory_overallocation_behavior\0", + ) + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct AmdMemoryOverallocationBehaviorFn {} +unsafe impl Send for AmdMemoryOverallocationBehaviorFn {} +unsafe impl Sync for AmdMemoryOverallocationBehaviorFn {} +impl AmdMemoryOverallocationBehaviorFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_AMD_memory_overallocation_behavior'"] +impl StructureType { + pub const DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD: Self = Self(1_000_189_000); +} +impl ExtVertexAttributeDivisorFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_vertex_attribute_divisor\0") + } + } + pub const SPEC_VERSION: u32 = 3u32; +} +#[derive(Clone)] +pub struct ExtVertexAttributeDivisorFn {} +unsafe impl Send for ExtVertexAttributeDivisorFn {} +unsafe impl Sync for ExtVertexAttributeDivisorFn {} +impl ExtVertexAttributeDivisorFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_vertex_attribute_divisor'"] +impl StructureType { + pub const PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT: Self = Self(1_000_190_000); + pub const PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT: Self = Self(1_000_190_001); + pub const PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT: Self = Self(1_000_190_002); +} +impl GgpFrameTokenFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_GGP_frame_token\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct GgpFrameTokenFn {} +unsafe impl Send for GgpFrameTokenFn {} +unsafe impl Sync for GgpFrameTokenFn {} +impl GgpFrameTokenFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_GGP_frame_token'"] +impl StructureType { + pub const PRESENT_FRAME_TOKEN_GGP: Self = Self(1_000_191_000); +} +impl ExtPipelineCreationFeedbackFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_pipeline_creation_feedback\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct ExtPipelineCreationFeedbackFn {} +unsafe impl Send for ExtPipelineCreationFeedbackFn {} +unsafe impl Sync for ExtPipelineCreationFeedbackFn {} +impl ExtPipelineCreationFeedbackFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_pipeline_creation_feedback'"] +impl StructureType { + pub const PIPELINE_CREATION_FEEDBACK_CREATE_INFO_EXT: Self = + Self::PIPELINE_CREATION_FEEDBACK_CREATE_INFO; +} +impl GoogleExtension194Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_GOOGLE_extension_194\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct GoogleExtension194Fn {} +unsafe impl Send for GoogleExtension194Fn {} +unsafe impl Sync for GoogleExtension194Fn {} +impl GoogleExtension194Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl GoogleExtension195Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_GOOGLE_extension_195\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct GoogleExtension195Fn {} +unsafe impl Send for GoogleExtension195Fn {} +unsafe impl Sync for GoogleExtension195Fn {} +impl GoogleExtension195Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl GoogleExtension196Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_GOOGLE_extension_196\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct GoogleExtension196Fn {} +unsafe impl Send for GoogleExtension196Fn {} +unsafe impl Sync for GoogleExtension196Fn {} +impl GoogleExtension196Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_GOOGLE_extension_196'"] +impl PipelineCacheCreateFlags { + pub const RESERVED_1_EXT: Self = Self(0b10); +} +impl KhrDriverPropertiesFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_driver_properties\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct KhrDriverPropertiesFn {} +unsafe impl Send for KhrDriverPropertiesFn {} +unsafe impl Sync for KhrDriverPropertiesFn {} +impl KhrDriverPropertiesFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_KHR_driver_properties'"] +impl DriverId { + pub const AMD_PROPRIETARY_KHR: Self = Self::AMD_PROPRIETARY; + pub const AMD_OPEN_SOURCE_KHR: Self = Self::AMD_OPEN_SOURCE; + pub const MESA_RADV_KHR: Self = Self::MESA_RADV; + pub const NVIDIA_PROPRIETARY_KHR: Self = Self::NVIDIA_PROPRIETARY; + pub const INTEL_PROPRIETARY_WINDOWS_KHR: Self = Self::INTEL_PROPRIETARY_WINDOWS; + pub const INTEL_OPEN_SOURCE_MESA_KHR: Self = Self::INTEL_OPEN_SOURCE_MESA; + pub const IMAGINATION_PROPRIETARY_KHR: Self = Self::IMAGINATION_PROPRIETARY; + pub const QUALCOMM_PROPRIETARY_KHR: Self = Self::QUALCOMM_PROPRIETARY; + pub const ARM_PROPRIETARY_KHR: Self = Self::ARM_PROPRIETARY; + pub const GOOGLE_SWIFTSHADER_KHR: Self = Self::GOOGLE_SWIFTSHADER; + pub const GGP_PROPRIETARY_KHR: Self = Self::GGP_PROPRIETARY; + pub const BROADCOM_PROPRIETARY_KHR: Self = Self::BROADCOM_PROPRIETARY; +} +#[doc = "Generated from 'VK_KHR_driver_properties'"] +impl StructureType { + pub const PHYSICAL_DEVICE_DRIVER_PROPERTIES_KHR: Self = Self::PHYSICAL_DEVICE_DRIVER_PROPERTIES; +} +impl KhrShaderFloatControlsFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_shader_float_controls\0") + } + } + pub const SPEC_VERSION: u32 = 4u32; +} +#[derive(Clone)] +pub struct KhrShaderFloatControlsFn {} +unsafe impl Send for KhrShaderFloatControlsFn {} +unsafe impl Sync for KhrShaderFloatControlsFn {} +impl KhrShaderFloatControlsFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_KHR_shader_float_controls'"] +impl ShaderFloatControlsIndependence { + pub const TYPE_32_ONLY_KHR: Self = Self::TYPE_32_ONLY; + pub const ALL_KHR: Self = Self::ALL; + pub const NONE_KHR: Self = Self::NONE; +} +#[doc = "Generated from 'VK_KHR_shader_float_controls'"] +impl StructureType { + pub const PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES_KHR: Self = + Self::PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES; +} +impl NvShaderSubgroupPartitionedFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_shader_subgroup_partitioned\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct NvShaderSubgroupPartitionedFn {} +unsafe impl Send for NvShaderSubgroupPartitionedFn {} +unsafe impl Sync for NvShaderSubgroupPartitionedFn {} +impl NvShaderSubgroupPartitionedFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_NV_shader_subgroup_partitioned'"] +impl SubgroupFeatureFlags { + pub const PARTITIONED_NV: Self = Self(0b1_0000_0000); +} +impl KhrDepthStencilResolveFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_depth_stencil_resolve\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct KhrDepthStencilResolveFn {} +unsafe impl Send for KhrDepthStencilResolveFn {} +unsafe impl Sync for KhrDepthStencilResolveFn {} +impl KhrDepthStencilResolveFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_KHR_depth_stencil_resolve'"] +impl ResolveModeFlags { + pub const NONE_KHR: Self = Self::NONE; + pub const SAMPLE_ZERO_KHR: Self = Self::SAMPLE_ZERO; + pub const AVERAGE_KHR: Self = Self::AVERAGE; + pub const MIN_KHR: Self = Self::MIN; + pub const MAX_KHR: Self = Self::MAX; +} +#[doc = "Generated from 'VK_KHR_depth_stencil_resolve'"] +impl StructureType { + pub const PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES_KHR: Self = + Self::PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES; + pub const SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE_KHR: Self = + Self::SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE; +} +impl KhrSwapchainMutableFormatFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_swapchain_mutable_format\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct KhrSwapchainMutableFormatFn {} +unsafe impl Send for KhrSwapchainMutableFormatFn {} +unsafe impl Sync for KhrSwapchainMutableFormatFn {} +impl KhrSwapchainMutableFormatFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_KHR_swapchain_mutable_format'"] +impl SwapchainCreateFlagsKHR { + pub const MUTABLE_FORMAT: Self = Self(0b100); +} +impl NvComputeShaderDerivativesFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_compute_shader_derivatives\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct NvComputeShaderDerivativesFn {} +unsafe impl Send for NvComputeShaderDerivativesFn {} +unsafe impl Sync for NvComputeShaderDerivativesFn {} +impl NvComputeShaderDerivativesFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_NV_compute_shader_derivatives'"] +impl StructureType { + pub const PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV: Self = Self(1_000_201_000); +} +impl NvMeshShaderFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_mesh_shader\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkCmdDrawMeshTasksNV = + unsafe extern "system" fn(command_buffer: CommandBuffer, task_count: u32, first_task: u32); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdDrawMeshTasksIndirectNV = unsafe extern "system" fn( + command_buffer: CommandBuffer, + buffer: Buffer, + offset: DeviceSize, + draw_count: u32, + stride: u32, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdDrawMeshTasksIndirectCountNV = unsafe extern "system" fn( + command_buffer: CommandBuffer, + buffer: Buffer, + offset: DeviceSize, + count_buffer: Buffer, + count_buffer_offset: DeviceSize, + max_draw_count: u32, + stride: u32, +); +#[derive(Clone)] +pub struct NvMeshShaderFn { + pub cmd_draw_mesh_tasks_nv: PFN_vkCmdDrawMeshTasksNV, + pub cmd_draw_mesh_tasks_indirect_nv: PFN_vkCmdDrawMeshTasksIndirectNV, + pub cmd_draw_mesh_tasks_indirect_count_nv: PFN_vkCmdDrawMeshTasksIndirectCountNV, +} +unsafe impl Send for NvMeshShaderFn {} +unsafe impl Sync for NvMeshShaderFn {} +impl NvMeshShaderFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + cmd_draw_mesh_tasks_nv: unsafe { + unsafe extern "system" fn cmd_draw_mesh_tasks_nv( + _command_buffer: CommandBuffer, + _task_count: u32, + _first_task: u32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_draw_mesh_tasks_nv) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdDrawMeshTasksNV\0"); + let val = _f(cname); + if val.is_null() { + cmd_draw_mesh_tasks_nv + } else { + ::std::mem::transmute(val) + } + }, + cmd_draw_mesh_tasks_indirect_nv: unsafe { + unsafe extern "system" fn cmd_draw_mesh_tasks_indirect_nv( + _command_buffer: CommandBuffer, + _buffer: Buffer, + _offset: DeviceSize, + _draw_count: u32, + _stride: u32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_draw_mesh_tasks_indirect_nv) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdDrawMeshTasksIndirectNV\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_draw_mesh_tasks_indirect_nv + } else { + ::std::mem::transmute(val) + } + }, + cmd_draw_mesh_tasks_indirect_count_nv: unsafe { + unsafe extern "system" fn cmd_draw_mesh_tasks_indirect_count_nv( + _command_buffer: CommandBuffer, + _buffer: Buffer, + _offset: DeviceSize, + _count_buffer: Buffer, + _count_buffer_offset: DeviceSize, + _max_draw_count: u32, + _stride: u32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_draw_mesh_tasks_indirect_count_nv) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdDrawMeshTasksIndirectCountNV\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_draw_mesh_tasks_indirect_count_nv + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_NV_mesh_shader'"] +impl PipelineStageFlags { + pub const TASK_SHADER_NV: Self = Self::TASK_SHADER_EXT; + pub const MESH_SHADER_NV: Self = Self::MESH_SHADER_EXT; +} +#[doc = "Generated from 'VK_NV_mesh_shader'"] +impl ShaderStageFlags { + pub const TASK_NV: Self = Self::TASK_EXT; + pub const MESH_NV: Self = Self::MESH_EXT; +} +#[doc = "Generated from 'VK_NV_mesh_shader'"] +impl StructureType { + pub const PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV: Self = Self(1_000_202_000); + pub const PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV: Self = Self(1_000_202_001); +} +impl NvFragmentShaderBarycentricFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_fragment_shader_barycentric\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct NvFragmentShaderBarycentricFn {} +unsafe impl Send for NvFragmentShaderBarycentricFn {} +unsafe impl Sync for NvFragmentShaderBarycentricFn {} +impl NvFragmentShaderBarycentricFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_NV_fragment_shader_barycentric'"] +impl StructureType { + pub const PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV: Self = + Self::PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR; +} +impl NvShaderImageFootprintFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_shader_image_footprint\0") + } + } + pub const SPEC_VERSION: u32 = 2u32; +} +#[derive(Clone)] +pub struct NvShaderImageFootprintFn {} +unsafe impl Send for NvShaderImageFootprintFn {} +unsafe impl Sync for NvShaderImageFootprintFn {} +impl NvShaderImageFootprintFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_NV_shader_image_footprint'"] +impl StructureType { + pub const PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV: Self = Self(1_000_204_000); +} +impl NvScissorExclusiveFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_scissor_exclusive\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetExclusiveScissorNV = unsafe extern "system" fn( + command_buffer: CommandBuffer, + first_exclusive_scissor: u32, + exclusive_scissor_count: u32, + p_exclusive_scissors: *const Rect2D, +); +#[derive(Clone)] +pub struct NvScissorExclusiveFn { + pub cmd_set_exclusive_scissor_nv: PFN_vkCmdSetExclusiveScissorNV, +} +unsafe impl Send for NvScissorExclusiveFn {} +unsafe impl Sync for NvScissorExclusiveFn {} +impl NvScissorExclusiveFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + cmd_set_exclusive_scissor_nv: unsafe { + unsafe extern "system" fn cmd_set_exclusive_scissor_nv( + _command_buffer: CommandBuffer, + _first_exclusive_scissor: u32, + _exclusive_scissor_count: u32, + _p_exclusive_scissors: *const Rect2D, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_exclusive_scissor_nv) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetExclusiveScissorNV\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_exclusive_scissor_nv + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_NV_scissor_exclusive'"] +impl DynamicState { + pub const EXCLUSIVE_SCISSOR_NV: Self = Self(1_000_205_001); +} +#[doc = "Generated from 'VK_NV_scissor_exclusive'"] +impl StructureType { + pub const PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV: Self = Self(1_000_205_000); + pub const PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV: Self = Self(1_000_205_002); +} +impl NvDeviceDiagnosticCheckpointsFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"VK_NV_device_diagnostic_checkpoints\0", + ) + } + } + pub const SPEC_VERSION: u32 = 2u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetCheckpointNV = + unsafe extern "system" fn(command_buffer: CommandBuffer, p_checkpoint_marker: *const c_void); +#[allow(non_camel_case_types)] +pub type PFN_vkGetQueueCheckpointDataNV = unsafe extern "system" fn( + queue: Queue, + p_checkpoint_data_count: *mut u32, + p_checkpoint_data: *mut CheckpointDataNV, +); +#[derive(Clone)] +pub struct NvDeviceDiagnosticCheckpointsFn { + pub cmd_set_checkpoint_nv: PFN_vkCmdSetCheckpointNV, + pub get_queue_checkpoint_data_nv: PFN_vkGetQueueCheckpointDataNV, +} +unsafe impl Send for NvDeviceDiagnosticCheckpointsFn {} +unsafe impl Sync for NvDeviceDiagnosticCheckpointsFn {} +impl NvDeviceDiagnosticCheckpointsFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + cmd_set_checkpoint_nv: unsafe { + unsafe extern "system" fn cmd_set_checkpoint_nv( + _command_buffer: CommandBuffer, + _p_checkpoint_marker: *const c_void, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_checkpoint_nv) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetCheckpointNV\0"); + let val = _f(cname); + if val.is_null() { + cmd_set_checkpoint_nv + } else { + ::std::mem::transmute(val) + } + }, + get_queue_checkpoint_data_nv: unsafe { + unsafe extern "system" fn get_queue_checkpoint_data_nv( + _queue: Queue, + _p_checkpoint_data_count: *mut u32, + _p_checkpoint_data: *mut CheckpointDataNV, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_queue_checkpoint_data_nv) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetQueueCheckpointDataNV\0", + ); + let val = _f(cname); + if val.is_null() { + get_queue_checkpoint_data_nv + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_NV_device_diagnostic_checkpoints'"] +impl StructureType { + pub const CHECKPOINT_DATA_NV: Self = Self(1_000_206_000); + pub const QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV: Self = Self(1_000_206_001); +} +impl KhrTimelineSemaphoreFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_timeline_semaphore\0") } + } + pub const SPEC_VERSION: u32 = 2u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkGetSemaphoreCounterValue = + unsafe extern "system" fn(device: Device, semaphore: Semaphore, p_value: *mut u64) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkWaitSemaphores = unsafe extern "system" fn( + device: Device, + p_wait_info: *const SemaphoreWaitInfo, + timeout: u64, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkSignalSemaphore = + unsafe extern "system" fn(device: Device, p_signal_info: *const SemaphoreSignalInfo) -> Result; +#[derive(Clone)] +pub struct KhrTimelineSemaphoreFn { + pub get_semaphore_counter_value_khr: PFN_vkGetSemaphoreCounterValue, + pub wait_semaphores_khr: PFN_vkWaitSemaphores, + pub signal_semaphore_khr: PFN_vkSignalSemaphore, +} +unsafe impl Send for KhrTimelineSemaphoreFn {} +unsafe impl Sync for KhrTimelineSemaphoreFn {} +impl KhrTimelineSemaphoreFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + get_semaphore_counter_value_khr: unsafe { + unsafe extern "system" fn get_semaphore_counter_value_khr( + _device: Device, + _semaphore: Semaphore, + _p_value: *mut u64, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_semaphore_counter_value_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetSemaphoreCounterValueKHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_semaphore_counter_value_khr + } else { + ::std::mem::transmute(val) + } + }, + wait_semaphores_khr: unsafe { + unsafe extern "system" fn wait_semaphores_khr( + _device: Device, + _p_wait_info: *const SemaphoreWaitInfo, + _timeout: u64, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(wait_semaphores_khr))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkWaitSemaphoresKHR\0"); + let val = _f(cname); + if val.is_null() { + wait_semaphores_khr + } else { + ::std::mem::transmute(val) + } + }, + signal_semaphore_khr: unsafe { + unsafe extern "system" fn signal_semaphore_khr( + _device: Device, + _p_signal_info: *const SemaphoreSignalInfo, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(signal_semaphore_khr))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkSignalSemaphoreKHR\0"); + let val = _f(cname); + if val.is_null() { + signal_semaphore_khr + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_KHR_timeline_semaphore'"] +impl SemaphoreType { + pub const BINARY_KHR: Self = Self::BINARY; + pub const TIMELINE_KHR: Self = Self::TIMELINE; +} +#[doc = "Generated from 'VK_KHR_timeline_semaphore'"] +impl SemaphoreWaitFlags { + pub const ANY_KHR: Self = Self::ANY; +} +#[doc = "Generated from 'VK_KHR_timeline_semaphore'"] +impl StructureType { + pub const PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES_KHR: Self = + Self::PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES; + pub const PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES_KHR: Self = + Self::PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES; + pub const SEMAPHORE_TYPE_CREATE_INFO_KHR: Self = Self::SEMAPHORE_TYPE_CREATE_INFO; + pub const TIMELINE_SEMAPHORE_SUBMIT_INFO_KHR: Self = Self::TIMELINE_SEMAPHORE_SUBMIT_INFO; + pub const SEMAPHORE_WAIT_INFO_KHR: Self = Self::SEMAPHORE_WAIT_INFO; + pub const SEMAPHORE_SIGNAL_INFO_KHR: Self = Self::SEMAPHORE_SIGNAL_INFO; +} +impl KhrExtension209Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_extension_209\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct KhrExtension209Fn {} +unsafe impl Send for KhrExtension209Fn {} +unsafe impl Sync for KhrExtension209Fn {} +impl KhrExtension209Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl IntelShaderIntegerFunctions2Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_INTEL_shader_integer_functions2\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct IntelShaderIntegerFunctions2Fn {} +unsafe impl Send for IntelShaderIntegerFunctions2Fn {} +unsafe impl Sync for IntelShaderIntegerFunctions2Fn {} +impl IntelShaderIntegerFunctions2Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_INTEL_shader_integer_functions2'"] +impl StructureType { + pub const PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL: Self = Self(1_000_209_000); +} +impl IntelPerformanceQueryFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_INTEL_performance_query\0") } + } + pub const SPEC_VERSION: u32 = 2u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkInitializePerformanceApiINTEL = unsafe extern "system" fn( + device: Device, + p_initialize_info: *const InitializePerformanceApiInfoINTEL, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkUninitializePerformanceApiINTEL = unsafe extern "system" fn(device: Device); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetPerformanceMarkerINTEL = unsafe extern "system" fn( + command_buffer: CommandBuffer, + p_marker_info: *const PerformanceMarkerInfoINTEL, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetPerformanceStreamMarkerINTEL = unsafe extern "system" fn( + command_buffer: CommandBuffer, + p_marker_info: *const PerformanceStreamMarkerInfoINTEL, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetPerformanceOverrideINTEL = unsafe extern "system" fn( + command_buffer: CommandBuffer, + p_override_info: *const PerformanceOverrideInfoINTEL, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkAcquirePerformanceConfigurationINTEL = unsafe extern "system" fn( + device: Device, + p_acquire_info: *const PerformanceConfigurationAcquireInfoINTEL, + p_configuration: *mut PerformanceConfigurationINTEL, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkReleasePerformanceConfigurationINTEL = unsafe extern "system" fn( + device: Device, + configuration: PerformanceConfigurationINTEL, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkQueueSetPerformanceConfigurationINTEL = + unsafe extern "system" fn(queue: Queue, configuration: PerformanceConfigurationINTEL) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetPerformanceParameterINTEL = unsafe extern "system" fn( + device: Device, + parameter: PerformanceParameterTypeINTEL, + p_value: *mut PerformanceValueINTEL, +) -> Result; +#[derive(Clone)] +pub struct IntelPerformanceQueryFn { + pub initialize_performance_api_intel: PFN_vkInitializePerformanceApiINTEL, + pub uninitialize_performance_api_intel: PFN_vkUninitializePerformanceApiINTEL, + pub cmd_set_performance_marker_intel: PFN_vkCmdSetPerformanceMarkerINTEL, + pub cmd_set_performance_stream_marker_intel: PFN_vkCmdSetPerformanceStreamMarkerINTEL, + pub cmd_set_performance_override_intel: PFN_vkCmdSetPerformanceOverrideINTEL, + pub acquire_performance_configuration_intel: PFN_vkAcquirePerformanceConfigurationINTEL, + pub release_performance_configuration_intel: PFN_vkReleasePerformanceConfigurationINTEL, + pub queue_set_performance_configuration_intel: PFN_vkQueueSetPerformanceConfigurationINTEL, + pub get_performance_parameter_intel: PFN_vkGetPerformanceParameterINTEL, +} +unsafe impl Send for IntelPerformanceQueryFn {} +unsafe impl Sync for IntelPerformanceQueryFn {} +impl IntelPerformanceQueryFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + initialize_performance_api_intel: unsafe { + unsafe extern "system" fn initialize_performance_api_intel( + _device: Device, + _p_initialize_info: *const InitializePerformanceApiInfoINTEL, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(initialize_performance_api_intel) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkInitializePerformanceApiINTEL\0", + ); + let val = _f(cname); + if val.is_null() { + initialize_performance_api_intel + } else { + ::std::mem::transmute(val) + } + }, + uninitialize_performance_api_intel: unsafe { + unsafe extern "system" fn uninitialize_performance_api_intel(_device: Device) { + panic!(concat!( + "Unable to load ", + stringify!(uninitialize_performance_api_intel) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkUninitializePerformanceApiINTEL\0", + ); + let val = _f(cname); + if val.is_null() { + uninitialize_performance_api_intel + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_performance_marker_intel: unsafe { + unsafe extern "system" fn cmd_set_performance_marker_intel( + _command_buffer: CommandBuffer, + _p_marker_info: *const PerformanceMarkerInfoINTEL, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_performance_marker_intel) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetPerformanceMarkerINTEL\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_performance_marker_intel + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_performance_stream_marker_intel: unsafe { + unsafe extern "system" fn cmd_set_performance_stream_marker_intel( + _command_buffer: CommandBuffer, + _p_marker_info: *const PerformanceStreamMarkerInfoINTEL, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_performance_stream_marker_intel) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetPerformanceStreamMarkerINTEL\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_performance_stream_marker_intel + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_performance_override_intel: unsafe { + unsafe extern "system" fn cmd_set_performance_override_intel( + _command_buffer: CommandBuffer, + _p_override_info: *const PerformanceOverrideInfoINTEL, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_performance_override_intel) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetPerformanceOverrideINTEL\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_performance_override_intel + } else { + ::std::mem::transmute(val) + } + }, + acquire_performance_configuration_intel: unsafe { + unsafe extern "system" fn acquire_performance_configuration_intel( + _device: Device, + _p_acquire_info: *const PerformanceConfigurationAcquireInfoINTEL, + _p_configuration: *mut PerformanceConfigurationINTEL, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(acquire_performance_configuration_intel) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkAcquirePerformanceConfigurationINTEL\0", + ); + let val = _f(cname); + if val.is_null() { + acquire_performance_configuration_intel + } else { + ::std::mem::transmute(val) + } + }, + release_performance_configuration_intel: unsafe { + unsafe extern "system" fn release_performance_configuration_intel( + _device: Device, + _configuration: PerformanceConfigurationINTEL, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(release_performance_configuration_intel) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkReleasePerformanceConfigurationINTEL\0", + ); + let val = _f(cname); + if val.is_null() { + release_performance_configuration_intel + } else { + ::std::mem::transmute(val) + } + }, + queue_set_performance_configuration_intel: unsafe { + unsafe extern "system" fn queue_set_performance_configuration_intel( + _queue: Queue, + _configuration: PerformanceConfigurationINTEL, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(queue_set_performance_configuration_intel) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkQueueSetPerformanceConfigurationINTEL\0", + ); + let val = _f(cname); + if val.is_null() { + queue_set_performance_configuration_intel + } else { + ::std::mem::transmute(val) + } + }, + get_performance_parameter_intel: unsafe { + unsafe extern "system" fn get_performance_parameter_intel( + _device: Device, + _parameter: PerformanceParameterTypeINTEL, + _p_value: *mut PerformanceValueINTEL, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_performance_parameter_intel) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPerformanceParameterINTEL\0", + ); + let val = _f(cname); + if val.is_null() { + get_performance_parameter_intel + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_INTEL_performance_query'"] +impl ObjectType { + pub const PERFORMANCE_CONFIGURATION_INTEL: Self = Self(1_000_210_000); +} +#[doc = "Generated from 'VK_INTEL_performance_query'"] +impl QueryType { + pub const PERFORMANCE_QUERY_INTEL: Self = Self(1_000_210_000); +} +#[doc = "Generated from 'VK_INTEL_performance_query'"] +impl StructureType { + pub const QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL: Self = Self(1_000_210_000); + pub const INITIALIZE_PERFORMANCE_API_INFO_INTEL: Self = Self(1_000_210_001); + pub const PERFORMANCE_MARKER_INFO_INTEL: Self = Self(1_000_210_002); + pub const PERFORMANCE_STREAM_MARKER_INFO_INTEL: Self = Self(1_000_210_003); + pub const PERFORMANCE_OVERRIDE_INFO_INTEL: Self = Self(1_000_210_004); + pub const PERFORMANCE_CONFIGURATION_ACQUIRE_INFO_INTEL: Self = Self(1_000_210_005); +} +impl KhrVulkanMemoryModelFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_vulkan_memory_model\0") } + } + pub const SPEC_VERSION: u32 = 3u32; +} +#[derive(Clone)] +pub struct KhrVulkanMemoryModelFn {} +unsafe impl Send for KhrVulkanMemoryModelFn {} +unsafe impl Sync for KhrVulkanMemoryModelFn {} +impl KhrVulkanMemoryModelFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_KHR_vulkan_memory_model'"] +impl StructureType { + pub const PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES_KHR: Self = + Self::PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES; +} +impl ExtPciBusInfoFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_pci_bus_info\0") } + } + pub const SPEC_VERSION: u32 = 2u32; +} +#[derive(Clone)] +pub struct ExtPciBusInfoFn {} +unsafe impl Send for ExtPciBusInfoFn {} +unsafe impl Sync for ExtPciBusInfoFn {} +impl ExtPciBusInfoFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_pci_bus_info'"] +impl StructureType { + pub const PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT: Self = Self(1_000_212_000); +} +impl AmdDisplayNativeHdrFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_display_native_hdr\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkSetLocalDimmingAMD = unsafe extern "system" fn( + device: Device, + swap_chain: SwapchainKHR, + local_dimming_enable: Bool32, +); +#[derive(Clone)] +pub struct AmdDisplayNativeHdrFn { + pub set_local_dimming_amd: PFN_vkSetLocalDimmingAMD, +} +unsafe impl Send for AmdDisplayNativeHdrFn {} +unsafe impl Sync for AmdDisplayNativeHdrFn {} +impl AmdDisplayNativeHdrFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + set_local_dimming_amd: unsafe { + unsafe extern "system" fn set_local_dimming_amd( + _device: Device, + _swap_chain: SwapchainKHR, + _local_dimming_enable: Bool32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(set_local_dimming_amd) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkSetLocalDimmingAMD\0"); + let val = _f(cname); + if val.is_null() { + set_local_dimming_amd + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_AMD_display_native_hdr'"] +impl ColorSpaceKHR { + pub const DISPLAY_NATIVE_AMD: Self = Self(1_000_213_000); +} +#[doc = "Generated from 'VK_AMD_display_native_hdr'"] +impl StructureType { + pub const DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD: Self = Self(1_000_213_000); + pub const SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD: Self = Self(1_000_213_001); +} +impl FuchsiaImagepipeSurfaceFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_FUCHSIA_imagepipe_surface\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkCreateImagePipeSurfaceFUCHSIA = unsafe extern "system" fn( + instance: Instance, + p_create_info: *const ImagePipeSurfaceCreateInfoFUCHSIA, + p_allocator: *const AllocationCallbacks, + p_surface: *mut SurfaceKHR, +) -> Result; +#[derive(Clone)] +pub struct FuchsiaImagepipeSurfaceFn { + pub create_image_pipe_surface_fuchsia: PFN_vkCreateImagePipeSurfaceFUCHSIA, +} +unsafe impl Send for FuchsiaImagepipeSurfaceFn {} +unsafe impl Sync for FuchsiaImagepipeSurfaceFn {} +impl FuchsiaImagepipeSurfaceFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + create_image_pipe_surface_fuchsia: unsafe { + unsafe extern "system" fn create_image_pipe_surface_fuchsia( + _instance: Instance, + _p_create_info: *const ImagePipeSurfaceCreateInfoFUCHSIA, + _p_allocator: *const AllocationCallbacks, + _p_surface: *mut SurfaceKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(create_image_pipe_surface_fuchsia) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCreateImagePipeSurfaceFUCHSIA\0", + ); + let val = _f(cname); + if val.is_null() { + create_image_pipe_surface_fuchsia + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_FUCHSIA_imagepipe_surface'"] +impl StructureType { + pub const IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA: Self = Self(1_000_214_000); +} +impl KhrShaderTerminateInvocationFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_shader_terminate_invocation\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct KhrShaderTerminateInvocationFn {} +unsafe impl Send for KhrShaderTerminateInvocationFn {} +unsafe impl Sync for KhrShaderTerminateInvocationFn {} +impl KhrShaderTerminateInvocationFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_KHR_shader_terminate_invocation'"] +impl StructureType { + pub const PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES_KHR: Self = + Self::PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES; +} +impl GoogleExtension217Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_GOOGLE_extension_217\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct GoogleExtension217Fn {} +unsafe impl Send for GoogleExtension217Fn {} +unsafe impl Sync for GoogleExtension217Fn {} +impl GoogleExtension217Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtMetalSurfaceFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_metal_surface\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkCreateMetalSurfaceEXT = unsafe extern "system" fn( + instance: Instance, + p_create_info: *const MetalSurfaceCreateInfoEXT, + p_allocator: *const AllocationCallbacks, + p_surface: *mut SurfaceKHR, +) -> Result; +#[derive(Clone)] +pub struct ExtMetalSurfaceFn { + pub create_metal_surface_ext: PFN_vkCreateMetalSurfaceEXT, +} +unsafe impl Send for ExtMetalSurfaceFn {} +unsafe impl Sync for ExtMetalSurfaceFn {} +impl ExtMetalSurfaceFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + create_metal_surface_ext: unsafe { + unsafe extern "system" fn create_metal_surface_ext( + _instance: Instance, + _p_create_info: *const MetalSurfaceCreateInfoEXT, + _p_allocator: *const AllocationCallbacks, + _p_surface: *mut SurfaceKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(create_metal_surface_ext) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateMetalSurfaceEXT\0"); + let val = _f(cname); + if val.is_null() { + create_metal_surface_ext + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_EXT_metal_surface'"] +impl StructureType { + pub const METAL_SURFACE_CREATE_INFO_EXT: Self = Self(1_000_217_000); +} +impl ExtFragmentDensityMapFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_fragment_density_map\0") } + } + pub const SPEC_VERSION: u32 = 2u32; +} +#[derive(Clone)] +pub struct ExtFragmentDensityMapFn {} +unsafe impl Send for ExtFragmentDensityMapFn {} +unsafe impl Sync for ExtFragmentDensityMapFn {} +impl ExtFragmentDensityMapFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_fragment_density_map'"] +impl AccessFlags { + pub const FRAGMENT_DENSITY_MAP_READ_EXT: Self = Self(0b1_0000_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_EXT_fragment_density_map'"] +impl FormatFeatureFlags { + pub const FRAGMENT_DENSITY_MAP_EXT: Self = Self(0b1_0000_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_EXT_fragment_density_map'"] +impl FormatFeatureFlags2 { + pub const FRAGMENT_DENSITY_MAP_EXT: Self = Self(0b1_0000_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_EXT_fragment_density_map'"] +impl ImageCreateFlags { + pub const SUBSAMPLED_EXT: Self = Self(0b100_0000_0000_0000); +} +#[doc = "Generated from 'VK_EXT_fragment_density_map'"] +impl ImageLayout { + pub const FRAGMENT_DENSITY_MAP_OPTIMAL_EXT: Self = Self(1_000_218_000); +} +#[doc = "Generated from 'VK_EXT_fragment_density_map'"] +impl ImageUsageFlags { + pub const FRAGMENT_DENSITY_MAP_EXT: Self = Self(0b10_0000_0000); +} +#[doc = "Generated from 'VK_EXT_fragment_density_map'"] +impl ImageViewCreateFlags { + pub const FRAGMENT_DENSITY_MAP_DYNAMIC_EXT: Self = Self(0b1); +} +#[doc = "Generated from 'VK_EXT_fragment_density_map'"] +impl PipelineStageFlags { + pub const FRAGMENT_DENSITY_PROCESS_EXT: Self = Self(0b1000_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_EXT_fragment_density_map'"] +impl SamplerCreateFlags { + pub const SUBSAMPLED_EXT: Self = Self(0b1); + pub const SUBSAMPLED_COARSE_RECONSTRUCTION_EXT: Self = Self(0b10); +} +#[doc = "Generated from 'VK_EXT_fragment_density_map'"] +impl StructureType { + pub const PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT: Self = Self(1_000_218_000); + pub const PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT: Self = Self(1_000_218_001); + pub const RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT: Self = Self(1_000_218_002); +} +impl ExtExtension220Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_220\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct ExtExtension220Fn {} +unsafe impl Send for ExtExtension220Fn {} +unsafe impl Sync for ExtExtension220Fn {} +impl ExtExtension220Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl KhrExtension221Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_extension_221\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct KhrExtension221Fn {} +unsafe impl Send for KhrExtension221Fn {} +unsafe impl Sync for KhrExtension221Fn {} +impl KhrExtension221Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_KHR_extension_221'"] +impl RenderPassCreateFlags { + pub const RESERVED_0_KHR: Self = Self(0b1); +} +impl ExtScalarBlockLayoutFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_scalar_block_layout\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct ExtScalarBlockLayoutFn {} +unsafe impl Send for ExtScalarBlockLayoutFn {} +unsafe impl Sync for ExtScalarBlockLayoutFn {} +impl ExtScalarBlockLayoutFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_scalar_block_layout'"] +impl StructureType { + pub const PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES_EXT: Self = + Self::PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES; +} +impl ExtExtension223Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_223\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct ExtExtension223Fn {} +unsafe impl Send for ExtExtension223Fn {} +unsafe impl Sync for ExtExtension223Fn {} +impl ExtExtension223Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl GoogleHlslFunctionality1Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_GOOGLE_hlsl_functionality1\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct GoogleHlslFunctionality1Fn {} +unsafe impl Send for GoogleHlslFunctionality1Fn {} +unsafe impl Sync for GoogleHlslFunctionality1Fn {} +impl GoogleHlslFunctionality1Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl GoogleDecorateStringFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_GOOGLE_decorate_string\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct GoogleDecorateStringFn {} +unsafe impl Send for GoogleDecorateStringFn {} +unsafe impl Sync for GoogleDecorateStringFn {} +impl GoogleDecorateStringFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtSubgroupSizeControlFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_subgroup_size_control\0") + } + } + pub const SPEC_VERSION: u32 = 2u32; +} +#[derive(Clone)] +pub struct ExtSubgroupSizeControlFn {} +unsafe impl Send for ExtSubgroupSizeControlFn {} +unsafe impl Sync for ExtSubgroupSizeControlFn {} +impl ExtSubgroupSizeControlFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_subgroup_size_control'"] +impl PipelineShaderStageCreateFlags { + pub const ALLOW_VARYING_SUBGROUP_SIZE_EXT: Self = Self::ALLOW_VARYING_SUBGROUP_SIZE; + pub const REQUIRE_FULL_SUBGROUPS_EXT: Self = Self::REQUIRE_FULL_SUBGROUPS; +} +#[doc = "Generated from 'VK_EXT_subgroup_size_control'"] +impl StructureType { + pub const PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT: Self = + Self::PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES; + pub const PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT: Self = + Self::PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO; + pub const PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT: Self = + Self::PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES; +} +impl KhrFragmentShadingRateFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_fragment_shading_rate\0") + } + } + pub const SPEC_VERSION: u32 = 2u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkGetPhysicalDeviceFragmentShadingRatesKHR = unsafe extern "system" fn( + physical_device: PhysicalDevice, + p_fragment_shading_rate_count: *mut u32, + p_fragment_shading_rates: *mut PhysicalDeviceFragmentShadingRateKHR, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetFragmentShadingRateKHR = unsafe extern "system" fn( + command_buffer: CommandBuffer, + p_fragment_size: *const Extent2D, + combiner_ops: *const [FragmentShadingRateCombinerOpKHR; 2], +); +#[derive(Clone)] +pub struct KhrFragmentShadingRateFn { + pub get_physical_device_fragment_shading_rates_khr: + PFN_vkGetPhysicalDeviceFragmentShadingRatesKHR, + pub cmd_set_fragment_shading_rate_khr: PFN_vkCmdSetFragmentShadingRateKHR, +} +unsafe impl Send for KhrFragmentShadingRateFn {} +unsafe impl Sync for KhrFragmentShadingRateFn {} +impl KhrFragmentShadingRateFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + get_physical_device_fragment_shading_rates_khr: unsafe { + unsafe extern "system" fn get_physical_device_fragment_shading_rates_khr( + _physical_device: PhysicalDevice, + _p_fragment_shading_rate_count: *mut u32, + _p_fragment_shading_rates: *mut PhysicalDeviceFragmentShadingRateKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_fragment_shading_rates_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPhysicalDeviceFragmentShadingRatesKHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_physical_device_fragment_shading_rates_khr + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_fragment_shading_rate_khr: unsafe { + unsafe extern "system" fn cmd_set_fragment_shading_rate_khr( + _command_buffer: CommandBuffer, + _p_fragment_size: *const Extent2D, + _combiner_ops: *const [FragmentShadingRateCombinerOpKHR; 2], + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_fragment_shading_rate_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetFragmentShadingRateKHR\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_fragment_shading_rate_khr + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_KHR_fragment_shading_rate'"] +impl AccessFlags { + pub const FRAGMENT_SHADING_RATE_ATTACHMENT_READ_KHR: Self = + Self(0b1000_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_KHR_fragment_shading_rate'"] +impl DynamicState { + pub const FRAGMENT_SHADING_RATE_KHR: Self = Self(1_000_226_000); +} +#[doc = "Generated from 'VK_KHR_fragment_shading_rate'"] +impl FormatFeatureFlags { + pub const FRAGMENT_SHADING_RATE_ATTACHMENT_KHR: Self = + Self(0b100_0000_0000_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_KHR_fragment_shading_rate'"] +impl FormatFeatureFlags2 { + pub const FRAGMENT_SHADING_RATE_ATTACHMENT_KHR: Self = + Self(0b100_0000_0000_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_KHR_fragment_shading_rate'"] +impl ImageLayout { + pub const FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR: Self = Self(1_000_164_003); +} +#[doc = "Generated from 'VK_KHR_fragment_shading_rate'"] +impl ImageUsageFlags { + pub const FRAGMENT_SHADING_RATE_ATTACHMENT_KHR: Self = Self(0b1_0000_0000); +} +#[doc = "Generated from 'VK_KHR_fragment_shading_rate'"] +impl PipelineStageFlags { + pub const FRAGMENT_SHADING_RATE_ATTACHMENT_KHR: Self = Self(0b100_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_KHR_fragment_shading_rate'"] +impl StructureType { + pub const FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR: Self = Self(1_000_226_000); + pub const PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR: Self = Self(1_000_226_001); + pub const PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR: Self = Self(1_000_226_002); + pub const PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR: Self = Self(1_000_226_003); + pub const PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR: Self = Self(1_000_226_004); +} +impl AmdShaderCoreProperties2Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_shader_core_properties2\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct AmdShaderCoreProperties2Fn {} +unsafe impl Send for AmdShaderCoreProperties2Fn {} +unsafe impl Sync for AmdShaderCoreProperties2Fn {} +impl AmdShaderCoreProperties2Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_AMD_shader_core_properties2'"] +impl StructureType { + pub const PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD: Self = Self(1_000_227_000); +} +impl AmdExtension229Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_229\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct AmdExtension229Fn {} +unsafe impl Send for AmdExtension229Fn {} +unsafe impl Sync for AmdExtension229Fn {} +impl AmdExtension229Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl AmdDeviceCoherentMemoryFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_device_coherent_memory\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct AmdDeviceCoherentMemoryFn {} +unsafe impl Send for AmdDeviceCoherentMemoryFn {} +unsafe impl Sync for AmdDeviceCoherentMemoryFn {} +impl AmdDeviceCoherentMemoryFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_AMD_device_coherent_memory'"] +impl MemoryPropertyFlags { + pub const DEVICE_COHERENT_AMD: Self = Self(0b100_0000); + pub const DEVICE_UNCACHED_AMD: Self = Self(0b1000_0000); +} +#[doc = "Generated from 'VK_AMD_device_coherent_memory'"] +impl StructureType { + pub const PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD: Self = Self(1_000_229_000); +} +impl AmdExtension231Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_231\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct AmdExtension231Fn {} +unsafe impl Send for AmdExtension231Fn {} +unsafe impl Sync for AmdExtension231Fn {} +impl AmdExtension231Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl AmdExtension232Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_232\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct AmdExtension232Fn {} +unsafe impl Send for AmdExtension232Fn {} +unsafe impl Sync for AmdExtension232Fn {} +impl AmdExtension232Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl AmdExtension233Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_233\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct AmdExtension233Fn {} +unsafe impl Send for AmdExtension233Fn {} +unsafe impl Sync for AmdExtension233Fn {} +impl AmdExtension233Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl AmdExtension234Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_234\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct AmdExtension234Fn {} +unsafe impl Send for AmdExtension234Fn {} +unsafe impl Sync for AmdExtension234Fn {} +impl AmdExtension234Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtShaderImageAtomicInt64Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_shader_image_atomic_int64\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct ExtShaderImageAtomicInt64Fn {} +unsafe impl Send for ExtShaderImageAtomicInt64Fn {} +unsafe impl Sync for ExtShaderImageAtomicInt64Fn {} +impl ExtShaderImageAtomicInt64Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_shader_image_atomic_int64'"] +impl StructureType { + pub const PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT: Self = Self(1_000_234_000); +} +impl AmdExtension236Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_236\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct AmdExtension236Fn {} +unsafe impl Send for AmdExtension236Fn {} +unsafe impl Sync for AmdExtension236Fn {} +impl AmdExtension236Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl KhrSpirv14Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_spirv_1_4\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct KhrSpirv14Fn {} +unsafe impl Send for KhrSpirv14Fn {} +unsafe impl Sync for KhrSpirv14Fn {} +impl KhrSpirv14Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtMemoryBudgetFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_memory_budget\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct ExtMemoryBudgetFn {} +unsafe impl Send for ExtMemoryBudgetFn {} +unsafe impl Sync for ExtMemoryBudgetFn {} +impl ExtMemoryBudgetFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_memory_budget'"] +impl StructureType { + pub const PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT: Self = Self(1_000_237_000); +} +impl ExtMemoryPriorityFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_memory_priority\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct ExtMemoryPriorityFn {} +unsafe impl Send for ExtMemoryPriorityFn {} +unsafe impl Sync for ExtMemoryPriorityFn {} +impl ExtMemoryPriorityFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_memory_priority'"] +impl StructureType { + pub const PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT: Self = Self(1_000_238_000); + pub const MEMORY_PRIORITY_ALLOCATE_INFO_EXT: Self = Self(1_000_238_001); +} +impl KhrSurfaceProtectedCapabilitiesFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"VK_KHR_surface_protected_capabilities\0", + ) + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct KhrSurfaceProtectedCapabilitiesFn {} +unsafe impl Send for KhrSurfaceProtectedCapabilitiesFn {} +unsafe impl Sync for KhrSurfaceProtectedCapabilitiesFn {} +impl KhrSurfaceProtectedCapabilitiesFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_KHR_surface_protected_capabilities'"] +impl StructureType { + pub const SURFACE_PROTECTED_CAPABILITIES_KHR: Self = Self(1_000_239_000); +} +impl NvDedicatedAllocationImageAliasingFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"VK_NV_dedicated_allocation_image_aliasing\0", + ) + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct NvDedicatedAllocationImageAliasingFn {} +unsafe impl Send for NvDedicatedAllocationImageAliasingFn {} +unsafe impl Sync for NvDedicatedAllocationImageAliasingFn {} +impl NvDedicatedAllocationImageAliasingFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_NV_dedicated_allocation_image_aliasing'"] +impl StructureType { + pub const PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV: Self = + Self(1_000_240_000); +} +impl KhrSeparateDepthStencilLayoutsFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"VK_KHR_separate_depth_stencil_layouts\0", + ) + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct KhrSeparateDepthStencilLayoutsFn {} +unsafe impl Send for KhrSeparateDepthStencilLayoutsFn {} +unsafe impl Sync for KhrSeparateDepthStencilLayoutsFn {} +impl KhrSeparateDepthStencilLayoutsFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_KHR_separate_depth_stencil_layouts'"] +impl ImageLayout { + pub const DEPTH_ATTACHMENT_OPTIMAL_KHR: Self = Self::DEPTH_ATTACHMENT_OPTIMAL; + pub const DEPTH_READ_ONLY_OPTIMAL_KHR: Self = Self::DEPTH_READ_ONLY_OPTIMAL; + pub const STENCIL_ATTACHMENT_OPTIMAL_KHR: Self = Self::STENCIL_ATTACHMENT_OPTIMAL; + pub const STENCIL_READ_ONLY_OPTIMAL_KHR: Self = Self::STENCIL_READ_ONLY_OPTIMAL; +} +#[doc = "Generated from 'VK_KHR_separate_depth_stencil_layouts'"] +impl StructureType { + pub const PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES_KHR: Self = + Self::PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES; + pub const ATTACHMENT_REFERENCE_STENCIL_LAYOUT_KHR: Self = + Self::ATTACHMENT_REFERENCE_STENCIL_LAYOUT; + pub const ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT_KHR: Self = + Self::ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT; +} +impl IntelExtension243Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_INTEL_extension_243\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct IntelExtension243Fn {} +unsafe impl Send for IntelExtension243Fn {} +unsafe impl Sync for IntelExtension243Fn {} +impl IntelExtension243Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_INTEL_extension_243'"] +impl AccessFlags2 { + pub const RESERVED_46_EXT: Self = + Self(0b100_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000); +} +impl MesaExtension244Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_MESA_extension_244\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct MesaExtension244Fn {} +unsafe impl Send for MesaExtension244Fn {} +unsafe impl Sync for MesaExtension244Fn {} +impl MesaExtension244Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtBufferDeviceAddressFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_buffer_device_address\0") + } + } + pub const SPEC_VERSION: u32 = 2u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkGetBufferDeviceAddress = unsafe extern "system" fn( + device: Device, + p_info: *const BufferDeviceAddressInfo, +) -> DeviceAddress; +#[derive(Clone)] +pub struct ExtBufferDeviceAddressFn { + pub get_buffer_device_address_ext: PFN_vkGetBufferDeviceAddress, +} +unsafe impl Send for ExtBufferDeviceAddressFn {} +unsafe impl Sync for ExtBufferDeviceAddressFn {} +impl ExtBufferDeviceAddressFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + get_buffer_device_address_ext: unsafe { + unsafe extern "system" fn get_buffer_device_address_ext( + _device: Device, + _p_info: *const BufferDeviceAddressInfo, + ) -> DeviceAddress { + panic!(concat!( + "Unable to load ", + stringify!(get_buffer_device_address_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetBufferDeviceAddressEXT\0", + ); + let val = _f(cname); + if val.is_null() { + get_buffer_device_address_ext + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_EXT_buffer_device_address'"] +impl BufferCreateFlags { + pub const DEVICE_ADDRESS_CAPTURE_REPLAY_EXT: Self = Self::DEVICE_ADDRESS_CAPTURE_REPLAY; +} +#[doc = "Generated from 'VK_EXT_buffer_device_address'"] +impl BufferUsageFlags { + pub const SHADER_DEVICE_ADDRESS_EXT: Self = Self::SHADER_DEVICE_ADDRESS; +} +#[doc = "Generated from 'VK_EXT_buffer_device_address'"] +impl Result { + pub const ERROR_INVALID_DEVICE_ADDRESS_EXT: Self = Self::ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS; +} +#[doc = "Generated from 'VK_EXT_buffer_device_address'"] +impl StructureType { + pub const PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT: Self = Self(1_000_244_000); + pub const PHYSICAL_DEVICE_BUFFER_ADDRESS_FEATURES_EXT: Self = + Self::PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT; + pub const BUFFER_DEVICE_ADDRESS_INFO_EXT: Self = Self::BUFFER_DEVICE_ADDRESS_INFO; + pub const BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT: Self = Self(1_000_244_002); +} +impl ExtToolingInfoFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_tooling_info\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkGetPhysicalDeviceToolProperties = unsafe extern "system" fn( + physical_device: PhysicalDevice, + p_tool_count: *mut u32, + p_tool_properties: *mut PhysicalDeviceToolProperties, +) -> Result; +#[derive(Clone)] +pub struct ExtToolingInfoFn { + pub get_physical_device_tool_properties_ext: PFN_vkGetPhysicalDeviceToolProperties, +} +unsafe impl Send for ExtToolingInfoFn {} +unsafe impl Sync for ExtToolingInfoFn {} +impl ExtToolingInfoFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + get_physical_device_tool_properties_ext: unsafe { + unsafe extern "system" fn get_physical_device_tool_properties_ext( + _physical_device: PhysicalDevice, + _p_tool_count: *mut u32, + _p_tool_properties: *mut PhysicalDeviceToolProperties, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_tool_properties_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPhysicalDeviceToolPropertiesEXT\0", + ); + let val = _f(cname); + if val.is_null() { + get_physical_device_tool_properties_ext + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_EXT_tooling_info'"] +impl StructureType { + pub const PHYSICAL_DEVICE_TOOL_PROPERTIES_EXT: Self = Self::PHYSICAL_DEVICE_TOOL_PROPERTIES; +} +#[doc = "Generated from 'VK_EXT_tooling_info'"] +impl ToolPurposeFlags { + pub const DEBUG_REPORTING_EXT: Self = Self(0b10_0000); + pub const DEBUG_MARKERS_EXT: Self = Self(0b100_0000); +} +impl ExtSeparateStencilUsageFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_separate_stencil_usage\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct ExtSeparateStencilUsageFn {} +unsafe impl Send for ExtSeparateStencilUsageFn {} +unsafe impl Sync for ExtSeparateStencilUsageFn {} +impl ExtSeparateStencilUsageFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_separate_stencil_usage'"] +impl StructureType { + pub const IMAGE_STENCIL_USAGE_CREATE_INFO_EXT: Self = Self::IMAGE_STENCIL_USAGE_CREATE_INFO; +} +impl ExtValidationFeaturesFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_validation_features\0") } + } + pub const SPEC_VERSION: u32 = 5u32; +} +#[derive(Clone)] +pub struct ExtValidationFeaturesFn {} +unsafe impl Send for ExtValidationFeaturesFn {} +unsafe impl Sync for ExtValidationFeaturesFn {} +impl ExtValidationFeaturesFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_validation_features'"] +impl StructureType { + pub const VALIDATION_FEATURES_EXT: Self = Self(1_000_247_000); +} +impl KhrPresentWaitFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_present_wait\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkWaitForPresentKHR = unsafe extern "system" fn( + device: Device, + swapchain: SwapchainKHR, + present_id: u64, + timeout: u64, +) -> Result; +#[derive(Clone)] +pub struct KhrPresentWaitFn { + pub wait_for_present_khr: PFN_vkWaitForPresentKHR, +} +unsafe impl Send for KhrPresentWaitFn {} +unsafe impl Sync for KhrPresentWaitFn {} +impl KhrPresentWaitFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + wait_for_present_khr: unsafe { + unsafe extern "system" fn wait_for_present_khr( + _device: Device, + _swapchain: SwapchainKHR, + _present_id: u64, + _timeout: u64, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(wait_for_present_khr))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkWaitForPresentKHR\0"); + let val = _f(cname); + if val.is_null() { + wait_for_present_khr + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_KHR_present_wait'"] +impl StructureType { + pub const PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR: Self = Self(1_000_248_000); +} +impl NvCooperativeMatrixFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_cooperative_matrix\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV = unsafe extern "system" fn( + physical_device: PhysicalDevice, + p_property_count: *mut u32, + p_properties: *mut CooperativeMatrixPropertiesNV, +) + -> Result; +#[derive(Clone)] +pub struct NvCooperativeMatrixFn { + pub get_physical_device_cooperative_matrix_properties_nv: + PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV, +} +unsafe impl Send for NvCooperativeMatrixFn {} +unsafe impl Sync for NvCooperativeMatrixFn {} +impl NvCooperativeMatrixFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + get_physical_device_cooperative_matrix_properties_nv: unsafe { + unsafe extern "system" fn get_physical_device_cooperative_matrix_properties_nv( + _physical_device: PhysicalDevice, + _p_property_count: *mut u32, + _p_properties: *mut CooperativeMatrixPropertiesNV, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_cooperative_matrix_properties_nv) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPhysicalDeviceCooperativeMatrixPropertiesNV\0", + ); + let val = _f(cname); + if val.is_null() { + get_physical_device_cooperative_matrix_properties_nv + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_NV_cooperative_matrix'"] +impl StructureType { + pub const PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV: Self = Self(1_000_249_000); + pub const COOPERATIVE_MATRIX_PROPERTIES_NV: Self = Self(1_000_249_001); + pub const PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV: Self = Self(1_000_249_002); +} +impl NvCoverageReductionModeFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_coverage_reduction_mode\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV = + unsafe extern "system" fn( + physical_device: PhysicalDevice, + p_combination_count: *mut u32, + p_combinations: *mut FramebufferMixedSamplesCombinationNV, + ) -> Result; +#[derive(Clone)] +pub struct NvCoverageReductionModeFn { + pub get_physical_device_supported_framebuffer_mixed_samples_combinations_nv: + PFN_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV, +} +unsafe impl Send for NvCoverageReductionModeFn {} +unsafe impl Sync for NvCoverageReductionModeFn {} +impl NvCoverageReductionModeFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + get_physical_device_supported_framebuffer_mixed_samples_combinations_nv: unsafe { + unsafe extern "system" fn get_physical_device_supported_framebuffer_mixed_samples_combinations_nv( + _physical_device: PhysicalDevice, + _p_combination_count: *mut u32, + _p_combinations: *mut FramebufferMixedSamplesCombinationNV, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!( + get_physical_device_supported_framebuffer_mixed_samples_combinations_nv + ) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV\0", + ); + let val = _f(cname); + if val.is_null() { + get_physical_device_supported_framebuffer_mixed_samples_combinations_nv + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_NV_coverage_reduction_mode'"] +impl StructureType { + pub const PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV: Self = Self(1_000_250_000); + pub const PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV: Self = Self(1_000_250_001); + pub const FRAMEBUFFER_MIXED_SAMPLES_COMBINATION_NV: Self = Self(1_000_250_002); +} +impl ExtFragmentShaderInterlockFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_fragment_shader_interlock\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct ExtFragmentShaderInterlockFn {} +unsafe impl Send for ExtFragmentShaderInterlockFn {} +unsafe impl Sync for ExtFragmentShaderInterlockFn {} +impl ExtFragmentShaderInterlockFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_fragment_shader_interlock'"] +impl StructureType { + pub const PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT: Self = Self(1_000_251_000); +} +impl ExtYcbcrImageArraysFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_ycbcr_image_arrays\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct ExtYcbcrImageArraysFn {} +unsafe impl Send for ExtYcbcrImageArraysFn {} +unsafe impl Sync for ExtYcbcrImageArraysFn {} +impl ExtYcbcrImageArraysFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_ycbcr_image_arrays'"] +impl StructureType { + pub const PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT: Self = Self(1_000_252_000); +} +impl KhrUniformBufferStandardLayoutFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"VK_KHR_uniform_buffer_standard_layout\0", + ) + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct KhrUniformBufferStandardLayoutFn {} +unsafe impl Send for KhrUniformBufferStandardLayoutFn {} +unsafe impl Sync for KhrUniformBufferStandardLayoutFn {} +impl KhrUniformBufferStandardLayoutFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_KHR_uniform_buffer_standard_layout'"] +impl StructureType { + pub const PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES_KHR: Self = + Self::PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES; +} +impl ExtProvokingVertexFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_provoking_vertex\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct ExtProvokingVertexFn {} +unsafe impl Send for ExtProvokingVertexFn {} +unsafe impl Sync for ExtProvokingVertexFn {} +impl ExtProvokingVertexFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_provoking_vertex'"] +impl StructureType { + pub const PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT: Self = Self(1_000_254_000); + pub const PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT: Self = + Self(1_000_254_001); + pub const PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT: Self = Self(1_000_254_002); +} +impl ExtFullScreenExclusiveFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_full_screen_exclusive\0") + } + } + pub const SPEC_VERSION: u32 = 4u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkGetPhysicalDeviceSurfacePresentModes2EXT = unsafe extern "system" fn( + physical_device: PhysicalDevice, + p_surface_info: *const PhysicalDeviceSurfaceInfo2KHR, + p_present_mode_count: *mut u32, + p_present_modes: *mut PresentModeKHR, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkAcquireFullScreenExclusiveModeEXT = + unsafe extern "system" fn(device: Device, swapchain: SwapchainKHR) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkReleaseFullScreenExclusiveModeEXT = + unsafe extern "system" fn(device: Device, swapchain: SwapchainKHR) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetDeviceGroupSurfacePresentModes2EXT = unsafe extern "system" fn( + device: Device, + p_surface_info: *const PhysicalDeviceSurfaceInfo2KHR, + p_modes: *mut DeviceGroupPresentModeFlagsKHR, +) -> Result; +#[derive(Clone)] +pub struct ExtFullScreenExclusiveFn { + pub get_physical_device_surface_present_modes2_ext: + PFN_vkGetPhysicalDeviceSurfacePresentModes2EXT, + pub acquire_full_screen_exclusive_mode_ext: PFN_vkAcquireFullScreenExclusiveModeEXT, + pub release_full_screen_exclusive_mode_ext: PFN_vkReleaseFullScreenExclusiveModeEXT, + pub get_device_group_surface_present_modes2_ext: PFN_vkGetDeviceGroupSurfacePresentModes2EXT, +} +unsafe impl Send for ExtFullScreenExclusiveFn {} +unsafe impl Sync for ExtFullScreenExclusiveFn {} +impl ExtFullScreenExclusiveFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + get_physical_device_surface_present_modes2_ext: unsafe { + unsafe extern "system" fn get_physical_device_surface_present_modes2_ext( + _physical_device: PhysicalDevice, + _p_surface_info: *const PhysicalDeviceSurfaceInfo2KHR, + _p_present_mode_count: *mut u32, + _p_present_modes: *mut PresentModeKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_surface_present_modes2_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPhysicalDeviceSurfacePresentModes2EXT\0", + ); + let val = _f(cname); + if val.is_null() { + get_physical_device_surface_present_modes2_ext + } else { + ::std::mem::transmute(val) + } + }, + acquire_full_screen_exclusive_mode_ext: unsafe { + unsafe extern "system" fn acquire_full_screen_exclusive_mode_ext( + _device: Device, + _swapchain: SwapchainKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(acquire_full_screen_exclusive_mode_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkAcquireFullScreenExclusiveModeEXT\0", + ); + let val = _f(cname); + if val.is_null() { + acquire_full_screen_exclusive_mode_ext + } else { + ::std::mem::transmute(val) + } + }, + release_full_screen_exclusive_mode_ext: unsafe { + unsafe extern "system" fn release_full_screen_exclusive_mode_ext( + _device: Device, + _swapchain: SwapchainKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(release_full_screen_exclusive_mode_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkReleaseFullScreenExclusiveModeEXT\0", + ); + let val = _f(cname); + if val.is_null() { + release_full_screen_exclusive_mode_ext + } else { + ::std::mem::transmute(val) + } + }, + get_device_group_surface_present_modes2_ext: unsafe { + unsafe extern "system" fn get_device_group_surface_present_modes2_ext( + _device: Device, + _p_surface_info: *const PhysicalDeviceSurfaceInfo2KHR, + _p_modes: *mut DeviceGroupPresentModeFlagsKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_device_group_surface_present_modes2_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetDeviceGroupSurfacePresentModes2EXT\0", + ); + let val = _f(cname); + if val.is_null() { + get_device_group_surface_present_modes2_ext + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_EXT_full_screen_exclusive'"] +impl Result { + pub const ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT: Self = Self(-1_000_255_000); +} +#[doc = "Generated from 'VK_EXT_full_screen_exclusive'"] +impl StructureType { + pub const SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT: Self = Self(1_000_255_000); + pub const SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT: Self = Self(1_000_255_002); + pub const SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT: Self = Self(1_000_255_001); +} +impl ExtHeadlessSurfaceFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_headless_surface\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkCreateHeadlessSurfaceEXT = unsafe extern "system" fn( + instance: Instance, + p_create_info: *const HeadlessSurfaceCreateInfoEXT, + p_allocator: *const AllocationCallbacks, + p_surface: *mut SurfaceKHR, +) -> Result; +#[derive(Clone)] +pub struct ExtHeadlessSurfaceFn { + pub create_headless_surface_ext: PFN_vkCreateHeadlessSurfaceEXT, +} +unsafe impl Send for ExtHeadlessSurfaceFn {} +unsafe impl Sync for ExtHeadlessSurfaceFn {} +impl ExtHeadlessSurfaceFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + create_headless_surface_ext: unsafe { + unsafe extern "system" fn create_headless_surface_ext( + _instance: Instance, + _p_create_info: *const HeadlessSurfaceCreateInfoEXT, + _p_allocator: *const AllocationCallbacks, + _p_surface: *mut SurfaceKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(create_headless_surface_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCreateHeadlessSurfaceEXT\0", + ); + let val = _f(cname); + if val.is_null() { + create_headless_surface_ext + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_EXT_headless_surface'"] +impl StructureType { + pub const HEADLESS_SURFACE_CREATE_INFO_EXT: Self = Self(1_000_256_000); +} +impl KhrBufferDeviceAddressFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_buffer_device_address\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkGetBufferOpaqueCaptureAddress = + unsafe extern "system" fn(device: Device, p_info: *const BufferDeviceAddressInfo) -> u64; +#[allow(non_camel_case_types)] +pub type PFN_vkGetDeviceMemoryOpaqueCaptureAddress = unsafe extern "system" fn( + device: Device, + p_info: *const DeviceMemoryOpaqueCaptureAddressInfo, +) -> u64; +#[derive(Clone)] +pub struct KhrBufferDeviceAddressFn { + pub get_buffer_device_address_khr: crate::vk::PFN_vkGetBufferDeviceAddress, + pub get_buffer_opaque_capture_address_khr: PFN_vkGetBufferOpaqueCaptureAddress, + pub get_device_memory_opaque_capture_address_khr: PFN_vkGetDeviceMemoryOpaqueCaptureAddress, +} +unsafe impl Send for KhrBufferDeviceAddressFn {} +unsafe impl Sync for KhrBufferDeviceAddressFn {} +impl KhrBufferDeviceAddressFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + get_buffer_device_address_khr: unsafe { + unsafe extern "system" fn get_buffer_device_address_khr( + _device: Device, + _p_info: *const BufferDeviceAddressInfo, + ) -> DeviceAddress { + panic!(concat!( + "Unable to load ", + stringify!(get_buffer_device_address_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetBufferDeviceAddressKHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_buffer_device_address_khr + } else { + ::std::mem::transmute(val) + } + }, + get_buffer_opaque_capture_address_khr: unsafe { + unsafe extern "system" fn get_buffer_opaque_capture_address_khr( + _device: Device, + _p_info: *const BufferDeviceAddressInfo, + ) -> u64 { + panic!(concat!( + "Unable to load ", + stringify!(get_buffer_opaque_capture_address_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetBufferOpaqueCaptureAddressKHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_buffer_opaque_capture_address_khr + } else { + ::std::mem::transmute(val) + } + }, + get_device_memory_opaque_capture_address_khr: unsafe { + unsafe extern "system" fn get_device_memory_opaque_capture_address_khr( + _device: Device, + _p_info: *const DeviceMemoryOpaqueCaptureAddressInfo, + ) -> u64 { + panic!(concat!( + "Unable to load ", + stringify!(get_device_memory_opaque_capture_address_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetDeviceMemoryOpaqueCaptureAddressKHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_device_memory_opaque_capture_address_khr + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_KHR_buffer_device_address'"] +impl BufferCreateFlags { + pub const DEVICE_ADDRESS_CAPTURE_REPLAY_KHR: Self = Self::DEVICE_ADDRESS_CAPTURE_REPLAY; +} +#[doc = "Generated from 'VK_KHR_buffer_device_address'"] +impl BufferUsageFlags { + pub const SHADER_DEVICE_ADDRESS_KHR: Self = Self::SHADER_DEVICE_ADDRESS; +} +#[doc = "Generated from 'VK_KHR_buffer_device_address'"] +impl MemoryAllocateFlags { + pub const DEVICE_ADDRESS_KHR: Self = Self::DEVICE_ADDRESS; + pub const DEVICE_ADDRESS_CAPTURE_REPLAY_KHR: Self = Self::DEVICE_ADDRESS_CAPTURE_REPLAY; +} +#[doc = "Generated from 'VK_KHR_buffer_device_address'"] +impl Result { + pub const ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS_KHR: Self = + Self::ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS; +} +#[doc = "Generated from 'VK_KHR_buffer_device_address'"] +impl StructureType { + pub const PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_KHR: Self = + Self::PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES; + pub const BUFFER_DEVICE_ADDRESS_INFO_KHR: Self = Self::BUFFER_DEVICE_ADDRESS_INFO; + pub const BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO_KHR: Self = + Self::BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO; + pub const MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO_KHR: Self = + Self::MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO; + pub const DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO_KHR: Self = + Self::DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO; +} +impl ExtExtension259Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_259\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct ExtExtension259Fn {} +unsafe impl Send for ExtExtension259Fn {} +unsafe impl Sync for ExtExtension259Fn {} +impl ExtExtension259Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_extension_259'"] +impl FormatFeatureFlags2 { + pub const RESERVED_44_EXT: Self = + Self(0b1_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000); + pub const RESERVED_45_EXT: Self = + Self(0b10_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_EXT_extension_259'"] +impl ImageCreateFlags { + pub const RESERVED_19_EXT: Self = Self(0b1000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_EXT_extension_259'"] +impl QueueFlags { + pub const RESERVED_9_EXT: Self = Self(0b10_0000_0000); +} +impl ExtLineRasterizationFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_line_rasterization\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetLineStippleEXT = unsafe extern "system" fn( + command_buffer: CommandBuffer, + line_stipple_factor: u32, + line_stipple_pattern: u16, +); +#[derive(Clone)] +pub struct ExtLineRasterizationFn { + pub cmd_set_line_stipple_ext: PFN_vkCmdSetLineStippleEXT, +} +unsafe impl Send for ExtLineRasterizationFn {} +unsafe impl Sync for ExtLineRasterizationFn {} +impl ExtLineRasterizationFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + cmd_set_line_stipple_ext: unsafe { + unsafe extern "system" fn cmd_set_line_stipple_ext( + _command_buffer: CommandBuffer, + _line_stipple_factor: u32, + _line_stipple_pattern: u16, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_line_stipple_ext) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetLineStippleEXT\0"); + let val = _f(cname); + if val.is_null() { + cmd_set_line_stipple_ext + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_EXT_line_rasterization'"] +impl DynamicState { + pub const LINE_STIPPLE_EXT: Self = Self(1_000_259_000); +} +#[doc = "Generated from 'VK_EXT_line_rasterization'"] +impl StructureType { + pub const PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT: Self = Self(1_000_259_000); + pub const PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT: Self = Self(1_000_259_001); + pub const PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT: Self = Self(1_000_259_002); +} +impl ExtShaderAtomicFloatFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_shader_atomic_float\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct ExtShaderAtomicFloatFn {} +unsafe impl Send for ExtShaderAtomicFloatFn {} +unsafe impl Sync for ExtShaderAtomicFloatFn {} +impl ExtShaderAtomicFloatFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_shader_atomic_float'"] +impl StructureType { + pub const PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT: Self = Self(1_000_260_000); +} +impl ExtHostQueryResetFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_host_query_reset\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkResetQueryPool = unsafe extern "system" fn( + device: Device, + query_pool: QueryPool, + first_query: u32, + query_count: u32, +); +#[derive(Clone)] +pub struct ExtHostQueryResetFn { + pub reset_query_pool_ext: PFN_vkResetQueryPool, +} +unsafe impl Send for ExtHostQueryResetFn {} +unsafe impl Sync for ExtHostQueryResetFn {} +impl ExtHostQueryResetFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + reset_query_pool_ext: unsafe { + unsafe extern "system" fn reset_query_pool_ext( + _device: Device, + _query_pool: QueryPool, + _first_query: u32, + _query_count: u32, + ) { + panic!(concat!("Unable to load ", stringify!(reset_query_pool_ext))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkResetQueryPoolEXT\0"); + let val = _f(cname); + if val.is_null() { + reset_query_pool_ext + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_EXT_host_query_reset'"] +impl StructureType { + pub const PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES_EXT: Self = + Self::PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES; +} +impl GgpExtension263Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_GGP_extension_263\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct GgpExtension263Fn {} +unsafe impl Send for GgpExtension263Fn {} +unsafe impl Sync for GgpExtension263Fn {} +impl GgpExtension263Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl BrcmExtension264Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_BRCM_extension_264\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct BrcmExtension264Fn {} +unsafe impl Send for BrcmExtension264Fn {} +unsafe impl Sync for BrcmExtension264Fn {} +impl BrcmExtension264Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl BrcmExtension265Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_BRCM_extension_265\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct BrcmExtension265Fn {} +unsafe impl Send for BrcmExtension265Fn {} +unsafe impl Sync for BrcmExtension265Fn {} +impl BrcmExtension265Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtIndexTypeUint8Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_index_type_uint8\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct ExtIndexTypeUint8Fn {} +unsafe impl Send for ExtIndexTypeUint8Fn {} +unsafe impl Sync for ExtIndexTypeUint8Fn {} +impl ExtIndexTypeUint8Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_index_type_uint8'"] +impl IndexType { + pub const UINT8_EXT: Self = Self(1_000_265_000); +} +#[doc = "Generated from 'VK_EXT_index_type_uint8'"] +impl StructureType { + pub const PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT: Self = Self(1_000_265_000); +} +impl ExtExtension267Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_267\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct ExtExtension267Fn {} +unsafe impl Send for ExtExtension267Fn {} +unsafe impl Sync for ExtExtension267Fn {} +impl ExtExtension267Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtExtendedDynamicStateFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extended_dynamic_state\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetCullMode = + unsafe extern "system" fn(command_buffer: CommandBuffer, cull_mode: CullModeFlags); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetFrontFace = + unsafe extern "system" fn(command_buffer: CommandBuffer, front_face: FrontFace); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetPrimitiveTopology = + unsafe extern "system" fn(command_buffer: CommandBuffer, primitive_topology: PrimitiveTopology); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetViewportWithCount = unsafe extern "system" fn( + command_buffer: CommandBuffer, + viewport_count: u32, + p_viewports: *const Viewport, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetScissorWithCount = unsafe extern "system" fn( + command_buffer: CommandBuffer, + scissor_count: u32, + p_scissors: *const Rect2D, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdBindVertexBuffers2 = unsafe extern "system" fn( + command_buffer: CommandBuffer, + first_binding: u32, + binding_count: u32, + p_buffers: *const Buffer, + p_offsets: *const DeviceSize, + p_sizes: *const DeviceSize, + p_strides: *const DeviceSize, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetDepthTestEnable = + unsafe extern "system" fn(command_buffer: CommandBuffer, depth_test_enable: Bool32); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetDepthWriteEnable = + unsafe extern "system" fn(command_buffer: CommandBuffer, depth_write_enable: Bool32); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetDepthCompareOp = + unsafe extern "system" fn(command_buffer: CommandBuffer, depth_compare_op: CompareOp); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetDepthBoundsTestEnable = + unsafe extern "system" fn(command_buffer: CommandBuffer, depth_bounds_test_enable: Bool32); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetStencilTestEnable = + unsafe extern "system" fn(command_buffer: CommandBuffer, stencil_test_enable: Bool32); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetStencilOp = unsafe extern "system" fn( + command_buffer: CommandBuffer, + face_mask: StencilFaceFlags, + fail_op: StencilOp, + pass_op: StencilOp, + depth_fail_op: StencilOp, + compare_op: CompareOp, +); +#[derive(Clone)] +pub struct ExtExtendedDynamicStateFn { + pub cmd_set_cull_mode_ext: PFN_vkCmdSetCullMode, + pub cmd_set_front_face_ext: PFN_vkCmdSetFrontFace, + pub cmd_set_primitive_topology_ext: PFN_vkCmdSetPrimitiveTopology, + pub cmd_set_viewport_with_count_ext: PFN_vkCmdSetViewportWithCount, + pub cmd_set_scissor_with_count_ext: PFN_vkCmdSetScissorWithCount, + pub cmd_bind_vertex_buffers2_ext: PFN_vkCmdBindVertexBuffers2, + pub cmd_set_depth_test_enable_ext: PFN_vkCmdSetDepthTestEnable, + pub cmd_set_depth_write_enable_ext: PFN_vkCmdSetDepthWriteEnable, + pub cmd_set_depth_compare_op_ext: PFN_vkCmdSetDepthCompareOp, + pub cmd_set_depth_bounds_test_enable_ext: PFN_vkCmdSetDepthBoundsTestEnable, + pub cmd_set_stencil_test_enable_ext: PFN_vkCmdSetStencilTestEnable, + pub cmd_set_stencil_op_ext: PFN_vkCmdSetStencilOp, +} +unsafe impl Send for ExtExtendedDynamicStateFn {} +unsafe impl Sync for ExtExtendedDynamicStateFn {} +impl ExtExtendedDynamicStateFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + cmd_set_cull_mode_ext: unsafe { + unsafe extern "system" fn cmd_set_cull_mode_ext( + _command_buffer: CommandBuffer, + _cull_mode: CullModeFlags, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_cull_mode_ext) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetCullModeEXT\0"); + let val = _f(cname); + if val.is_null() { + cmd_set_cull_mode_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_front_face_ext: unsafe { + unsafe extern "system" fn cmd_set_front_face_ext( + _command_buffer: CommandBuffer, + _front_face: FrontFace, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_front_face_ext) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetFrontFaceEXT\0"); + let val = _f(cname); + if val.is_null() { + cmd_set_front_face_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_primitive_topology_ext: unsafe { + unsafe extern "system" fn cmd_set_primitive_topology_ext( + _command_buffer: CommandBuffer, + _primitive_topology: PrimitiveTopology, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_primitive_topology_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetPrimitiveTopologyEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_primitive_topology_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_viewport_with_count_ext: unsafe { + unsafe extern "system" fn cmd_set_viewport_with_count_ext( + _command_buffer: CommandBuffer, + _viewport_count: u32, + _p_viewports: *const Viewport, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_viewport_with_count_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetViewportWithCountEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_viewport_with_count_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_scissor_with_count_ext: unsafe { + unsafe extern "system" fn cmd_set_scissor_with_count_ext( + _command_buffer: CommandBuffer, + _scissor_count: u32, + _p_scissors: *const Rect2D, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_scissor_with_count_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetScissorWithCountEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_scissor_with_count_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_bind_vertex_buffers2_ext: unsafe { + unsafe extern "system" fn cmd_bind_vertex_buffers2_ext( + _command_buffer: CommandBuffer, + _first_binding: u32, + _binding_count: u32, + _p_buffers: *const Buffer, + _p_offsets: *const DeviceSize, + _p_sizes: *const DeviceSize, + _p_strides: *const DeviceSize, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_bind_vertex_buffers2_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdBindVertexBuffers2EXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_bind_vertex_buffers2_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_depth_test_enable_ext: unsafe { + unsafe extern "system" fn cmd_set_depth_test_enable_ext( + _command_buffer: CommandBuffer, + _depth_test_enable: Bool32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_depth_test_enable_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetDepthTestEnableEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_depth_test_enable_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_depth_write_enable_ext: unsafe { + unsafe extern "system" fn cmd_set_depth_write_enable_ext( + _command_buffer: CommandBuffer, + _depth_write_enable: Bool32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_depth_write_enable_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetDepthWriteEnableEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_depth_write_enable_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_depth_compare_op_ext: unsafe { + unsafe extern "system" fn cmd_set_depth_compare_op_ext( + _command_buffer: CommandBuffer, + _depth_compare_op: CompareOp, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_depth_compare_op_ext) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetDepthCompareOpEXT\0"); + let val = _f(cname); + if val.is_null() { + cmd_set_depth_compare_op_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_depth_bounds_test_enable_ext: unsafe { + unsafe extern "system" fn cmd_set_depth_bounds_test_enable_ext( + _command_buffer: CommandBuffer, + _depth_bounds_test_enable: Bool32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_depth_bounds_test_enable_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetDepthBoundsTestEnableEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_depth_bounds_test_enable_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_stencil_test_enable_ext: unsafe { + unsafe extern "system" fn cmd_set_stencil_test_enable_ext( + _command_buffer: CommandBuffer, + _stencil_test_enable: Bool32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_stencil_test_enable_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetStencilTestEnableEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_stencil_test_enable_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_stencil_op_ext: unsafe { + unsafe extern "system" fn cmd_set_stencil_op_ext( + _command_buffer: CommandBuffer, + _face_mask: StencilFaceFlags, + _fail_op: StencilOp, + _pass_op: StencilOp, + _depth_fail_op: StencilOp, + _compare_op: CompareOp, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_stencil_op_ext) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetStencilOpEXT\0"); + let val = _f(cname); + if val.is_null() { + cmd_set_stencil_op_ext + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_EXT_extended_dynamic_state'"] +impl DynamicState { + pub const CULL_MODE_EXT: Self = Self::CULL_MODE; + pub const FRONT_FACE_EXT: Self = Self::FRONT_FACE; + pub const PRIMITIVE_TOPOLOGY_EXT: Self = Self::PRIMITIVE_TOPOLOGY; + pub const VIEWPORT_WITH_COUNT_EXT: Self = Self::VIEWPORT_WITH_COUNT; + pub const SCISSOR_WITH_COUNT_EXT: Self = Self::SCISSOR_WITH_COUNT; + pub const VERTEX_INPUT_BINDING_STRIDE_EXT: Self = Self::VERTEX_INPUT_BINDING_STRIDE; + pub const DEPTH_TEST_ENABLE_EXT: Self = Self::DEPTH_TEST_ENABLE; + pub const DEPTH_WRITE_ENABLE_EXT: Self = Self::DEPTH_WRITE_ENABLE; + pub const DEPTH_COMPARE_OP_EXT: Self = Self::DEPTH_COMPARE_OP; + pub const DEPTH_BOUNDS_TEST_ENABLE_EXT: Self = Self::DEPTH_BOUNDS_TEST_ENABLE; + pub const STENCIL_TEST_ENABLE_EXT: Self = Self::STENCIL_TEST_ENABLE; + pub const STENCIL_OP_EXT: Self = Self::STENCIL_OP; +} +#[doc = "Generated from 'VK_EXT_extended_dynamic_state'"] +impl StructureType { + #[doc = "Not promoted to 1.3"] + pub const PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT: Self = Self(1_000_267_000); +} +impl KhrDeferredHostOperationsFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_deferred_host_operations\0") + } + } + pub const SPEC_VERSION: u32 = 4u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkCreateDeferredOperationKHR = unsafe extern "system" fn( + device: Device, + p_allocator: *const AllocationCallbacks, + p_deferred_operation: *mut DeferredOperationKHR, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkDestroyDeferredOperationKHR = unsafe extern "system" fn( + device: Device, + operation: DeferredOperationKHR, + p_allocator: *const AllocationCallbacks, +); +#[allow(non_camel_case_types)] +pub type PFN_vkGetDeferredOperationMaxConcurrencyKHR = + unsafe extern "system" fn(device: Device, operation: DeferredOperationKHR) -> u32; +#[allow(non_camel_case_types)] +pub type PFN_vkGetDeferredOperationResultKHR = + unsafe extern "system" fn(device: Device, operation: DeferredOperationKHR) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkDeferredOperationJoinKHR = + unsafe extern "system" fn(device: Device, operation: DeferredOperationKHR) -> Result; +#[derive(Clone)] +pub struct KhrDeferredHostOperationsFn { + pub create_deferred_operation_khr: PFN_vkCreateDeferredOperationKHR, + pub destroy_deferred_operation_khr: PFN_vkDestroyDeferredOperationKHR, + pub get_deferred_operation_max_concurrency_khr: PFN_vkGetDeferredOperationMaxConcurrencyKHR, + pub get_deferred_operation_result_khr: PFN_vkGetDeferredOperationResultKHR, + pub deferred_operation_join_khr: PFN_vkDeferredOperationJoinKHR, +} +unsafe impl Send for KhrDeferredHostOperationsFn {} +unsafe impl Sync for KhrDeferredHostOperationsFn {} +impl KhrDeferredHostOperationsFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + create_deferred_operation_khr: unsafe { + unsafe extern "system" fn create_deferred_operation_khr( + _device: Device, + _p_allocator: *const AllocationCallbacks, + _p_deferred_operation: *mut DeferredOperationKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(create_deferred_operation_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCreateDeferredOperationKHR\0", + ); + let val = _f(cname); + if val.is_null() { + create_deferred_operation_khr + } else { + ::std::mem::transmute(val) + } + }, + destroy_deferred_operation_khr: unsafe { + unsafe extern "system" fn destroy_deferred_operation_khr( + _device: Device, + _operation: DeferredOperationKHR, + _p_allocator: *const AllocationCallbacks, + ) { + panic!(concat!( + "Unable to load ", + stringify!(destroy_deferred_operation_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkDestroyDeferredOperationKHR\0", + ); + let val = _f(cname); + if val.is_null() { + destroy_deferred_operation_khr + } else { + ::std::mem::transmute(val) + } + }, + get_deferred_operation_max_concurrency_khr: unsafe { + unsafe extern "system" fn get_deferred_operation_max_concurrency_khr( + _device: Device, + _operation: DeferredOperationKHR, + ) -> u32 { + panic!(concat!( + "Unable to load ", + stringify!(get_deferred_operation_max_concurrency_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetDeferredOperationMaxConcurrencyKHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_deferred_operation_max_concurrency_khr + } else { + ::std::mem::transmute(val) + } + }, + get_deferred_operation_result_khr: unsafe { + unsafe extern "system" fn get_deferred_operation_result_khr( + _device: Device, + _operation: DeferredOperationKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_deferred_operation_result_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetDeferredOperationResultKHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_deferred_operation_result_khr + } else { + ::std::mem::transmute(val) + } + }, + deferred_operation_join_khr: unsafe { + unsafe extern "system" fn deferred_operation_join_khr( + _device: Device, + _operation: DeferredOperationKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(deferred_operation_join_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkDeferredOperationJoinKHR\0", + ); + let val = _f(cname); + if val.is_null() { + deferred_operation_join_khr + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_KHR_deferred_host_operations'"] +impl ObjectType { + pub const DEFERRED_OPERATION_KHR: Self = Self(1_000_268_000); +} +#[doc = "Generated from 'VK_KHR_deferred_host_operations'"] +impl Result { + pub const THREAD_IDLE_KHR: Self = Self(1_000_268_000); + pub const THREAD_DONE_KHR: Self = Self(1_000_268_001); + pub const OPERATION_DEFERRED_KHR: Self = Self(1_000_268_002); + pub const OPERATION_NOT_DEFERRED_KHR: Self = Self(1_000_268_003); +} +impl KhrPipelineExecutablePropertiesFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"VK_KHR_pipeline_executable_properties\0", + ) + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkGetPipelineExecutablePropertiesKHR = unsafe extern "system" fn( + device: Device, + p_pipeline_info: *const PipelineInfoKHR, + p_executable_count: *mut u32, + p_properties: *mut PipelineExecutablePropertiesKHR, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetPipelineExecutableStatisticsKHR = unsafe extern "system" fn( + device: Device, + p_executable_info: *const PipelineExecutableInfoKHR, + p_statistic_count: *mut u32, + p_statistics: *mut PipelineExecutableStatisticKHR, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetPipelineExecutableInternalRepresentationsKHR = + unsafe extern "system" fn( + device: Device, + p_executable_info: *const PipelineExecutableInfoKHR, + p_internal_representation_count: *mut u32, + p_internal_representations: *mut PipelineExecutableInternalRepresentationKHR, + ) -> Result; +#[derive(Clone)] +pub struct KhrPipelineExecutablePropertiesFn { + pub get_pipeline_executable_properties_khr: PFN_vkGetPipelineExecutablePropertiesKHR, + pub get_pipeline_executable_statistics_khr: PFN_vkGetPipelineExecutableStatisticsKHR, + pub get_pipeline_executable_internal_representations_khr: + PFN_vkGetPipelineExecutableInternalRepresentationsKHR, +} +unsafe impl Send for KhrPipelineExecutablePropertiesFn {} +unsafe impl Sync for KhrPipelineExecutablePropertiesFn {} +impl KhrPipelineExecutablePropertiesFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + get_pipeline_executable_properties_khr: unsafe { + unsafe extern "system" fn get_pipeline_executable_properties_khr( + _device: Device, + _p_pipeline_info: *const PipelineInfoKHR, + _p_executable_count: *mut u32, + _p_properties: *mut PipelineExecutablePropertiesKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_pipeline_executable_properties_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPipelineExecutablePropertiesKHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_pipeline_executable_properties_khr + } else { + ::std::mem::transmute(val) + } + }, + get_pipeline_executable_statistics_khr: unsafe { + unsafe extern "system" fn get_pipeline_executable_statistics_khr( + _device: Device, + _p_executable_info: *const PipelineExecutableInfoKHR, + _p_statistic_count: *mut u32, + _p_statistics: *mut PipelineExecutableStatisticKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_pipeline_executable_statistics_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPipelineExecutableStatisticsKHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_pipeline_executable_statistics_khr + } else { + ::std::mem::transmute(val) + } + }, + get_pipeline_executable_internal_representations_khr: unsafe { + unsafe extern "system" fn get_pipeline_executable_internal_representations_khr( + _device: Device, + _p_executable_info: *const PipelineExecutableInfoKHR, + _p_internal_representation_count: *mut u32, + _p_internal_representations: *mut PipelineExecutableInternalRepresentationKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_pipeline_executable_internal_representations_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPipelineExecutableInternalRepresentationsKHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_pipeline_executable_internal_representations_khr + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_KHR_pipeline_executable_properties'"] +impl PipelineCreateFlags { + pub const CAPTURE_STATISTICS_KHR: Self = Self(0b100_0000); + pub const CAPTURE_INTERNAL_REPRESENTATIONS_KHR: Self = Self(0b1000_0000); +} +#[doc = "Generated from 'VK_KHR_pipeline_executable_properties'"] +impl StructureType { + pub const PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR: Self = + Self(1_000_269_000); + pub const PIPELINE_INFO_KHR: Self = Self(1_000_269_001); + pub const PIPELINE_EXECUTABLE_PROPERTIES_KHR: Self = Self(1_000_269_002); + pub const PIPELINE_EXECUTABLE_INFO_KHR: Self = Self(1_000_269_003); + pub const PIPELINE_EXECUTABLE_STATISTIC_KHR: Self = Self(1_000_269_004); + pub const PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR: Self = Self(1_000_269_005); +} +impl IntelExtension271Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_INTEL_extension_271\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct IntelExtension271Fn {} +unsafe impl Send for IntelExtension271Fn {} +unsafe impl Sync for IntelExtension271Fn {} +impl IntelExtension271Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_INTEL_extension_271'"] +impl ImageUsageFlags { + pub const RESERVED_22_EXT: Self = Self(0b100_0000_0000_0000_0000_0000); +} +impl IntelExtension272Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_INTEL_extension_272\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct IntelExtension272Fn {} +unsafe impl Send for IntelExtension272Fn {} +unsafe impl Sync for IntelExtension272Fn {} +impl IntelExtension272Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl IntelExtension273Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_INTEL_extension_273\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct IntelExtension273Fn {} +unsafe impl Send for IntelExtension273Fn {} +unsafe impl Sync for IntelExtension273Fn {} +impl IntelExtension273Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtShaderAtomicFloat2Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_shader_atomic_float2\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct ExtShaderAtomicFloat2Fn {} +unsafe impl Send for ExtShaderAtomicFloat2Fn {} +unsafe impl Sync for ExtShaderAtomicFloat2Fn {} +impl ExtShaderAtomicFloat2Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_shader_atomic_float2'"] +impl StructureType { + pub const PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT: Self = Self(1_000_273_000); +} +impl ExtSurfaceMaintenance1Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_surface_maintenance1\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct ExtSurfaceMaintenance1Fn {} +unsafe impl Send for ExtSurfaceMaintenance1Fn {} +unsafe impl Sync for ExtSurfaceMaintenance1Fn {} +impl ExtSurfaceMaintenance1Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_surface_maintenance1'"] +impl StructureType { + pub const SURFACE_PRESENT_MODE_EXT: Self = Self(1_000_274_000); + pub const SURFACE_PRESENT_SCALING_CAPABILITIES_EXT: Self = Self(1_000_274_001); + pub const SURFACE_PRESENT_MODE_COMPATIBILITY_EXT: Self = Self(1_000_274_002); +} +impl ExtSwapchainMaintenance1Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_swapchain_maintenance1\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkReleaseSwapchainImagesEXT = unsafe extern "system" fn( + device: Device, + p_release_info: *const ReleaseSwapchainImagesInfoEXT, +) -> Result; +#[derive(Clone)] +pub struct ExtSwapchainMaintenance1Fn { + pub release_swapchain_images_ext: PFN_vkReleaseSwapchainImagesEXT, +} +unsafe impl Send for ExtSwapchainMaintenance1Fn {} +unsafe impl Sync for ExtSwapchainMaintenance1Fn {} +impl ExtSwapchainMaintenance1Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + release_swapchain_images_ext: unsafe { + unsafe extern "system" fn release_swapchain_images_ext( + _device: Device, + _p_release_info: *const ReleaseSwapchainImagesInfoEXT, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(release_swapchain_images_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkReleaseSwapchainImagesEXT\0", + ); + let val = _f(cname); + if val.is_null() { + release_swapchain_images_ext + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_EXT_swapchain_maintenance1'"] +impl StructureType { + pub const PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT: Self = Self(1_000_275_000); + pub const SWAPCHAIN_PRESENT_FENCE_INFO_EXT: Self = Self(1_000_275_001); + pub const SWAPCHAIN_PRESENT_MODES_CREATE_INFO_EXT: Self = Self(1_000_275_002); + pub const SWAPCHAIN_PRESENT_MODE_INFO_EXT: Self = Self(1_000_275_003); + pub const SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_EXT: Self = Self(1_000_275_004); + pub const RELEASE_SWAPCHAIN_IMAGES_INFO_EXT: Self = Self(1_000_275_005); +} +#[doc = "Generated from 'VK_EXT_swapchain_maintenance1'"] +impl SwapchainCreateFlagsKHR { + pub const DEFERRED_MEMORY_ALLOCATION_EXT: Self = Self(0b1000); +} +impl ExtShaderDemoteToHelperInvocationFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"VK_EXT_shader_demote_to_helper_invocation\0", + ) + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct ExtShaderDemoteToHelperInvocationFn {} +unsafe impl Send for ExtShaderDemoteToHelperInvocationFn {} +unsafe impl Sync for ExtShaderDemoteToHelperInvocationFn {} +impl ExtShaderDemoteToHelperInvocationFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_shader_demote_to_helper_invocation'"] +impl StructureType { + pub const PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT: Self = + Self::PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES; +} +impl NvDeviceGeneratedCommandsFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_device_generated_commands\0") + } + } + pub const SPEC_VERSION: u32 = 3u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkGetGeneratedCommandsMemoryRequirementsNV = unsafe extern "system" fn( + device: Device, + p_info: *const GeneratedCommandsMemoryRequirementsInfoNV, + p_memory_requirements: *mut MemoryRequirements2, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdPreprocessGeneratedCommandsNV = unsafe extern "system" fn( + command_buffer: CommandBuffer, + p_generated_commands_info: *const GeneratedCommandsInfoNV, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdExecuteGeneratedCommandsNV = unsafe extern "system" fn( + command_buffer: CommandBuffer, + is_preprocessed: Bool32, + p_generated_commands_info: *const GeneratedCommandsInfoNV, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdBindPipelineShaderGroupNV = unsafe extern "system" fn( + command_buffer: CommandBuffer, + pipeline_bind_point: PipelineBindPoint, + pipeline: Pipeline, + group_index: u32, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCreateIndirectCommandsLayoutNV = unsafe extern "system" fn( + device: Device, + p_create_info: *const IndirectCommandsLayoutCreateInfoNV, + p_allocator: *const AllocationCallbacks, + p_indirect_commands_layout: *mut IndirectCommandsLayoutNV, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkDestroyIndirectCommandsLayoutNV = unsafe extern "system" fn( + device: Device, + indirect_commands_layout: IndirectCommandsLayoutNV, + p_allocator: *const AllocationCallbacks, +); +#[derive(Clone)] +pub struct NvDeviceGeneratedCommandsFn { + pub get_generated_commands_memory_requirements_nv: + PFN_vkGetGeneratedCommandsMemoryRequirementsNV, + pub cmd_preprocess_generated_commands_nv: PFN_vkCmdPreprocessGeneratedCommandsNV, + pub cmd_execute_generated_commands_nv: PFN_vkCmdExecuteGeneratedCommandsNV, + pub cmd_bind_pipeline_shader_group_nv: PFN_vkCmdBindPipelineShaderGroupNV, + pub create_indirect_commands_layout_nv: PFN_vkCreateIndirectCommandsLayoutNV, + pub destroy_indirect_commands_layout_nv: PFN_vkDestroyIndirectCommandsLayoutNV, +} +unsafe impl Send for NvDeviceGeneratedCommandsFn {} +unsafe impl Sync for NvDeviceGeneratedCommandsFn {} +impl NvDeviceGeneratedCommandsFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + get_generated_commands_memory_requirements_nv: unsafe { + unsafe extern "system" fn get_generated_commands_memory_requirements_nv( + _device: Device, + _p_info: *const GeneratedCommandsMemoryRequirementsInfoNV, + _p_memory_requirements: *mut MemoryRequirements2, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_generated_commands_memory_requirements_nv) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetGeneratedCommandsMemoryRequirementsNV\0", + ); + let val = _f(cname); + if val.is_null() { + get_generated_commands_memory_requirements_nv + } else { + ::std::mem::transmute(val) + } + }, + cmd_preprocess_generated_commands_nv: unsafe { + unsafe extern "system" fn cmd_preprocess_generated_commands_nv( + _command_buffer: CommandBuffer, + _p_generated_commands_info: *const GeneratedCommandsInfoNV, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_preprocess_generated_commands_nv) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdPreprocessGeneratedCommandsNV\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_preprocess_generated_commands_nv + } else { + ::std::mem::transmute(val) + } + }, + cmd_execute_generated_commands_nv: unsafe { + unsafe extern "system" fn cmd_execute_generated_commands_nv( + _command_buffer: CommandBuffer, + _is_preprocessed: Bool32, + _p_generated_commands_info: *const GeneratedCommandsInfoNV, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_execute_generated_commands_nv) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdExecuteGeneratedCommandsNV\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_execute_generated_commands_nv + } else { + ::std::mem::transmute(val) + } + }, + cmd_bind_pipeline_shader_group_nv: unsafe { + unsafe extern "system" fn cmd_bind_pipeline_shader_group_nv( + _command_buffer: CommandBuffer, + _pipeline_bind_point: PipelineBindPoint, + _pipeline: Pipeline, + _group_index: u32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_bind_pipeline_shader_group_nv) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdBindPipelineShaderGroupNV\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_bind_pipeline_shader_group_nv + } else { + ::std::mem::transmute(val) + } + }, + create_indirect_commands_layout_nv: unsafe { + unsafe extern "system" fn create_indirect_commands_layout_nv( + _device: Device, + _p_create_info: *const IndirectCommandsLayoutCreateInfoNV, + _p_allocator: *const AllocationCallbacks, + _p_indirect_commands_layout: *mut IndirectCommandsLayoutNV, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(create_indirect_commands_layout_nv) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCreateIndirectCommandsLayoutNV\0", + ); + let val = _f(cname); + if val.is_null() { + create_indirect_commands_layout_nv + } else { + ::std::mem::transmute(val) + } + }, + destroy_indirect_commands_layout_nv: unsafe { + unsafe extern "system" fn destroy_indirect_commands_layout_nv( + _device: Device, + _indirect_commands_layout: IndirectCommandsLayoutNV, + _p_allocator: *const AllocationCallbacks, + ) { + panic!(concat!( + "Unable to load ", + stringify!(destroy_indirect_commands_layout_nv) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkDestroyIndirectCommandsLayoutNV\0", + ); + let val = _f(cname); + if val.is_null() { + destroy_indirect_commands_layout_nv + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_NV_device_generated_commands'"] +impl AccessFlags { + pub const COMMAND_PREPROCESS_READ_NV: Self = Self(0b10_0000_0000_0000_0000); + pub const COMMAND_PREPROCESS_WRITE_NV: Self = Self(0b100_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_NV_device_generated_commands'"] +impl ObjectType { + pub const INDIRECT_COMMANDS_LAYOUT_NV: Self = Self(1_000_277_000); +} +#[doc = "Generated from 'VK_NV_device_generated_commands'"] +impl PipelineCreateFlags { + pub const INDIRECT_BINDABLE_NV: Self = Self(0b100_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_NV_device_generated_commands'"] +impl PipelineStageFlags { + pub const COMMAND_PREPROCESS_NV: Self = Self(0b10_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_NV_device_generated_commands'"] +impl StructureType { + pub const PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV: Self = Self(1_000_277_000); + pub const GRAPHICS_SHADER_GROUP_CREATE_INFO_NV: Self = Self(1_000_277_001); + pub const GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV: Self = Self(1_000_277_002); + pub const INDIRECT_COMMANDS_LAYOUT_TOKEN_NV: Self = Self(1_000_277_003); + pub const INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NV: Self = Self(1_000_277_004); + pub const GENERATED_COMMANDS_INFO_NV: Self = Self(1_000_277_005); + pub const GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_NV: Self = Self(1_000_277_006); + pub const PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV: Self = Self(1_000_277_007); +} +impl NvInheritedViewportScissorFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_inherited_viewport_scissor\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct NvInheritedViewportScissorFn {} +unsafe impl Send for NvInheritedViewportScissorFn {} +unsafe impl Sync for NvInheritedViewportScissorFn {} +impl NvInheritedViewportScissorFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_NV_inherited_viewport_scissor'"] +impl StructureType { + pub const PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV: Self = Self(1_000_278_000); + pub const COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV: Self = Self(1_000_278_001); +} +impl KhrExtension280Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_extension_280\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct KhrExtension280Fn {} +unsafe impl Send for KhrExtension280Fn {} +unsafe impl Sync for KhrExtension280Fn {} +impl KhrExtension280Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl KhrShaderIntegerDotProductFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_shader_integer_dot_product\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct KhrShaderIntegerDotProductFn {} +unsafe impl Send for KhrShaderIntegerDotProductFn {} +unsafe impl Sync for KhrShaderIntegerDotProductFn {} +impl KhrShaderIntegerDotProductFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_KHR_shader_integer_dot_product'"] +impl StructureType { + pub const PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES_KHR: Self = + Self::PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES; + pub const PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES_KHR: Self = + Self::PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES; +} +impl ExtTexelBufferAlignmentFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_texel_buffer_alignment\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct ExtTexelBufferAlignmentFn {} +unsafe impl Send for ExtTexelBufferAlignmentFn {} +unsafe impl Sync for ExtTexelBufferAlignmentFn {} +impl ExtTexelBufferAlignmentFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_texel_buffer_alignment'"] +impl StructureType { + #[doc = "Not promoted to 1.3"] + pub const PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT: Self = Self(1_000_281_000); + pub const PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT: Self = + Self::PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES; +} +impl QcomRenderPassTransformFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_QCOM_render_pass_transform\0") + } + } + pub const SPEC_VERSION: u32 = 3u32; +} +#[derive(Clone)] +pub struct QcomRenderPassTransformFn {} +unsafe impl Send for QcomRenderPassTransformFn {} +unsafe impl Sync for QcomRenderPassTransformFn {} +impl QcomRenderPassTransformFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_QCOM_render_pass_transform'"] +impl RenderPassCreateFlags { + pub const TRANSFORM_QCOM: Self = Self(0b10); +} +#[doc = "Generated from 'VK_QCOM_render_pass_transform'"] +impl StructureType { + pub const COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM: Self = + Self(1_000_282_000); + pub const RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM: Self = Self(1_000_282_001); +} +impl ExtExtension284Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_284\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct ExtExtension284Fn {} +unsafe impl Send for ExtExtension284Fn {} +unsafe impl Sync for ExtExtension284Fn {} +impl ExtExtension284Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtDeviceMemoryReportFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_device_memory_report\0") } + } + pub const SPEC_VERSION: u32 = 2u32; +} +#[derive(Clone)] +pub struct ExtDeviceMemoryReportFn {} +unsafe impl Send for ExtDeviceMemoryReportFn {} +unsafe impl Sync for ExtDeviceMemoryReportFn {} +impl ExtDeviceMemoryReportFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_device_memory_report'"] +impl StructureType { + pub const PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT: Self = Self(1_000_284_000); + pub const DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT: Self = Self(1_000_284_001); + pub const DEVICE_MEMORY_REPORT_CALLBACK_DATA_EXT: Self = Self(1_000_284_002); +} +impl ExtAcquireDrmDisplayFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_acquire_drm_display\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkAcquireDrmDisplayEXT = unsafe extern "system" fn( + physical_device: PhysicalDevice, + drm_fd: i32, + display: DisplayKHR, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetDrmDisplayEXT = unsafe extern "system" fn( + physical_device: PhysicalDevice, + drm_fd: i32, + connector_id: u32, + display: *mut DisplayKHR, +) -> Result; +#[derive(Clone)] +pub struct ExtAcquireDrmDisplayFn { + pub acquire_drm_display_ext: PFN_vkAcquireDrmDisplayEXT, + pub get_drm_display_ext: PFN_vkGetDrmDisplayEXT, +} +unsafe impl Send for ExtAcquireDrmDisplayFn {} +unsafe impl Sync for ExtAcquireDrmDisplayFn {} +impl ExtAcquireDrmDisplayFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + acquire_drm_display_ext: unsafe { + unsafe extern "system" fn acquire_drm_display_ext( + _physical_device: PhysicalDevice, + _drm_fd: i32, + _display: DisplayKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(acquire_drm_display_ext) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkAcquireDrmDisplayEXT\0"); + let val = _f(cname); + if val.is_null() { + acquire_drm_display_ext + } else { + ::std::mem::transmute(val) + } + }, + get_drm_display_ext: unsafe { + unsafe extern "system" fn get_drm_display_ext( + _physical_device: PhysicalDevice, + _drm_fd: i32, + _connector_id: u32, + _display: *mut DisplayKHR, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(get_drm_display_ext))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetDrmDisplayEXT\0"); + let val = _f(cname); + if val.is_null() { + get_drm_display_ext + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +impl ExtRobustness2Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_robustness2\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct ExtRobustness2Fn {} +unsafe impl Send for ExtRobustness2Fn {} +unsafe impl Sync for ExtRobustness2Fn {} +impl ExtRobustness2Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_robustness2'"] +impl StructureType { + pub const PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT: Self = Self(1_000_286_000); + pub const PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT: Self = Self(1_000_286_001); +} +impl ExtCustomBorderColorFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_custom_border_color\0") } + } + pub const SPEC_VERSION: u32 = 12u32; +} +#[derive(Clone)] +pub struct ExtCustomBorderColorFn {} +unsafe impl Send for ExtCustomBorderColorFn {} +unsafe impl Sync for ExtCustomBorderColorFn {} +impl ExtCustomBorderColorFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_custom_border_color'"] +impl BorderColor { + pub const FLOAT_CUSTOM_EXT: Self = Self(1_000_287_003); + pub const INT_CUSTOM_EXT: Self = Self(1_000_287_004); +} +#[doc = "Generated from 'VK_EXT_custom_border_color'"] +impl StructureType { + pub const SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT: Self = Self(1_000_287_000); + pub const PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT: Self = Self(1_000_287_001); + pub const PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT: Self = Self(1_000_287_002); +} +impl ExtExtension289Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_289\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct ExtExtension289Fn {} +unsafe impl Send for ExtExtension289Fn {} +unsafe impl Sync for ExtExtension289Fn {} +impl ExtExtension289Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_extension_289'"] +impl Format { + pub const ASTC_3X3X3_UNORM_BLOCK_EXT: Self = Self(1_000_288_000); + pub const ASTC_3X3X3_SRGB_BLOCK_EXT: Self = Self(1_000_288_001); + pub const ASTC_3X3X3_SFLOAT_BLOCK_EXT: Self = Self(1_000_288_002); + pub const ASTC_4X3X3_UNORM_BLOCK_EXT: Self = Self(1_000_288_003); + pub const ASTC_4X3X3_SRGB_BLOCK_EXT: Self = Self(1_000_288_004); + pub const ASTC_4X3X3_SFLOAT_BLOCK_EXT: Self = Self(1_000_288_005); + pub const ASTC_4X4X3_UNORM_BLOCK_EXT: Self = Self(1_000_288_006); + pub const ASTC_4X4X3_SRGB_BLOCK_EXT: Self = Self(1_000_288_007); + pub const ASTC_4X4X3_SFLOAT_BLOCK_EXT: Self = Self(1_000_288_008); + pub const ASTC_4X4X4_UNORM_BLOCK_EXT: Self = Self(1_000_288_009); + pub const ASTC_4X4X4_SRGB_BLOCK_EXT: Self = Self(1_000_288_010); + pub const ASTC_4X4X4_SFLOAT_BLOCK_EXT: Self = Self(1_000_288_011); + pub const ASTC_5X4X4_UNORM_BLOCK_EXT: Self = Self(1_000_288_012); + pub const ASTC_5X4X4_SRGB_BLOCK_EXT: Self = Self(1_000_288_013); + pub const ASTC_5X4X4_SFLOAT_BLOCK_EXT: Self = Self(1_000_288_014); + pub const ASTC_5X5X4_UNORM_BLOCK_EXT: Self = Self(1_000_288_015); + pub const ASTC_5X5X4_SRGB_BLOCK_EXT: Self = Self(1_000_288_016); + pub const ASTC_5X5X4_SFLOAT_BLOCK_EXT: Self = Self(1_000_288_017); + pub const ASTC_5X5X5_UNORM_BLOCK_EXT: Self = Self(1_000_288_018); + pub const ASTC_5X5X5_SRGB_BLOCK_EXT: Self = Self(1_000_288_019); + pub const ASTC_5X5X5_SFLOAT_BLOCK_EXT: Self = Self(1_000_288_020); + pub const ASTC_6X5X5_UNORM_BLOCK_EXT: Self = Self(1_000_288_021); + pub const ASTC_6X5X5_SRGB_BLOCK_EXT: Self = Self(1_000_288_022); + pub const ASTC_6X5X5_SFLOAT_BLOCK_EXT: Self = Self(1_000_288_023); + pub const ASTC_6X6X5_UNORM_BLOCK_EXT: Self = Self(1_000_288_024); + pub const ASTC_6X6X5_SRGB_BLOCK_EXT: Self = Self(1_000_288_025); + pub const ASTC_6X6X5_SFLOAT_BLOCK_EXT: Self = Self(1_000_288_026); + pub const ASTC_6X6X6_UNORM_BLOCK_EXT: Self = Self(1_000_288_027); + pub const ASTC_6X6X6_SRGB_BLOCK_EXT: Self = Self(1_000_288_028); + pub const ASTC_6X6X6_SFLOAT_BLOCK_EXT: Self = Self(1_000_288_029); +} +impl GoogleUserTypeFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_GOOGLE_user_type\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct GoogleUserTypeFn {} +unsafe impl Send for GoogleUserTypeFn {} +unsafe impl Sync for GoogleUserTypeFn {} +impl GoogleUserTypeFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl KhrPipelineLibraryFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_pipeline_library\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct KhrPipelineLibraryFn {} +unsafe impl Send for KhrPipelineLibraryFn {} +unsafe impl Sync for KhrPipelineLibraryFn {} +impl KhrPipelineLibraryFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_KHR_pipeline_library'"] +impl PipelineCreateFlags { + pub const LIBRARY_KHR: Self = Self(0b1000_0000_0000); +} +#[doc = "Generated from 'VK_KHR_pipeline_library'"] +impl StructureType { + pub const PIPELINE_LIBRARY_CREATE_INFO_KHR: Self = Self(1_000_290_000); +} +impl NvExtension292Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_292\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct NvExtension292Fn {} +unsafe impl Send for NvExtension292Fn {} +unsafe impl Sync for NvExtension292Fn {} +impl NvExtension292Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl NvPresentBarrierFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_present_barrier\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct NvPresentBarrierFn {} +unsafe impl Send for NvPresentBarrierFn {} +unsafe impl Sync for NvPresentBarrierFn {} +impl NvPresentBarrierFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_NV_present_barrier'"] +impl StructureType { + pub const PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV: Self = Self(1_000_292_000); + pub const SURFACE_CAPABILITIES_PRESENT_BARRIER_NV: Self = Self(1_000_292_001); + pub const SWAPCHAIN_PRESENT_BARRIER_CREATE_INFO_NV: Self = Self(1_000_292_002); +} +impl KhrShaderNonSemanticInfoFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_shader_non_semantic_info\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct KhrShaderNonSemanticInfoFn {} +unsafe impl Send for KhrShaderNonSemanticInfoFn {} +unsafe impl Sync for KhrShaderNonSemanticInfoFn {} +impl KhrShaderNonSemanticInfoFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl KhrPresentIdFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_present_id\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct KhrPresentIdFn {} +unsafe impl Send for KhrPresentIdFn {} +unsafe impl Sync for KhrPresentIdFn {} +impl KhrPresentIdFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_KHR_present_id'"] +impl StructureType { + pub const PRESENT_ID_KHR: Self = Self(1_000_294_000); + pub const PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR: Self = Self(1_000_294_001); +} +impl ExtPrivateDataFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_private_data\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkCreatePrivateDataSlot = unsafe extern "system" fn( + device: Device, + p_create_info: *const PrivateDataSlotCreateInfo, + p_allocator: *const AllocationCallbacks, + p_private_data_slot: *mut PrivateDataSlot, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkDestroyPrivateDataSlot = unsafe extern "system" fn( + device: Device, + private_data_slot: PrivateDataSlot, + p_allocator: *const AllocationCallbacks, +); +#[allow(non_camel_case_types)] +pub type PFN_vkSetPrivateData = unsafe extern "system" fn( + device: Device, + object_type: ObjectType, + object_handle: u64, + private_data_slot: PrivateDataSlot, + data: u64, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetPrivateData = unsafe extern "system" fn( + device: Device, + object_type: ObjectType, + object_handle: u64, + private_data_slot: PrivateDataSlot, + p_data: *mut u64, +); +#[derive(Clone)] +pub struct ExtPrivateDataFn { + pub create_private_data_slot_ext: PFN_vkCreatePrivateDataSlot, + pub destroy_private_data_slot_ext: PFN_vkDestroyPrivateDataSlot, + pub set_private_data_ext: PFN_vkSetPrivateData, + pub get_private_data_ext: PFN_vkGetPrivateData, +} +unsafe impl Send for ExtPrivateDataFn {} +unsafe impl Sync for ExtPrivateDataFn {} +impl ExtPrivateDataFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + create_private_data_slot_ext: unsafe { + unsafe extern "system" fn create_private_data_slot_ext( + _device: Device, + _p_create_info: *const PrivateDataSlotCreateInfo, + _p_allocator: *const AllocationCallbacks, + _p_private_data_slot: *mut PrivateDataSlot, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(create_private_data_slot_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCreatePrivateDataSlotEXT\0", + ); + let val = _f(cname); + if val.is_null() { + create_private_data_slot_ext + } else { + ::std::mem::transmute(val) + } + }, + destroy_private_data_slot_ext: unsafe { + unsafe extern "system" fn destroy_private_data_slot_ext( + _device: Device, + _private_data_slot: PrivateDataSlot, + _p_allocator: *const AllocationCallbacks, + ) { + panic!(concat!( + "Unable to load ", + stringify!(destroy_private_data_slot_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkDestroyPrivateDataSlotEXT\0", + ); + let val = _f(cname); + if val.is_null() { + destroy_private_data_slot_ext + } else { + ::std::mem::transmute(val) + } + }, + set_private_data_ext: unsafe { + unsafe extern "system" fn set_private_data_ext( + _device: Device, + _object_type: ObjectType, + _object_handle: u64, + _private_data_slot: PrivateDataSlot, + _data: u64, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(set_private_data_ext))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkSetPrivateDataEXT\0"); + let val = _f(cname); + if val.is_null() { + set_private_data_ext + } else { + ::std::mem::transmute(val) + } + }, + get_private_data_ext: unsafe { + unsafe extern "system" fn get_private_data_ext( + _device: Device, + _object_type: ObjectType, + _object_handle: u64, + _private_data_slot: PrivateDataSlot, + _p_data: *mut u64, + ) { + panic!(concat!("Unable to load ", stringify!(get_private_data_ext))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetPrivateDataEXT\0"); + let val = _f(cname); + if val.is_null() { + get_private_data_ext + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_EXT_private_data'"] +impl ObjectType { + pub const PRIVATE_DATA_SLOT_EXT: Self = Self::PRIVATE_DATA_SLOT; +} +#[doc = "Generated from 'VK_EXT_private_data'"] +impl StructureType { + pub const PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES_EXT: Self = + Self::PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES; + pub const DEVICE_PRIVATE_DATA_CREATE_INFO_EXT: Self = Self::DEVICE_PRIVATE_DATA_CREATE_INFO; + pub const PRIVATE_DATA_SLOT_CREATE_INFO_EXT: Self = Self::PRIVATE_DATA_SLOT_CREATE_INFO; +} +impl KhrExtension297Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_extension_297\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct KhrExtension297Fn {} +unsafe impl Send for KhrExtension297Fn {} +unsafe impl Sync for KhrExtension297Fn {} +impl KhrExtension297Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_KHR_extension_297'"] +impl PipelineShaderStageCreateFlags { + pub const RESERVED_3_KHR: Self = Self(0b1000); +} +impl ExtPipelineCreationCacheControlFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"VK_EXT_pipeline_creation_cache_control\0", + ) + } + } + pub const SPEC_VERSION: u32 = 3u32; +} +#[derive(Clone)] +pub struct ExtPipelineCreationCacheControlFn {} +unsafe impl Send for ExtPipelineCreationCacheControlFn {} +unsafe impl Sync for ExtPipelineCreationCacheControlFn {} +impl ExtPipelineCreationCacheControlFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_pipeline_creation_cache_control'"] +impl PipelineCacheCreateFlags { + pub const EXTERNALLY_SYNCHRONIZED_EXT: Self = Self::EXTERNALLY_SYNCHRONIZED; +} +#[doc = "Generated from 'VK_EXT_pipeline_creation_cache_control'"] +impl PipelineCreateFlags { + pub const FAIL_ON_PIPELINE_COMPILE_REQUIRED_EXT: Self = Self::FAIL_ON_PIPELINE_COMPILE_REQUIRED; + pub const EARLY_RETURN_ON_FAILURE_EXT: Self = Self::EARLY_RETURN_ON_FAILURE; +} +#[doc = "Generated from 'VK_EXT_pipeline_creation_cache_control'"] +impl Result { + pub const PIPELINE_COMPILE_REQUIRED_EXT: Self = Self::PIPELINE_COMPILE_REQUIRED; + pub const ERROR_PIPELINE_COMPILE_REQUIRED_EXT: Self = Self::PIPELINE_COMPILE_REQUIRED; +} +#[doc = "Generated from 'VK_EXT_pipeline_creation_cache_control'"] +impl StructureType { + pub const PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES_EXT: Self = + Self::PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES; +} +impl KhrExtension299Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_extension_299\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct KhrExtension299Fn {} +unsafe impl Send for KhrExtension299Fn {} +unsafe impl Sync for KhrExtension299Fn {} +impl KhrExtension299Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_KHR_extension_299'"] +impl MemoryHeapFlags { + pub const RESERVED_2_KHR: Self = Self(0b100); +} +#[doc = "Generated from 'VK_KHR_extension_299'"] +impl PipelineCacheCreateFlags { + pub const RESERVED_1_KHR: Self = Self::RESERVED_1_EXT; + pub const RESERVED_2_KHR: Self = Self(0b100); +} +impl KhrVideoEncodeQueueFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_video_encode_queue\0") } + } + pub const SPEC_VERSION: u32 = 7u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkCmdEncodeVideoKHR = unsafe extern "system" fn( + command_buffer: CommandBuffer, + p_encode_info: *const VideoEncodeInfoKHR, +); +#[derive(Clone)] +pub struct KhrVideoEncodeQueueFn { + pub cmd_encode_video_khr: PFN_vkCmdEncodeVideoKHR, +} +unsafe impl Send for KhrVideoEncodeQueueFn {} +unsafe impl Sync for KhrVideoEncodeQueueFn {} +impl KhrVideoEncodeQueueFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + cmd_encode_video_khr: unsafe { + unsafe extern "system" fn cmd_encode_video_khr( + _command_buffer: CommandBuffer, + _p_encode_info: *const VideoEncodeInfoKHR, + ) { + panic!(concat!("Unable to load ", stringify!(cmd_encode_video_khr))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdEncodeVideoKHR\0"); + let val = _f(cname); + if val.is_null() { + cmd_encode_video_khr + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_KHR_video_encode_queue'"] +impl AccessFlags2 { + pub const VIDEO_ENCODE_READ_KHR: Self = Self(0b10_0000_0000_0000_0000_0000_0000_0000_0000_0000); + pub const VIDEO_ENCODE_WRITE_KHR: Self = + Self(0b100_0000_0000_0000_0000_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_KHR_video_encode_queue'"] +impl BufferUsageFlags { + pub const VIDEO_ENCODE_DST_KHR: Self = Self(0b1000_0000_0000_0000); + pub const VIDEO_ENCODE_SRC_KHR: Self = Self(0b1_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_KHR_video_encode_queue'"] +impl FormatFeatureFlags { + pub const VIDEO_ENCODE_INPUT_KHR: Self = Self(0b1000_0000_0000_0000_0000_0000_0000); + pub const VIDEO_ENCODE_DPB_KHR: Self = Self(0b1_0000_0000_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_KHR_video_encode_queue'"] +impl FormatFeatureFlags2 { + pub const VIDEO_ENCODE_INPUT_KHR: Self = Self(0b1000_0000_0000_0000_0000_0000_0000); + pub const VIDEO_ENCODE_DPB_KHR: Self = Self(0b1_0000_0000_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_KHR_video_encode_queue'"] +impl ImageLayout { + pub const VIDEO_ENCODE_DST_KHR: Self = Self(1_000_299_000); + pub const VIDEO_ENCODE_SRC_KHR: Self = Self(1_000_299_001); + pub const VIDEO_ENCODE_DPB_KHR: Self = Self(1_000_299_002); +} +#[doc = "Generated from 'VK_KHR_video_encode_queue'"] +impl ImageUsageFlags { + pub const VIDEO_ENCODE_DST_KHR: Self = Self(0b10_0000_0000_0000); + pub const VIDEO_ENCODE_SRC_KHR: Self = Self(0b100_0000_0000_0000); + pub const VIDEO_ENCODE_DPB_KHR: Self = Self(0b1000_0000_0000_0000); +} +#[doc = "Generated from 'VK_KHR_video_encode_queue'"] +impl PipelineStageFlags2 { + pub const VIDEO_ENCODE_KHR: Self = Self(0b1000_0000_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_KHR_video_encode_queue'"] +impl QueryType { + pub const VIDEO_ENCODESTREAM_BUFFER_RANGE_KHR: Self = Self(1_000_299_000); +} +#[doc = "Generated from 'VK_KHR_video_encode_queue'"] +impl QueueFlags { + pub const VIDEO_ENCODE_KHR: Self = Self(0b100_0000); +} +#[doc = "Generated from 'VK_KHR_video_encode_queue'"] +impl StructureType { + pub const VIDEO_ENCODE_INFO_KHR: Self = Self(1_000_299_000); + pub const VIDEO_ENCODE_RATE_CONTROL_INFO_KHR: Self = Self(1_000_299_001); + pub const VIDEO_ENCODE_RATE_CONTROL_LAYER_INFO_KHR: Self = Self(1_000_299_002); + pub const VIDEO_ENCODE_CAPABILITIES_KHR: Self = Self(1_000_299_003); + pub const VIDEO_ENCODE_USAGE_INFO_KHR: Self = Self(1_000_299_004); +} +#[doc = "Generated from 'VK_KHR_video_encode_queue'"] +impl VideoCodingControlFlagsKHR { + pub const ENCODE_RATE_CONTROL: Self = Self(0b10); + pub const ENCODE_RATE_CONTROL_LAYER: Self = Self(0b100); +} +impl NvDeviceDiagnosticsConfigFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_device_diagnostics_config\0") + } + } + pub const SPEC_VERSION: u32 = 2u32; +} +#[derive(Clone)] +pub struct NvDeviceDiagnosticsConfigFn {} +unsafe impl Send for NvDeviceDiagnosticsConfigFn {} +unsafe impl Sync for NvDeviceDiagnosticsConfigFn {} +impl NvDeviceDiagnosticsConfigFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_NV_device_diagnostics_config'"] +impl StructureType { + pub const PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV: Self = Self(1_000_300_000); + pub const DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV: Self = Self(1_000_300_001); +} +impl QcomRenderPassStoreOpsFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_QCOM_render_pass_store_ops\0") + } + } + pub const SPEC_VERSION: u32 = 2u32; +} +#[derive(Clone)] +pub struct QcomRenderPassStoreOpsFn {} +unsafe impl Send for QcomRenderPassStoreOpsFn {} +unsafe impl Sync for QcomRenderPassStoreOpsFn {} +impl QcomRenderPassStoreOpsFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_QCOM_render_pass_store_ops'"] +impl AttachmentStoreOp { + pub const NONE_QCOM: Self = Self::NONE; +} +impl QcomExtension303Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_QCOM_extension_303\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct QcomExtension303Fn {} +unsafe impl Send for QcomExtension303Fn {} +unsafe impl Sync for QcomExtension303Fn {} +impl QcomExtension303Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl QcomExtension304Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_QCOM_extension_304\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct QcomExtension304Fn {} +unsafe impl Send for QcomExtension304Fn {} +unsafe impl Sync for QcomExtension304Fn {} +impl QcomExtension304Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl QcomExtension305Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_QCOM_extension_305\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct QcomExtension305Fn {} +unsafe impl Send for QcomExtension305Fn {} +unsafe impl Sync for QcomExtension305Fn {} +impl QcomExtension305Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl QcomExtension306Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_QCOM_extension_306\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct QcomExtension306Fn {} +unsafe impl Send for QcomExtension306Fn {} +unsafe impl Sync for QcomExtension306Fn {} +impl QcomExtension306Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl QcomExtension307Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_QCOM_extension_307\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct QcomExtension307Fn {} +unsafe impl Send for QcomExtension307Fn {} +unsafe impl Sync for QcomExtension307Fn {} +impl QcomExtension307Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl NvExtension308Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_308\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct NvExtension308Fn {} +unsafe impl Send for NvExtension308Fn {} +unsafe impl Sync for NvExtension308Fn {} +impl NvExtension308Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl KhrExtension309Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_extension_309\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct KhrExtension309Fn {} +unsafe impl Send for KhrExtension309Fn {} +unsafe impl Sync for KhrExtension309Fn {} +impl KhrExtension309Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl QcomExtension310Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_QCOM_extension_310\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct QcomExtension310Fn {} +unsafe impl Send for QcomExtension310Fn {} +unsafe impl Sync for QcomExtension310Fn {} +impl QcomExtension310Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_QCOM_extension_310'"] +impl StructureType { + pub const RESERVED_QCOM: Self = Self(1_000_309_000); +} +impl NvExtension311Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_311\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct NvExtension311Fn {} +unsafe impl Send for NvExtension311Fn {} +unsafe impl Sync for NvExtension311Fn {} +impl NvExtension311Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtMetalObjectsFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_metal_objects\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkExportMetalObjectsEXT = + unsafe extern "system" fn(device: Device, p_metal_objects_info: *mut ExportMetalObjectsInfoEXT); +#[derive(Clone)] +pub struct ExtMetalObjectsFn { + pub export_metal_objects_ext: PFN_vkExportMetalObjectsEXT, +} +unsafe impl Send for ExtMetalObjectsFn {} +unsafe impl Sync for ExtMetalObjectsFn {} +impl ExtMetalObjectsFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + export_metal_objects_ext: unsafe { + unsafe extern "system" fn export_metal_objects_ext( + _device: Device, + _p_metal_objects_info: *mut ExportMetalObjectsInfoEXT, + ) { + panic!(concat!( + "Unable to load ", + stringify!(export_metal_objects_ext) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkExportMetalObjectsEXT\0"); + let val = _f(cname); + if val.is_null() { + export_metal_objects_ext + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_EXT_metal_objects'"] +impl StructureType { + pub const EXPORT_METAL_OBJECT_CREATE_INFO_EXT: Self = Self(1_000_311_000); + pub const EXPORT_METAL_OBJECTS_INFO_EXT: Self = Self(1_000_311_001); + pub const EXPORT_METAL_DEVICE_INFO_EXT: Self = Self(1_000_311_002); + pub const EXPORT_METAL_COMMAND_QUEUE_INFO_EXT: Self = Self(1_000_311_003); + pub const EXPORT_METAL_BUFFER_INFO_EXT: Self = Self(1_000_311_004); + pub const IMPORT_METAL_BUFFER_INFO_EXT: Self = Self(1_000_311_005); + pub const EXPORT_METAL_TEXTURE_INFO_EXT: Self = Self(1_000_311_006); + pub const IMPORT_METAL_TEXTURE_INFO_EXT: Self = Self(1_000_311_007); + pub const EXPORT_METAL_IO_SURFACE_INFO_EXT: Self = Self(1_000_311_008); + pub const IMPORT_METAL_IO_SURFACE_INFO_EXT: Self = Self(1_000_311_009); + pub const EXPORT_METAL_SHARED_EVENT_INFO_EXT: Self = Self(1_000_311_010); + pub const IMPORT_METAL_SHARED_EVENT_INFO_EXT: Self = Self(1_000_311_011); +} +impl ExtExtension313Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_313\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct ExtExtension313Fn {} +unsafe impl Send for ExtExtension313Fn {} +unsafe impl Sync for ExtExtension313Fn {} +impl ExtExtension313Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl AmdExtension314Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_314\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct AmdExtension314Fn {} +unsafe impl Send for AmdExtension314Fn {} +unsafe impl Sync for AmdExtension314Fn {} +impl AmdExtension314Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl KhrSynchronization2Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_synchronization2\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetEvent2 = unsafe extern "system" fn( + command_buffer: CommandBuffer, + event: Event, + p_dependency_info: *const DependencyInfo, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdResetEvent2 = unsafe extern "system" fn( + command_buffer: CommandBuffer, + event: Event, + stage_mask: PipelineStageFlags2, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdWaitEvents2 = unsafe extern "system" fn( + command_buffer: CommandBuffer, + event_count: u32, + p_events: *const Event, + p_dependency_infos: *const DependencyInfo, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdPipelineBarrier2 = unsafe extern "system" fn( + command_buffer: CommandBuffer, + p_dependency_info: *const DependencyInfo, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdWriteTimestamp2 = unsafe extern "system" fn( + command_buffer: CommandBuffer, + stage: PipelineStageFlags2, + query_pool: QueryPool, + query: u32, +); +#[allow(non_camel_case_types)] +pub type PFN_vkQueueSubmit2 = unsafe extern "system" fn( + queue: Queue, + submit_count: u32, + p_submits: *const SubmitInfo2, + fence: Fence, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkCmdWriteBufferMarker2AMD = unsafe extern "system" fn( + command_buffer: CommandBuffer, + stage: PipelineStageFlags2, + dst_buffer: Buffer, + dst_offset: DeviceSize, + marker: u32, +); +#[allow(non_camel_case_types)] +pub type PFN_vkGetQueueCheckpointData2NV = unsafe extern "system" fn( + queue: Queue, + p_checkpoint_data_count: *mut u32, + p_checkpoint_data: *mut CheckpointData2NV, +); +#[derive(Clone)] +pub struct KhrSynchronization2Fn { + pub cmd_set_event2_khr: PFN_vkCmdSetEvent2, + pub cmd_reset_event2_khr: PFN_vkCmdResetEvent2, + pub cmd_wait_events2_khr: PFN_vkCmdWaitEvents2, + pub cmd_pipeline_barrier2_khr: PFN_vkCmdPipelineBarrier2, + pub cmd_write_timestamp2_khr: PFN_vkCmdWriteTimestamp2, + pub queue_submit2_khr: PFN_vkQueueSubmit2, + pub cmd_write_buffer_marker2_amd: PFN_vkCmdWriteBufferMarker2AMD, + pub get_queue_checkpoint_data2_nv: PFN_vkGetQueueCheckpointData2NV, +} +unsafe impl Send for KhrSynchronization2Fn {} +unsafe impl Sync for KhrSynchronization2Fn {} +impl KhrSynchronization2Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + cmd_set_event2_khr: unsafe { + unsafe extern "system" fn cmd_set_event2_khr( + _command_buffer: CommandBuffer, + _event: Event, + _p_dependency_info: *const DependencyInfo, + ) { + panic!(concat!("Unable to load ", stringify!(cmd_set_event2_khr))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetEvent2KHR\0"); + let val = _f(cname); + if val.is_null() { + cmd_set_event2_khr + } else { + ::std::mem::transmute(val) + } + }, + cmd_reset_event2_khr: unsafe { + unsafe extern "system" fn cmd_reset_event2_khr( + _command_buffer: CommandBuffer, + _event: Event, + _stage_mask: PipelineStageFlags2, + ) { + panic!(concat!("Unable to load ", stringify!(cmd_reset_event2_khr))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdResetEvent2KHR\0"); + let val = _f(cname); + if val.is_null() { + cmd_reset_event2_khr + } else { + ::std::mem::transmute(val) + } + }, + cmd_wait_events2_khr: unsafe { + unsafe extern "system" fn cmd_wait_events2_khr( + _command_buffer: CommandBuffer, + _event_count: u32, + _p_events: *const Event, + _p_dependency_infos: *const DependencyInfo, + ) { + panic!(concat!("Unable to load ", stringify!(cmd_wait_events2_khr))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdWaitEvents2KHR\0"); + let val = _f(cname); + if val.is_null() { + cmd_wait_events2_khr + } else { + ::std::mem::transmute(val) + } + }, + cmd_pipeline_barrier2_khr: unsafe { + unsafe extern "system" fn cmd_pipeline_barrier2_khr( + _command_buffer: CommandBuffer, + _p_dependency_info: *const DependencyInfo, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_pipeline_barrier2_khr) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdPipelineBarrier2KHR\0"); + let val = _f(cname); + if val.is_null() { + cmd_pipeline_barrier2_khr + } else { + ::std::mem::transmute(val) + } + }, + cmd_write_timestamp2_khr: unsafe { + unsafe extern "system" fn cmd_write_timestamp2_khr( + _command_buffer: CommandBuffer, + _stage: PipelineStageFlags2, + _query_pool: QueryPool, + _query: u32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_write_timestamp2_khr) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdWriteTimestamp2KHR\0"); + let val = _f(cname); + if val.is_null() { + cmd_write_timestamp2_khr + } else { + ::std::mem::transmute(val) + } + }, + queue_submit2_khr: unsafe { + unsafe extern "system" fn queue_submit2_khr( + _queue: Queue, + _submit_count: u32, + _p_submits: *const SubmitInfo2, + _fence: Fence, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(queue_submit2_khr))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkQueueSubmit2KHR\0"); + let val = _f(cname); + if val.is_null() { + queue_submit2_khr + } else { + ::std::mem::transmute(val) + } + }, + cmd_write_buffer_marker2_amd: unsafe { + unsafe extern "system" fn cmd_write_buffer_marker2_amd( + _command_buffer: CommandBuffer, + _stage: PipelineStageFlags2, + _dst_buffer: Buffer, + _dst_offset: DeviceSize, + _marker: u32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_write_buffer_marker2_amd) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdWriteBufferMarker2AMD\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_write_buffer_marker2_amd + } else { + ::std::mem::transmute(val) + } + }, + get_queue_checkpoint_data2_nv: unsafe { + unsafe extern "system" fn get_queue_checkpoint_data2_nv( + _queue: Queue, + _p_checkpoint_data_count: *mut u32, + _p_checkpoint_data: *mut CheckpointData2NV, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_queue_checkpoint_data2_nv) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetQueueCheckpointData2NV\0", + ); + let val = _f(cname); + if val.is_null() { + get_queue_checkpoint_data2_nv + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_KHR_synchronization2'"] +impl AccessFlags { + pub const NONE_KHR: Self = Self::NONE; +} +#[doc = "Generated from 'VK_KHR_synchronization2'"] +impl AccessFlags2 { + pub const TRANSFORM_FEEDBACK_WRITE_EXT: Self = Self(0b10_0000_0000_0000_0000_0000_0000); + pub const TRANSFORM_FEEDBACK_COUNTER_READ_EXT: Self = Self(0b100_0000_0000_0000_0000_0000_0000); + pub const TRANSFORM_FEEDBACK_COUNTER_WRITE_EXT: Self = + Self(0b1000_0000_0000_0000_0000_0000_0000); + #[doc = "read access flag for reading conditional rendering predicate"] + pub const CONDITIONAL_RENDERING_READ_EXT: Self = Self(0b1_0000_0000_0000_0000_0000); + pub const COMMAND_PREPROCESS_READ_NV: Self = Self(0b10_0000_0000_0000_0000); + pub const COMMAND_PREPROCESS_WRITE_NV: Self = Self(0b100_0000_0000_0000_0000); + pub const FRAGMENT_SHADING_RATE_ATTACHMENT_READ_KHR: Self = + Self(0b1000_0000_0000_0000_0000_0000); + pub const SHADING_RATE_IMAGE_READ_NV: Self = Self::FRAGMENT_SHADING_RATE_ATTACHMENT_READ_KHR; + pub const ACCELERATION_STRUCTURE_READ_KHR: Self = Self(0b10_0000_0000_0000_0000_0000); + pub const ACCELERATION_STRUCTURE_WRITE_KHR: Self = Self(0b100_0000_0000_0000_0000_0000); + pub const ACCELERATION_STRUCTURE_READ_NV: Self = Self::ACCELERATION_STRUCTURE_READ_KHR; + pub const ACCELERATION_STRUCTURE_WRITE_NV: Self = Self::ACCELERATION_STRUCTURE_WRITE_KHR; + pub const FRAGMENT_DENSITY_MAP_READ_EXT: Self = Self(0b1_0000_0000_0000_0000_0000_0000); + pub const COLOR_ATTACHMENT_READ_NONCOHERENT_EXT: Self = Self(0b1000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_KHR_synchronization2'"] +impl EventCreateFlags { + pub const DEVICE_ONLY_KHR: Self = Self::DEVICE_ONLY; +} +#[doc = "Generated from 'VK_KHR_synchronization2'"] +impl ImageLayout { + pub const READ_ONLY_OPTIMAL_KHR: Self = Self::READ_ONLY_OPTIMAL; + pub const ATTACHMENT_OPTIMAL_KHR: Self = Self::ATTACHMENT_OPTIMAL; +} +#[doc = "Generated from 'VK_KHR_synchronization2'"] +impl PipelineStageFlags { + pub const NONE_KHR: Self = Self::NONE; +} +#[doc = "Generated from 'VK_KHR_synchronization2'"] +impl PipelineStageFlags2 { + pub const TRANSFORM_FEEDBACK_EXT: Self = Self(0b1_0000_0000_0000_0000_0000_0000); + #[doc = "A pipeline stage for conditional rendering predicate fetch"] + pub const CONDITIONAL_RENDERING_EXT: Self = Self(0b100_0000_0000_0000_0000); + pub const COMMAND_PREPROCESS_NV: Self = Self(0b10_0000_0000_0000_0000); + pub const FRAGMENT_SHADING_RATE_ATTACHMENT_KHR: Self = Self(0b100_0000_0000_0000_0000_0000); + pub const SHADING_RATE_IMAGE_NV: Self = Self::FRAGMENT_SHADING_RATE_ATTACHMENT_KHR; + pub const ACCELERATION_STRUCTURE_BUILD_KHR: Self = Self(0b10_0000_0000_0000_0000_0000_0000); + pub const RAY_TRACING_SHADER_KHR: Self = Self(0b10_0000_0000_0000_0000_0000); + pub const RAY_TRACING_SHADER_NV: Self = Self::RAY_TRACING_SHADER_KHR; + pub const ACCELERATION_STRUCTURE_BUILD_NV: Self = Self::ACCELERATION_STRUCTURE_BUILD_KHR; + pub const FRAGMENT_DENSITY_PROCESS_EXT: Self = Self(0b1000_0000_0000_0000_0000_0000); + pub const TASK_SHADER_NV: Self = Self::TASK_SHADER_EXT; + pub const MESH_SHADER_NV: Self = Self::MESH_SHADER_EXT; + pub const TASK_SHADER_EXT: Self = Self(0b1000_0000_0000_0000_0000); + pub const MESH_SHADER_EXT: Self = Self(0b1_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_KHR_synchronization2'"] +impl StructureType { + pub const MEMORY_BARRIER_2_KHR: Self = Self::MEMORY_BARRIER_2; + pub const BUFFER_MEMORY_BARRIER_2_KHR: Self = Self::BUFFER_MEMORY_BARRIER_2; + pub const IMAGE_MEMORY_BARRIER_2_KHR: Self = Self::IMAGE_MEMORY_BARRIER_2; + pub const DEPENDENCY_INFO_KHR: Self = Self::DEPENDENCY_INFO; + pub const SUBMIT_INFO_2_KHR: Self = Self::SUBMIT_INFO_2; + pub const SEMAPHORE_SUBMIT_INFO_KHR: Self = Self::SEMAPHORE_SUBMIT_INFO; + pub const COMMAND_BUFFER_SUBMIT_INFO_KHR: Self = Self::COMMAND_BUFFER_SUBMIT_INFO; + pub const PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES_KHR: Self = + Self::PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES; + pub const QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV: Self = Self(1_000_314_008); + pub const CHECKPOINT_DATA_2_NV: Self = Self(1_000_314_009); +} +impl AmdExtension316Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_316\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct AmdExtension316Fn {} +unsafe impl Send for AmdExtension316Fn {} +unsafe impl Sync for AmdExtension316Fn {} +impl AmdExtension316Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtDescriptorBufferFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_descriptor_buffer\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkGetDescriptorSetLayoutSizeEXT = unsafe extern "system" fn( + device: Device, + layout: DescriptorSetLayout, + p_layout_size_in_bytes: *mut DeviceSize, +); +#[allow(non_camel_case_types)] +pub type PFN_vkGetDescriptorSetLayoutBindingOffsetEXT = unsafe extern "system" fn( + device: Device, + layout: DescriptorSetLayout, + binding: u32, + p_offset: *mut DeviceSize, +); +#[allow(non_camel_case_types)] +pub type PFN_vkGetDescriptorEXT = unsafe extern "system" fn( + device: Device, + p_descriptor_info: *const DescriptorGetInfoEXT, + data_size: usize, + p_descriptor: *mut c_void, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdBindDescriptorBuffersEXT = unsafe extern "system" fn( + command_buffer: CommandBuffer, + buffer_count: u32, + p_binding_infos: *const DescriptorBufferBindingInfoEXT, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetDescriptorBufferOffsetsEXT = unsafe extern "system" fn( + command_buffer: CommandBuffer, + pipeline_bind_point: PipelineBindPoint, + layout: PipelineLayout, + first_set: u32, + set_count: u32, + p_buffer_indices: *const u32, + p_offsets: *const DeviceSize, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdBindDescriptorBufferEmbeddedSamplersEXT = unsafe extern "system" fn( + command_buffer: CommandBuffer, + pipeline_bind_point: PipelineBindPoint, + layout: PipelineLayout, + set: u32, +); +#[allow(non_camel_case_types)] +pub type PFN_vkGetBufferOpaqueCaptureDescriptorDataEXT = unsafe extern "system" fn( + device: Device, + p_info: *const BufferCaptureDescriptorDataInfoEXT, + p_data: *mut c_void, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetImageOpaqueCaptureDescriptorDataEXT = unsafe extern "system" fn( + device: Device, + p_info: *const ImageCaptureDescriptorDataInfoEXT, + p_data: *mut c_void, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetImageViewOpaqueCaptureDescriptorDataEXT = unsafe extern "system" fn( + device: Device, + p_info: *const ImageViewCaptureDescriptorDataInfoEXT, + p_data: *mut c_void, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetSamplerOpaqueCaptureDescriptorDataEXT = unsafe extern "system" fn( + device: Device, + p_info: *const SamplerCaptureDescriptorDataInfoEXT, + p_data: *mut c_void, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT = + unsafe extern "system" fn( + device: Device, + p_info: *const AccelerationStructureCaptureDescriptorDataInfoEXT, + p_data: *mut c_void, + ) -> Result; +#[derive(Clone)] +pub struct ExtDescriptorBufferFn { + pub get_descriptor_set_layout_size_ext: PFN_vkGetDescriptorSetLayoutSizeEXT, + pub get_descriptor_set_layout_binding_offset_ext: PFN_vkGetDescriptorSetLayoutBindingOffsetEXT, + pub get_descriptor_ext: PFN_vkGetDescriptorEXT, + pub cmd_bind_descriptor_buffers_ext: PFN_vkCmdBindDescriptorBuffersEXT, + pub cmd_set_descriptor_buffer_offsets_ext: PFN_vkCmdSetDescriptorBufferOffsetsEXT, + pub cmd_bind_descriptor_buffer_embedded_samplers_ext: + PFN_vkCmdBindDescriptorBufferEmbeddedSamplersEXT, + pub get_buffer_opaque_capture_descriptor_data_ext: + PFN_vkGetBufferOpaqueCaptureDescriptorDataEXT, + pub get_image_opaque_capture_descriptor_data_ext: PFN_vkGetImageOpaqueCaptureDescriptorDataEXT, + pub get_image_view_opaque_capture_descriptor_data_ext: + PFN_vkGetImageViewOpaqueCaptureDescriptorDataEXT, + pub get_sampler_opaque_capture_descriptor_data_ext: + PFN_vkGetSamplerOpaqueCaptureDescriptorDataEXT, + pub get_acceleration_structure_opaque_capture_descriptor_data_ext: + PFN_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT, +} +unsafe impl Send for ExtDescriptorBufferFn {} +unsafe impl Sync for ExtDescriptorBufferFn {} +impl ExtDescriptorBufferFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + get_descriptor_set_layout_size_ext: unsafe { + unsafe extern "system" fn get_descriptor_set_layout_size_ext( + _device: Device, + _layout: DescriptorSetLayout, + _p_layout_size_in_bytes: *mut DeviceSize, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_descriptor_set_layout_size_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetDescriptorSetLayoutSizeEXT\0", + ); + let val = _f(cname); + if val.is_null() { + get_descriptor_set_layout_size_ext + } else { + ::std::mem::transmute(val) + } + }, + get_descriptor_set_layout_binding_offset_ext: unsafe { + unsafe extern "system" fn get_descriptor_set_layout_binding_offset_ext( + _device: Device, + _layout: DescriptorSetLayout, + _binding: u32, + _p_offset: *mut DeviceSize, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_descriptor_set_layout_binding_offset_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetDescriptorSetLayoutBindingOffsetEXT\0", + ); + let val = _f(cname); + if val.is_null() { + get_descriptor_set_layout_binding_offset_ext + } else { + ::std::mem::transmute(val) + } + }, + get_descriptor_ext: unsafe { + unsafe extern "system" fn get_descriptor_ext( + _device: Device, + _p_descriptor_info: *const DescriptorGetInfoEXT, + _data_size: usize, + _p_descriptor: *mut c_void, + ) { + panic!(concat!("Unable to load ", stringify!(get_descriptor_ext))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetDescriptorEXT\0"); + let val = _f(cname); + if val.is_null() { + get_descriptor_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_bind_descriptor_buffers_ext: unsafe { + unsafe extern "system" fn cmd_bind_descriptor_buffers_ext( + _command_buffer: CommandBuffer, + _buffer_count: u32, + _p_binding_infos: *const DescriptorBufferBindingInfoEXT, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_bind_descriptor_buffers_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdBindDescriptorBuffersEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_bind_descriptor_buffers_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_descriptor_buffer_offsets_ext: unsafe { + unsafe extern "system" fn cmd_set_descriptor_buffer_offsets_ext( + _command_buffer: CommandBuffer, + _pipeline_bind_point: PipelineBindPoint, + _layout: PipelineLayout, + _first_set: u32, + _set_count: u32, + _p_buffer_indices: *const u32, + _p_offsets: *const DeviceSize, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_descriptor_buffer_offsets_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetDescriptorBufferOffsetsEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_descriptor_buffer_offsets_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_bind_descriptor_buffer_embedded_samplers_ext: unsafe { + unsafe extern "system" fn cmd_bind_descriptor_buffer_embedded_samplers_ext( + _command_buffer: CommandBuffer, + _pipeline_bind_point: PipelineBindPoint, + _layout: PipelineLayout, + _set: u32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_bind_descriptor_buffer_embedded_samplers_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdBindDescriptorBufferEmbeddedSamplersEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_bind_descriptor_buffer_embedded_samplers_ext + } else { + ::std::mem::transmute(val) + } + }, + get_buffer_opaque_capture_descriptor_data_ext: unsafe { + unsafe extern "system" fn get_buffer_opaque_capture_descriptor_data_ext( + _device: Device, + _p_info: *const BufferCaptureDescriptorDataInfoEXT, + _p_data: *mut c_void, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_buffer_opaque_capture_descriptor_data_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetBufferOpaqueCaptureDescriptorDataEXT\0", + ); + let val = _f(cname); + if val.is_null() { + get_buffer_opaque_capture_descriptor_data_ext + } else { + ::std::mem::transmute(val) + } + }, + get_image_opaque_capture_descriptor_data_ext: unsafe { + unsafe extern "system" fn get_image_opaque_capture_descriptor_data_ext( + _device: Device, + _p_info: *const ImageCaptureDescriptorDataInfoEXT, + _p_data: *mut c_void, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_image_opaque_capture_descriptor_data_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetImageOpaqueCaptureDescriptorDataEXT\0", + ); + let val = _f(cname); + if val.is_null() { + get_image_opaque_capture_descriptor_data_ext + } else { + ::std::mem::transmute(val) + } + }, + get_image_view_opaque_capture_descriptor_data_ext: unsafe { + unsafe extern "system" fn get_image_view_opaque_capture_descriptor_data_ext( + _device: Device, + _p_info: *const ImageViewCaptureDescriptorDataInfoEXT, + _p_data: *mut c_void, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_image_view_opaque_capture_descriptor_data_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetImageViewOpaqueCaptureDescriptorDataEXT\0", + ); + let val = _f(cname); + if val.is_null() { + get_image_view_opaque_capture_descriptor_data_ext + } else { + ::std::mem::transmute(val) + } + }, + get_sampler_opaque_capture_descriptor_data_ext: unsafe { + unsafe extern "system" fn get_sampler_opaque_capture_descriptor_data_ext( + _device: Device, + _p_info: *const SamplerCaptureDescriptorDataInfoEXT, + _p_data: *mut c_void, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_sampler_opaque_capture_descriptor_data_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetSamplerOpaqueCaptureDescriptorDataEXT\0", + ); + let val = _f(cname); + if val.is_null() { + get_sampler_opaque_capture_descriptor_data_ext + } else { + ::std::mem::transmute(val) + } + }, + get_acceleration_structure_opaque_capture_descriptor_data_ext: unsafe { + unsafe extern "system" fn get_acceleration_structure_opaque_capture_descriptor_data_ext( + _device: Device, + _p_info: *const AccelerationStructureCaptureDescriptorDataInfoEXT, + _p_data: *mut c_void, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_acceleration_structure_opaque_capture_descriptor_data_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT\0", + ); + let val = _f(cname); + if val.is_null() { + get_acceleration_structure_opaque_capture_descriptor_data_ext + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_EXT_descriptor_buffer'"] +impl AccelerationStructureCreateFlagsKHR { + pub const DESCRIPTOR_BUFFER_CAPTURE_REPLAY_EXT: Self = Self(0b1000); +} +#[doc = "Generated from 'VK_EXT_descriptor_buffer'"] +impl AccessFlags2 { + pub const DESCRIPTOR_BUFFER_READ_EXT: Self = + Self(0b10_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_EXT_descriptor_buffer'"] +impl BufferCreateFlags { + pub const DESCRIPTOR_BUFFER_CAPTURE_REPLAY_EXT: Self = Self(0b10_0000); +} +#[doc = "Generated from 'VK_EXT_descriptor_buffer'"] +impl BufferUsageFlags { + pub const SAMPLER_DESCRIPTOR_BUFFER_EXT: Self = Self(0b10_0000_0000_0000_0000_0000); + pub const RESOURCE_DESCRIPTOR_BUFFER_EXT: Self = Self(0b100_0000_0000_0000_0000_0000); + pub const PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER_EXT: Self = + Self(0b100_0000_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_EXT_descriptor_buffer'"] +impl DescriptorSetLayoutCreateFlags { + pub const DESCRIPTOR_BUFFER_EXT: Self = Self(0b1_0000); + pub const EMBEDDED_IMMUTABLE_SAMPLERS_EXT: Self = Self(0b10_0000); +} +#[doc = "Generated from 'VK_EXT_descriptor_buffer'"] +impl ImageCreateFlags { + pub const DESCRIPTOR_BUFFER_CAPTURE_REPLAY_EXT: Self = Self(0b1_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_EXT_descriptor_buffer'"] +impl ImageViewCreateFlags { + pub const DESCRIPTOR_BUFFER_CAPTURE_REPLAY_EXT: Self = Self(0b100); +} +#[doc = "Generated from 'VK_EXT_descriptor_buffer'"] +impl PipelineCreateFlags { + pub const DESCRIPTOR_BUFFER_EXT: Self = Self(0b10_0000_0000_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_EXT_descriptor_buffer'"] +impl SamplerCreateFlags { + pub const DESCRIPTOR_BUFFER_CAPTURE_REPLAY_EXT: Self = Self(0b1000); +} +#[doc = "Generated from 'VK_EXT_descriptor_buffer'"] +impl StructureType { + pub const PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT: Self = Self(1_000_316_000); + pub const PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT: Self = + Self(1_000_316_001); + pub const PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT: Self = Self(1_000_316_002); + pub const DESCRIPTOR_ADDRESS_INFO_EXT: Self = Self(1_000_316_003); + pub const DESCRIPTOR_GET_INFO_EXT: Self = Self(1_000_316_004); + pub const BUFFER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT: Self = Self(1_000_316_005); + pub const IMAGE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT: Self = Self(1_000_316_006); + pub const IMAGE_VIEW_CAPTURE_DESCRIPTOR_DATA_INFO_EXT: Self = Self(1_000_316_007); + pub const SAMPLER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT: Self = Self(1_000_316_008); + pub const OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT: Self = Self(1_000_316_010); + pub const DESCRIPTOR_BUFFER_BINDING_INFO_EXT: Self = Self(1_000_316_011); + pub const DESCRIPTOR_BUFFER_BINDING_PUSH_DESCRIPTOR_BUFFER_HANDLE_EXT: Self = + Self(1_000_316_012); + pub const ACCELERATION_STRUCTURE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT: Self = Self(1_000_316_009); +} +impl AmdExtension318Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_318\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct AmdExtension318Fn {} +unsafe impl Send for AmdExtension318Fn {} +unsafe impl Sync for AmdExtension318Fn {} +impl AmdExtension318Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl AmdExtension319Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_319\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct AmdExtension319Fn {} +unsafe impl Send for AmdExtension319Fn {} +unsafe impl Sync for AmdExtension319Fn {} +impl AmdExtension319Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_AMD_extension_319'"] +impl DescriptorSetLayoutCreateFlags { + pub const RESERVED_3_AMD: Self = Self(0b1000); +} +#[doc = "Generated from 'VK_AMD_extension_319'"] +impl PipelineLayoutCreateFlags { + pub const RESERVED_0_AMD: Self = Self(0b1); +} +impl AmdExtension320Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_320\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct AmdExtension320Fn {} +unsafe impl Send for AmdExtension320Fn {} +unsafe impl Sync for AmdExtension320Fn {} +impl AmdExtension320Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtGraphicsPipelineLibraryFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_graphics_pipeline_library\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct ExtGraphicsPipelineLibraryFn {} +unsafe impl Send for ExtGraphicsPipelineLibraryFn {} +unsafe impl Sync for ExtGraphicsPipelineLibraryFn {} +impl ExtGraphicsPipelineLibraryFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_graphics_pipeline_library'"] +impl PipelineCreateFlags { + pub const RETAIN_LINK_TIME_OPTIMIZATION_INFO_EXT: Self = Self(0b1000_0000_0000_0000_0000_0000); + pub const LINK_TIME_OPTIMIZATION_EXT: Self = Self(0b100_0000_0000); +} +#[doc = "Generated from 'VK_EXT_graphics_pipeline_library'"] +impl PipelineLayoutCreateFlags { + pub const INDEPENDENT_SETS_EXT: Self = Self(0b10); +} +#[doc = "Generated from 'VK_EXT_graphics_pipeline_library'"] +impl StructureType { + pub const PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT: Self = Self(1_000_320_000); + pub const PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT: Self = Self(1_000_320_001); + pub const GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT: Self = Self(1_000_320_002); +} +impl AmdShaderEarlyAndLateFragmentTestsFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"VK_AMD_shader_early_and_late_fragment_tests\0", + ) + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct AmdShaderEarlyAndLateFragmentTestsFn {} +unsafe impl Send for AmdShaderEarlyAndLateFragmentTestsFn {} +unsafe impl Sync for AmdShaderEarlyAndLateFragmentTestsFn {} +impl AmdShaderEarlyAndLateFragmentTestsFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_AMD_shader_early_and_late_fragment_tests'"] +impl StructureType { + pub const PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD: Self = + Self(1_000_321_000); +} +impl KhrFragmentShaderBarycentricFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_fragment_shader_barycentric\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct KhrFragmentShaderBarycentricFn {} +unsafe impl Send for KhrFragmentShaderBarycentricFn {} +unsafe impl Sync for KhrFragmentShaderBarycentricFn {} +impl KhrFragmentShaderBarycentricFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_KHR_fragment_shader_barycentric'"] +impl StructureType { + pub const PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR: Self = Self(1_000_203_000); + pub const PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR: Self = + Self(1_000_322_000); +} +impl KhrShaderSubgroupUniformControlFlowFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"VK_KHR_shader_subgroup_uniform_control_flow\0", + ) + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct KhrShaderSubgroupUniformControlFlowFn {} +unsafe impl Send for KhrShaderSubgroupUniformControlFlowFn {} +unsafe impl Sync for KhrShaderSubgroupUniformControlFlowFn {} +impl KhrShaderSubgroupUniformControlFlowFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_KHR_shader_subgroup_uniform_control_flow'"] +impl StructureType { + pub const PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR: Self = + Self(1_000_323_000); +} +impl KhrExtension325Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_extension_325\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct KhrExtension325Fn {} +unsafe impl Send for KhrExtension325Fn {} +unsafe impl Sync for KhrExtension325Fn {} +impl KhrExtension325Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl KhrZeroInitializeWorkgroupMemoryFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"VK_KHR_zero_initialize_workgroup_memory\0", + ) + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct KhrZeroInitializeWorkgroupMemoryFn {} +unsafe impl Send for KhrZeroInitializeWorkgroupMemoryFn {} +unsafe impl Sync for KhrZeroInitializeWorkgroupMemoryFn {} +impl KhrZeroInitializeWorkgroupMemoryFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_KHR_zero_initialize_workgroup_memory'"] +impl StructureType { + pub const PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES_KHR: Self = + Self::PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES; +} +impl NvFragmentShadingRateEnumsFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_fragment_shading_rate_enums\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetFragmentShadingRateEnumNV = unsafe extern "system" fn( + command_buffer: CommandBuffer, + shading_rate: FragmentShadingRateNV, + combiner_ops: *const [FragmentShadingRateCombinerOpKHR; 2], +); +#[derive(Clone)] +pub struct NvFragmentShadingRateEnumsFn { + pub cmd_set_fragment_shading_rate_enum_nv: PFN_vkCmdSetFragmentShadingRateEnumNV, +} +unsafe impl Send for NvFragmentShadingRateEnumsFn {} +unsafe impl Sync for NvFragmentShadingRateEnumsFn {} +impl NvFragmentShadingRateEnumsFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + cmd_set_fragment_shading_rate_enum_nv: unsafe { + unsafe extern "system" fn cmd_set_fragment_shading_rate_enum_nv( + _command_buffer: CommandBuffer, + _shading_rate: FragmentShadingRateNV, + _combiner_ops: *const [FragmentShadingRateCombinerOpKHR; 2], + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_fragment_shading_rate_enum_nv) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetFragmentShadingRateEnumNV\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_fragment_shading_rate_enum_nv + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_NV_fragment_shading_rate_enums'"] +impl StructureType { + pub const PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV: Self = Self(1_000_326_000); + pub const PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV: Self = Self(1_000_326_001); + pub const PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV: Self = Self(1_000_326_002); +} +impl NvRayTracingMotionBlurFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_ray_tracing_motion_blur\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct NvRayTracingMotionBlurFn {} +unsafe impl Send for NvRayTracingMotionBlurFn {} +unsafe impl Sync for NvRayTracingMotionBlurFn {} +impl NvRayTracingMotionBlurFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_NV_ray_tracing_motion_blur'"] +impl AccelerationStructureCreateFlagsKHR { + pub const MOTION_NV: Self = Self(0b100); +} +#[doc = "Generated from 'VK_NV_ray_tracing_motion_blur'"] +impl BuildAccelerationStructureFlagsKHR { + pub const MOTION_NV: Self = Self(0b10_0000); +} +#[doc = "Generated from 'VK_NV_ray_tracing_motion_blur'"] +impl PipelineCreateFlags { + pub const RAY_TRACING_ALLOW_MOTION_NV: Self = Self(0b1_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_NV_ray_tracing_motion_blur'"] +impl StructureType { + pub const ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV: Self = Self(1_000_327_000); + pub const PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV: Self = Self(1_000_327_001); + pub const ACCELERATION_STRUCTURE_MOTION_INFO_NV: Self = Self(1_000_327_002); +} +impl ExtMeshShaderFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_mesh_shader\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkCmdDrawMeshTasksEXT = unsafe extern "system" fn( + command_buffer: CommandBuffer, + group_count_x: u32, + group_count_y: u32, + group_count_z: u32, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdDrawMeshTasksIndirectEXT = unsafe extern "system" fn( + command_buffer: CommandBuffer, + buffer: Buffer, + offset: DeviceSize, + draw_count: u32, + stride: u32, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdDrawMeshTasksIndirectCountEXT = unsafe extern "system" fn( + command_buffer: CommandBuffer, + buffer: Buffer, + offset: DeviceSize, + count_buffer: Buffer, + count_buffer_offset: DeviceSize, + max_draw_count: u32, + stride: u32, +); +#[derive(Clone)] +pub struct ExtMeshShaderFn { + pub cmd_draw_mesh_tasks_ext: PFN_vkCmdDrawMeshTasksEXT, + pub cmd_draw_mesh_tasks_indirect_ext: PFN_vkCmdDrawMeshTasksIndirectEXT, + pub cmd_draw_mesh_tasks_indirect_count_ext: PFN_vkCmdDrawMeshTasksIndirectCountEXT, +} +unsafe impl Send for ExtMeshShaderFn {} +unsafe impl Sync for ExtMeshShaderFn {} +impl ExtMeshShaderFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + cmd_draw_mesh_tasks_ext: unsafe { + unsafe extern "system" fn cmd_draw_mesh_tasks_ext( + _command_buffer: CommandBuffer, + _group_count_x: u32, + _group_count_y: u32, + _group_count_z: u32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_draw_mesh_tasks_ext) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdDrawMeshTasksEXT\0"); + let val = _f(cname); + if val.is_null() { + cmd_draw_mesh_tasks_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_draw_mesh_tasks_indirect_ext: unsafe { + unsafe extern "system" fn cmd_draw_mesh_tasks_indirect_ext( + _command_buffer: CommandBuffer, + _buffer: Buffer, + _offset: DeviceSize, + _draw_count: u32, + _stride: u32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_draw_mesh_tasks_indirect_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdDrawMeshTasksIndirectEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_draw_mesh_tasks_indirect_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_draw_mesh_tasks_indirect_count_ext: unsafe { + unsafe extern "system" fn cmd_draw_mesh_tasks_indirect_count_ext( + _command_buffer: CommandBuffer, + _buffer: Buffer, + _offset: DeviceSize, + _count_buffer: Buffer, + _count_buffer_offset: DeviceSize, + _max_draw_count: u32, + _stride: u32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_draw_mesh_tasks_indirect_count_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdDrawMeshTasksIndirectCountEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_draw_mesh_tasks_indirect_count_ext + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_EXT_mesh_shader'"] +impl IndirectCommandsTokenTypeNV { + pub const DRAW_MESH_TASKS: Self = Self(1_000_328_000); +} +#[doc = "Generated from 'VK_EXT_mesh_shader'"] +impl PipelineStageFlags { + pub const TASK_SHADER_EXT: Self = Self(0b1000_0000_0000_0000_0000); + pub const MESH_SHADER_EXT: Self = Self(0b1_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_EXT_mesh_shader'"] +impl QueryPipelineStatisticFlags { + pub const TASK_SHADER_INVOCATIONS_EXT: Self = Self(0b1000_0000_0000); + pub const MESH_SHADER_INVOCATIONS_EXT: Self = Self(0b1_0000_0000_0000); +} +#[doc = "Generated from 'VK_EXT_mesh_shader'"] +impl QueryType { + pub const MESH_PRIMITIVES_GENERATED_EXT: Self = Self(1_000_328_000); +} +#[doc = "Generated from 'VK_EXT_mesh_shader'"] +impl ShaderStageFlags { + pub const TASK_EXT: Self = Self(0b100_0000); + pub const MESH_EXT: Self = Self(0b1000_0000); +} +#[doc = "Generated from 'VK_EXT_mesh_shader'"] +impl StructureType { + pub const PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT: Self = Self(1_000_328_000); + pub const PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT: Self = Self(1_000_328_001); +} +impl NvExtension330Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_330\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct NvExtension330Fn {} +unsafe impl Send for NvExtension330Fn {} +unsafe impl Sync for NvExtension330Fn {} +impl NvExtension330Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtYcbcr2plane444FormatsFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_ycbcr_2plane_444_formats\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct ExtYcbcr2plane444FormatsFn {} +unsafe impl Send for ExtYcbcr2plane444FormatsFn {} +unsafe impl Sync for ExtYcbcr2plane444FormatsFn {} +impl ExtYcbcr2plane444FormatsFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_ycbcr_2plane_444_formats'"] +impl Format { + pub const G8_B8R8_2PLANE_444_UNORM_EXT: Self = Self::G8_B8R8_2PLANE_444_UNORM; + pub const G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16_EXT: Self = + Self::G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16; + pub const G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16_EXT: Self = + Self::G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16; + pub const G16_B16R16_2PLANE_444_UNORM_EXT: Self = Self::G16_B16R16_2PLANE_444_UNORM; +} +#[doc = "Generated from 'VK_EXT_ycbcr_2plane_444_formats'"] +impl StructureType { + pub const PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT: Self = Self(1_000_330_000); +} +impl NvExtension332Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_332\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct NvExtension332Fn {} +unsafe impl Send for NvExtension332Fn {} +unsafe impl Sync for NvExtension332Fn {} +impl NvExtension332Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtFragmentDensityMap2Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_fragment_density_map2\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct ExtFragmentDensityMap2Fn {} +unsafe impl Send for ExtFragmentDensityMap2Fn {} +unsafe impl Sync for ExtFragmentDensityMap2Fn {} +impl ExtFragmentDensityMap2Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_fragment_density_map2'"] +impl ImageViewCreateFlags { + pub const FRAGMENT_DENSITY_MAP_DEFERRED_EXT: Self = Self(0b10); +} +#[doc = "Generated from 'VK_EXT_fragment_density_map2'"] +impl StructureType { + pub const PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT: Self = Self(1_000_332_000); + pub const PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT: Self = Self(1_000_332_001); +} +impl QcomRotatedCopyCommandsFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_QCOM_rotated_copy_commands\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct QcomRotatedCopyCommandsFn {} +unsafe impl Send for QcomRotatedCopyCommandsFn {} +unsafe impl Sync for QcomRotatedCopyCommandsFn {} +impl QcomRotatedCopyCommandsFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_QCOM_rotated_copy_commands'"] +impl StructureType { + pub const COPY_COMMAND_TRANSFORM_INFO_QCOM: Self = Self(1_000_333_000); +} +impl KhrExtension335Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_extension_335\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct KhrExtension335Fn {} +unsafe impl Send for KhrExtension335Fn {} +unsafe impl Sync for KhrExtension335Fn {} +impl KhrExtension335Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtImageRobustnessFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_image_robustness\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct ExtImageRobustnessFn {} +unsafe impl Send for ExtImageRobustnessFn {} +unsafe impl Sync for ExtImageRobustnessFn {} +impl ExtImageRobustnessFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_image_robustness'"] +impl StructureType { + pub const PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES_EXT: Self = + Self::PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES; +} +impl KhrWorkgroupMemoryExplicitLayoutFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"VK_KHR_workgroup_memory_explicit_layout\0", + ) + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct KhrWorkgroupMemoryExplicitLayoutFn {} +unsafe impl Send for KhrWorkgroupMemoryExplicitLayoutFn {} +unsafe impl Sync for KhrWorkgroupMemoryExplicitLayoutFn {} +impl KhrWorkgroupMemoryExplicitLayoutFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_KHR_workgroup_memory_explicit_layout'"] +impl StructureType { + pub const PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR: Self = + Self(1_000_336_000); +} +impl KhrCopyCommands2Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_copy_commands2\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkCmdCopyBuffer2 = unsafe extern "system" fn( + command_buffer: CommandBuffer, + p_copy_buffer_info: *const CopyBufferInfo2, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdCopyImage2 = unsafe extern "system" fn( + command_buffer: CommandBuffer, + p_copy_image_info: *const CopyImageInfo2, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdCopyBufferToImage2 = unsafe extern "system" fn( + command_buffer: CommandBuffer, + p_copy_buffer_to_image_info: *const CopyBufferToImageInfo2, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdCopyImageToBuffer2 = unsafe extern "system" fn( + command_buffer: CommandBuffer, + p_copy_image_to_buffer_info: *const CopyImageToBufferInfo2, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdBlitImage2 = unsafe extern "system" fn( + command_buffer: CommandBuffer, + p_blit_image_info: *const BlitImageInfo2, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdResolveImage2 = unsafe extern "system" fn( + command_buffer: CommandBuffer, + p_resolve_image_info: *const ResolveImageInfo2, +); +#[derive(Clone)] +pub struct KhrCopyCommands2Fn { + pub cmd_copy_buffer2_khr: PFN_vkCmdCopyBuffer2, + pub cmd_copy_image2_khr: PFN_vkCmdCopyImage2, + pub cmd_copy_buffer_to_image2_khr: PFN_vkCmdCopyBufferToImage2, + pub cmd_copy_image_to_buffer2_khr: PFN_vkCmdCopyImageToBuffer2, + pub cmd_blit_image2_khr: PFN_vkCmdBlitImage2, + pub cmd_resolve_image2_khr: PFN_vkCmdResolveImage2, +} +unsafe impl Send for KhrCopyCommands2Fn {} +unsafe impl Sync for KhrCopyCommands2Fn {} +impl KhrCopyCommands2Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + cmd_copy_buffer2_khr: unsafe { + unsafe extern "system" fn cmd_copy_buffer2_khr( + _command_buffer: CommandBuffer, + _p_copy_buffer_info: *const CopyBufferInfo2, + ) { + panic!(concat!("Unable to load ", stringify!(cmd_copy_buffer2_khr))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdCopyBuffer2KHR\0"); + let val = _f(cname); + if val.is_null() { + cmd_copy_buffer2_khr + } else { + ::std::mem::transmute(val) + } + }, + cmd_copy_image2_khr: unsafe { + unsafe extern "system" fn cmd_copy_image2_khr( + _command_buffer: CommandBuffer, + _p_copy_image_info: *const CopyImageInfo2, + ) { + panic!(concat!("Unable to load ", stringify!(cmd_copy_image2_khr))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdCopyImage2KHR\0"); + let val = _f(cname); + if val.is_null() { + cmd_copy_image2_khr + } else { + ::std::mem::transmute(val) + } + }, + cmd_copy_buffer_to_image2_khr: unsafe { + unsafe extern "system" fn cmd_copy_buffer_to_image2_khr( + _command_buffer: CommandBuffer, + _p_copy_buffer_to_image_info: *const CopyBufferToImageInfo2, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_copy_buffer_to_image2_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdCopyBufferToImage2KHR\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_copy_buffer_to_image2_khr + } else { + ::std::mem::transmute(val) + } + }, + cmd_copy_image_to_buffer2_khr: unsafe { + unsafe extern "system" fn cmd_copy_image_to_buffer2_khr( + _command_buffer: CommandBuffer, + _p_copy_image_to_buffer_info: *const CopyImageToBufferInfo2, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_copy_image_to_buffer2_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdCopyImageToBuffer2KHR\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_copy_image_to_buffer2_khr + } else { + ::std::mem::transmute(val) + } + }, + cmd_blit_image2_khr: unsafe { + unsafe extern "system" fn cmd_blit_image2_khr( + _command_buffer: CommandBuffer, + _p_blit_image_info: *const BlitImageInfo2, + ) { + panic!(concat!("Unable to load ", stringify!(cmd_blit_image2_khr))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdBlitImage2KHR\0"); + let val = _f(cname); + if val.is_null() { + cmd_blit_image2_khr + } else { + ::std::mem::transmute(val) + } + }, + cmd_resolve_image2_khr: unsafe { + unsafe extern "system" fn cmd_resolve_image2_khr( + _command_buffer: CommandBuffer, + _p_resolve_image_info: *const ResolveImageInfo2, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_resolve_image2_khr) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdResolveImage2KHR\0"); + let val = _f(cname); + if val.is_null() { + cmd_resolve_image2_khr + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_KHR_copy_commands2'"] +impl StructureType { + pub const COPY_BUFFER_INFO_2_KHR: Self = Self::COPY_BUFFER_INFO_2; + pub const COPY_IMAGE_INFO_2_KHR: Self = Self::COPY_IMAGE_INFO_2; + pub const COPY_BUFFER_TO_IMAGE_INFO_2_KHR: Self = Self::COPY_BUFFER_TO_IMAGE_INFO_2; + pub const COPY_IMAGE_TO_BUFFER_INFO_2_KHR: Self = Self::COPY_IMAGE_TO_BUFFER_INFO_2; + pub const BLIT_IMAGE_INFO_2_KHR: Self = Self::BLIT_IMAGE_INFO_2; + pub const RESOLVE_IMAGE_INFO_2_KHR: Self = Self::RESOLVE_IMAGE_INFO_2; + pub const BUFFER_COPY_2_KHR: Self = Self::BUFFER_COPY_2; + pub const IMAGE_COPY_2_KHR: Self = Self::IMAGE_COPY_2; + pub const IMAGE_BLIT_2_KHR: Self = Self::IMAGE_BLIT_2; + pub const BUFFER_IMAGE_COPY_2_KHR: Self = Self::BUFFER_IMAGE_COPY_2; + pub const IMAGE_RESOLVE_2_KHR: Self = Self::IMAGE_RESOLVE_2; +} +impl ExtImageCompressionControlFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_image_compression_control\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkGetImageSubresourceLayout2EXT = unsafe extern "system" fn( + device: Device, + image: Image, + p_subresource: *const ImageSubresource2EXT, + p_layout: *mut SubresourceLayout2EXT, +); +#[derive(Clone)] +pub struct ExtImageCompressionControlFn { + pub get_image_subresource_layout2_ext: PFN_vkGetImageSubresourceLayout2EXT, +} +unsafe impl Send for ExtImageCompressionControlFn {} +unsafe impl Sync for ExtImageCompressionControlFn {} +impl ExtImageCompressionControlFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + get_image_subresource_layout2_ext: unsafe { + unsafe extern "system" fn get_image_subresource_layout2_ext( + _device: Device, + _image: Image, + _p_subresource: *const ImageSubresource2EXT, + _p_layout: *mut SubresourceLayout2EXT, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_image_subresource_layout2_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetImageSubresourceLayout2EXT\0", + ); + let val = _f(cname); + if val.is_null() { + get_image_subresource_layout2_ext + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_EXT_image_compression_control'"] +impl Result { + pub const ERROR_COMPRESSION_EXHAUSTED_EXT: Self = Self(-1_000_338_000); +} +#[doc = "Generated from 'VK_EXT_image_compression_control'"] +impl StructureType { + pub const PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT: Self = Self(1_000_338_000); + pub const IMAGE_COMPRESSION_CONTROL_EXT: Self = Self(1_000_338_001); + pub const SUBRESOURCE_LAYOUT_2_EXT: Self = Self(1_000_338_002); + pub const IMAGE_SUBRESOURCE_2_EXT: Self = Self(1_000_338_003); + pub const IMAGE_COMPRESSION_PROPERTIES_EXT: Self = Self(1_000_338_004); +} +impl ExtAttachmentFeedbackLoopLayoutFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"VK_EXT_attachment_feedback_loop_layout\0", + ) + } + } + pub const SPEC_VERSION: u32 = 2u32; +} +#[derive(Clone)] +pub struct ExtAttachmentFeedbackLoopLayoutFn {} +unsafe impl Send for ExtAttachmentFeedbackLoopLayoutFn {} +unsafe impl Sync for ExtAttachmentFeedbackLoopLayoutFn {} +impl ExtAttachmentFeedbackLoopLayoutFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_attachment_feedback_loop_layout'"] +impl DependencyFlags { + #[doc = "Dependency may be a feedback loop"] + pub const FEEDBACK_LOOP_EXT: Self = Self(0b1000); +} +#[doc = "Generated from 'VK_EXT_attachment_feedback_loop_layout'"] +impl ImageLayout { + pub const ATTACHMENT_FEEDBACK_LOOP_OPTIMAL_EXT: Self = Self(1_000_339_000); +} +#[doc = "Generated from 'VK_EXT_attachment_feedback_loop_layout'"] +impl ImageUsageFlags { + pub const ATTACHMENT_FEEDBACK_LOOP_EXT: Self = Self(0b1000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_EXT_attachment_feedback_loop_layout'"] +impl PipelineCreateFlags { + pub const COLOR_ATTACHMENT_FEEDBACK_LOOP_EXT: Self = Self(0b10_0000_0000_0000_0000_0000_0000); + pub const DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP_EXT: Self = + Self(0b100_0000_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_EXT_attachment_feedback_loop_layout'"] +impl StructureType { + pub const PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT: Self = + Self(1_000_339_000); +} +impl Ext4444FormatsFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_4444_formats\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct Ext4444FormatsFn {} +unsafe impl Send for Ext4444FormatsFn {} +unsafe impl Sync for Ext4444FormatsFn {} +impl Ext4444FormatsFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_4444_formats'"] +impl Format { + pub const A4R4G4B4_UNORM_PACK16_EXT: Self = Self::A4R4G4B4_UNORM_PACK16; + pub const A4B4G4R4_UNORM_PACK16_EXT: Self = Self::A4B4G4R4_UNORM_PACK16; +} +#[doc = "Generated from 'VK_EXT_4444_formats'"] +impl StructureType { + pub const PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT: Self = Self(1_000_340_000); +} +impl ExtDeviceFaultFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_device_fault\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkGetDeviceFaultInfoEXT = unsafe extern "system" fn( + device: Device, + p_fault_counts: *mut DeviceFaultCountsEXT, + p_fault_info: *mut DeviceFaultInfoEXT, +) -> Result; +#[derive(Clone)] +pub struct ExtDeviceFaultFn { + pub get_device_fault_info_ext: PFN_vkGetDeviceFaultInfoEXT, +} +unsafe impl Send for ExtDeviceFaultFn {} +unsafe impl Sync for ExtDeviceFaultFn {} +impl ExtDeviceFaultFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + get_device_fault_info_ext: unsafe { + unsafe extern "system" fn get_device_fault_info_ext( + _device: Device, + _p_fault_counts: *mut DeviceFaultCountsEXT, + _p_fault_info: *mut DeviceFaultInfoEXT, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_device_fault_info_ext) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetDeviceFaultInfoEXT\0"); + let val = _f(cname); + if val.is_null() { + get_device_fault_info_ext + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_EXT_device_fault'"] +impl StructureType { + pub const PHYSICAL_DEVICE_FAULT_FEATURES_EXT: Self = Self(1_000_341_000); + pub const DEVICE_FAULT_COUNTS_EXT: Self = Self(1_000_341_001); + pub const DEVICE_FAULT_INFO_EXT: Self = Self(1_000_341_002); +} +impl ArmRasterizationOrderAttachmentAccessFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"VK_ARM_rasterization_order_attachment_access\0", + ) + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct ArmRasterizationOrderAttachmentAccessFn {} +unsafe impl Send for ArmRasterizationOrderAttachmentAccessFn {} +unsafe impl Sync for ArmRasterizationOrderAttachmentAccessFn {} +impl ArmRasterizationOrderAttachmentAccessFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_ARM_rasterization_order_attachment_access'"] +impl PipelineColorBlendStateCreateFlags { + pub const RASTERIZATION_ORDER_ATTACHMENT_ACCESS_ARM: Self = + Self::RASTERIZATION_ORDER_ATTACHMENT_ACCESS_EXT; +} +#[doc = "Generated from 'VK_ARM_rasterization_order_attachment_access'"] +impl PipelineDepthStencilStateCreateFlags { + pub const RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_ARM: Self = + Self::RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_EXT; + pub const RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_ARM: Self = + Self::RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_EXT; +} +#[doc = "Generated from 'VK_ARM_rasterization_order_attachment_access'"] +impl StructureType { + pub const PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_ARM: Self = + Self::PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT; +} +#[doc = "Generated from 'VK_ARM_rasterization_order_attachment_access'"] +impl SubpassDescriptionFlags { + pub const RASTERIZATION_ORDER_ATTACHMENT_COLOR_ACCESS_ARM: Self = + Self::RASTERIZATION_ORDER_ATTACHMENT_COLOR_ACCESS_EXT; + pub const RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_ARM: Self = + Self::RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_EXT; + pub const RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_ARM: Self = + Self::RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_EXT; +} +impl ArmExtension344Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_ARM_extension_344\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct ArmExtension344Fn {} +unsafe impl Send for ArmExtension344Fn {} +unsafe impl Sync for ArmExtension344Fn {} +impl ArmExtension344Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtRgba10x6FormatsFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_rgba10x6_formats\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct ExtRgba10x6FormatsFn {} +unsafe impl Send for ExtRgba10x6FormatsFn {} +unsafe impl Sync for ExtRgba10x6FormatsFn {} +impl ExtRgba10x6FormatsFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_rgba10x6_formats'"] +impl StructureType { + pub const PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT: Self = Self(1_000_344_000); +} +impl NvAcquireWinrtDisplayFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_acquire_winrt_display\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkAcquireWinrtDisplayNV = + unsafe extern "system" fn(physical_device: PhysicalDevice, display: DisplayKHR) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetWinrtDisplayNV = unsafe extern "system" fn( + physical_device: PhysicalDevice, + device_relative_id: u32, + p_display: *mut DisplayKHR, +) -> Result; +#[derive(Clone)] +pub struct NvAcquireWinrtDisplayFn { + pub acquire_winrt_display_nv: PFN_vkAcquireWinrtDisplayNV, + pub get_winrt_display_nv: PFN_vkGetWinrtDisplayNV, +} +unsafe impl Send for NvAcquireWinrtDisplayFn {} +unsafe impl Sync for NvAcquireWinrtDisplayFn {} +impl NvAcquireWinrtDisplayFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + acquire_winrt_display_nv: unsafe { + unsafe extern "system" fn acquire_winrt_display_nv( + _physical_device: PhysicalDevice, + _display: DisplayKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(acquire_winrt_display_nv) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkAcquireWinrtDisplayNV\0"); + let val = _f(cname); + if val.is_null() { + acquire_winrt_display_nv + } else { + ::std::mem::transmute(val) + } + }, + get_winrt_display_nv: unsafe { + unsafe extern "system" fn get_winrt_display_nv( + _physical_device: PhysicalDevice, + _device_relative_id: u32, + _p_display: *mut DisplayKHR, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(get_winrt_display_nv))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetWinrtDisplayNV\0"); + let val = _f(cname); + if val.is_null() { + get_winrt_display_nv + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +impl ExtDirectfbSurfaceFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_directfb_surface\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkCreateDirectFBSurfaceEXT = unsafe extern "system" fn( + instance: Instance, + p_create_info: *const DirectFBSurfaceCreateInfoEXT, + p_allocator: *const AllocationCallbacks, + p_surface: *mut SurfaceKHR, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetPhysicalDeviceDirectFBPresentationSupportEXT = + unsafe extern "system" fn( + physical_device: PhysicalDevice, + queue_family_index: u32, + dfb: *mut IDirectFB, + ) -> Bool32; +#[derive(Clone)] +pub struct ExtDirectfbSurfaceFn { + pub create_direct_fb_surface_ext: PFN_vkCreateDirectFBSurfaceEXT, + pub get_physical_device_direct_fb_presentation_support_ext: + PFN_vkGetPhysicalDeviceDirectFBPresentationSupportEXT, +} +unsafe impl Send for ExtDirectfbSurfaceFn {} +unsafe impl Sync for ExtDirectfbSurfaceFn {} +impl ExtDirectfbSurfaceFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + create_direct_fb_surface_ext: unsafe { + unsafe extern "system" fn create_direct_fb_surface_ext( + _instance: Instance, + _p_create_info: *const DirectFBSurfaceCreateInfoEXT, + _p_allocator: *const AllocationCallbacks, + _p_surface: *mut SurfaceKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(create_direct_fb_surface_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCreateDirectFBSurfaceEXT\0", + ); + let val = _f(cname); + if val.is_null() { + create_direct_fb_surface_ext + } else { + ::std::mem::transmute(val) + } + }, + get_physical_device_direct_fb_presentation_support_ext: unsafe { + unsafe extern "system" fn get_physical_device_direct_fb_presentation_support_ext( + _physical_device: PhysicalDevice, + _queue_family_index: u32, + _dfb: *mut IDirectFB, + ) -> Bool32 { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_direct_fb_presentation_support_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPhysicalDeviceDirectFBPresentationSupportEXT\0", + ); + let val = _f(cname); + if val.is_null() { + get_physical_device_direct_fb_presentation_support_ext + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_EXT_directfb_surface'"] +impl StructureType { + pub const DIRECTFB_SURFACE_CREATE_INFO_EXT: Self = Self(1_000_346_000); +} +impl KhrExtension350Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_extension_350\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct KhrExtension350Fn {} +unsafe impl Send for KhrExtension350Fn {} +unsafe impl Sync for KhrExtension350Fn {} +impl KhrExtension350Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl NvExtension351Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_351\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct NvExtension351Fn {} +unsafe impl Send for NvExtension351Fn {} +unsafe impl Sync for NvExtension351Fn {} +impl NvExtension351Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ValveMutableDescriptorTypeFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_VALVE_mutable_descriptor_type\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct ValveMutableDescriptorTypeFn {} +unsafe impl Send for ValveMutableDescriptorTypeFn {} +unsafe impl Sync for ValveMutableDescriptorTypeFn {} +impl ValveMutableDescriptorTypeFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_VALVE_mutable_descriptor_type'"] +impl DescriptorPoolCreateFlags { + pub const HOST_ONLY_VALVE: Self = Self::HOST_ONLY_EXT; +} +#[doc = "Generated from 'VK_VALVE_mutable_descriptor_type'"] +impl DescriptorSetLayoutCreateFlags { + pub const HOST_ONLY_POOL_VALVE: Self = Self::HOST_ONLY_POOL_EXT; +} +#[doc = "Generated from 'VK_VALVE_mutable_descriptor_type'"] +impl DescriptorType { + pub const MUTABLE_VALVE: Self = Self::MUTABLE_EXT; +} +#[doc = "Generated from 'VK_VALVE_mutable_descriptor_type'"] +impl StructureType { + pub const PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_VALVE: Self = + Self::PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT; + pub const MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_VALVE: Self = + Self::MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT; +} +impl ExtVertexInputDynamicStateFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_vertex_input_dynamic_state\0") + } + } + pub const SPEC_VERSION: u32 = 2u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetVertexInputEXT = unsafe extern "system" fn( + command_buffer: CommandBuffer, + vertex_binding_description_count: u32, + p_vertex_binding_descriptions: *const VertexInputBindingDescription2EXT, + vertex_attribute_description_count: u32, + p_vertex_attribute_descriptions: *const VertexInputAttributeDescription2EXT, +); +#[derive(Clone)] +pub struct ExtVertexInputDynamicStateFn { + pub cmd_set_vertex_input_ext: PFN_vkCmdSetVertexInputEXT, +} +unsafe impl Send for ExtVertexInputDynamicStateFn {} +unsafe impl Sync for ExtVertexInputDynamicStateFn {} +impl ExtVertexInputDynamicStateFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + cmd_set_vertex_input_ext: unsafe { + unsafe extern "system" fn cmd_set_vertex_input_ext( + _command_buffer: CommandBuffer, + _vertex_binding_description_count: u32, + _p_vertex_binding_descriptions: *const VertexInputBindingDescription2EXT, + _vertex_attribute_description_count: u32, + _p_vertex_attribute_descriptions: *const VertexInputAttributeDescription2EXT, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_vertex_input_ext) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetVertexInputEXT\0"); + let val = _f(cname); + if val.is_null() { + cmd_set_vertex_input_ext + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_EXT_vertex_input_dynamic_state'"] +impl DynamicState { + pub const VERTEX_INPUT_EXT: Self = Self(1_000_352_000); +} +#[doc = "Generated from 'VK_EXT_vertex_input_dynamic_state'"] +impl StructureType { + pub const PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT: Self = Self(1_000_352_000); + pub const VERTEX_INPUT_BINDING_DESCRIPTION_2_EXT: Self = Self(1_000_352_001); + pub const VERTEX_INPUT_ATTRIBUTE_DESCRIPTION_2_EXT: Self = Self(1_000_352_002); +} +impl ExtPhysicalDeviceDrmFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_physical_device_drm\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct ExtPhysicalDeviceDrmFn {} +unsafe impl Send for ExtPhysicalDeviceDrmFn {} +unsafe impl Sync for ExtPhysicalDeviceDrmFn {} +impl ExtPhysicalDeviceDrmFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_physical_device_drm'"] +impl StructureType { + pub const PHYSICAL_DEVICE_DRM_PROPERTIES_EXT: Self = Self(1_000_353_000); +} +impl ExtDeviceAddressBindingReportFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"VK_EXT_device_address_binding_report\0", + ) + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct ExtDeviceAddressBindingReportFn {} +unsafe impl Send for ExtDeviceAddressBindingReportFn {} +unsafe impl Sync for ExtDeviceAddressBindingReportFn {} +impl ExtDeviceAddressBindingReportFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_device_address_binding_report'"] +impl DebugUtilsMessageTypeFlagsEXT { + pub const DEVICE_ADDRESS_BINDING: Self = Self(0b1000); +} +#[doc = "Generated from 'VK_EXT_device_address_binding_report'"] +impl StructureType { + pub const PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT: Self = Self(1_000_354_000); + pub const DEVICE_ADDRESS_BINDING_CALLBACK_DATA_EXT: Self = Self(1_000_354_001); +} +impl ExtDepthClipControlFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_depth_clip_control\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct ExtDepthClipControlFn {} +unsafe impl Send for ExtDepthClipControlFn {} +unsafe impl Sync for ExtDepthClipControlFn {} +impl ExtDepthClipControlFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_depth_clip_control'"] +impl StructureType { + pub const PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT: Self = Self(1_000_355_000); + pub const PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT: Self = Self(1_000_355_001); +} +impl ExtPrimitiveTopologyListRestartFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"VK_EXT_primitive_topology_list_restart\0", + ) + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct ExtPrimitiveTopologyListRestartFn {} +unsafe impl Send for ExtPrimitiveTopologyListRestartFn {} +unsafe impl Sync for ExtPrimitiveTopologyListRestartFn {} +impl ExtPrimitiveTopologyListRestartFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_primitive_topology_list_restart'"] +impl StructureType { + pub const PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT: Self = + Self(1_000_356_000); +} +impl KhrExtension358Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_extension_358\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct KhrExtension358Fn {} +unsafe impl Send for KhrExtension358Fn {} +unsafe impl Sync for KhrExtension358Fn {} +impl KhrExtension358Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtExtension359Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_359\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct ExtExtension359Fn {} +unsafe impl Send for ExtExtension359Fn {} +unsafe impl Sync for ExtExtension359Fn {} +impl ExtExtension359Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtExtension360Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_360\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct ExtExtension360Fn {} +unsafe impl Send for ExtExtension360Fn {} +unsafe impl Sync for ExtExtension360Fn {} +impl ExtExtension360Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl KhrFormatFeatureFlags2Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_format_feature_flags2\0") + } + } + pub const SPEC_VERSION: u32 = 2u32; +} +#[derive(Clone)] +pub struct KhrFormatFeatureFlags2Fn {} +unsafe impl Send for KhrFormatFeatureFlags2Fn {} +unsafe impl Sync for KhrFormatFeatureFlags2Fn {} +impl KhrFormatFeatureFlags2Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_KHR_format_feature_flags2'"] +impl StructureType { + pub const FORMAT_PROPERTIES_3_KHR: Self = Self::FORMAT_PROPERTIES_3; +} +impl ExtExtension362Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_362\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct ExtExtension362Fn {} +unsafe impl Send for ExtExtension362Fn {} +unsafe impl Sync for ExtExtension362Fn {} +impl ExtExtension362Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtExtension363Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_363\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct ExtExtension363Fn {} +unsafe impl Send for ExtExtension363Fn {} +unsafe impl Sync for ExtExtension363Fn {} +impl ExtExtension363Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl FuchsiaExtension364Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_FUCHSIA_extension_364\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct FuchsiaExtension364Fn {} +unsafe impl Send for FuchsiaExtension364Fn {} +unsafe impl Sync for FuchsiaExtension364Fn {} +impl FuchsiaExtension364Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl FuchsiaExternalMemoryFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_FUCHSIA_external_memory\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkGetMemoryZirconHandleFUCHSIA = unsafe extern "system" fn( + device: Device, + p_get_zircon_handle_info: *const MemoryGetZirconHandleInfoFUCHSIA, + p_zircon_handle: *mut zx_handle_t, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetMemoryZirconHandlePropertiesFUCHSIA = unsafe extern "system" fn( + device: Device, + handle_type: ExternalMemoryHandleTypeFlags, + zircon_handle: zx_handle_t, + p_memory_zircon_handle_properties: *mut MemoryZirconHandlePropertiesFUCHSIA, +) -> Result; +#[derive(Clone)] +pub struct FuchsiaExternalMemoryFn { + pub get_memory_zircon_handle_fuchsia: PFN_vkGetMemoryZirconHandleFUCHSIA, + pub get_memory_zircon_handle_properties_fuchsia: PFN_vkGetMemoryZirconHandlePropertiesFUCHSIA, +} +unsafe impl Send for FuchsiaExternalMemoryFn {} +unsafe impl Sync for FuchsiaExternalMemoryFn {} +impl FuchsiaExternalMemoryFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + get_memory_zircon_handle_fuchsia: unsafe { + unsafe extern "system" fn get_memory_zircon_handle_fuchsia( + _device: Device, + _p_get_zircon_handle_info: *const MemoryGetZirconHandleInfoFUCHSIA, + _p_zircon_handle: *mut zx_handle_t, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_memory_zircon_handle_fuchsia) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetMemoryZirconHandleFUCHSIA\0", + ); + let val = _f(cname); + if val.is_null() { + get_memory_zircon_handle_fuchsia + } else { + ::std::mem::transmute(val) + } + }, + get_memory_zircon_handle_properties_fuchsia: unsafe { + unsafe extern "system" fn get_memory_zircon_handle_properties_fuchsia( + _device: Device, + _handle_type: ExternalMemoryHandleTypeFlags, + _zircon_handle: zx_handle_t, + _p_memory_zircon_handle_properties: *mut MemoryZirconHandlePropertiesFUCHSIA, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_memory_zircon_handle_properties_fuchsia) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetMemoryZirconHandlePropertiesFUCHSIA\0", + ); + let val = _f(cname); + if val.is_null() { + get_memory_zircon_handle_properties_fuchsia + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_FUCHSIA_external_memory'"] +impl ExternalMemoryHandleTypeFlags { + pub const ZIRCON_VMO_FUCHSIA: Self = Self(0b1000_0000_0000); +} +#[doc = "Generated from 'VK_FUCHSIA_external_memory'"] +impl StructureType { + pub const IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA: Self = Self(1_000_364_000); + pub const MEMORY_ZIRCON_HANDLE_PROPERTIES_FUCHSIA: Self = Self(1_000_364_001); + pub const MEMORY_GET_ZIRCON_HANDLE_INFO_FUCHSIA: Self = Self(1_000_364_002); +} +impl FuchsiaExternalSemaphoreFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_FUCHSIA_external_semaphore\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkImportSemaphoreZirconHandleFUCHSIA = unsafe extern "system" fn( + device: Device, + p_import_semaphore_zircon_handle_info: *const ImportSemaphoreZirconHandleInfoFUCHSIA, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetSemaphoreZirconHandleFUCHSIA = unsafe extern "system" fn( + device: Device, + p_get_zircon_handle_info: *const SemaphoreGetZirconHandleInfoFUCHSIA, + p_zircon_handle: *mut zx_handle_t, +) -> Result; +#[derive(Clone)] +pub struct FuchsiaExternalSemaphoreFn { + pub import_semaphore_zircon_handle_fuchsia: PFN_vkImportSemaphoreZirconHandleFUCHSIA, + pub get_semaphore_zircon_handle_fuchsia: PFN_vkGetSemaphoreZirconHandleFUCHSIA, +} +unsafe impl Send for FuchsiaExternalSemaphoreFn {} +unsafe impl Sync for FuchsiaExternalSemaphoreFn {} +impl FuchsiaExternalSemaphoreFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + import_semaphore_zircon_handle_fuchsia: unsafe { + unsafe extern "system" fn import_semaphore_zircon_handle_fuchsia( + _device: Device, + _p_import_semaphore_zircon_handle_info : * const ImportSemaphoreZirconHandleInfoFUCHSIA, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(import_semaphore_zircon_handle_fuchsia) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkImportSemaphoreZirconHandleFUCHSIA\0", + ); + let val = _f(cname); + if val.is_null() { + import_semaphore_zircon_handle_fuchsia + } else { + ::std::mem::transmute(val) + } + }, + get_semaphore_zircon_handle_fuchsia: unsafe { + unsafe extern "system" fn get_semaphore_zircon_handle_fuchsia( + _device: Device, + _p_get_zircon_handle_info: *const SemaphoreGetZirconHandleInfoFUCHSIA, + _p_zircon_handle: *mut zx_handle_t, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_semaphore_zircon_handle_fuchsia) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetSemaphoreZirconHandleFUCHSIA\0", + ); + let val = _f(cname); + if val.is_null() { + get_semaphore_zircon_handle_fuchsia + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_FUCHSIA_external_semaphore'"] +impl ExternalSemaphoreHandleTypeFlags { + pub const ZIRCON_EVENT_FUCHSIA: Self = Self(0b1000_0000); +} +#[doc = "Generated from 'VK_FUCHSIA_external_semaphore'"] +impl StructureType { + pub const IMPORT_SEMAPHORE_ZIRCON_HANDLE_INFO_FUCHSIA: Self = Self(1_000_365_000); + pub const SEMAPHORE_GET_ZIRCON_HANDLE_INFO_FUCHSIA: Self = Self(1_000_365_001); +} +impl FuchsiaBufferCollectionFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_FUCHSIA_buffer_collection\0") + } + } + pub const SPEC_VERSION: u32 = 2u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkCreateBufferCollectionFUCHSIA = unsafe extern "system" fn( + device: Device, + p_create_info: *const BufferCollectionCreateInfoFUCHSIA, + p_allocator: *const AllocationCallbacks, + p_collection: *mut BufferCollectionFUCHSIA, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkSetBufferCollectionImageConstraintsFUCHSIA = unsafe extern "system" fn( + device: Device, + collection: BufferCollectionFUCHSIA, + p_image_constraints_info: *const ImageConstraintsInfoFUCHSIA, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkSetBufferCollectionBufferConstraintsFUCHSIA = unsafe extern "system" fn( + device: Device, + collection: BufferCollectionFUCHSIA, + p_buffer_constraints_info: *const BufferConstraintsInfoFUCHSIA, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkDestroyBufferCollectionFUCHSIA = unsafe extern "system" fn( + device: Device, + collection: BufferCollectionFUCHSIA, + p_allocator: *const AllocationCallbacks, +); +#[allow(non_camel_case_types)] +pub type PFN_vkGetBufferCollectionPropertiesFUCHSIA = unsafe extern "system" fn( + device: Device, + collection: BufferCollectionFUCHSIA, + p_properties: *mut BufferCollectionPropertiesFUCHSIA, +) -> Result; +#[derive(Clone)] +pub struct FuchsiaBufferCollectionFn { + pub create_buffer_collection_fuchsia: PFN_vkCreateBufferCollectionFUCHSIA, + pub set_buffer_collection_image_constraints_fuchsia: + PFN_vkSetBufferCollectionImageConstraintsFUCHSIA, + pub set_buffer_collection_buffer_constraints_fuchsia: + PFN_vkSetBufferCollectionBufferConstraintsFUCHSIA, + pub destroy_buffer_collection_fuchsia: PFN_vkDestroyBufferCollectionFUCHSIA, + pub get_buffer_collection_properties_fuchsia: PFN_vkGetBufferCollectionPropertiesFUCHSIA, +} +unsafe impl Send for FuchsiaBufferCollectionFn {} +unsafe impl Sync for FuchsiaBufferCollectionFn {} +impl FuchsiaBufferCollectionFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + create_buffer_collection_fuchsia: unsafe { + unsafe extern "system" fn create_buffer_collection_fuchsia( + _device: Device, + _p_create_info: *const BufferCollectionCreateInfoFUCHSIA, + _p_allocator: *const AllocationCallbacks, + _p_collection: *mut BufferCollectionFUCHSIA, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(create_buffer_collection_fuchsia) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCreateBufferCollectionFUCHSIA\0", + ); + let val = _f(cname); + if val.is_null() { + create_buffer_collection_fuchsia + } else { + ::std::mem::transmute(val) + } + }, + set_buffer_collection_image_constraints_fuchsia: unsafe { + unsafe extern "system" fn set_buffer_collection_image_constraints_fuchsia( + _device: Device, + _collection: BufferCollectionFUCHSIA, + _p_image_constraints_info: *const ImageConstraintsInfoFUCHSIA, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(set_buffer_collection_image_constraints_fuchsia) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkSetBufferCollectionImageConstraintsFUCHSIA\0", + ); + let val = _f(cname); + if val.is_null() { + set_buffer_collection_image_constraints_fuchsia + } else { + ::std::mem::transmute(val) + } + }, + set_buffer_collection_buffer_constraints_fuchsia: unsafe { + unsafe extern "system" fn set_buffer_collection_buffer_constraints_fuchsia( + _device: Device, + _collection: BufferCollectionFUCHSIA, + _p_buffer_constraints_info: *const BufferConstraintsInfoFUCHSIA, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(set_buffer_collection_buffer_constraints_fuchsia) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkSetBufferCollectionBufferConstraintsFUCHSIA\0", + ); + let val = _f(cname); + if val.is_null() { + set_buffer_collection_buffer_constraints_fuchsia + } else { + ::std::mem::transmute(val) + } + }, + destroy_buffer_collection_fuchsia: unsafe { + unsafe extern "system" fn destroy_buffer_collection_fuchsia( + _device: Device, + _collection: BufferCollectionFUCHSIA, + _p_allocator: *const AllocationCallbacks, + ) { + panic!(concat!( + "Unable to load ", + stringify!(destroy_buffer_collection_fuchsia) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkDestroyBufferCollectionFUCHSIA\0", + ); + let val = _f(cname); + if val.is_null() { + destroy_buffer_collection_fuchsia + } else { + ::std::mem::transmute(val) + } + }, + get_buffer_collection_properties_fuchsia: unsafe { + unsafe extern "system" fn get_buffer_collection_properties_fuchsia( + _device: Device, + _collection: BufferCollectionFUCHSIA, + _p_properties: *mut BufferCollectionPropertiesFUCHSIA, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_buffer_collection_properties_fuchsia) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetBufferCollectionPropertiesFUCHSIA\0", + ); + let val = _f(cname); + if val.is_null() { + get_buffer_collection_properties_fuchsia + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_FUCHSIA_buffer_collection'"] +impl DebugReportObjectTypeEXT { + pub const BUFFER_COLLECTION_FUCHSIA: Self = Self(1_000_366_000); +} +#[doc = "Generated from 'VK_FUCHSIA_buffer_collection'"] +impl ObjectType { + #[doc = "VkBufferCollectionFUCHSIA"] + pub const BUFFER_COLLECTION_FUCHSIA: Self = Self(1_000_366_000); +} +#[doc = "Generated from 'VK_FUCHSIA_buffer_collection'"] +impl StructureType { + pub const BUFFER_COLLECTION_CREATE_INFO_FUCHSIA: Self = Self(1_000_366_000); + pub const IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA: Self = Self(1_000_366_001); + pub const BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA: Self = Self(1_000_366_002); + pub const BUFFER_COLLECTION_PROPERTIES_FUCHSIA: Self = Self(1_000_366_003); + pub const BUFFER_CONSTRAINTS_INFO_FUCHSIA: Self = Self(1_000_366_004); + pub const BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA: Self = Self(1_000_366_005); + pub const IMAGE_CONSTRAINTS_INFO_FUCHSIA: Self = Self(1_000_366_006); + pub const IMAGE_FORMAT_CONSTRAINTS_INFO_FUCHSIA: Self = Self(1_000_366_007); + pub const SYSMEM_COLOR_SPACE_FUCHSIA: Self = Self(1_000_366_008); + pub const BUFFER_COLLECTION_CONSTRAINTS_INFO_FUCHSIA: Self = Self(1_000_366_009); +} +impl FuchsiaExtension368Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_FUCHSIA_extension_368\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct FuchsiaExtension368Fn {} +unsafe impl Send for FuchsiaExtension368Fn {} +unsafe impl Sync for FuchsiaExtension368Fn {} +impl FuchsiaExtension368Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl QcomExtension369Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_QCOM_extension_369\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct QcomExtension369Fn {} +unsafe impl Send for QcomExtension369Fn {} +unsafe impl Sync for QcomExtension369Fn {} +impl QcomExtension369Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_QCOM_extension_369'"] +impl DescriptorBindingFlags { + pub const RESERVED_4_QCOM: Self = Self(0b1_0000); +} +impl HuaweiSubpassShadingFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_HUAWEI_subpass_shading\0") } + } + pub const SPEC_VERSION: u32 = 2u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI = unsafe extern "system" fn( + device: Device, + renderpass: RenderPass, + p_max_workgroup_size: *mut Extent2D, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSubpassShadingHUAWEI = unsafe extern "system" fn(command_buffer: CommandBuffer); +#[derive(Clone)] +pub struct HuaweiSubpassShadingFn { + pub get_device_subpass_shading_max_workgroup_size_huawei: + PFN_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI, + pub cmd_subpass_shading_huawei: PFN_vkCmdSubpassShadingHUAWEI, +} +unsafe impl Send for HuaweiSubpassShadingFn {} +unsafe impl Sync for HuaweiSubpassShadingFn {} +impl HuaweiSubpassShadingFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + get_device_subpass_shading_max_workgroup_size_huawei: unsafe { + unsafe extern "system" fn get_device_subpass_shading_max_workgroup_size_huawei( + _device: Device, + _renderpass: RenderPass, + _p_max_workgroup_size: *mut Extent2D, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_device_subpass_shading_max_workgroup_size_huawei) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI\0", + ); + let val = _f(cname); + if val.is_null() { + get_device_subpass_shading_max_workgroup_size_huawei + } else { + ::std::mem::transmute(val) + } + }, + cmd_subpass_shading_huawei: unsafe { + unsafe extern "system" fn cmd_subpass_shading_huawei( + _command_buffer: CommandBuffer, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_subpass_shading_huawei) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSubpassShadingHUAWEI\0"); + let val = _f(cname); + if val.is_null() { + cmd_subpass_shading_huawei + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_HUAWEI_subpass_shading'"] +impl PipelineBindPoint { + pub const SUBPASS_SHADING_HUAWEI: Self = Self(1_000_369_003); +} +#[doc = "Generated from 'VK_HUAWEI_subpass_shading'"] +impl PipelineStageFlags2 { + pub const SUBPASS_SHADING_HUAWEI: Self = + Self(0b1000_0000_0000_0000_0000_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_HUAWEI_subpass_shading'"] +impl ShaderStageFlags { + pub const SUBPASS_SHADING_HUAWEI: Self = Self(0b100_0000_0000_0000); +} +#[doc = "Generated from 'VK_HUAWEI_subpass_shading'"] +impl StructureType { + pub const SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI: Self = Self(1_000_369_000); + pub const PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI: Self = Self(1_000_369_001); + pub const PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI: Self = Self(1_000_369_002); +} +impl HuaweiInvocationMaskFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_HUAWEI_invocation_mask\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkCmdBindInvocationMaskHUAWEI = unsafe extern "system" fn( + command_buffer: CommandBuffer, + image_view: ImageView, + image_layout: ImageLayout, +); +#[derive(Clone)] +pub struct HuaweiInvocationMaskFn { + pub cmd_bind_invocation_mask_huawei: PFN_vkCmdBindInvocationMaskHUAWEI, +} +unsafe impl Send for HuaweiInvocationMaskFn {} +unsafe impl Sync for HuaweiInvocationMaskFn {} +impl HuaweiInvocationMaskFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + cmd_bind_invocation_mask_huawei: unsafe { + unsafe extern "system" fn cmd_bind_invocation_mask_huawei( + _command_buffer: CommandBuffer, + _image_view: ImageView, + _image_layout: ImageLayout, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_bind_invocation_mask_huawei) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdBindInvocationMaskHUAWEI\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_bind_invocation_mask_huawei + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_HUAWEI_invocation_mask'"] +impl AccessFlags2 { + pub const INVOCATION_MASK_READ_HUAWEI: Self = + Self(0b1000_0000_0000_0000_0000_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_HUAWEI_invocation_mask'"] +impl ImageUsageFlags { + pub const INVOCATION_MASK_HUAWEI: Self = Self(0b100_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_HUAWEI_invocation_mask'"] +impl PipelineStageFlags2 { + pub const INVOCATION_MASK_HUAWEI: Self = + Self(0b1_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_HUAWEI_invocation_mask'"] +impl StructureType { + pub const PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI: Self = Self(1_000_370_000); +} +impl NvExternalMemoryRdmaFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_external_memory_rdma\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkGetMemoryRemoteAddressNV = unsafe extern "system" fn( + device: Device, + p_memory_get_remote_address_info: *const MemoryGetRemoteAddressInfoNV, + p_address: *mut RemoteAddressNV, +) -> Result; +#[derive(Clone)] +pub struct NvExternalMemoryRdmaFn { + pub get_memory_remote_address_nv: PFN_vkGetMemoryRemoteAddressNV, +} +unsafe impl Send for NvExternalMemoryRdmaFn {} +unsafe impl Sync for NvExternalMemoryRdmaFn {} +impl NvExternalMemoryRdmaFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + get_memory_remote_address_nv: unsafe { + unsafe extern "system" fn get_memory_remote_address_nv( + _device: Device, + _p_memory_get_remote_address_info: *const MemoryGetRemoteAddressInfoNV, + _p_address: *mut RemoteAddressNV, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_memory_remote_address_nv) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetMemoryRemoteAddressNV\0", + ); + let val = _f(cname); + if val.is_null() { + get_memory_remote_address_nv + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_NV_external_memory_rdma'"] +impl ExternalMemoryHandleTypeFlags { + pub const RDMA_ADDRESS_NV: Self = Self(0b1_0000_0000_0000); +} +#[doc = "Generated from 'VK_NV_external_memory_rdma'"] +impl MemoryPropertyFlags { + pub const RDMA_CAPABLE_NV: Self = Self(0b1_0000_0000); +} +#[doc = "Generated from 'VK_NV_external_memory_rdma'"] +impl StructureType { + pub const MEMORY_GET_REMOTE_ADDRESS_INFO_NV: Self = Self(1_000_371_000); + pub const PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV: Self = Self(1_000_371_001); +} +impl ExtPipelinePropertiesFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_pipeline_properties\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkGetPipelinePropertiesEXT = unsafe extern "system" fn( + device: Device, + p_pipeline_info: *const PipelineInfoEXT, + p_pipeline_properties: *mut BaseOutStructure, +) -> Result; +#[derive(Clone)] +pub struct ExtPipelinePropertiesFn { + pub get_pipeline_properties_ext: PFN_vkGetPipelinePropertiesEXT, +} +unsafe impl Send for ExtPipelinePropertiesFn {} +unsafe impl Sync for ExtPipelinePropertiesFn {} +impl ExtPipelinePropertiesFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + get_pipeline_properties_ext: unsafe { + unsafe extern "system" fn get_pipeline_properties_ext( + _device: Device, + _p_pipeline_info: *const PipelineInfoEXT, + _p_pipeline_properties: *mut BaseOutStructure, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_pipeline_properties_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPipelinePropertiesEXT\0", + ); + let val = _f(cname); + if val.is_null() { + get_pipeline_properties_ext + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_EXT_pipeline_properties'"] +impl StructureType { + pub const PIPELINE_PROPERTIES_IDENTIFIER_EXT: Self = Self(1_000_372_000); + pub const PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT: Self = Self(1_000_372_001); + pub const PIPELINE_INFO_EXT: Self = Self::PIPELINE_INFO_KHR; +} +impl NvExtension374Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_374\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct NvExtension374Fn {} +unsafe impl Send for NvExtension374Fn {} +unsafe impl Sync for NvExtension374Fn {} +impl NvExtension374Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_NV_extension_374'"] +impl ExternalFenceHandleTypeFlags { + pub const RESERVED_4_NV: Self = Self(0b1_0000); + pub const RESERVED_5_NV: Self = Self(0b10_0000); +} +#[doc = "Generated from 'VK_NV_extension_374'"] +impl ExternalSemaphoreHandleTypeFlags { + pub const RESERVED_5_NV: Self = Self(0b10_0000); +} +impl NvExtension375Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_375\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct NvExtension375Fn {} +unsafe impl Send for NvExtension375Fn {} +unsafe impl Sync for NvExtension375Fn {} +impl NvExtension375Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_NV_extension_375'"] +impl ExternalMemoryHandleTypeFlags { + pub const RESERVED_13_NV: Self = Self(0b10_0000_0000_0000); +} +impl ExtExtension376Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_376\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct ExtExtension376Fn {} +unsafe impl Send for ExtExtension376Fn {} +unsafe impl Sync for ExtExtension376Fn {} +impl ExtExtension376Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtMultisampledRenderToSingleSampledFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"VK_EXT_multisampled_render_to_single_sampled\0", + ) + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct ExtMultisampledRenderToSingleSampledFn {} +unsafe impl Send for ExtMultisampledRenderToSingleSampledFn {} +unsafe impl Sync for ExtMultisampledRenderToSingleSampledFn {} +impl ExtMultisampledRenderToSingleSampledFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_multisampled_render_to_single_sampled'"] +impl ImageCreateFlags { + pub const MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_EXT: Self = Self(0b100_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_EXT_multisampled_render_to_single_sampled'"] +impl StructureType { + pub const PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT: Self = + Self(1_000_376_000); + pub const SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT: Self = Self(1_000_376_001); + pub const MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT: Self = Self(1_000_376_002); +} +impl ExtExtendedDynamicState2Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extended_dynamic_state2\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetPatchControlPointsEXT = + unsafe extern "system" fn(command_buffer: CommandBuffer, patch_control_points: u32); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetRasterizerDiscardEnable = + unsafe extern "system" fn(command_buffer: CommandBuffer, rasterizer_discard_enable: Bool32); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetDepthBiasEnable = + unsafe extern "system" fn(command_buffer: CommandBuffer, depth_bias_enable: Bool32); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetLogicOpEXT = + unsafe extern "system" fn(command_buffer: CommandBuffer, logic_op: LogicOp); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetPrimitiveRestartEnable = + unsafe extern "system" fn(command_buffer: CommandBuffer, primitive_restart_enable: Bool32); +#[derive(Clone)] +pub struct ExtExtendedDynamicState2Fn { + pub cmd_set_patch_control_points_ext: PFN_vkCmdSetPatchControlPointsEXT, + pub cmd_set_rasterizer_discard_enable_ext: PFN_vkCmdSetRasterizerDiscardEnable, + pub cmd_set_depth_bias_enable_ext: PFN_vkCmdSetDepthBiasEnable, + pub cmd_set_logic_op_ext: PFN_vkCmdSetLogicOpEXT, + pub cmd_set_primitive_restart_enable_ext: PFN_vkCmdSetPrimitiveRestartEnable, +} +unsafe impl Send for ExtExtendedDynamicState2Fn {} +unsafe impl Sync for ExtExtendedDynamicState2Fn {} +impl ExtExtendedDynamicState2Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + cmd_set_patch_control_points_ext: unsafe { + unsafe extern "system" fn cmd_set_patch_control_points_ext( + _command_buffer: CommandBuffer, + _patch_control_points: u32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_patch_control_points_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetPatchControlPointsEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_patch_control_points_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_rasterizer_discard_enable_ext: unsafe { + unsafe extern "system" fn cmd_set_rasterizer_discard_enable_ext( + _command_buffer: CommandBuffer, + _rasterizer_discard_enable: Bool32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_rasterizer_discard_enable_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetRasterizerDiscardEnableEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_rasterizer_discard_enable_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_depth_bias_enable_ext: unsafe { + unsafe extern "system" fn cmd_set_depth_bias_enable_ext( + _command_buffer: CommandBuffer, + _depth_bias_enable: Bool32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_depth_bias_enable_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetDepthBiasEnableEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_depth_bias_enable_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_logic_op_ext: unsafe { + unsafe extern "system" fn cmd_set_logic_op_ext( + _command_buffer: CommandBuffer, + _logic_op: LogicOp, + ) { + panic!(concat!("Unable to load ", stringify!(cmd_set_logic_op_ext))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetLogicOpEXT\0"); + let val = _f(cname); + if val.is_null() { + cmd_set_logic_op_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_primitive_restart_enable_ext: unsafe { + unsafe extern "system" fn cmd_set_primitive_restart_enable_ext( + _command_buffer: CommandBuffer, + _primitive_restart_enable: Bool32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_primitive_restart_enable_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetPrimitiveRestartEnableEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_primitive_restart_enable_ext + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_EXT_extended_dynamic_state2'"] +impl DynamicState { + #[doc = "Not promoted to 1.3"] + pub const PATCH_CONTROL_POINTS_EXT: Self = Self(1_000_377_000); + pub const RASTERIZER_DISCARD_ENABLE_EXT: Self = Self::RASTERIZER_DISCARD_ENABLE; + pub const DEPTH_BIAS_ENABLE_EXT: Self = Self::DEPTH_BIAS_ENABLE; + #[doc = "Not promoted to 1.3"] + pub const LOGIC_OP_EXT: Self = Self(1_000_377_003); + pub const PRIMITIVE_RESTART_ENABLE_EXT: Self = Self::PRIMITIVE_RESTART_ENABLE; +} +#[doc = "Generated from 'VK_EXT_extended_dynamic_state2'"] +impl StructureType { + #[doc = "Not promoted to 1.3"] + pub const PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT: Self = Self(1_000_377_000); +} +impl QnxScreenSurfaceFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_QNX_screen_surface\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkCreateScreenSurfaceQNX = unsafe extern "system" fn( + instance: Instance, + p_create_info: *const ScreenSurfaceCreateInfoQNX, + p_allocator: *const AllocationCallbacks, + p_surface: *mut SurfaceKHR, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetPhysicalDeviceScreenPresentationSupportQNX = unsafe extern "system" fn( + physical_device: PhysicalDevice, + queue_family_index: u32, + window: *mut _screen_window, +) -> Bool32; +#[derive(Clone)] +pub struct QnxScreenSurfaceFn { + pub create_screen_surface_qnx: PFN_vkCreateScreenSurfaceQNX, + pub get_physical_device_screen_presentation_support_qnx: + PFN_vkGetPhysicalDeviceScreenPresentationSupportQNX, +} +unsafe impl Send for QnxScreenSurfaceFn {} +unsafe impl Sync for QnxScreenSurfaceFn {} +impl QnxScreenSurfaceFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + create_screen_surface_qnx: unsafe { + unsafe extern "system" fn create_screen_surface_qnx( + _instance: Instance, + _p_create_info: *const ScreenSurfaceCreateInfoQNX, + _p_allocator: *const AllocationCallbacks, + _p_surface: *mut SurfaceKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(create_screen_surface_qnx) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateScreenSurfaceQNX\0"); + let val = _f(cname); + if val.is_null() { + create_screen_surface_qnx + } else { + ::std::mem::transmute(val) + } + }, + get_physical_device_screen_presentation_support_qnx: unsafe { + unsafe extern "system" fn get_physical_device_screen_presentation_support_qnx( + _physical_device: PhysicalDevice, + _queue_family_index: u32, + _window: *mut _screen_window, + ) -> Bool32 { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_screen_presentation_support_qnx) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPhysicalDeviceScreenPresentationSupportQNX\0", + ); + let val = _f(cname); + if val.is_null() { + get_physical_device_screen_presentation_support_qnx + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_QNX_screen_surface'"] +impl StructureType { + pub const SCREEN_SURFACE_CREATE_INFO_QNX: Self = Self(1_000_378_000); +} +impl KhrExtension380Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_extension_380\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct KhrExtension380Fn {} +unsafe impl Send for KhrExtension380Fn {} +unsafe impl Sync for KhrExtension380Fn {} +impl KhrExtension380Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl KhrExtension381Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_extension_381\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct KhrExtension381Fn {} +unsafe impl Send for KhrExtension381Fn {} +unsafe impl Sync for KhrExtension381Fn {} +impl KhrExtension381Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtColorWriteEnableFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_color_write_enable\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetColorWriteEnableEXT = unsafe extern "system" fn( + command_buffer: CommandBuffer, + attachment_count: u32, + p_color_write_enables: *const Bool32, +); +#[derive(Clone)] +pub struct ExtColorWriteEnableFn { + pub cmd_set_color_write_enable_ext: PFN_vkCmdSetColorWriteEnableEXT, +} +unsafe impl Send for ExtColorWriteEnableFn {} +unsafe impl Sync for ExtColorWriteEnableFn {} +impl ExtColorWriteEnableFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + cmd_set_color_write_enable_ext: unsafe { + unsafe extern "system" fn cmd_set_color_write_enable_ext( + _command_buffer: CommandBuffer, + _attachment_count: u32, + _p_color_write_enables: *const Bool32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_color_write_enable_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetColorWriteEnableEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_color_write_enable_ext + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_EXT_color_write_enable'"] +impl DynamicState { + pub const COLOR_WRITE_ENABLE_EXT: Self = Self(1_000_381_000); +} +#[doc = "Generated from 'VK_EXT_color_write_enable'"] +impl StructureType { + pub const PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT: Self = Self(1_000_381_000); + pub const PIPELINE_COLOR_WRITE_CREATE_INFO_EXT: Self = Self(1_000_381_001); +} +impl ExtPrimitivesGeneratedQueryFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_primitives_generated_query\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct ExtPrimitivesGeneratedQueryFn {} +unsafe impl Send for ExtPrimitivesGeneratedQueryFn {} +unsafe impl Sync for ExtPrimitivesGeneratedQueryFn {} +impl ExtPrimitivesGeneratedQueryFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_primitives_generated_query'"] +impl QueryType { + pub const PRIMITIVES_GENERATED_EXT: Self = Self(1_000_382_000); +} +#[doc = "Generated from 'VK_EXT_primitives_generated_query'"] +impl StructureType { + pub const PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT: Self = Self(1_000_382_000); +} +impl ExtExtension384Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_384\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct ExtExtension384Fn {} +unsafe impl Send for ExtExtension384Fn {} +unsafe impl Sync for ExtExtension384Fn {} +impl ExtExtension384Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl MesaExtension385Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_MESA_extension_385\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct MesaExtension385Fn {} +unsafe impl Send for MesaExtension385Fn {} +unsafe impl Sync for MesaExtension385Fn {} +impl MesaExtension385Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl GoogleExtension386Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_GOOGLE_extension_386\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct GoogleExtension386Fn {} +unsafe impl Send for GoogleExtension386Fn {} +unsafe impl Sync for GoogleExtension386Fn {} +impl GoogleExtension386Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl KhrRayTracingMaintenance1Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_ray_tracing_maintenance1\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkCmdTraceRaysIndirect2KHR = unsafe extern "system" fn( + command_buffer: CommandBuffer, + indirect_device_address: DeviceAddress, +); +#[derive(Clone)] +pub struct KhrRayTracingMaintenance1Fn { + pub cmd_trace_rays_indirect2_khr: PFN_vkCmdTraceRaysIndirect2KHR, +} +unsafe impl Send for KhrRayTracingMaintenance1Fn {} +unsafe impl Sync for KhrRayTracingMaintenance1Fn {} +impl KhrRayTracingMaintenance1Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + cmd_trace_rays_indirect2_khr: unsafe { + unsafe extern "system" fn cmd_trace_rays_indirect2_khr( + _command_buffer: CommandBuffer, + _indirect_device_address: DeviceAddress, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_trace_rays_indirect2_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdTraceRaysIndirect2KHR\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_trace_rays_indirect2_khr + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_KHR_ray_tracing_maintenance1'"] +impl AccessFlags2 { + pub const SHADER_BINDING_TABLE_READ_KHR: Self = + Self(0b1_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_KHR_ray_tracing_maintenance1'"] +impl PipelineStageFlags2 { + pub const ACCELERATION_STRUCTURE_COPY_KHR: Self = Self(0b1_0000_0000_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_KHR_ray_tracing_maintenance1'"] +impl QueryType { + pub const ACCELERATION_STRUCTURE_SERIALIZATION_BOTTOM_LEVEL_POINTERS_KHR: Self = + Self(1_000_386_000); + pub const ACCELERATION_STRUCTURE_SIZE_KHR: Self = Self(1_000_386_001); +} +#[doc = "Generated from 'VK_KHR_ray_tracing_maintenance1'"] +impl StructureType { + pub const PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR: Self = Self(1_000_386_000); +} +impl ExtExtension388Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_388\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct ExtExtension388Fn {} +unsafe impl Send for ExtExtension388Fn {} +unsafe impl Sync for ExtExtension388Fn {} +impl ExtExtension388Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtGlobalPriorityQueryFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_global_priority_query\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct ExtGlobalPriorityQueryFn {} +unsafe impl Send for ExtGlobalPriorityQueryFn {} +unsafe impl Sync for ExtGlobalPriorityQueryFn {} +impl ExtGlobalPriorityQueryFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_global_priority_query'"] +impl StructureType { + pub const PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_EXT: Self = + Self::PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR; + pub const QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_EXT: Self = + Self::QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR; +} +impl ExtExtension390Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_390\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct ExtExtension390Fn {} +unsafe impl Send for ExtExtension390Fn {} +unsafe impl Sync for ExtExtension390Fn {} +impl ExtExtension390Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtExtension391Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_391\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct ExtExtension391Fn {} +unsafe impl Send for ExtExtension391Fn {} +unsafe impl Sync for ExtExtension391Fn {} +impl ExtExtension391Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtImageViewMinLodFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_image_view_min_lod\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct ExtImageViewMinLodFn {} +unsafe impl Send for ExtImageViewMinLodFn {} +unsafe impl Sync for ExtImageViewMinLodFn {} +impl ExtImageViewMinLodFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_image_view_min_lod'"] +impl StructureType { + pub const PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT: Self = Self(1_000_391_000); + pub const IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT: Self = Self(1_000_391_001); +} +impl ExtMultiDrawFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_multi_draw\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkCmdDrawMultiEXT = unsafe extern "system" fn( + command_buffer: CommandBuffer, + draw_count: u32, + p_vertex_info: *const MultiDrawInfoEXT, + instance_count: u32, + first_instance: u32, + stride: u32, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdDrawMultiIndexedEXT = unsafe extern "system" fn( + command_buffer: CommandBuffer, + draw_count: u32, + p_index_info: *const MultiDrawIndexedInfoEXT, + instance_count: u32, + first_instance: u32, + stride: u32, + p_vertex_offset: *const i32, +); +#[derive(Clone)] +pub struct ExtMultiDrawFn { + pub cmd_draw_multi_ext: PFN_vkCmdDrawMultiEXT, + pub cmd_draw_multi_indexed_ext: PFN_vkCmdDrawMultiIndexedEXT, +} +unsafe impl Send for ExtMultiDrawFn {} +unsafe impl Sync for ExtMultiDrawFn {} +impl ExtMultiDrawFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + cmd_draw_multi_ext: unsafe { + unsafe extern "system" fn cmd_draw_multi_ext( + _command_buffer: CommandBuffer, + _draw_count: u32, + _p_vertex_info: *const MultiDrawInfoEXT, + _instance_count: u32, + _first_instance: u32, + _stride: u32, + ) { + panic!(concat!("Unable to load ", stringify!(cmd_draw_multi_ext))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdDrawMultiEXT\0"); + let val = _f(cname); + if val.is_null() { + cmd_draw_multi_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_draw_multi_indexed_ext: unsafe { + unsafe extern "system" fn cmd_draw_multi_indexed_ext( + _command_buffer: CommandBuffer, + _draw_count: u32, + _p_index_info: *const MultiDrawIndexedInfoEXT, + _instance_count: u32, + _first_instance: u32, + _stride: u32, + _p_vertex_offset: *const i32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_draw_multi_indexed_ext) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdDrawMultiIndexedEXT\0"); + let val = _f(cname); + if val.is_null() { + cmd_draw_multi_indexed_ext + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_EXT_multi_draw'"] +impl StructureType { + pub const PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT: Self = Self(1_000_392_000); + pub const PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT: Self = Self(1_000_392_001); +} +impl ExtImage2dViewOf3dFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_image_2d_view_of_3d\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct ExtImage2dViewOf3dFn {} +unsafe impl Send for ExtImage2dViewOf3dFn {} +unsafe impl Sync for ExtImage2dViewOf3dFn {} +impl ExtImage2dViewOf3dFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_image_2d_view_of_3d'"] +impl ImageCreateFlags { + #[doc = "Image is created with a layout where individual slices are capable of being used as 2D images"] + pub const TYPE_2D_VIEW_COMPATIBLE_EXT: Self = Self(0b10_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_EXT_image_2d_view_of_3d'"] +impl StructureType { + pub const PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT: Self = Self(1_000_393_000); +} +impl KhrPortabilityEnumerationFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_portability_enumeration\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct KhrPortabilityEnumerationFn {} +unsafe impl Send for KhrPortabilityEnumerationFn {} +unsafe impl Sync for KhrPortabilityEnumerationFn {} +impl KhrPortabilityEnumerationFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_KHR_portability_enumeration'"] +impl InstanceCreateFlags { + pub const ENUMERATE_PORTABILITY_KHR: Self = Self(0b1); +} +impl KhrExtension396Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_extension_396\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct KhrExtension396Fn {} +unsafe impl Send for KhrExtension396Fn {} +unsafe impl Sync for KhrExtension396Fn {} +impl KhrExtension396Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtOpacityMicromapFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_opacity_micromap\0") } + } + pub const SPEC_VERSION: u32 = 2u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkCreateMicromapEXT = unsafe extern "system" fn( + device: Device, + p_create_info: *const MicromapCreateInfoEXT, + p_allocator: *const AllocationCallbacks, + p_micromap: *mut MicromapEXT, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkDestroyMicromapEXT = unsafe extern "system" fn( + device: Device, + micromap: MicromapEXT, + p_allocator: *const AllocationCallbacks, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdBuildMicromapsEXT = unsafe extern "system" fn( + command_buffer: CommandBuffer, + info_count: u32, + p_infos: *const MicromapBuildInfoEXT, +); +#[allow(non_camel_case_types)] +pub type PFN_vkBuildMicromapsEXT = unsafe extern "system" fn( + device: Device, + deferred_operation: DeferredOperationKHR, + info_count: u32, + p_infos: *const MicromapBuildInfoEXT, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkCopyMicromapEXT = unsafe extern "system" fn( + device: Device, + deferred_operation: DeferredOperationKHR, + p_info: *const CopyMicromapInfoEXT, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkCopyMicromapToMemoryEXT = unsafe extern "system" fn( + device: Device, + deferred_operation: DeferredOperationKHR, + p_info: *const CopyMicromapToMemoryInfoEXT, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkCopyMemoryToMicromapEXT = unsafe extern "system" fn( + device: Device, + deferred_operation: DeferredOperationKHR, + p_info: *const CopyMemoryToMicromapInfoEXT, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkWriteMicromapsPropertiesEXT = unsafe extern "system" fn( + device: Device, + micromap_count: u32, + p_micromaps: *const MicromapEXT, + query_type: QueryType, + data_size: usize, + p_data: *mut c_void, + stride: usize, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkCmdCopyMicromapEXT = + unsafe extern "system" fn(command_buffer: CommandBuffer, p_info: *const CopyMicromapInfoEXT); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdCopyMicromapToMemoryEXT = unsafe extern "system" fn( + command_buffer: CommandBuffer, + p_info: *const CopyMicromapToMemoryInfoEXT, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdCopyMemoryToMicromapEXT = unsafe extern "system" fn( + command_buffer: CommandBuffer, + p_info: *const CopyMemoryToMicromapInfoEXT, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdWriteMicromapsPropertiesEXT = unsafe extern "system" fn( + command_buffer: CommandBuffer, + micromap_count: u32, + p_micromaps: *const MicromapEXT, + query_type: QueryType, + query_pool: QueryPool, + first_query: u32, +); +#[allow(non_camel_case_types)] +pub type PFN_vkGetDeviceMicromapCompatibilityEXT = unsafe extern "system" fn( + device: Device, + p_version_info: *const MicromapVersionInfoEXT, + p_compatibility: *mut AccelerationStructureCompatibilityKHR, +); +#[allow(non_camel_case_types)] +pub type PFN_vkGetMicromapBuildSizesEXT = unsafe extern "system" fn( + device: Device, + build_type: AccelerationStructureBuildTypeKHR, + p_build_info: *const MicromapBuildInfoEXT, + p_size_info: *mut MicromapBuildSizesInfoEXT, +); +#[derive(Clone)] +pub struct ExtOpacityMicromapFn { + pub create_micromap_ext: PFN_vkCreateMicromapEXT, + pub destroy_micromap_ext: PFN_vkDestroyMicromapEXT, + pub cmd_build_micromaps_ext: PFN_vkCmdBuildMicromapsEXT, + pub build_micromaps_ext: PFN_vkBuildMicromapsEXT, + pub copy_micromap_ext: PFN_vkCopyMicromapEXT, + pub copy_micromap_to_memory_ext: PFN_vkCopyMicromapToMemoryEXT, + pub copy_memory_to_micromap_ext: PFN_vkCopyMemoryToMicromapEXT, + pub write_micromaps_properties_ext: PFN_vkWriteMicromapsPropertiesEXT, + pub cmd_copy_micromap_ext: PFN_vkCmdCopyMicromapEXT, + pub cmd_copy_micromap_to_memory_ext: PFN_vkCmdCopyMicromapToMemoryEXT, + pub cmd_copy_memory_to_micromap_ext: PFN_vkCmdCopyMemoryToMicromapEXT, + pub cmd_write_micromaps_properties_ext: PFN_vkCmdWriteMicromapsPropertiesEXT, + pub get_device_micromap_compatibility_ext: PFN_vkGetDeviceMicromapCompatibilityEXT, + pub get_micromap_build_sizes_ext: PFN_vkGetMicromapBuildSizesEXT, +} +unsafe impl Send for ExtOpacityMicromapFn {} +unsafe impl Sync for ExtOpacityMicromapFn {} +impl ExtOpacityMicromapFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + create_micromap_ext: unsafe { + unsafe extern "system" fn create_micromap_ext( + _device: Device, + _p_create_info: *const MicromapCreateInfoEXT, + _p_allocator: *const AllocationCallbacks, + _p_micromap: *mut MicromapEXT, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(create_micromap_ext))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateMicromapEXT\0"); + let val = _f(cname); + if val.is_null() { + create_micromap_ext + } else { + ::std::mem::transmute(val) + } + }, + destroy_micromap_ext: unsafe { + unsafe extern "system" fn destroy_micromap_ext( + _device: Device, + _micromap: MicromapEXT, + _p_allocator: *const AllocationCallbacks, + ) { + panic!(concat!("Unable to load ", stringify!(destroy_micromap_ext))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyMicromapEXT\0"); + let val = _f(cname); + if val.is_null() { + destroy_micromap_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_build_micromaps_ext: unsafe { + unsafe extern "system" fn cmd_build_micromaps_ext( + _command_buffer: CommandBuffer, + _info_count: u32, + _p_infos: *const MicromapBuildInfoEXT, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_build_micromaps_ext) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdBuildMicromapsEXT\0"); + let val = _f(cname); + if val.is_null() { + cmd_build_micromaps_ext + } else { + ::std::mem::transmute(val) + } + }, + build_micromaps_ext: unsafe { + unsafe extern "system" fn build_micromaps_ext( + _device: Device, + _deferred_operation: DeferredOperationKHR, + _info_count: u32, + _p_infos: *const MicromapBuildInfoEXT, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(build_micromaps_ext))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkBuildMicromapsEXT\0"); + let val = _f(cname); + if val.is_null() { + build_micromaps_ext + } else { + ::std::mem::transmute(val) + } + }, + copy_micromap_ext: unsafe { + unsafe extern "system" fn copy_micromap_ext( + _device: Device, + _deferred_operation: DeferredOperationKHR, + _p_info: *const CopyMicromapInfoEXT, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(copy_micromap_ext))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCopyMicromapEXT\0"); + let val = _f(cname); + if val.is_null() { + copy_micromap_ext + } else { + ::std::mem::transmute(val) + } + }, + copy_micromap_to_memory_ext: unsafe { + unsafe extern "system" fn copy_micromap_to_memory_ext( + _device: Device, + _deferred_operation: DeferredOperationKHR, + _p_info: *const CopyMicromapToMemoryInfoEXT, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(copy_micromap_to_memory_ext) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCopyMicromapToMemoryEXT\0"); + let val = _f(cname); + if val.is_null() { + copy_micromap_to_memory_ext + } else { + ::std::mem::transmute(val) + } + }, + copy_memory_to_micromap_ext: unsafe { + unsafe extern "system" fn copy_memory_to_micromap_ext( + _device: Device, + _deferred_operation: DeferredOperationKHR, + _p_info: *const CopyMemoryToMicromapInfoEXT, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(copy_memory_to_micromap_ext) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCopyMemoryToMicromapEXT\0"); + let val = _f(cname); + if val.is_null() { + copy_memory_to_micromap_ext + } else { + ::std::mem::transmute(val) + } + }, + write_micromaps_properties_ext: unsafe { + unsafe extern "system" fn write_micromaps_properties_ext( + _device: Device, + _micromap_count: u32, + _p_micromaps: *const MicromapEXT, + _query_type: QueryType, + _data_size: usize, + _p_data: *mut c_void, + _stride: usize, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(write_micromaps_properties_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkWriteMicromapsPropertiesEXT\0", + ); + let val = _f(cname); + if val.is_null() { + write_micromaps_properties_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_copy_micromap_ext: unsafe { + unsafe extern "system" fn cmd_copy_micromap_ext( + _command_buffer: CommandBuffer, + _p_info: *const CopyMicromapInfoEXT, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_copy_micromap_ext) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdCopyMicromapEXT\0"); + let val = _f(cname); + if val.is_null() { + cmd_copy_micromap_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_copy_micromap_to_memory_ext: unsafe { + unsafe extern "system" fn cmd_copy_micromap_to_memory_ext( + _command_buffer: CommandBuffer, + _p_info: *const CopyMicromapToMemoryInfoEXT, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_copy_micromap_to_memory_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdCopyMicromapToMemoryEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_copy_micromap_to_memory_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_copy_memory_to_micromap_ext: unsafe { + unsafe extern "system" fn cmd_copy_memory_to_micromap_ext( + _command_buffer: CommandBuffer, + _p_info: *const CopyMemoryToMicromapInfoEXT, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_copy_memory_to_micromap_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdCopyMemoryToMicromapEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_copy_memory_to_micromap_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_write_micromaps_properties_ext: unsafe { + unsafe extern "system" fn cmd_write_micromaps_properties_ext( + _command_buffer: CommandBuffer, + _micromap_count: u32, + _p_micromaps: *const MicromapEXT, + _query_type: QueryType, + _query_pool: QueryPool, + _first_query: u32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_write_micromaps_properties_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdWriteMicromapsPropertiesEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_write_micromaps_properties_ext + } else { + ::std::mem::transmute(val) + } + }, + get_device_micromap_compatibility_ext: unsafe { + unsafe extern "system" fn get_device_micromap_compatibility_ext( + _device: Device, + _p_version_info: *const MicromapVersionInfoEXT, + _p_compatibility: *mut AccelerationStructureCompatibilityKHR, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_device_micromap_compatibility_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetDeviceMicromapCompatibilityEXT\0", + ); + let val = _f(cname); + if val.is_null() { + get_device_micromap_compatibility_ext + } else { + ::std::mem::transmute(val) + } + }, + get_micromap_build_sizes_ext: unsafe { + unsafe extern "system" fn get_micromap_build_sizes_ext( + _device: Device, + _build_type: AccelerationStructureBuildTypeKHR, + _p_build_info: *const MicromapBuildInfoEXT, + _p_size_info: *mut MicromapBuildSizesInfoEXT, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_micromap_build_sizes_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetMicromapBuildSizesEXT\0", + ); + let val = _f(cname); + if val.is_null() { + get_micromap_build_sizes_ext + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_EXT_opacity_micromap'"] +impl AccessFlags2 { + pub const MICROMAP_READ_EXT: Self = + Self(0b1_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000); + pub const MICROMAP_WRITE_EXT: Self = + Self(0b10_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_EXT_opacity_micromap'"] +impl BufferUsageFlags { + pub const MICROMAP_BUILD_INPUT_READ_ONLY_EXT: Self = Self(0b1000_0000_0000_0000_0000_0000); + pub const MICROMAP_STORAGE_EXT: Self = Self(0b1_0000_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_EXT_opacity_micromap'"] +impl BuildAccelerationStructureFlagsKHR { + pub const ALLOW_OPACITY_MICROMAP_UPDATE_EXT: Self = Self(0b100_0000); + pub const ALLOW_DISABLE_OPACITY_MICROMAPS_EXT: Self = Self(0b1000_0000); + pub const ALLOW_OPACITY_MICROMAP_DATA_UPDATE_EXT: Self = Self(0b1_0000_0000); +} +#[doc = "Generated from 'VK_EXT_opacity_micromap'"] +impl GeometryInstanceFlagsKHR { + pub const FORCE_OPACITY_MICROMAP_2_STATE_EXT: Self = Self(0b1_0000); + pub const DISABLE_OPACITY_MICROMAPS_EXT: Self = Self(0b10_0000); +} +#[doc = "Generated from 'VK_EXT_opacity_micromap'"] +impl ObjectType { + pub const MICROMAP_EXT: Self = Self(1_000_396_000); +} +#[doc = "Generated from 'VK_EXT_opacity_micromap'"] +impl PipelineCreateFlags { + pub const RAY_TRACING_OPACITY_MICROMAP_EXT: Self = Self(0b1_0000_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_EXT_opacity_micromap'"] +impl PipelineStageFlags2 { + pub const MICROMAP_BUILD_EXT: Self = Self(0b100_0000_0000_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_EXT_opacity_micromap'"] +impl QueryType { + pub const MICROMAP_SERIALIZATION_SIZE_EXT: Self = Self(1_000_396_000); + pub const MICROMAP_COMPACTED_SIZE_EXT: Self = Self(1_000_396_001); +} +#[doc = "Generated from 'VK_EXT_opacity_micromap'"] +impl StructureType { + pub const MICROMAP_BUILD_INFO_EXT: Self = Self(1_000_396_000); + pub const MICROMAP_VERSION_INFO_EXT: Self = Self(1_000_396_001); + pub const COPY_MICROMAP_INFO_EXT: Self = Self(1_000_396_002); + pub const COPY_MICROMAP_TO_MEMORY_INFO_EXT: Self = Self(1_000_396_003); + pub const COPY_MEMORY_TO_MICROMAP_INFO_EXT: Self = Self(1_000_396_004); + pub const PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT: Self = Self(1_000_396_005); + pub const PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT: Self = Self(1_000_396_006); + pub const MICROMAP_CREATE_INFO_EXT: Self = Self(1_000_396_007); + pub const MICROMAP_BUILD_SIZES_INFO_EXT: Self = Self(1_000_396_008); + pub const ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_EXT: Self = Self(1_000_396_009); +} +impl NvExtension398Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_398\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct NvExtension398Fn {} +unsafe impl Send for NvExtension398Fn {} +unsafe impl Sync for NvExtension398Fn {} +impl NvExtension398Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_NV_extension_398'"] +impl BuildAccelerationStructureFlagsKHR { + pub const RESERVED_9_NV: Self = Self(0b10_0000_0000); + pub const RESERVED_10_NV: Self = Self(0b100_0000_0000); +} +#[doc = "Generated from 'VK_NV_extension_398'"] +impl PipelineCreateFlags { + pub const RESERVED_28_NV: Self = Self(0b1_0000_0000_0000_0000_0000_0000_0000); +} +impl JuiceExtension399Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_JUICE_extension_399\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct JuiceExtension399Fn {} +unsafe impl Send for JuiceExtension399Fn {} +unsafe impl Sync for JuiceExtension399Fn {} +impl JuiceExtension399Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl JuiceExtension400Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_JUICE_extension_400\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct JuiceExtension400Fn {} +unsafe impl Send for JuiceExtension400Fn {} +unsafe impl Sync for JuiceExtension400Fn {} +impl JuiceExtension400Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtLoadStoreOpNoneFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_load_store_op_none\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct ExtLoadStoreOpNoneFn {} +unsafe impl Send for ExtLoadStoreOpNoneFn {} +unsafe impl Sync for ExtLoadStoreOpNoneFn {} +impl ExtLoadStoreOpNoneFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_load_store_op_none'"] +impl AttachmentLoadOp { + pub const NONE_EXT: Self = Self(1_000_400_000); +} +#[doc = "Generated from 'VK_EXT_load_store_op_none'"] +impl AttachmentStoreOp { + pub const NONE_EXT: Self = Self::NONE; +} +impl FbExtension402Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_FB_extension_402\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct FbExtension402Fn {} +unsafe impl Send for FbExtension402Fn {} +unsafe impl Sync for FbExtension402Fn {} +impl FbExtension402Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl FbExtension403Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_FB_extension_403\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct FbExtension403Fn {} +unsafe impl Send for FbExtension403Fn {} +unsafe impl Sync for FbExtension403Fn {} +impl FbExtension403Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl FbExtension404Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_FB_extension_404\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct FbExtension404Fn {} +unsafe impl Send for FbExtension404Fn {} +unsafe impl Sync for FbExtension404Fn {} +impl FbExtension404Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl HuaweiExtension405Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_HUAWEI_extension_405\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct HuaweiExtension405Fn {} +unsafe impl Send for HuaweiExtension405Fn {} +unsafe impl Sync for HuaweiExtension405Fn {} +impl HuaweiExtension405Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_HUAWEI_extension_405'"] +impl PipelineStageFlags2 { + pub const RESEVED_41_HUAWEI: Self = + Self(0b10_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_HUAWEI_extension_405'"] +impl ShaderStageFlags { + pub const RESERVED_19_HUAWEI: Self = Self(0b1000_0000_0000_0000_0000); +} +impl HuaweiExtension406Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_HUAWEI_extension_406\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct HuaweiExtension406Fn {} +unsafe impl Send for HuaweiExtension406Fn {} +unsafe impl Sync for HuaweiExtension406Fn {} +impl HuaweiExtension406Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl GgpExtension407Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_GGP_extension_407\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct GgpExtension407Fn {} +unsafe impl Send for GgpExtension407Fn {} +unsafe impl Sync for GgpExtension407Fn {} +impl GgpExtension407Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl GgpExtension408Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_GGP_extension_408\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct GgpExtension408Fn {} +unsafe impl Send for GgpExtension408Fn {} +unsafe impl Sync for GgpExtension408Fn {} +impl GgpExtension408Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl GgpExtension409Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_GGP_extension_409\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct GgpExtension409Fn {} +unsafe impl Send for GgpExtension409Fn {} +unsafe impl Sync for GgpExtension409Fn {} +impl GgpExtension409Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl GgpExtension410Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_GGP_extension_410\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct GgpExtension410Fn {} +unsafe impl Send for GgpExtension410Fn {} +unsafe impl Sync for GgpExtension410Fn {} +impl GgpExtension410Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl GgpExtension411Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_GGP_extension_411\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct GgpExtension411Fn {} +unsafe impl Send for GgpExtension411Fn {} +unsafe impl Sync for GgpExtension411Fn {} +impl GgpExtension411Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtBorderColorSwizzleFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_border_color_swizzle\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct ExtBorderColorSwizzleFn {} +unsafe impl Send for ExtBorderColorSwizzleFn {} +unsafe impl Sync for ExtBorderColorSwizzleFn {} +impl ExtBorderColorSwizzleFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_border_color_swizzle'"] +impl StructureType { + pub const PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT: Self = Self(1_000_411_000); + pub const SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT: Self = Self(1_000_411_001); +} +impl ExtPageableDeviceLocalMemoryFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"VK_EXT_pageable_device_local_memory\0", + ) + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkSetDeviceMemoryPriorityEXT = + unsafe extern "system" fn(device: Device, memory: DeviceMemory, priority: f32); +#[derive(Clone)] +pub struct ExtPageableDeviceLocalMemoryFn { + pub set_device_memory_priority_ext: PFN_vkSetDeviceMemoryPriorityEXT, +} +unsafe impl Send for ExtPageableDeviceLocalMemoryFn {} +unsafe impl Sync for ExtPageableDeviceLocalMemoryFn {} +impl ExtPageableDeviceLocalMemoryFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + set_device_memory_priority_ext: unsafe { + unsafe extern "system" fn set_device_memory_priority_ext( + _device: Device, + _memory: DeviceMemory, + _priority: f32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(set_device_memory_priority_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkSetDeviceMemoryPriorityEXT\0", + ); + let val = _f(cname); + if val.is_null() { + set_device_memory_priority_ext + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_EXT_pageable_device_local_memory'"] +impl StructureType { + pub const PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT: Self = Self(1_000_412_000); +} +impl KhrMaintenance4Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_maintenance4\0") } + } + pub const SPEC_VERSION: u32 = 2u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkGetDeviceBufferMemoryRequirements = unsafe extern "system" fn( + device: Device, + p_info: *const DeviceBufferMemoryRequirements, + p_memory_requirements: *mut MemoryRequirements2, +); +#[allow(non_camel_case_types)] +pub type PFN_vkGetDeviceImageMemoryRequirements = unsafe extern "system" fn( + device: Device, + p_info: *const DeviceImageMemoryRequirements, + p_memory_requirements: *mut MemoryRequirements2, +); +#[allow(non_camel_case_types)] +pub type PFN_vkGetDeviceImageSparseMemoryRequirements = unsafe extern "system" fn( + device: Device, + p_info: *const DeviceImageMemoryRequirements, + p_sparse_memory_requirement_count: *mut u32, + p_sparse_memory_requirements: *mut SparseImageMemoryRequirements2, +); +#[derive(Clone)] +pub struct KhrMaintenance4Fn { + pub get_device_buffer_memory_requirements_khr: PFN_vkGetDeviceBufferMemoryRequirements, + pub get_device_image_memory_requirements_khr: PFN_vkGetDeviceImageMemoryRequirements, + pub get_device_image_sparse_memory_requirements_khr: + PFN_vkGetDeviceImageSparseMemoryRequirements, +} +unsafe impl Send for KhrMaintenance4Fn {} +unsafe impl Sync for KhrMaintenance4Fn {} +impl KhrMaintenance4Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + get_device_buffer_memory_requirements_khr: unsafe { + unsafe extern "system" fn get_device_buffer_memory_requirements_khr( + _device: Device, + _p_info: *const DeviceBufferMemoryRequirements, + _p_memory_requirements: *mut MemoryRequirements2, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_device_buffer_memory_requirements_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetDeviceBufferMemoryRequirementsKHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_device_buffer_memory_requirements_khr + } else { + ::std::mem::transmute(val) + } + }, + get_device_image_memory_requirements_khr: unsafe { + unsafe extern "system" fn get_device_image_memory_requirements_khr( + _device: Device, + _p_info: *const DeviceImageMemoryRequirements, + _p_memory_requirements: *mut MemoryRequirements2, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_device_image_memory_requirements_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetDeviceImageMemoryRequirementsKHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_device_image_memory_requirements_khr + } else { + ::std::mem::transmute(val) + } + }, + get_device_image_sparse_memory_requirements_khr: unsafe { + unsafe extern "system" fn get_device_image_sparse_memory_requirements_khr( + _device: Device, + _p_info: *const DeviceImageMemoryRequirements, + _p_sparse_memory_requirement_count: *mut u32, + _p_sparse_memory_requirements: *mut SparseImageMemoryRequirements2, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_device_image_sparse_memory_requirements_khr) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetDeviceImageSparseMemoryRequirementsKHR\0", + ); + let val = _f(cname); + if val.is_null() { + get_device_image_sparse_memory_requirements_khr + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_KHR_maintenance4'"] +impl ImageAspectFlags { + pub const NONE_KHR: Self = Self::NONE; +} +#[doc = "Generated from 'VK_KHR_maintenance4'"] +impl StructureType { + pub const PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES_KHR: Self = + Self::PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES; + pub const PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES_KHR: Self = + Self::PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES; + pub const DEVICE_BUFFER_MEMORY_REQUIREMENTS_KHR: Self = Self::DEVICE_BUFFER_MEMORY_REQUIREMENTS; + pub const DEVICE_IMAGE_MEMORY_REQUIREMENTS_KHR: Self = Self::DEVICE_IMAGE_MEMORY_REQUIREMENTS; +} +impl HuaweiExtension415Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_HUAWEI_extension_415\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct HuaweiExtension415Fn {} +unsafe impl Send for HuaweiExtension415Fn {} +unsafe impl Sync for HuaweiExtension415Fn {} +impl HuaweiExtension415Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ArmExtension416Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_ARM_extension_416\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct ArmExtension416Fn {} +unsafe impl Send for ArmExtension416Fn {} +unsafe impl Sync for ArmExtension416Fn {} +impl ArmExtension416Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl KhrExtension417Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_extension_417\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct KhrExtension417Fn {} +unsafe impl Send for KhrExtension417Fn {} +unsafe impl Sync for KhrExtension417Fn {} +impl KhrExtension417Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ArmExtension418Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_ARM_extension_418\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct ArmExtension418Fn {} +unsafe impl Send for ArmExtension418Fn {} +unsafe impl Sync for ArmExtension418Fn {} +impl ArmExtension418Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtExtension419Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_419\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct ExtExtension419Fn {} +unsafe impl Send for ExtExtension419Fn {} +unsafe impl Sync for ExtExtension419Fn {} +impl ExtExtension419Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_extension_419'"] +impl ImageViewCreateFlags { + pub const RESERVED_3_EXT: Self = Self(0b1000); +} +impl ExtExtension420Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_420\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct ExtExtension420Fn {} +unsafe impl Send for ExtExtension420Fn {} +unsafe impl Sync for ExtExtension420Fn {} +impl ExtExtension420Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_extension_420'"] +impl SwapchainCreateFlagsKHR { + pub const RESERVED_4_EXT: Self = Self(0b1_0000); +} +impl ValveDescriptorSetHostMappingFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"VK_VALVE_descriptor_set_host_mapping\0", + ) + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkGetDescriptorSetLayoutHostMappingInfoVALVE = unsafe extern "system" fn( + device: Device, + p_binding_reference: *const DescriptorSetBindingReferenceVALVE, + p_host_mapping: *mut DescriptorSetLayoutHostMappingInfoVALVE, +); +#[allow(non_camel_case_types)] +pub type PFN_vkGetDescriptorSetHostMappingVALVE = unsafe extern "system" fn( + device: Device, + descriptor_set: DescriptorSet, + pp_data: *mut *mut c_void, +); +#[derive(Clone)] +pub struct ValveDescriptorSetHostMappingFn { + pub get_descriptor_set_layout_host_mapping_info_valve: + PFN_vkGetDescriptorSetLayoutHostMappingInfoVALVE, + pub get_descriptor_set_host_mapping_valve: PFN_vkGetDescriptorSetHostMappingVALVE, +} +unsafe impl Send for ValveDescriptorSetHostMappingFn {} +unsafe impl Sync for ValveDescriptorSetHostMappingFn {} +impl ValveDescriptorSetHostMappingFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + get_descriptor_set_layout_host_mapping_info_valve: unsafe { + unsafe extern "system" fn get_descriptor_set_layout_host_mapping_info_valve( + _device: Device, + _p_binding_reference: *const DescriptorSetBindingReferenceVALVE, + _p_host_mapping: *mut DescriptorSetLayoutHostMappingInfoVALVE, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_descriptor_set_layout_host_mapping_info_valve) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetDescriptorSetLayoutHostMappingInfoVALVE\0", + ); + let val = _f(cname); + if val.is_null() { + get_descriptor_set_layout_host_mapping_info_valve + } else { + ::std::mem::transmute(val) + } + }, + get_descriptor_set_host_mapping_valve: unsafe { + unsafe extern "system" fn get_descriptor_set_host_mapping_valve( + _device: Device, + _descriptor_set: DescriptorSet, + _pp_data: *mut *mut c_void, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_descriptor_set_host_mapping_valve) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetDescriptorSetHostMappingVALVE\0", + ); + let val = _f(cname); + if val.is_null() { + get_descriptor_set_host_mapping_valve + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_VALVE_descriptor_set_host_mapping'"] +impl StructureType { + pub const PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE: Self = + Self(1_000_420_000); + pub const DESCRIPTOR_SET_BINDING_REFERENCE_VALVE: Self = Self(1_000_420_001); + pub const DESCRIPTOR_SET_LAYOUT_HOST_MAPPING_INFO_VALVE: Self = Self(1_000_420_002); +} +impl ExtDepthClampZeroOneFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_depth_clamp_zero_one\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct ExtDepthClampZeroOneFn {} +unsafe impl Send for ExtDepthClampZeroOneFn {} +unsafe impl Sync for ExtDepthClampZeroOneFn {} +impl ExtDepthClampZeroOneFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_depth_clamp_zero_one'"] +impl StructureType { + pub const PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT: Self = Self(1_000_421_000); +} +impl ExtNonSeamlessCubeMapFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_non_seamless_cube_map\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct ExtNonSeamlessCubeMapFn {} +unsafe impl Send for ExtNonSeamlessCubeMapFn {} +unsafe impl Sync for ExtNonSeamlessCubeMapFn {} +impl ExtNonSeamlessCubeMapFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_non_seamless_cube_map'"] +impl SamplerCreateFlags { + pub const NON_SEAMLESS_CUBE_MAP_EXT: Self = Self(0b100); +} +#[doc = "Generated from 'VK_EXT_non_seamless_cube_map'"] +impl StructureType { + pub const PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT: Self = Self(1_000_422_000); +} +impl ArmExtension424Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_ARM_extension_424\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct ArmExtension424Fn {} +unsafe impl Send for ArmExtension424Fn {} +unsafe impl Sync for ArmExtension424Fn {} +impl ArmExtension424Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ArmExtension425Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_ARM_extension_425\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct ArmExtension425Fn {} +unsafe impl Send for ArmExtension425Fn {} +unsafe impl Sync for ArmExtension425Fn {} +impl ArmExtension425Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl QcomFragmentDensityMapOffsetFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"VK_QCOM_fragment_density_map_offset\0", + ) + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct QcomFragmentDensityMapOffsetFn {} +unsafe impl Send for QcomFragmentDensityMapOffsetFn {} +unsafe impl Sync for QcomFragmentDensityMapOffsetFn {} +impl QcomFragmentDensityMapOffsetFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_QCOM_fragment_density_map_offset'"] +impl ImageCreateFlags { + pub const FRAGMENT_DENSITY_MAP_OFFSET_QCOM: Self = Self(0b1000_0000_0000_0000); +} +#[doc = "Generated from 'VK_QCOM_fragment_density_map_offset'"] +impl StructureType { + pub const PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM: Self = Self(1_000_425_000); + pub const PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM: Self = + Self(1_000_425_001); + pub const SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM: Self = Self(1_000_425_002); +} +impl NvCopyMemoryIndirectFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_copy_memory_indirect\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkCmdCopyMemoryIndirectNV = unsafe extern "system" fn( + command_buffer: CommandBuffer, + copy_buffer_address: DeviceAddress, + copy_count: u32, + stride: u32, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdCopyMemoryToImageIndirectNV = unsafe extern "system" fn( + command_buffer: CommandBuffer, + copy_buffer_address: DeviceAddress, + copy_count: u32, + stride: u32, + dst_image: Image, + dst_image_layout: ImageLayout, + p_image_subresources: *const ImageSubresourceLayers, +); +#[derive(Clone)] +pub struct NvCopyMemoryIndirectFn { + pub cmd_copy_memory_indirect_nv: PFN_vkCmdCopyMemoryIndirectNV, + pub cmd_copy_memory_to_image_indirect_nv: PFN_vkCmdCopyMemoryToImageIndirectNV, +} +unsafe impl Send for NvCopyMemoryIndirectFn {} +unsafe impl Sync for NvCopyMemoryIndirectFn {} +impl NvCopyMemoryIndirectFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + cmd_copy_memory_indirect_nv: unsafe { + unsafe extern "system" fn cmd_copy_memory_indirect_nv( + _command_buffer: CommandBuffer, + _copy_buffer_address: DeviceAddress, + _copy_count: u32, + _stride: u32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_copy_memory_indirect_nv) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdCopyMemoryIndirectNV\0"); + let val = _f(cname); + if val.is_null() { + cmd_copy_memory_indirect_nv + } else { + ::std::mem::transmute(val) + } + }, + cmd_copy_memory_to_image_indirect_nv: unsafe { + unsafe extern "system" fn cmd_copy_memory_to_image_indirect_nv( + _command_buffer: CommandBuffer, + _copy_buffer_address: DeviceAddress, + _copy_count: u32, + _stride: u32, + _dst_image: Image, + _dst_image_layout: ImageLayout, + _p_image_subresources: *const ImageSubresourceLayers, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_copy_memory_to_image_indirect_nv) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdCopyMemoryToImageIndirectNV\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_copy_memory_to_image_indirect_nv + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_NV_copy_memory_indirect'"] +impl StructureType { + pub const PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV: Self = Self(1_000_426_000); + pub const PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV: Self = Self(1_000_426_001); +} +impl NvMemoryDecompressionFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_memory_decompression\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkCmdDecompressMemoryNV = unsafe extern "system" fn( + command_buffer: CommandBuffer, + decompress_region_count: u32, + p_decompress_memory_regions: *const DecompressMemoryRegionNV, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdDecompressMemoryIndirectCountNV = unsafe extern "system" fn( + command_buffer: CommandBuffer, + indirect_commands_address: DeviceAddress, + indirect_commands_count_address: DeviceAddress, + stride: u32, +); +#[derive(Clone)] +pub struct NvMemoryDecompressionFn { + pub cmd_decompress_memory_nv: PFN_vkCmdDecompressMemoryNV, + pub cmd_decompress_memory_indirect_count_nv: PFN_vkCmdDecompressMemoryIndirectCountNV, +} +unsafe impl Send for NvMemoryDecompressionFn {} +unsafe impl Sync for NvMemoryDecompressionFn {} +impl NvMemoryDecompressionFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + cmd_decompress_memory_nv: unsafe { + unsafe extern "system" fn cmd_decompress_memory_nv( + _command_buffer: CommandBuffer, + _decompress_region_count: u32, + _p_decompress_memory_regions: *const DecompressMemoryRegionNV, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_decompress_memory_nv) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdDecompressMemoryNV\0"); + let val = _f(cname); + if val.is_null() { + cmd_decompress_memory_nv + } else { + ::std::mem::transmute(val) + } + }, + cmd_decompress_memory_indirect_count_nv: unsafe { + unsafe extern "system" fn cmd_decompress_memory_indirect_count_nv( + _command_buffer: CommandBuffer, + _indirect_commands_address: DeviceAddress, + _indirect_commands_count_address: DeviceAddress, + _stride: u32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_decompress_memory_indirect_count_nv) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdDecompressMemoryIndirectCountNV\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_decompress_memory_indirect_count_nv + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_NV_memory_decompression'"] +impl StructureType { + pub const PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV: Self = Self(1_000_427_000); + pub const PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV: Self = Self(1_000_427_001); +} +impl NvExtension429Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_429\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct NvExtension429Fn {} +unsafe impl Send for NvExtension429Fn {} +unsafe impl Sync for NvExtension429Fn {} +impl NvExtension429Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl NvExtension430Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_430\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct NvExtension430Fn {} +unsafe impl Send for NvExtension430Fn {} +unsafe impl Sync for NvExtension430Fn {} +impl NvExtension430Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl NvLinearColorAttachmentFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_linear_color_attachment\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct NvLinearColorAttachmentFn {} +unsafe impl Send for NvLinearColorAttachmentFn {} +unsafe impl Sync for NvLinearColorAttachmentFn {} +impl NvLinearColorAttachmentFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_NV_linear_color_attachment'"] +impl FormatFeatureFlags2 { + #[doc = "Format support linear image as render target, it cannot be mixed with non linear attachment"] + pub const LINEAR_COLOR_ATTACHMENT_NV: Self = + Self(0b100_0000_0000_0000_0000_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_NV_linear_color_attachment'"] +impl StructureType { + pub const PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV: Self = Self(1_000_430_000); +} +impl NvExtension432Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_432\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct NvExtension432Fn {} +unsafe impl Send for NvExtension432Fn {} +unsafe impl Sync for NvExtension432Fn {} +impl NvExtension432Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl NvExtension433Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_433\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct NvExtension433Fn {} +unsafe impl Send for NvExtension433Fn {} +unsafe impl Sync for NvExtension433Fn {} +impl NvExtension433Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl GoogleSurfacelessQueryFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_GOOGLE_surfaceless_query\0") } + } + pub const SPEC_VERSION: u32 = 2u32; +} +#[derive(Clone)] +pub struct GoogleSurfacelessQueryFn {} +unsafe impl Send for GoogleSurfacelessQueryFn {} +unsafe impl Sync for GoogleSurfacelessQueryFn {} +impl GoogleSurfacelessQueryFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl KhrExtension435Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_extension_435\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct KhrExtension435Fn {} +unsafe impl Send for KhrExtension435Fn {} +unsafe impl Sync for KhrExtension435Fn {} +impl KhrExtension435Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl NvExtension436Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_436\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct NvExtension436Fn {} +unsafe impl Send for NvExtension436Fn {} +unsafe impl Sync for NvExtension436Fn {} +impl NvExtension436Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtExtension437Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_437\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct ExtExtension437Fn {} +unsafe impl Send for ExtExtension437Fn {} +unsafe impl Sync for ExtExtension437Fn {} +impl ExtExtension437Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtImageCompressionControlSwapchainFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"VK_EXT_image_compression_control_swapchain\0", + ) + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct ExtImageCompressionControlSwapchainFn {} +unsafe impl Send for ExtImageCompressionControlSwapchainFn {} +unsafe impl Sync for ExtImageCompressionControlSwapchainFn {} +impl ExtImageCompressionControlSwapchainFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_image_compression_control_swapchain'"] +impl StructureType { + pub const PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT: Self = + Self(1_000_437_000); +} +impl SecExtension439Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_SEC_extension_439\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct SecExtension439Fn {} +unsafe impl Send for SecExtension439Fn {} +unsafe impl Sync for SecExtension439Fn {} +impl SecExtension439Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl QcomExtension440Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_QCOM_extension_440\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct QcomExtension440Fn {} +unsafe impl Send for QcomExtension440Fn {} +unsafe impl Sync for QcomExtension440Fn {} +impl QcomExtension440Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_QCOM_extension_440'"] +impl DeviceQueueCreateFlags { + pub const RESERVED_1_QCOM: Self = Self(0b10); +} +#[doc = "Generated from 'VK_QCOM_extension_440'"] +impl QueueFlags { + pub const RESERVED_7_QCOM: Self = Self(0b1000_0000); +} +impl QcomImageProcessingFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_QCOM_image_processing\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct QcomImageProcessingFn {} +unsafe impl Send for QcomImageProcessingFn {} +unsafe impl Sync for QcomImageProcessingFn {} +impl QcomImageProcessingFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_QCOM_image_processing'"] +impl DescriptorType { + pub const SAMPLE_WEIGHT_IMAGE_QCOM: Self = Self(1_000_440_000); + pub const BLOCK_MATCH_IMAGE_QCOM: Self = Self(1_000_440_001); +} +#[doc = "Generated from 'VK_QCOM_image_processing'"] +impl FormatFeatureFlags2 { + pub const WEIGHT_IMAGE_QCOM: Self = Self(0b100_0000_0000_0000_0000_0000_0000_0000_0000); + pub const WEIGHT_SAMPLED_IMAGE_QCOM: Self = + Self(0b1000_0000_0000_0000_0000_0000_0000_0000_0000); + pub const BLOCK_MATCHING_QCOM: Self = Self(0b1_0000_0000_0000_0000_0000_0000_0000_0000_0000); + pub const BOX_FILTER_SAMPLED_QCOM: Self = + Self(0b10_0000_0000_0000_0000_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_QCOM_image_processing'"] +impl ImageUsageFlags { + pub const SAMPLE_WEIGHT_QCOM: Self = Self(0b1_0000_0000_0000_0000_0000); + pub const SAMPLE_BLOCK_MATCH_QCOM: Self = Self(0b10_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_QCOM_image_processing'"] +impl SamplerCreateFlags { + pub const IMAGE_PROCESSING_QCOM: Self = Self(0b1_0000); +} +#[doc = "Generated from 'VK_QCOM_image_processing'"] +impl StructureType { + pub const PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM: Self = Self(1_000_440_000); + pub const PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM: Self = Self(1_000_440_001); + pub const IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM: Self = Self(1_000_440_002); +} +impl CoreaviExtension442Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_COREAVI_extension_442\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct CoreaviExtension442Fn {} +unsafe impl Send for CoreaviExtension442Fn {} +unsafe impl Sync for CoreaviExtension442Fn {} +impl CoreaviExtension442Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl CoreaviExtension443Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_COREAVI_extension_443\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct CoreaviExtension443Fn {} +unsafe impl Send for CoreaviExtension443Fn {} +unsafe impl Sync for CoreaviExtension443Fn {} +impl CoreaviExtension443Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl CoreaviExtension444Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_COREAVI_extension_444\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct CoreaviExtension444Fn {} +unsafe impl Send for CoreaviExtension444Fn {} +unsafe impl Sync for CoreaviExtension444Fn {} +impl CoreaviExtension444Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_COREAVI_extension_444'"] +impl CommandPoolResetFlags { + pub const RESERVED_1_COREAVI: Self = Self(0b10); +} +impl CoreaviExtension445Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_COREAVI_extension_445\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct CoreaviExtension445Fn {} +unsafe impl Send for CoreaviExtension445Fn {} +unsafe impl Sync for CoreaviExtension445Fn {} +impl CoreaviExtension445Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl CoreaviExtension446Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_COREAVI_extension_446\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct CoreaviExtension446Fn {} +unsafe impl Send for CoreaviExtension446Fn {} +unsafe impl Sync for CoreaviExtension446Fn {} +impl CoreaviExtension446Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl CoreaviExtension447Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_COREAVI_extension_447\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct CoreaviExtension447Fn {} +unsafe impl Send for CoreaviExtension447Fn {} +unsafe impl Sync for CoreaviExtension447Fn {} +impl CoreaviExtension447Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl SecExtension448Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_SEC_extension_448\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct SecExtension448Fn {} +unsafe impl Send for SecExtension448Fn {} +unsafe impl Sync for SecExtension448Fn {} +impl SecExtension448Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl SecExtension449Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_SEC_extension_449\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct SecExtension449Fn {} +unsafe impl Send for SecExtension449Fn {} +unsafe impl Sync for SecExtension449Fn {} +impl SecExtension449Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl SecExtension450Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_SEC_extension_450\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct SecExtension450Fn {} +unsafe impl Send for SecExtension450Fn {} +unsafe impl Sync for SecExtension450Fn {} +impl SecExtension450Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl SecExtension451Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_SEC_extension_451\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct SecExtension451Fn {} +unsafe impl Send for SecExtension451Fn {} +unsafe impl Sync for SecExtension451Fn {} +impl SecExtension451Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl NvExtension452Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_452\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct NvExtension452Fn {} +unsafe impl Send for NvExtension452Fn {} +unsafe impl Sync for NvExtension452Fn {} +impl NvExtension452Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ArmExtension453Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_ARM_extension_453\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct ArmExtension453Fn {} +unsafe impl Send for ArmExtension453Fn {} +unsafe impl Sync for ArmExtension453Fn {} +impl ArmExtension453Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl GoogleExtension454Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_GOOGLE_extension_454\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct GoogleExtension454Fn {} +unsafe impl Send for GoogleExtension454Fn {} +unsafe impl Sync for GoogleExtension454Fn {} +impl GoogleExtension454Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl GoogleExtension455Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_GOOGLE_extension_455\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct GoogleExtension455Fn {} +unsafe impl Send for GoogleExtension455Fn {} +unsafe impl Sync for GoogleExtension455Fn {} +impl GoogleExtension455Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtExtendedDynamicState3Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extended_dynamic_state3\0") + } + } + pub const SPEC_VERSION: u32 = 2u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetTessellationDomainOriginEXT = unsafe extern "system" fn( + command_buffer: CommandBuffer, + domain_origin: TessellationDomainOrigin, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetDepthClampEnableEXT = + unsafe extern "system" fn(command_buffer: CommandBuffer, depth_clamp_enable: Bool32); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetPolygonModeEXT = + unsafe extern "system" fn(command_buffer: CommandBuffer, polygon_mode: PolygonMode); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetRasterizationSamplesEXT = unsafe extern "system" fn( + command_buffer: CommandBuffer, + rasterization_samples: SampleCountFlags, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetSampleMaskEXT = unsafe extern "system" fn( + command_buffer: CommandBuffer, + samples: SampleCountFlags, + p_sample_mask: *const SampleMask, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetAlphaToCoverageEnableEXT = + unsafe extern "system" fn(command_buffer: CommandBuffer, alpha_to_coverage_enable: Bool32); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetAlphaToOneEnableEXT = + unsafe extern "system" fn(command_buffer: CommandBuffer, alpha_to_one_enable: Bool32); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetLogicOpEnableEXT = + unsafe extern "system" fn(command_buffer: CommandBuffer, logic_op_enable: Bool32); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetColorBlendEnableEXT = unsafe extern "system" fn( + command_buffer: CommandBuffer, + first_attachment: u32, + attachment_count: u32, + p_color_blend_enables: *const Bool32, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetColorBlendEquationEXT = unsafe extern "system" fn( + command_buffer: CommandBuffer, + first_attachment: u32, + attachment_count: u32, + p_color_blend_equations: *const ColorBlendEquationEXT, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetColorWriteMaskEXT = unsafe extern "system" fn( + command_buffer: CommandBuffer, + first_attachment: u32, + attachment_count: u32, + p_color_write_masks: *const ColorComponentFlags, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetRasterizationStreamEXT = + unsafe extern "system" fn(command_buffer: CommandBuffer, rasterization_stream: u32); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetConservativeRasterizationModeEXT = unsafe extern "system" fn( + command_buffer: CommandBuffer, + conservative_rasterization_mode: ConservativeRasterizationModeEXT, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT = unsafe extern "system" fn( + command_buffer: CommandBuffer, + extra_primitive_overestimation_size: f32, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetDepthClipEnableEXT = + unsafe extern "system" fn(command_buffer: CommandBuffer, depth_clip_enable: Bool32); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetSampleLocationsEnableEXT = + unsafe extern "system" fn(command_buffer: CommandBuffer, sample_locations_enable: Bool32); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetColorBlendAdvancedEXT = unsafe extern "system" fn( + command_buffer: CommandBuffer, + first_attachment: u32, + attachment_count: u32, + p_color_blend_advanced: *const ColorBlendAdvancedEXT, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetProvokingVertexModeEXT = unsafe extern "system" fn( + command_buffer: CommandBuffer, + provoking_vertex_mode: ProvokingVertexModeEXT, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetLineRasterizationModeEXT = unsafe extern "system" fn( + command_buffer: CommandBuffer, + line_rasterization_mode: LineRasterizationModeEXT, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetLineStippleEnableEXT = + unsafe extern "system" fn(command_buffer: CommandBuffer, stippled_line_enable: Bool32); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetDepthClipNegativeOneToOneEXT = + unsafe extern "system" fn(command_buffer: CommandBuffer, negative_one_to_one: Bool32); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetViewportWScalingEnableNV = + unsafe extern "system" fn(command_buffer: CommandBuffer, viewport_w_scaling_enable: Bool32); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetViewportSwizzleNV = unsafe extern "system" fn( + command_buffer: CommandBuffer, + first_viewport: u32, + viewport_count: u32, + p_viewport_swizzles: *const ViewportSwizzleNV, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetCoverageToColorEnableNV = + unsafe extern "system" fn(command_buffer: CommandBuffer, coverage_to_color_enable: Bool32); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetCoverageToColorLocationNV = + unsafe extern "system" fn(command_buffer: CommandBuffer, coverage_to_color_location: u32); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetCoverageModulationModeNV = unsafe extern "system" fn( + command_buffer: CommandBuffer, + coverage_modulation_mode: CoverageModulationModeNV, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetCoverageModulationTableEnableNV = unsafe extern "system" fn( + command_buffer: CommandBuffer, + coverage_modulation_table_enable: Bool32, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetCoverageModulationTableNV = unsafe extern "system" fn( + command_buffer: CommandBuffer, + coverage_modulation_table_count: u32, + p_coverage_modulation_table: *const f32, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetShadingRateImageEnableNV = + unsafe extern "system" fn(command_buffer: CommandBuffer, shading_rate_image_enable: Bool32); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetRepresentativeFragmentTestEnableNV = unsafe extern "system" fn( + command_buffer: CommandBuffer, + representative_fragment_test_enable: Bool32, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetCoverageReductionModeNV = unsafe extern "system" fn( + command_buffer: CommandBuffer, + coverage_reduction_mode: CoverageReductionModeNV, +); +#[derive(Clone)] +pub struct ExtExtendedDynamicState3Fn { + pub cmd_set_tessellation_domain_origin_ext: PFN_vkCmdSetTessellationDomainOriginEXT, + pub cmd_set_depth_clamp_enable_ext: PFN_vkCmdSetDepthClampEnableEXT, + pub cmd_set_polygon_mode_ext: PFN_vkCmdSetPolygonModeEXT, + pub cmd_set_rasterization_samples_ext: PFN_vkCmdSetRasterizationSamplesEXT, + pub cmd_set_sample_mask_ext: PFN_vkCmdSetSampleMaskEXT, + pub cmd_set_alpha_to_coverage_enable_ext: PFN_vkCmdSetAlphaToCoverageEnableEXT, + pub cmd_set_alpha_to_one_enable_ext: PFN_vkCmdSetAlphaToOneEnableEXT, + pub cmd_set_logic_op_enable_ext: PFN_vkCmdSetLogicOpEnableEXT, + pub cmd_set_color_blend_enable_ext: PFN_vkCmdSetColorBlendEnableEXT, + pub cmd_set_color_blend_equation_ext: PFN_vkCmdSetColorBlendEquationEXT, + pub cmd_set_color_write_mask_ext: PFN_vkCmdSetColorWriteMaskEXT, + pub cmd_set_rasterization_stream_ext: PFN_vkCmdSetRasterizationStreamEXT, + pub cmd_set_conservative_rasterization_mode_ext: PFN_vkCmdSetConservativeRasterizationModeEXT, + pub cmd_set_extra_primitive_overestimation_size_ext: + PFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT, + pub cmd_set_depth_clip_enable_ext: PFN_vkCmdSetDepthClipEnableEXT, + pub cmd_set_sample_locations_enable_ext: PFN_vkCmdSetSampleLocationsEnableEXT, + pub cmd_set_color_blend_advanced_ext: PFN_vkCmdSetColorBlendAdvancedEXT, + pub cmd_set_provoking_vertex_mode_ext: PFN_vkCmdSetProvokingVertexModeEXT, + pub cmd_set_line_rasterization_mode_ext: PFN_vkCmdSetLineRasterizationModeEXT, + pub cmd_set_line_stipple_enable_ext: PFN_vkCmdSetLineStippleEnableEXT, + pub cmd_set_depth_clip_negative_one_to_one_ext: PFN_vkCmdSetDepthClipNegativeOneToOneEXT, + pub cmd_set_viewport_w_scaling_enable_nv: PFN_vkCmdSetViewportWScalingEnableNV, + pub cmd_set_viewport_swizzle_nv: PFN_vkCmdSetViewportSwizzleNV, + pub cmd_set_coverage_to_color_enable_nv: PFN_vkCmdSetCoverageToColorEnableNV, + pub cmd_set_coverage_to_color_location_nv: PFN_vkCmdSetCoverageToColorLocationNV, + pub cmd_set_coverage_modulation_mode_nv: PFN_vkCmdSetCoverageModulationModeNV, + pub cmd_set_coverage_modulation_table_enable_nv: PFN_vkCmdSetCoverageModulationTableEnableNV, + pub cmd_set_coverage_modulation_table_nv: PFN_vkCmdSetCoverageModulationTableNV, + pub cmd_set_shading_rate_image_enable_nv: PFN_vkCmdSetShadingRateImageEnableNV, + pub cmd_set_representative_fragment_test_enable_nv: + PFN_vkCmdSetRepresentativeFragmentTestEnableNV, + pub cmd_set_coverage_reduction_mode_nv: PFN_vkCmdSetCoverageReductionModeNV, +} +unsafe impl Send for ExtExtendedDynamicState3Fn {} +unsafe impl Sync for ExtExtendedDynamicState3Fn {} +impl ExtExtendedDynamicState3Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + cmd_set_tessellation_domain_origin_ext: unsafe { + unsafe extern "system" fn cmd_set_tessellation_domain_origin_ext( + _command_buffer: CommandBuffer, + _domain_origin: TessellationDomainOrigin, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_tessellation_domain_origin_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetTessellationDomainOriginEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_tessellation_domain_origin_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_depth_clamp_enable_ext: unsafe { + unsafe extern "system" fn cmd_set_depth_clamp_enable_ext( + _command_buffer: CommandBuffer, + _depth_clamp_enable: Bool32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_depth_clamp_enable_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetDepthClampEnableEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_depth_clamp_enable_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_polygon_mode_ext: unsafe { + unsafe extern "system" fn cmd_set_polygon_mode_ext( + _command_buffer: CommandBuffer, + _polygon_mode: PolygonMode, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_polygon_mode_ext) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetPolygonModeEXT\0"); + let val = _f(cname); + if val.is_null() { + cmd_set_polygon_mode_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_rasterization_samples_ext: unsafe { + unsafe extern "system" fn cmd_set_rasterization_samples_ext( + _command_buffer: CommandBuffer, + _rasterization_samples: SampleCountFlags, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_rasterization_samples_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetRasterizationSamplesEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_rasterization_samples_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_sample_mask_ext: unsafe { + unsafe extern "system" fn cmd_set_sample_mask_ext( + _command_buffer: CommandBuffer, + _samples: SampleCountFlags, + _p_sample_mask: *const SampleMask, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_sample_mask_ext) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetSampleMaskEXT\0"); + let val = _f(cname); + if val.is_null() { + cmd_set_sample_mask_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_alpha_to_coverage_enable_ext: unsafe { + unsafe extern "system" fn cmd_set_alpha_to_coverage_enable_ext( + _command_buffer: CommandBuffer, + _alpha_to_coverage_enable: Bool32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_alpha_to_coverage_enable_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetAlphaToCoverageEnableEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_alpha_to_coverage_enable_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_alpha_to_one_enable_ext: unsafe { + unsafe extern "system" fn cmd_set_alpha_to_one_enable_ext( + _command_buffer: CommandBuffer, + _alpha_to_one_enable: Bool32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_alpha_to_one_enable_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetAlphaToOneEnableEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_alpha_to_one_enable_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_logic_op_enable_ext: unsafe { + unsafe extern "system" fn cmd_set_logic_op_enable_ext( + _command_buffer: CommandBuffer, + _logic_op_enable: Bool32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_logic_op_enable_ext) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetLogicOpEnableEXT\0"); + let val = _f(cname); + if val.is_null() { + cmd_set_logic_op_enable_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_color_blend_enable_ext: unsafe { + unsafe extern "system" fn cmd_set_color_blend_enable_ext( + _command_buffer: CommandBuffer, + _first_attachment: u32, + _attachment_count: u32, + _p_color_blend_enables: *const Bool32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_color_blend_enable_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetColorBlendEnableEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_color_blend_enable_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_color_blend_equation_ext: unsafe { + unsafe extern "system" fn cmd_set_color_blend_equation_ext( + _command_buffer: CommandBuffer, + _first_attachment: u32, + _attachment_count: u32, + _p_color_blend_equations: *const ColorBlendEquationEXT, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_color_blend_equation_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetColorBlendEquationEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_color_blend_equation_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_color_write_mask_ext: unsafe { + unsafe extern "system" fn cmd_set_color_write_mask_ext( + _command_buffer: CommandBuffer, + _first_attachment: u32, + _attachment_count: u32, + _p_color_write_masks: *const ColorComponentFlags, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_color_write_mask_ext) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetColorWriteMaskEXT\0"); + let val = _f(cname); + if val.is_null() { + cmd_set_color_write_mask_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_rasterization_stream_ext: unsafe { + unsafe extern "system" fn cmd_set_rasterization_stream_ext( + _command_buffer: CommandBuffer, + _rasterization_stream: u32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_rasterization_stream_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetRasterizationStreamEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_rasterization_stream_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_conservative_rasterization_mode_ext: unsafe { + unsafe extern "system" fn cmd_set_conservative_rasterization_mode_ext( + _command_buffer: CommandBuffer, + _conservative_rasterization_mode: ConservativeRasterizationModeEXT, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_conservative_rasterization_mode_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetConservativeRasterizationModeEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_conservative_rasterization_mode_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_extra_primitive_overestimation_size_ext: unsafe { + unsafe extern "system" fn cmd_set_extra_primitive_overestimation_size_ext( + _command_buffer: CommandBuffer, + _extra_primitive_overestimation_size: f32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_extra_primitive_overestimation_size_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetExtraPrimitiveOverestimationSizeEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_extra_primitive_overestimation_size_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_depth_clip_enable_ext: unsafe { + unsafe extern "system" fn cmd_set_depth_clip_enable_ext( + _command_buffer: CommandBuffer, + _depth_clip_enable: Bool32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_depth_clip_enable_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetDepthClipEnableEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_depth_clip_enable_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_sample_locations_enable_ext: unsafe { + unsafe extern "system" fn cmd_set_sample_locations_enable_ext( + _command_buffer: CommandBuffer, + _sample_locations_enable: Bool32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_sample_locations_enable_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetSampleLocationsEnableEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_sample_locations_enable_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_color_blend_advanced_ext: unsafe { + unsafe extern "system" fn cmd_set_color_blend_advanced_ext( + _command_buffer: CommandBuffer, + _first_attachment: u32, + _attachment_count: u32, + _p_color_blend_advanced: *const ColorBlendAdvancedEXT, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_color_blend_advanced_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetColorBlendAdvancedEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_color_blend_advanced_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_provoking_vertex_mode_ext: unsafe { + unsafe extern "system" fn cmd_set_provoking_vertex_mode_ext( + _command_buffer: CommandBuffer, + _provoking_vertex_mode: ProvokingVertexModeEXT, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_provoking_vertex_mode_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetProvokingVertexModeEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_provoking_vertex_mode_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_line_rasterization_mode_ext: unsafe { + unsafe extern "system" fn cmd_set_line_rasterization_mode_ext( + _command_buffer: CommandBuffer, + _line_rasterization_mode: LineRasterizationModeEXT, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_line_rasterization_mode_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetLineRasterizationModeEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_line_rasterization_mode_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_line_stipple_enable_ext: unsafe { + unsafe extern "system" fn cmd_set_line_stipple_enable_ext( + _command_buffer: CommandBuffer, + _stippled_line_enable: Bool32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_line_stipple_enable_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetLineStippleEnableEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_line_stipple_enable_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_depth_clip_negative_one_to_one_ext: unsafe { + unsafe extern "system" fn cmd_set_depth_clip_negative_one_to_one_ext( + _command_buffer: CommandBuffer, + _negative_one_to_one: Bool32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_depth_clip_negative_one_to_one_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetDepthClipNegativeOneToOneEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_depth_clip_negative_one_to_one_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_viewport_w_scaling_enable_nv: unsafe { + unsafe extern "system" fn cmd_set_viewport_w_scaling_enable_nv( + _command_buffer: CommandBuffer, + _viewport_w_scaling_enable: Bool32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_viewport_w_scaling_enable_nv) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetViewportWScalingEnableNV\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_viewport_w_scaling_enable_nv + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_viewport_swizzle_nv: unsafe { + unsafe extern "system" fn cmd_set_viewport_swizzle_nv( + _command_buffer: CommandBuffer, + _first_viewport: u32, + _viewport_count: u32, + _p_viewport_swizzles: *const ViewportSwizzleNV, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_viewport_swizzle_nv) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetViewportSwizzleNV\0"); + let val = _f(cname); + if val.is_null() { + cmd_set_viewport_swizzle_nv + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_coverage_to_color_enable_nv: unsafe { + unsafe extern "system" fn cmd_set_coverage_to_color_enable_nv( + _command_buffer: CommandBuffer, + _coverage_to_color_enable: Bool32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_coverage_to_color_enable_nv) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetCoverageToColorEnableNV\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_coverage_to_color_enable_nv + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_coverage_to_color_location_nv: unsafe { + unsafe extern "system" fn cmd_set_coverage_to_color_location_nv( + _command_buffer: CommandBuffer, + _coverage_to_color_location: u32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_coverage_to_color_location_nv) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetCoverageToColorLocationNV\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_coverage_to_color_location_nv + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_coverage_modulation_mode_nv: unsafe { + unsafe extern "system" fn cmd_set_coverage_modulation_mode_nv( + _command_buffer: CommandBuffer, + _coverage_modulation_mode: CoverageModulationModeNV, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_coverage_modulation_mode_nv) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetCoverageModulationModeNV\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_coverage_modulation_mode_nv + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_coverage_modulation_table_enable_nv: unsafe { + unsafe extern "system" fn cmd_set_coverage_modulation_table_enable_nv( + _command_buffer: CommandBuffer, + _coverage_modulation_table_enable: Bool32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_coverage_modulation_table_enable_nv) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetCoverageModulationTableEnableNV\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_coverage_modulation_table_enable_nv + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_coverage_modulation_table_nv: unsafe { + unsafe extern "system" fn cmd_set_coverage_modulation_table_nv( + _command_buffer: CommandBuffer, + _coverage_modulation_table_count: u32, + _p_coverage_modulation_table: *const f32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_coverage_modulation_table_nv) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetCoverageModulationTableNV\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_coverage_modulation_table_nv + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_shading_rate_image_enable_nv: unsafe { + unsafe extern "system" fn cmd_set_shading_rate_image_enable_nv( + _command_buffer: CommandBuffer, + _shading_rate_image_enable: Bool32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_shading_rate_image_enable_nv) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetShadingRateImageEnableNV\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_shading_rate_image_enable_nv + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_representative_fragment_test_enable_nv: unsafe { + unsafe extern "system" fn cmd_set_representative_fragment_test_enable_nv( + _command_buffer: CommandBuffer, + _representative_fragment_test_enable: Bool32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_representative_fragment_test_enable_nv) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetRepresentativeFragmentTestEnableNV\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_representative_fragment_test_enable_nv + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_coverage_reduction_mode_nv: unsafe { + unsafe extern "system" fn cmd_set_coverage_reduction_mode_nv( + _command_buffer: CommandBuffer, + _coverage_reduction_mode: CoverageReductionModeNV, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_coverage_reduction_mode_nv) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetCoverageReductionModeNV\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_coverage_reduction_mode_nv + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_EXT_extended_dynamic_state3'"] +impl DynamicState { + pub const TESSELLATION_DOMAIN_ORIGIN_EXT: Self = Self(1_000_455_002); + pub const DEPTH_CLAMP_ENABLE_EXT: Self = Self(1_000_455_003); + pub const POLYGON_MODE_EXT: Self = Self(1_000_455_004); + pub const RASTERIZATION_SAMPLES_EXT: Self = Self(1_000_455_005); + pub const SAMPLE_MASK_EXT: Self = Self(1_000_455_006); + pub const ALPHA_TO_COVERAGE_ENABLE_EXT: Self = Self(1_000_455_007); + pub const ALPHA_TO_ONE_ENABLE_EXT: Self = Self(1_000_455_008); + pub const LOGIC_OP_ENABLE_EXT: Self = Self(1_000_455_009); + pub const COLOR_BLEND_ENABLE_EXT: Self = Self(1_000_455_010); + pub const COLOR_BLEND_EQUATION_EXT: Self = Self(1_000_455_011); + pub const COLOR_WRITE_MASK_EXT: Self = Self(1_000_455_012); + pub const RASTERIZATION_STREAM_EXT: Self = Self(1_000_455_013); + pub const CONSERVATIVE_RASTERIZATION_MODE_EXT: Self = Self(1_000_455_014); + pub const EXTRA_PRIMITIVE_OVERESTIMATION_SIZE_EXT: Self = Self(1_000_455_015); + pub const DEPTH_CLIP_ENABLE_EXT: Self = Self(1_000_455_016); + pub const SAMPLE_LOCATIONS_ENABLE_EXT: Self = Self(1_000_455_017); + pub const COLOR_BLEND_ADVANCED_EXT: Self = Self(1_000_455_018); + pub const PROVOKING_VERTEX_MODE_EXT: Self = Self(1_000_455_019); + pub const LINE_RASTERIZATION_MODE_EXT: Self = Self(1_000_455_020); + pub const LINE_STIPPLE_ENABLE_EXT: Self = Self(1_000_455_021); + pub const DEPTH_CLIP_NEGATIVE_ONE_TO_ONE_EXT: Self = Self(1_000_455_022); + pub const VIEWPORT_W_SCALING_ENABLE_NV: Self = Self(1_000_455_023); + pub const VIEWPORT_SWIZZLE_NV: Self = Self(1_000_455_024); + pub const COVERAGE_TO_COLOR_ENABLE_NV: Self = Self(1_000_455_025); + pub const COVERAGE_TO_COLOR_LOCATION_NV: Self = Self(1_000_455_026); + pub const COVERAGE_MODULATION_MODE_NV: Self = Self(1_000_455_027); + pub const COVERAGE_MODULATION_TABLE_ENABLE_NV: Self = Self(1_000_455_028); + pub const COVERAGE_MODULATION_TABLE_NV: Self = Self(1_000_455_029); + pub const SHADING_RATE_IMAGE_ENABLE_NV: Self = Self(1_000_455_030); + pub const REPRESENTATIVE_FRAGMENT_TEST_ENABLE_NV: Self = Self(1_000_455_031); + pub const COVERAGE_REDUCTION_MODE_NV: Self = Self(1_000_455_032); +} +#[doc = "Generated from 'VK_EXT_extended_dynamic_state3'"] +impl StructureType { + pub const PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT: Self = Self(1_000_455_000); + pub const PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT: Self = Self(1_000_455_001); +} +impl ExtExtension457Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_457\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct ExtExtension457Fn {} +unsafe impl Send for ExtExtension457Fn {} +unsafe impl Sync for ExtExtension457Fn {} +impl ExtExtension457Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtExtension458Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_458\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct ExtExtension458Fn {} +unsafe impl Send for ExtExtension458Fn {} +unsafe impl Sync for ExtExtension458Fn {} +impl ExtExtension458Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtSubpassMergeFeedbackFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_subpass_merge_feedback\0") + } + } + pub const SPEC_VERSION: u32 = 2u32; +} +#[derive(Clone)] +pub struct ExtSubpassMergeFeedbackFn {} +unsafe impl Send for ExtSubpassMergeFeedbackFn {} +unsafe impl Sync for ExtSubpassMergeFeedbackFn {} +impl ExtSubpassMergeFeedbackFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_subpass_merge_feedback'"] +impl StructureType { + pub const PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT: Self = Self(1_000_458_000); + pub const RENDER_PASS_CREATION_CONTROL_EXT: Self = Self(1_000_458_001); + pub const RENDER_PASS_CREATION_FEEDBACK_CREATE_INFO_EXT: Self = Self(1_000_458_002); + pub const RENDER_PASS_SUBPASS_FEEDBACK_CREATE_INFO_EXT: Self = Self(1_000_458_003); +} +impl LunargDirectDriverLoadingFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_LUNARG_direct_driver_loading\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct LunargDirectDriverLoadingFn {} +unsafe impl Send for LunargDirectDriverLoadingFn {} +unsafe impl Sync for LunargDirectDriverLoadingFn {} +impl LunargDirectDriverLoadingFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_LUNARG_direct_driver_loading'"] +impl StructureType { + pub const DIRECT_DRIVER_LOADING_INFO_LUNARG: Self = Self(1_000_459_000); + pub const DIRECT_DRIVER_LOADING_LIST_LUNARG: Self = Self(1_000_459_001); +} +impl ExtExtension461Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_461\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct ExtExtension461Fn {} +unsafe impl Send for ExtExtension461Fn {} +unsafe impl Sync for ExtExtension461Fn {} +impl ExtExtension461Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_extension_461'"] +impl FormatFeatureFlags2 { + pub const RESERVED_39_EXT: Self = Self(0b1000_0000_0000_0000_0000_0000_0000_0000_0000_0000); +} +impl ExtExtension462Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_462\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct ExtExtension462Fn {} +unsafe impl Send for ExtExtension462Fn {} +unsafe impl Sync for ExtExtension462Fn {} +impl ExtExtension462Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtShaderModuleIdentifierFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_shader_module_identifier\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkGetShaderModuleIdentifierEXT = unsafe extern "system" fn( + device: Device, + shader_module: ShaderModule, + p_identifier: *mut ShaderModuleIdentifierEXT, +); +#[allow(non_camel_case_types)] +pub type PFN_vkGetShaderModuleCreateInfoIdentifierEXT = unsafe extern "system" fn( + device: Device, + p_create_info: *const ShaderModuleCreateInfo, + p_identifier: *mut ShaderModuleIdentifierEXT, +); +#[derive(Clone)] +pub struct ExtShaderModuleIdentifierFn { + pub get_shader_module_identifier_ext: PFN_vkGetShaderModuleIdentifierEXT, + pub get_shader_module_create_info_identifier_ext: PFN_vkGetShaderModuleCreateInfoIdentifierEXT, +} +unsafe impl Send for ExtShaderModuleIdentifierFn {} +unsafe impl Sync for ExtShaderModuleIdentifierFn {} +impl ExtShaderModuleIdentifierFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + get_shader_module_identifier_ext: unsafe { + unsafe extern "system" fn get_shader_module_identifier_ext( + _device: Device, + _shader_module: ShaderModule, + _p_identifier: *mut ShaderModuleIdentifierEXT, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_shader_module_identifier_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetShaderModuleIdentifierEXT\0", + ); + let val = _f(cname); + if val.is_null() { + get_shader_module_identifier_ext + } else { + ::std::mem::transmute(val) + } + }, + get_shader_module_create_info_identifier_ext: unsafe { + unsafe extern "system" fn get_shader_module_create_info_identifier_ext( + _device: Device, + _p_create_info: *const ShaderModuleCreateInfo, + _p_identifier: *mut ShaderModuleIdentifierEXT, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_shader_module_create_info_identifier_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetShaderModuleCreateInfoIdentifierEXT\0", + ); + let val = _f(cname); + if val.is_null() { + get_shader_module_create_info_identifier_ext + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_EXT_shader_module_identifier'"] +impl StructureType { + pub const PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT: Self = Self(1_000_462_000); + pub const PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT: Self = Self(1_000_462_001); + pub const PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT: Self = Self(1_000_462_002); + pub const SHADER_MODULE_IDENTIFIER_EXT: Self = Self(1_000_462_003); +} +impl ExtRasterizationOrderAttachmentAccessFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"VK_EXT_rasterization_order_attachment_access\0", + ) + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct ExtRasterizationOrderAttachmentAccessFn {} +unsafe impl Send for ExtRasterizationOrderAttachmentAccessFn {} +unsafe impl Sync for ExtRasterizationOrderAttachmentAccessFn {} +impl ExtRasterizationOrderAttachmentAccessFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_rasterization_order_attachment_access'"] +impl PipelineColorBlendStateCreateFlags { + pub const RASTERIZATION_ORDER_ATTACHMENT_ACCESS_EXT: Self = Self(0b1); +} +#[doc = "Generated from 'VK_EXT_rasterization_order_attachment_access'"] +impl PipelineDepthStencilStateCreateFlags { + pub const RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_EXT: Self = Self(0b1); + pub const RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_EXT: Self = Self(0b10); +} +#[doc = "Generated from 'VK_EXT_rasterization_order_attachment_access'"] +impl StructureType { + pub const PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT: Self = + Self(1_000_342_000); +} +#[doc = "Generated from 'VK_EXT_rasterization_order_attachment_access'"] +impl SubpassDescriptionFlags { + pub const RASTERIZATION_ORDER_ATTACHMENT_COLOR_ACCESS_EXT: Self = Self(0b1_0000); + pub const RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_EXT: Self = Self(0b10_0000); + pub const RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_EXT: Self = Self(0b100_0000); +} +impl NvOpticalFlowFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_optical_flow\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkGetPhysicalDeviceOpticalFlowImageFormatsNV = unsafe extern "system" fn( + physical_device: PhysicalDevice, + p_optical_flow_image_format_info: *const OpticalFlowImageFormatInfoNV, + p_format_count: *mut u32, + p_image_format_properties: *mut OpticalFlowImageFormatPropertiesNV, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkCreateOpticalFlowSessionNV = unsafe extern "system" fn( + device: Device, + p_create_info: *const OpticalFlowSessionCreateInfoNV, + p_allocator: *const AllocationCallbacks, + p_session: *mut OpticalFlowSessionNV, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkDestroyOpticalFlowSessionNV = unsafe extern "system" fn( + device: Device, + session: OpticalFlowSessionNV, + p_allocator: *const AllocationCallbacks, +); +#[allow(non_camel_case_types)] +pub type PFN_vkBindOpticalFlowSessionImageNV = unsafe extern "system" fn( + device: Device, + session: OpticalFlowSessionNV, + binding_point: OpticalFlowSessionBindingPointNV, + view: ImageView, + layout: ImageLayout, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkCmdOpticalFlowExecuteNV = unsafe extern "system" fn( + command_buffer: CommandBuffer, + session: OpticalFlowSessionNV, + p_execute_info: *const OpticalFlowExecuteInfoNV, +); +#[derive(Clone)] +pub struct NvOpticalFlowFn { + pub get_physical_device_optical_flow_image_formats_nv: + PFN_vkGetPhysicalDeviceOpticalFlowImageFormatsNV, + pub create_optical_flow_session_nv: PFN_vkCreateOpticalFlowSessionNV, + pub destroy_optical_flow_session_nv: PFN_vkDestroyOpticalFlowSessionNV, + pub bind_optical_flow_session_image_nv: PFN_vkBindOpticalFlowSessionImageNV, + pub cmd_optical_flow_execute_nv: PFN_vkCmdOpticalFlowExecuteNV, +} +unsafe impl Send for NvOpticalFlowFn {} +unsafe impl Sync for NvOpticalFlowFn {} +impl NvOpticalFlowFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + get_physical_device_optical_flow_image_formats_nv: unsafe { + unsafe extern "system" fn get_physical_device_optical_flow_image_formats_nv( + _physical_device: PhysicalDevice, + _p_optical_flow_image_format_info: *const OpticalFlowImageFormatInfoNV, + _p_format_count: *mut u32, + _p_image_format_properties: *mut OpticalFlowImageFormatPropertiesNV, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_optical_flow_image_formats_nv) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPhysicalDeviceOpticalFlowImageFormatsNV\0", + ); + let val = _f(cname); + if val.is_null() { + get_physical_device_optical_flow_image_formats_nv + } else { + ::std::mem::transmute(val) + } + }, + create_optical_flow_session_nv: unsafe { + unsafe extern "system" fn create_optical_flow_session_nv( + _device: Device, + _p_create_info: *const OpticalFlowSessionCreateInfoNV, + _p_allocator: *const AllocationCallbacks, + _p_session: *mut OpticalFlowSessionNV, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(create_optical_flow_session_nv) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCreateOpticalFlowSessionNV\0", + ); + let val = _f(cname); + if val.is_null() { + create_optical_flow_session_nv + } else { + ::std::mem::transmute(val) + } + }, + destroy_optical_flow_session_nv: unsafe { + unsafe extern "system" fn destroy_optical_flow_session_nv( + _device: Device, + _session: OpticalFlowSessionNV, + _p_allocator: *const AllocationCallbacks, + ) { + panic!(concat!( + "Unable to load ", + stringify!(destroy_optical_flow_session_nv) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkDestroyOpticalFlowSessionNV\0", + ); + let val = _f(cname); + if val.is_null() { + destroy_optical_flow_session_nv + } else { + ::std::mem::transmute(val) + } + }, + bind_optical_flow_session_image_nv: unsafe { + unsafe extern "system" fn bind_optical_flow_session_image_nv( + _device: Device, + _session: OpticalFlowSessionNV, + _binding_point: OpticalFlowSessionBindingPointNV, + _view: ImageView, + _layout: ImageLayout, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(bind_optical_flow_session_image_nv) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkBindOpticalFlowSessionImageNV\0", + ); + let val = _f(cname); + if val.is_null() { + bind_optical_flow_session_image_nv + } else { + ::std::mem::transmute(val) + } + }, + cmd_optical_flow_execute_nv: unsafe { + unsafe extern "system" fn cmd_optical_flow_execute_nv( + _command_buffer: CommandBuffer, + _session: OpticalFlowSessionNV, + _p_execute_info: *const OpticalFlowExecuteInfoNV, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_optical_flow_execute_nv) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdOpticalFlowExecuteNV\0"); + let val = _f(cname); + if val.is_null() { + cmd_optical_flow_execute_nv + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_NV_optical_flow'"] +impl AccessFlags2 { + pub const OPTICAL_FLOW_READ_NV: Self = + Self(0b100_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000); + pub const OPTICAL_FLOW_WRITE_NV: Self = + Self(0b1000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_NV_optical_flow'"] +impl Format { + pub const R16G16_S10_5_NV: Self = Self(1_000_464_000); +} +#[doc = "Generated from 'VK_NV_optical_flow'"] +impl FormatFeatureFlags2 { + pub const OPTICAL_FLOW_IMAGE_NV: Self = + Self(0b1_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000); + pub const OPTICAL_FLOW_VECTOR_NV: Self = + Self(0b10_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000); + pub const OPTICAL_FLOW_COST_NV: Self = + Self(0b100_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_NV_optical_flow'"] +impl ObjectType { + pub const OPTICAL_FLOW_SESSION_NV: Self = Self(1_000_464_000); +} +#[doc = "Generated from 'VK_NV_optical_flow'"] +impl PipelineStageFlags2 { + pub const OPTICAL_FLOW_NV: Self = Self(0b10_0000_0000_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_NV_optical_flow'"] +impl QueueFlags { + pub const OPTICAL_FLOW_NV: Self = Self(0b1_0000_0000); +} +#[doc = "Generated from 'VK_NV_optical_flow'"] +impl StructureType { + pub const PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV: Self = Self(1_000_464_000); + pub const PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV: Self = Self(1_000_464_001); + pub const OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV: Self = Self(1_000_464_002); + pub const OPTICAL_FLOW_IMAGE_FORMAT_PROPERTIES_NV: Self = Self(1_000_464_003); + pub const OPTICAL_FLOW_SESSION_CREATE_INFO_NV: Self = Self(1_000_464_004); + pub const OPTICAL_FLOW_EXECUTE_INFO_NV: Self = Self(1_000_464_005); + pub const OPTICAL_FLOW_SESSION_CREATE_PRIVATE_DATA_INFO_NV: Self = Self(1_000_464_010); +} +impl ExtLegacyDitheringFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_legacy_dithering\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct ExtLegacyDitheringFn {} +unsafe impl Send for ExtLegacyDitheringFn {} +unsafe impl Sync for ExtLegacyDitheringFn {} +impl ExtLegacyDitheringFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_legacy_dithering'"] +impl RenderingFlags { + pub const ENABLE_LEGACY_DITHERING_EXT: Self = Self(0b1000); +} +#[doc = "Generated from 'VK_EXT_legacy_dithering'"] +impl StructureType { + pub const PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT: Self = Self(1_000_465_000); +} +#[doc = "Generated from 'VK_EXT_legacy_dithering'"] +impl SubpassDescriptionFlags { + pub const ENABLE_LEGACY_DITHERING_EXT: Self = Self(0b1000_0000); +} +impl ExtPipelineProtectedAccessFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_pipeline_protected_access\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct ExtPipelineProtectedAccessFn {} +unsafe impl Send for ExtPipelineProtectedAccessFn {} +unsafe impl Sync for ExtPipelineProtectedAccessFn {} +impl ExtPipelineProtectedAccessFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_pipeline_protected_access'"] +impl PipelineCreateFlags { + pub const NO_PROTECTED_ACCESS_EXT: Self = Self(0b1000_0000_0000_0000_0000_0000_0000); + pub const PROTECTED_ACCESS_ONLY_EXT: Self = Self(0b100_0000_0000_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_EXT_pipeline_protected_access'"] +impl StructureType { + pub const PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT: Self = Self(1_000_466_000); +} +impl ExtExtension468Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_468\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct ExtExtension468Fn {} +unsafe impl Send for ExtExtension468Fn {} +unsafe impl Sync for ExtExtension468Fn {} +impl ExtExtension468Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl AndroidExtension469Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_ANDROID_extension_469\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct AndroidExtension469Fn {} +unsafe impl Send for AndroidExtension469Fn {} +unsafe impl Sync for AndroidExtension469Fn {} +impl AndroidExtension469Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl AmdExtension470Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_470\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct AmdExtension470Fn {} +unsafe impl Send for AmdExtension470Fn {} +unsafe impl Sync for AmdExtension470Fn {} +impl AmdExtension470Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl AmdExtension471Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_471\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct AmdExtension471Fn {} +unsafe impl Send for AmdExtension471Fn {} +unsafe impl Sync for AmdExtension471Fn {} +impl AmdExtension471Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl AmdExtension472Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_472\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct AmdExtension472Fn {} +unsafe impl Send for AmdExtension472Fn {} +unsafe impl Sync for AmdExtension472Fn {} +impl AmdExtension472Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl AmdExtension473Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_473\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct AmdExtension473Fn {} +unsafe impl Send for AmdExtension473Fn {} +unsafe impl Sync for AmdExtension473Fn {} +impl AmdExtension473Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl AmdExtension474Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_474\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct AmdExtension474Fn {} +unsafe impl Send for AmdExtension474Fn {} +unsafe impl Sync for AmdExtension474Fn {} +impl AmdExtension474Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl AmdExtension475Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_475\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct AmdExtension475Fn {} +unsafe impl Send for AmdExtension475Fn {} +unsafe impl Sync for AmdExtension475Fn {} +impl AmdExtension475Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl AmdExtension476Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_476\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct AmdExtension476Fn {} +unsafe impl Send for AmdExtension476Fn {} +unsafe impl Sync for AmdExtension476Fn {} +impl AmdExtension476Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl AmdExtension477Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_477\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct AmdExtension477Fn {} +unsafe impl Send for AmdExtension477Fn {} +unsafe impl Sync for AmdExtension477Fn {} +impl AmdExtension477Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl AmdExtension478Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_478\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct AmdExtension478Fn {} +unsafe impl Send for AmdExtension478Fn {} +unsafe impl Sync for AmdExtension478Fn {} +impl AmdExtension478Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl AmdExtension479Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_479\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct AmdExtension479Fn {} +unsafe impl Send for AmdExtension479Fn {} +unsafe impl Sync for AmdExtension479Fn {} +impl AmdExtension479Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtExtension480Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_480\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct ExtExtension480Fn {} +unsafe impl Send for ExtExtension480Fn {} +unsafe impl Sync for ExtExtension480Fn {} +impl ExtExtension480Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtExtension481Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_481\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct ExtExtension481Fn {} +unsafe impl Send for ExtExtension481Fn {} +unsafe impl Sync for ExtExtension481Fn {} +impl ExtExtension481Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtExtension482Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_482\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct ExtExtension482Fn {} +unsafe impl Send for ExtExtension482Fn {} +unsafe impl Sync for ExtExtension482Fn {} +impl ExtExtension482Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtExtension483Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_483\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct ExtExtension483Fn {} +unsafe impl Send for ExtExtension483Fn {} +unsafe impl Sync for ExtExtension483Fn {} +impl ExtExtension483Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_extension_483'"] +impl ShaderStageFlags { + pub const EXT_483_RESERVE_15: Self = Self(0b1000_0000_0000_0000); + pub const EXT_483_RESERVE_16: Self = Self(0b1_0000_0000_0000_0000); + pub const EXT_483_RESERVE_17: Self = Self(0b10_0000_0000_0000_0000); +} +impl ExtExtension484Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_484\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct ExtExtension484Fn {} +unsafe impl Send for ExtExtension484Fn {} +unsafe impl Sync for ExtExtension484Fn {} +impl ExtExtension484Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl QcomTilePropertiesFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_QCOM_tile_properties\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkGetFramebufferTilePropertiesQCOM = unsafe extern "system" fn( + device: Device, + framebuffer: Framebuffer, + p_properties_count: *mut u32, + p_properties: *mut TilePropertiesQCOM, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetDynamicRenderingTilePropertiesQCOM = unsafe extern "system" fn( + device: Device, + p_rendering_info: *const RenderingInfo, + p_properties: *mut TilePropertiesQCOM, +) -> Result; +#[derive(Clone)] +pub struct QcomTilePropertiesFn { + pub get_framebuffer_tile_properties_qcom: PFN_vkGetFramebufferTilePropertiesQCOM, + pub get_dynamic_rendering_tile_properties_qcom: PFN_vkGetDynamicRenderingTilePropertiesQCOM, +} +unsafe impl Send for QcomTilePropertiesFn {} +unsafe impl Sync for QcomTilePropertiesFn {} +impl QcomTilePropertiesFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + get_framebuffer_tile_properties_qcom: unsafe { + unsafe extern "system" fn get_framebuffer_tile_properties_qcom( + _device: Device, + _framebuffer: Framebuffer, + _p_properties_count: *mut u32, + _p_properties: *mut TilePropertiesQCOM, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_framebuffer_tile_properties_qcom) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetFramebufferTilePropertiesQCOM\0", + ); + let val = _f(cname); + if val.is_null() { + get_framebuffer_tile_properties_qcom + } else { + ::std::mem::transmute(val) + } + }, + get_dynamic_rendering_tile_properties_qcom: unsafe { + unsafe extern "system" fn get_dynamic_rendering_tile_properties_qcom( + _device: Device, + _p_rendering_info: *const RenderingInfo, + _p_properties: *mut TilePropertiesQCOM, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_dynamic_rendering_tile_properties_qcom) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetDynamicRenderingTilePropertiesQCOM\0", + ); + let val = _f(cname); + if val.is_null() { + get_dynamic_rendering_tile_properties_qcom + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_QCOM_tile_properties'"] +impl StructureType { + pub const PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM: Self = Self(1_000_484_000); + pub const TILE_PROPERTIES_QCOM: Self = Self(1_000_484_001); +} +impl SecAmigoProfilingFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_SEC_amigo_profiling\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct SecAmigoProfilingFn {} +unsafe impl Send for SecAmigoProfilingFn {} +unsafe impl Sync for SecAmigoProfilingFn {} +impl SecAmigoProfilingFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_SEC_amigo_profiling'"] +impl StructureType { + pub const PHYSICAL_DEVICE_AMIGO_PROFILING_FEATURES_SEC: Self = Self(1_000_485_000); + pub const AMIGO_PROFILING_SUBMIT_INFO_SEC: Self = Self(1_000_485_001); +} +impl ExtExtension487Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_487\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct ExtExtension487Fn {} +unsafe impl Send for ExtExtension487Fn {} +unsafe impl Sync for ExtExtension487Fn {} +impl ExtExtension487Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtExtension488Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_488\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct ExtExtension488Fn {} +unsafe impl Send for ExtExtension488Fn {} +unsafe impl Sync for ExtExtension488Fn {} +impl ExtExtension488Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl QcomMultiviewPerViewViewportsFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"VK_QCOM_multiview_per_view_viewports\0", + ) + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct QcomMultiviewPerViewViewportsFn {} +unsafe impl Send for QcomMultiviewPerViewViewportsFn {} +unsafe impl Sync for QcomMultiviewPerViewViewportsFn {} +impl QcomMultiviewPerViewViewportsFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_QCOM_multiview_per_view_viewports'"] +impl StructureType { + pub const PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM: Self = + Self(1_000_488_000); +} +impl NvExtension490Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_490\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct NvExtension490Fn {} +unsafe impl Send for NvExtension490Fn {} +unsafe impl Sync for NvExtension490Fn {} +impl NvExtension490Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl NvRayTracingInvocationReorderFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"VK_NV_ray_tracing_invocation_reorder\0", + ) + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct NvRayTracingInvocationReorderFn {} +unsafe impl Send for NvRayTracingInvocationReorderFn {} +unsafe impl Sync for NvRayTracingInvocationReorderFn {} +impl NvRayTracingInvocationReorderFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_NV_ray_tracing_invocation_reorder'"] +impl StructureType { + pub const PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV: Self = + Self(1_000_490_000); + pub const PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV: Self = + Self(1_000_490_001); +} +impl NvExtension492Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_492\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct NvExtension492Fn {} +unsafe impl Send for NvExtension492Fn {} +unsafe impl Sync for NvExtension492Fn {} +impl NvExtension492Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl NvExtension493Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_493\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct NvExtension493Fn {} +unsafe impl Send for NvExtension493Fn {} +unsafe impl Sync for NvExtension493Fn {} +impl NvExtension493Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl NvExtension494Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_494\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct NvExtension494Fn {} +unsafe impl Send for NvExtension494Fn {} +unsafe impl Sync for NvExtension494Fn {} +impl NvExtension494Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtMutableDescriptorTypeFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_mutable_descriptor_type\0") + } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct ExtMutableDescriptorTypeFn {} +unsafe impl Send for ExtMutableDescriptorTypeFn {} +unsafe impl Sync for ExtMutableDescriptorTypeFn {} +impl ExtMutableDescriptorTypeFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_mutable_descriptor_type'"] +impl DescriptorPoolCreateFlags { + pub const HOST_ONLY_EXT: Self = Self(0b100); +} +#[doc = "Generated from 'VK_EXT_mutable_descriptor_type'"] +impl DescriptorSetLayoutCreateFlags { + pub const HOST_ONLY_POOL_EXT: Self = Self(0b100); +} +#[doc = "Generated from 'VK_EXT_mutable_descriptor_type'"] +impl DescriptorType { + pub const MUTABLE_EXT: Self = Self(1_000_351_000); +} +#[doc = "Generated from 'VK_EXT_mutable_descriptor_type'"] +impl StructureType { + pub const PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT: Self = Self(1_000_351_000); + pub const MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT: Self = Self(1_000_351_002); +} +impl ExtExtension496Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_496\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct ExtExtension496Fn {} +unsafe impl Send for ExtExtension496Fn {} +unsafe impl Sync for ExtExtension496Fn {} +impl ExtExtension496Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtExtension497Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_497\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct ExtExtension497Fn {} +unsafe impl Send for ExtExtension497Fn {} +unsafe impl Sync for ExtExtension497Fn {} +impl ExtExtension497Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ArmShaderCoreBuiltinsFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_ARM_shader_core_builtins\0") } + } + pub const SPEC_VERSION: u32 = 2u32; +} +#[derive(Clone)] +pub struct ArmShaderCoreBuiltinsFn {} +unsafe impl Send for ArmShaderCoreBuiltinsFn {} +unsafe impl Sync for ArmShaderCoreBuiltinsFn {} +impl ArmShaderCoreBuiltinsFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_ARM_shader_core_builtins'"] +impl StructureType { + pub const PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM: Self = Self(1_000_497_000); + pub const PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM: Self = Self(1_000_497_001); +} +impl ExtExtension499Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_499\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct ExtExtension499Fn {} +unsafe impl Send for ExtExtension499Fn {} +unsafe impl Sync for ExtExtension499Fn {} +impl ExtExtension499Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtExtension500Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_500\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct ExtExtension500Fn {} +unsafe impl Send for ExtExtension500Fn {} +unsafe impl Sync for ExtExtension500Fn {} +impl ExtExtension500Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtExtension501Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_501\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct ExtExtension501Fn {} +unsafe impl Send for ExtExtension501Fn {} +unsafe impl Sync for ExtExtension501Fn {} +impl ExtExtension501Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtExtension502Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_502\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct ExtExtension502Fn {} +unsafe impl Send for ExtExtension502Fn {} +unsafe impl Sync for ExtExtension502Fn {} +impl ExtExtension502Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtExtension503Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_503\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct ExtExtension503Fn {} +unsafe impl Send for ExtExtension503Fn {} +unsafe impl Sync for ExtExtension503Fn {} +impl ExtExtension503Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl NvExtension504Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_504\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct NvExtension504Fn {} +unsafe impl Send for NvExtension504Fn {} +unsafe impl Sync for NvExtension504Fn {} +impl NvExtension504Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtExtension505Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_505\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct ExtExtension505Fn {} +unsafe impl Send for ExtExtension505Fn {} +unsafe impl Sync for ExtExtension505Fn {} +impl ExtExtension505Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl NvExtension506Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_506\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct NvExtension506Fn {} +unsafe impl Send for NvExtension506Fn {} +unsafe impl Sync for NvExtension506Fn {} +impl NvExtension506Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} diff --git a/third_party/rust/ash/src/vk/feature_extensions.rs b/third_party/rust/ash/src/vk/feature_extensions.rs new file mode 100644 index 0000000000..4b1820c9a7 --- /dev/null +++ b/third_party/rust/ash/src/vk/feature_extensions.rs @@ -0,0 +1,451 @@ +use crate::vk::bitflags::*; +use crate::vk::enums::*; +#[doc = "Generated from 'VK_VERSION_1_1'"] +impl BufferCreateFlags { + #[doc = "Buffer requires protected memory"] + pub const PROTECTED: Self = Self(0b1000); +} +#[doc = "Generated from 'VK_VERSION_1_1'"] +impl CommandPoolCreateFlags { + #[doc = "Command buffers allocated from pool are protected command buffers"] + pub const PROTECTED: Self = Self(0b100); +} +#[doc = "Generated from 'VK_VERSION_1_1'"] +impl DependencyFlags { + #[doc = "Dependency is across devices"] + pub const DEVICE_GROUP: Self = Self(0b100); + pub const VIEW_LOCAL: Self = Self(0b10); +} +#[doc = "Generated from 'VK_VERSION_1_1'"] +impl DeviceQueueCreateFlags { + #[doc = "Queue is a protected-capable device queue"] + pub const PROTECTED: Self = Self(0b1); +} +#[doc = "Generated from 'VK_VERSION_1_1'"] +impl Format { + pub const G8B8G8R8_422_UNORM: Self = Self(1_000_156_000); + pub const B8G8R8G8_422_UNORM: Self = Self(1_000_156_001); + pub const G8_B8_R8_3PLANE_420_UNORM: Self = Self(1_000_156_002); + pub const G8_B8R8_2PLANE_420_UNORM: Self = Self(1_000_156_003); + pub const G8_B8_R8_3PLANE_422_UNORM: Self = Self(1_000_156_004); + pub const G8_B8R8_2PLANE_422_UNORM: Self = Self(1_000_156_005); + pub const G8_B8_R8_3PLANE_444_UNORM: Self = Self(1_000_156_006); + pub const R10X6_UNORM_PACK16: Self = Self(1_000_156_007); + pub const R10X6G10X6_UNORM_2PACK16: Self = Self(1_000_156_008); + pub const R10X6G10X6B10X6A10X6_UNORM_4PACK16: Self = Self(1_000_156_009); + pub const G10X6B10X6G10X6R10X6_422_UNORM_4PACK16: Self = Self(1_000_156_010); + pub const B10X6G10X6R10X6G10X6_422_UNORM_4PACK16: Self = Self(1_000_156_011); + pub const G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16: Self = Self(1_000_156_012); + pub const G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16: Self = Self(1_000_156_013); + pub const G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16: Self = Self(1_000_156_014); + pub const G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16: Self = Self(1_000_156_015); + pub const G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16: Self = Self(1_000_156_016); + pub const R12X4_UNORM_PACK16: Self = Self(1_000_156_017); + pub const R12X4G12X4_UNORM_2PACK16: Self = Self(1_000_156_018); + pub const R12X4G12X4B12X4A12X4_UNORM_4PACK16: Self = Self(1_000_156_019); + pub const G12X4B12X4G12X4R12X4_422_UNORM_4PACK16: Self = Self(1_000_156_020); + pub const B12X4G12X4R12X4G12X4_422_UNORM_4PACK16: Self = Self(1_000_156_021); + pub const G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16: Self = Self(1_000_156_022); + pub const G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16: Self = Self(1_000_156_023); + pub const G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16: Self = Self(1_000_156_024); + pub const G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16: Self = Self(1_000_156_025); + pub const G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16: Self = Self(1_000_156_026); + pub const G16B16G16R16_422_UNORM: Self = Self(1_000_156_027); + pub const B16G16R16G16_422_UNORM: Self = Self(1_000_156_028); + pub const G16_B16_R16_3PLANE_420_UNORM: Self = Self(1_000_156_029); + pub const G16_B16R16_2PLANE_420_UNORM: Self = Self(1_000_156_030); + pub const G16_B16_R16_3PLANE_422_UNORM: Self = Self(1_000_156_031); + pub const G16_B16R16_2PLANE_422_UNORM: Self = Self(1_000_156_032); + pub const G16_B16_R16_3PLANE_444_UNORM: Self = Self(1_000_156_033); +} +#[doc = "Generated from 'VK_VERSION_1_1'"] +impl FormatFeatureFlags { + #[doc = "Format can be used as the source image of image transfer commands"] + pub const TRANSFER_SRC: Self = Self(0b100_0000_0000_0000); + #[doc = "Format can be used as the destination image of image transfer commands"] + pub const TRANSFER_DST: Self = Self(0b1000_0000_0000_0000); + #[doc = "Format can have midpoint rather than cosited chroma samples"] + pub const MIDPOINT_CHROMA_SAMPLES: Self = Self(0b10_0000_0000_0000_0000); + #[doc = "Format can be used with linear filtering whilst color conversion is enabled"] + pub const SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER: Self = Self(0b100_0000_0000_0000_0000); + #[doc = "Format can have different chroma, min and mag filters"] + pub const SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER: Self = + Self(0b1000_0000_0000_0000_0000); + pub const SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT: Self = + Self(0b1_0000_0000_0000_0000_0000); + pub const SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE: Self = + Self(0b10_0000_0000_0000_0000_0000); + #[doc = "Format supports disjoint planes"] + pub const DISJOINT: Self = Self(0b100_0000_0000_0000_0000_0000); + #[doc = "Format can have cosited rather than midpoint chroma samples"] + pub const COSITED_CHROMA_SAMPLES: Self = Self(0b1000_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_VERSION_1_1'"] +impl ImageAspectFlags { + pub const PLANE_0: Self = Self(0b1_0000); + pub const PLANE_1: Self = Self(0b10_0000); + pub const PLANE_2: Self = Self(0b100_0000); +} +#[doc = "Generated from 'VK_VERSION_1_1'"] +impl ImageCreateFlags { + pub const ALIAS: Self = Self(0b100_0000_0000); + #[doc = "Allows using VkBindImageMemoryDeviceGroupInfo::pSplitInstanceBindRegions when binding memory to the image"] + pub const SPLIT_INSTANCE_BIND_REGIONS: Self = Self(0b100_0000); + #[doc = "The 3D image can be viewed as a 2D or 2D array image"] + pub const TYPE_2D_ARRAY_COMPATIBLE: Self = Self(0b10_0000); + pub const BLOCK_TEXEL_VIEW_COMPATIBLE: Self = Self(0b1000_0000); + pub const EXTENDED_USAGE: Self = Self(0b1_0000_0000); + #[doc = "Image requires protected memory"] + pub const PROTECTED: Self = Self(0b1000_0000_0000); + pub const DISJOINT: Self = Self(0b10_0000_0000); +} +#[doc = "Generated from 'VK_VERSION_1_1'"] +impl ImageLayout { + pub const DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL: Self = Self(1_000_117_000); + pub const DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL: Self = Self(1_000_117_001); +} +#[doc = "Generated from 'VK_VERSION_1_1'"] +impl MemoryHeapFlags { + #[doc = "If set, heap allocations allocate multiple instances by default"] + pub const MULTI_INSTANCE: Self = Self(0b10); +} +#[doc = "Generated from 'VK_VERSION_1_1'"] +impl MemoryPropertyFlags { + #[doc = "Memory is protected"] + pub const PROTECTED: Self = Self(0b10_0000); +} +#[doc = "Generated from 'VK_VERSION_1_1'"] +impl ObjectType { + pub const SAMPLER_YCBCR_CONVERSION: Self = Self(1_000_156_000); + pub const DESCRIPTOR_UPDATE_TEMPLATE: Self = Self(1_000_085_000); +} +#[doc = "Generated from 'VK_VERSION_1_1'"] +impl PipelineCreateFlags { + pub const VIEW_INDEX_FROM_DEVICE_INDEX: Self = Self(0b1000); + pub const DISPATCH_BASE: Self = Self(0b1_0000); +} +#[doc = "Generated from 'VK_VERSION_1_1'"] +impl QueueFlags { + #[doc = "Queues may support protected operations"] + pub const PROTECTED: Self = Self(0b1_0000); +} +#[doc = "Generated from 'VK_VERSION_1_1'"] +impl Result { + pub const ERROR_OUT_OF_POOL_MEMORY: Self = Self(-1_000_069_000); + pub const ERROR_INVALID_EXTERNAL_HANDLE: Self = Self(-1_000_072_003); +} +#[doc = "Generated from 'VK_VERSION_1_1'"] +impl StructureType { + pub const PHYSICAL_DEVICE_SUBGROUP_PROPERTIES: Self = Self(1_000_094_000); + pub const BIND_BUFFER_MEMORY_INFO: Self = Self(1_000_157_000); + pub const BIND_IMAGE_MEMORY_INFO: Self = Self(1_000_157_001); + pub const PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES: Self = Self(1_000_083_000); + pub const MEMORY_DEDICATED_REQUIREMENTS: Self = Self(1_000_127_000); + pub const MEMORY_DEDICATED_ALLOCATE_INFO: Self = Self(1_000_127_001); + pub const MEMORY_ALLOCATE_FLAGS_INFO: Self = Self(1_000_060_000); + pub const DEVICE_GROUP_RENDER_PASS_BEGIN_INFO: Self = Self(1_000_060_003); + pub const DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO: Self = Self(1_000_060_004); + pub const DEVICE_GROUP_SUBMIT_INFO: Self = Self(1_000_060_005); + pub const DEVICE_GROUP_BIND_SPARSE_INFO: Self = Self(1_000_060_006); + pub const BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO: Self = Self(1_000_060_013); + pub const BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO: Self = Self(1_000_060_014); + pub const PHYSICAL_DEVICE_GROUP_PROPERTIES: Self = Self(1_000_070_000); + pub const DEVICE_GROUP_DEVICE_CREATE_INFO: Self = Self(1_000_070_001); + pub const BUFFER_MEMORY_REQUIREMENTS_INFO_2: Self = Self(1_000_146_000); + pub const IMAGE_MEMORY_REQUIREMENTS_INFO_2: Self = Self(1_000_146_001); + pub const IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2: Self = Self(1_000_146_002); + pub const MEMORY_REQUIREMENTS_2: Self = Self(1_000_146_003); + pub const SPARSE_IMAGE_MEMORY_REQUIREMENTS_2: Self = Self(1_000_146_004); + pub const PHYSICAL_DEVICE_FEATURES_2: Self = Self(1_000_059_000); + pub const PHYSICAL_DEVICE_PROPERTIES_2: Self = Self(1_000_059_001); + pub const FORMAT_PROPERTIES_2: Self = Self(1_000_059_002); + pub const IMAGE_FORMAT_PROPERTIES_2: Self = Self(1_000_059_003); + pub const PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2: Self = Self(1_000_059_004); + pub const QUEUE_FAMILY_PROPERTIES_2: Self = Self(1_000_059_005); + pub const PHYSICAL_DEVICE_MEMORY_PROPERTIES_2: Self = Self(1_000_059_006); + pub const SPARSE_IMAGE_FORMAT_PROPERTIES_2: Self = Self(1_000_059_007); + pub const PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2: Self = Self(1_000_059_008); + pub const PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES: Self = Self(1_000_117_000); + pub const RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO: Self = Self(1_000_117_001); + pub const IMAGE_VIEW_USAGE_CREATE_INFO: Self = Self(1_000_117_002); + pub const PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO: Self = Self(1_000_117_003); + pub const RENDER_PASS_MULTIVIEW_CREATE_INFO: Self = Self(1_000_053_000); + pub const PHYSICAL_DEVICE_MULTIVIEW_FEATURES: Self = Self(1_000_053_001); + pub const PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES: Self = Self(1_000_053_002); + pub const PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES: Self = Self(1_000_120_000); + pub const PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES: Self = + Self::PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES; + pub const PROTECTED_SUBMIT_INFO: Self = Self(1_000_145_000); + pub const PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES: Self = Self(1_000_145_001); + pub const PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES: Self = Self(1_000_145_002); + pub const DEVICE_QUEUE_INFO_2: Self = Self(1_000_145_003); + pub const SAMPLER_YCBCR_CONVERSION_CREATE_INFO: Self = Self(1_000_156_000); + pub const SAMPLER_YCBCR_CONVERSION_INFO: Self = Self(1_000_156_001); + pub const BIND_IMAGE_PLANE_MEMORY_INFO: Self = Self(1_000_156_002); + pub const IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO: Self = Self(1_000_156_003); + pub const PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES: Self = Self(1_000_156_004); + pub const SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES: Self = Self(1_000_156_005); + pub const DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO: Self = Self(1_000_085_000); + pub const PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO: Self = Self(1_000_071_000); + pub const EXTERNAL_IMAGE_FORMAT_PROPERTIES: Self = Self(1_000_071_001); + pub const PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO: Self = Self(1_000_071_002); + pub const EXTERNAL_BUFFER_PROPERTIES: Self = Self(1_000_071_003); + pub const PHYSICAL_DEVICE_ID_PROPERTIES: Self = Self(1_000_071_004); + pub const EXTERNAL_MEMORY_BUFFER_CREATE_INFO: Self = Self(1_000_072_000); + pub const EXTERNAL_MEMORY_IMAGE_CREATE_INFO: Self = Self(1_000_072_001); + pub const EXPORT_MEMORY_ALLOCATE_INFO: Self = Self(1_000_072_002); + pub const PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO: Self = Self(1_000_112_000); + pub const EXTERNAL_FENCE_PROPERTIES: Self = Self(1_000_112_001); + pub const EXPORT_FENCE_CREATE_INFO: Self = Self(1_000_113_000); + pub const EXPORT_SEMAPHORE_CREATE_INFO: Self = Self(1_000_077_000); + pub const PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO: Self = Self(1_000_076_000); + pub const EXTERNAL_SEMAPHORE_PROPERTIES: Self = Self(1_000_076_001); + pub const PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES: Self = Self(1_000_168_000); + pub const DESCRIPTOR_SET_LAYOUT_SUPPORT: Self = Self(1_000_168_001); + pub const PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES: Self = Self(1_000_063_000); + pub const PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES: Self = + Self::PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES; +} +#[doc = "Generated from 'VK_VERSION_1_2'"] +impl BufferCreateFlags { + pub const DEVICE_ADDRESS_CAPTURE_REPLAY: Self = Self(0b1_0000); +} +#[doc = "Generated from 'VK_VERSION_1_2'"] +impl BufferUsageFlags { + pub const SHADER_DEVICE_ADDRESS: Self = Self(0b10_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_VERSION_1_2'"] +impl DescriptorPoolCreateFlags { + pub const UPDATE_AFTER_BIND: Self = Self(0b10); +} +#[doc = "Generated from 'VK_VERSION_1_2'"] +impl DescriptorSetLayoutCreateFlags { + pub const UPDATE_AFTER_BIND_POOL: Self = Self(0b10); +} +#[doc = "Generated from 'VK_VERSION_1_2'"] +impl FormatFeatureFlags { + #[doc = "Format can be used with min/max reduction filtering"] + pub const SAMPLED_IMAGE_FILTER_MINMAX: Self = Self(0b1_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_VERSION_1_2'"] +impl FramebufferCreateFlags { + pub const IMAGELESS: Self = Self(0b1); +} +#[doc = "Generated from 'VK_VERSION_1_2'"] +impl ImageLayout { + pub const DEPTH_ATTACHMENT_OPTIMAL: Self = Self(1_000_241_000); + pub const DEPTH_READ_ONLY_OPTIMAL: Self = Self(1_000_241_001); + pub const STENCIL_ATTACHMENT_OPTIMAL: Self = Self(1_000_241_002); + pub const STENCIL_READ_ONLY_OPTIMAL: Self = Self(1_000_241_003); +} +#[doc = "Generated from 'VK_VERSION_1_2'"] +impl MemoryAllocateFlags { + pub const DEVICE_ADDRESS: Self = Self(0b10); + pub const DEVICE_ADDRESS_CAPTURE_REPLAY: Self = Self(0b100); +} +#[doc = "Generated from 'VK_VERSION_1_2'"] +impl Result { + pub const ERROR_FRAGMENTATION: Self = Self(-1_000_161_000); + pub const ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS: Self = Self(-1_000_257_000); +} +#[doc = "Generated from 'VK_VERSION_1_2'"] +impl StructureType { + pub const PHYSICAL_DEVICE_VULKAN_1_1_FEATURES: Self = Self(49); + pub const PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES: Self = Self(50); + pub const PHYSICAL_DEVICE_VULKAN_1_2_FEATURES: Self = Self(51); + pub const PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES: Self = Self(52); + pub const IMAGE_FORMAT_LIST_CREATE_INFO: Self = Self(1_000_147_000); + pub const ATTACHMENT_DESCRIPTION_2: Self = Self(1_000_109_000); + pub const ATTACHMENT_REFERENCE_2: Self = Self(1_000_109_001); + pub const SUBPASS_DESCRIPTION_2: Self = Self(1_000_109_002); + pub const SUBPASS_DEPENDENCY_2: Self = Self(1_000_109_003); + pub const RENDER_PASS_CREATE_INFO_2: Self = Self(1_000_109_004); + pub const SUBPASS_BEGIN_INFO: Self = Self(1_000_109_005); + pub const SUBPASS_END_INFO: Self = Self(1_000_109_006); + pub const PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES: Self = Self(1_000_177_000); + pub const PHYSICAL_DEVICE_DRIVER_PROPERTIES: Self = Self(1_000_196_000); + pub const PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES: Self = Self(1_000_180_000); + pub const PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES: Self = Self(1_000_082_000); + pub const PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES: Self = Self(1_000_197_000); + pub const DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO: Self = Self(1_000_161_000); + pub const PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES: Self = Self(1_000_161_001); + pub const PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES: Self = Self(1_000_161_002); + pub const DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO: Self = Self(1_000_161_003); + pub const DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT: Self = Self(1_000_161_004); + pub const PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES: Self = Self(1_000_199_000); + pub const SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE: Self = Self(1_000_199_001); + pub const PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES: Self = Self(1_000_221_000); + pub const IMAGE_STENCIL_USAGE_CREATE_INFO: Self = Self(1_000_246_000); + pub const PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES: Self = Self(1_000_130_000); + pub const SAMPLER_REDUCTION_MODE_CREATE_INFO: Self = Self(1_000_130_001); + pub const PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES: Self = Self(1_000_211_000); + pub const PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES: Self = Self(1_000_108_000); + pub const FRAMEBUFFER_ATTACHMENTS_CREATE_INFO: Self = Self(1_000_108_001); + pub const FRAMEBUFFER_ATTACHMENT_IMAGE_INFO: Self = Self(1_000_108_002); + pub const RENDER_PASS_ATTACHMENT_BEGIN_INFO: Self = Self(1_000_108_003); + pub const PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES: Self = Self(1_000_253_000); + pub const PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES: Self = Self(1_000_175_000); + pub const PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES: Self = Self(1_000_241_000); + pub const ATTACHMENT_REFERENCE_STENCIL_LAYOUT: Self = Self(1_000_241_001); + pub const ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT: Self = Self(1_000_241_002); + pub const PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES: Self = Self(1_000_261_000); + pub const PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES: Self = Self(1_000_207_000); + pub const PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES: Self = Self(1_000_207_001); + pub const SEMAPHORE_TYPE_CREATE_INFO: Self = Self(1_000_207_002); + pub const TIMELINE_SEMAPHORE_SUBMIT_INFO: Self = Self(1_000_207_003); + pub const SEMAPHORE_WAIT_INFO: Self = Self(1_000_207_004); + pub const SEMAPHORE_SIGNAL_INFO: Self = Self(1_000_207_005); + pub const PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES: Self = Self(1_000_257_000); + pub const BUFFER_DEVICE_ADDRESS_INFO: Self = Self(1_000_244_001); + pub const BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO: Self = Self(1_000_257_002); + pub const MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO: Self = Self(1_000_257_003); + pub const DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO: Self = Self(1_000_257_004); +} +#[doc = "Generated from 'VK_VERSION_1_3'"] +impl AccessFlags { + pub const NONE: Self = Self(0); +} +#[doc = "Generated from 'VK_VERSION_1_3'"] +impl AttachmentStoreOp { + pub const NONE: Self = Self(1_000_301_000); +} +#[doc = "Generated from 'VK_VERSION_1_3'"] +impl DescriptorType { + pub const INLINE_UNIFORM_BLOCK: Self = Self(1_000_138_000); +} +#[doc = "Generated from 'VK_VERSION_1_3'"] +impl DynamicState { + pub const CULL_MODE: Self = Self(1_000_267_000); + pub const FRONT_FACE: Self = Self(1_000_267_001); + pub const PRIMITIVE_TOPOLOGY: Self = Self(1_000_267_002); + pub const VIEWPORT_WITH_COUNT: Self = Self(1_000_267_003); + pub const SCISSOR_WITH_COUNT: Self = Self(1_000_267_004); + pub const VERTEX_INPUT_BINDING_STRIDE: Self = Self(1_000_267_005); + pub const DEPTH_TEST_ENABLE: Self = Self(1_000_267_006); + pub const DEPTH_WRITE_ENABLE: Self = Self(1_000_267_007); + pub const DEPTH_COMPARE_OP: Self = Self(1_000_267_008); + pub const DEPTH_BOUNDS_TEST_ENABLE: Self = Self(1_000_267_009); + pub const STENCIL_TEST_ENABLE: Self = Self(1_000_267_010); + pub const STENCIL_OP: Self = Self(1_000_267_011); + pub const RASTERIZER_DISCARD_ENABLE: Self = Self(1_000_377_001); + pub const DEPTH_BIAS_ENABLE: Self = Self(1_000_377_002); + pub const PRIMITIVE_RESTART_ENABLE: Self = Self(1_000_377_004); +} +#[doc = "Generated from 'VK_VERSION_1_3'"] +impl EventCreateFlags { + pub const DEVICE_ONLY: Self = Self(0b1); +} +#[doc = "Generated from 'VK_VERSION_1_3'"] +impl Format { + pub const G8_B8R8_2PLANE_444_UNORM: Self = Self(1_000_330_000); + pub const G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16: Self = Self(1_000_330_001); + pub const G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16: Self = Self(1_000_330_002); + pub const G16_B16R16_2PLANE_444_UNORM: Self = Self(1_000_330_003); + pub const A4R4G4B4_UNORM_PACK16: Self = Self(1_000_340_000); + pub const A4B4G4R4_UNORM_PACK16: Self = Self(1_000_340_001); + pub const ASTC_4X4_SFLOAT_BLOCK: Self = Self(1_000_066_000); + pub const ASTC_5X4_SFLOAT_BLOCK: Self = Self(1_000_066_001); + pub const ASTC_5X5_SFLOAT_BLOCK: Self = Self(1_000_066_002); + pub const ASTC_6X5_SFLOAT_BLOCK: Self = Self(1_000_066_003); + pub const ASTC_6X6_SFLOAT_BLOCK: Self = Self(1_000_066_004); + pub const ASTC_8X5_SFLOAT_BLOCK: Self = Self(1_000_066_005); + pub const ASTC_8X6_SFLOAT_BLOCK: Self = Self(1_000_066_006); + pub const ASTC_8X8_SFLOAT_BLOCK: Self = Self(1_000_066_007); + pub const ASTC_10X5_SFLOAT_BLOCK: Self = Self(1_000_066_008); + pub const ASTC_10X6_SFLOAT_BLOCK: Self = Self(1_000_066_009); + pub const ASTC_10X8_SFLOAT_BLOCK: Self = Self(1_000_066_010); + pub const ASTC_10X10_SFLOAT_BLOCK: Self = Self(1_000_066_011); + pub const ASTC_12X10_SFLOAT_BLOCK: Self = Self(1_000_066_012); + pub const ASTC_12X12_SFLOAT_BLOCK: Self = Self(1_000_066_013); +} +#[doc = "Generated from 'VK_VERSION_1_3'"] +impl ImageAspectFlags { + pub const NONE: Self = Self(0); +} +#[doc = "Generated from 'VK_VERSION_1_3'"] +impl ImageLayout { + pub const READ_ONLY_OPTIMAL: Self = Self(1_000_314_000); + pub const ATTACHMENT_OPTIMAL: Self = Self(1_000_314_001); +} +#[doc = "Generated from 'VK_VERSION_1_3'"] +impl ObjectType { + pub const PRIVATE_DATA_SLOT: Self = Self(1_000_295_000); +} +#[doc = "Generated from 'VK_VERSION_1_3'"] +impl PipelineCacheCreateFlags { + pub const EXTERNALLY_SYNCHRONIZED: Self = Self(0b1); +} +#[doc = "Generated from 'VK_VERSION_1_3'"] +impl PipelineCreateFlags { + pub const FAIL_ON_PIPELINE_COMPILE_REQUIRED: Self = Self(0b1_0000_0000); + pub const EARLY_RETURN_ON_FAILURE: Self = Self(0b10_0000_0000); +} +#[doc = "Generated from 'VK_VERSION_1_3'"] +impl PipelineShaderStageCreateFlags { + pub const ALLOW_VARYING_SUBGROUP_SIZE: Self = Self(0b1); + pub const REQUIRE_FULL_SUBGROUPS: Self = Self(0b10); +} +#[doc = "Generated from 'VK_VERSION_1_3'"] +impl PipelineStageFlags { + pub const NONE: Self = Self(0); +} +#[doc = "Generated from 'VK_VERSION_1_3'"] +impl Result { + pub const PIPELINE_COMPILE_REQUIRED: Self = Self(1_000_297_000); +} +#[doc = "Generated from 'VK_VERSION_1_3'"] +impl StructureType { + pub const PHYSICAL_DEVICE_VULKAN_1_3_FEATURES: Self = Self(53); + pub const PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES: Self = Self(54); + pub const PIPELINE_CREATION_FEEDBACK_CREATE_INFO: Self = Self(1_000_192_000); + pub const PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES: Self = Self(1_000_215_000); + pub const PHYSICAL_DEVICE_TOOL_PROPERTIES: Self = Self(1_000_245_000); + pub const PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES: Self = + Self(1_000_276_000); + pub const PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES: Self = Self(1_000_295_000); + pub const DEVICE_PRIVATE_DATA_CREATE_INFO: Self = Self(1_000_295_001); + pub const PRIVATE_DATA_SLOT_CREATE_INFO: Self = Self(1_000_295_002); + pub const PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES: Self = Self(1_000_297_000); + pub const MEMORY_BARRIER_2: Self = Self(1_000_314_000); + pub const BUFFER_MEMORY_BARRIER_2: Self = Self(1_000_314_001); + pub const IMAGE_MEMORY_BARRIER_2: Self = Self(1_000_314_002); + pub const DEPENDENCY_INFO: Self = Self(1_000_314_003); + pub const SUBMIT_INFO_2: Self = Self(1_000_314_004); + pub const SEMAPHORE_SUBMIT_INFO: Self = Self(1_000_314_005); + pub const COMMAND_BUFFER_SUBMIT_INFO: Self = Self(1_000_314_006); + pub const PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES: Self = Self(1_000_314_007); + pub const PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES: Self = Self(1_000_325_000); + pub const PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES: Self = Self(1_000_335_000); + pub const COPY_BUFFER_INFO_2: Self = Self(1_000_337_000); + pub const COPY_IMAGE_INFO_2: Self = Self(1_000_337_001); + pub const COPY_BUFFER_TO_IMAGE_INFO_2: Self = Self(1_000_337_002); + pub const COPY_IMAGE_TO_BUFFER_INFO_2: Self = Self(1_000_337_003); + pub const BLIT_IMAGE_INFO_2: Self = Self(1_000_337_004); + pub const RESOLVE_IMAGE_INFO_2: Self = Self(1_000_337_005); + pub const BUFFER_COPY_2: Self = Self(1_000_337_006); + pub const IMAGE_COPY_2: Self = Self(1_000_337_007); + pub const IMAGE_BLIT_2: Self = Self(1_000_337_008); + pub const BUFFER_IMAGE_COPY_2: Self = Self(1_000_337_009); + pub const IMAGE_RESOLVE_2: Self = Self(1_000_337_010); + pub const PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES: Self = Self(1_000_225_000); + pub const PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO: Self = Self(1_000_225_001); + pub const PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES: Self = Self(1_000_225_002); + pub const PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES: Self = Self(1_000_138_000); + pub const PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES: Self = Self(1_000_138_001); + pub const WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK: Self = Self(1_000_138_002); + pub const DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO: Self = Self(1_000_138_003); + pub const PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES: Self = Self(1_000_066_000); + pub const RENDERING_INFO: Self = Self(1_000_044_000); + pub const RENDERING_ATTACHMENT_INFO: Self = Self(1_000_044_001); + pub const PIPELINE_RENDERING_CREATE_INFO: Self = Self(1_000_044_002); + pub const PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES: Self = Self(1_000_044_003); + pub const COMMAND_BUFFER_INHERITANCE_RENDERING_INFO: Self = Self(1_000_044_004); + pub const PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES: Self = Self(1_000_280_000); + pub const PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES: Self = Self(1_000_280_001); + pub const PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES: Self = Self(1_000_281_001); + pub const FORMAT_PROPERTIES_3: Self = Self(1_000_360_000); + pub const PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES: Self = Self(1_000_413_000); + pub const PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES: Self = Self(1_000_413_001); + pub const DEVICE_BUFFER_MEMORY_REQUIREMENTS: Self = Self(1_000_413_002); + pub const DEVICE_IMAGE_MEMORY_REQUIREMENTS: Self = Self(1_000_413_003); +} diff --git a/third_party/rust/ash/src/vk/features.rs b/third_party/rust/ash/src/vk/features.rs new file mode 100644 index 0000000000..4a52e377ef --- /dev/null +++ b/third_party/rust/ash/src/vk/features.rs @@ -0,0 +1,5353 @@ +use crate::vk::bitflags::*; +use crate::vk::definitions::*; +use crate::vk::enums::*; +use std::os::raw::*; +#[allow(non_camel_case_types)] +pub type PFN_vkGetInstanceProcAddr = + unsafe extern "system" fn(instance: Instance, p_name: *const c_char) -> PFN_vkVoidFunction; +#[derive(Clone)] +pub struct StaticFn { + pub get_instance_proc_addr: PFN_vkGetInstanceProcAddr, +} +unsafe impl Send for StaticFn {} +unsafe impl Sync for StaticFn {} +impl StaticFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + get_instance_proc_addr: unsafe { + unsafe extern "system" fn get_instance_proc_addr( + _instance: Instance, + _p_name: *const c_char, + ) -> PFN_vkVoidFunction { + panic!(concat!( + "Unable to load ", + stringify!(get_instance_proc_addr) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetInstanceProcAddr\0"); + let val = _f(cname); + if val.is_null() { + get_instance_proc_addr + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[allow(non_camel_case_types)] +pub type PFN_vkCreateInstance = unsafe extern "system" fn( + p_create_info: *const InstanceCreateInfo, + p_allocator: *const AllocationCallbacks, + p_instance: *mut Instance, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkEnumerateInstanceExtensionProperties = unsafe extern "system" fn( + p_layer_name: *const c_char, + p_property_count: *mut u32, + p_properties: *mut ExtensionProperties, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkEnumerateInstanceLayerProperties = unsafe extern "system" fn( + p_property_count: *mut u32, + p_properties: *mut LayerProperties, +) -> Result; +#[derive(Clone)] +pub struct EntryFnV1_0 { + pub create_instance: PFN_vkCreateInstance, + pub enumerate_instance_extension_properties: PFN_vkEnumerateInstanceExtensionProperties, + pub enumerate_instance_layer_properties: PFN_vkEnumerateInstanceLayerProperties, +} +unsafe impl Send for EntryFnV1_0 {} +unsafe impl Sync for EntryFnV1_0 {} +impl EntryFnV1_0 { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + create_instance: unsafe { + unsafe extern "system" fn create_instance( + _p_create_info: *const InstanceCreateInfo, + _p_allocator: *const AllocationCallbacks, + _p_instance: *mut Instance, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(create_instance))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateInstance\0"); + let val = _f(cname); + if val.is_null() { + create_instance + } else { + ::std::mem::transmute(val) + } + }, + enumerate_instance_extension_properties: unsafe { + unsafe extern "system" fn enumerate_instance_extension_properties( + _p_layer_name: *const c_char, + _p_property_count: *mut u32, + _p_properties: *mut ExtensionProperties, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(enumerate_instance_extension_properties) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkEnumerateInstanceExtensionProperties\0", + ); + let val = _f(cname); + if val.is_null() { + enumerate_instance_extension_properties + } else { + ::std::mem::transmute(val) + } + }, + enumerate_instance_layer_properties: unsafe { + unsafe extern "system" fn enumerate_instance_layer_properties( + _p_property_count: *mut u32, + _p_properties: *mut LayerProperties, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(enumerate_instance_layer_properties) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkEnumerateInstanceLayerProperties\0", + ); + let val = _f(cname); + if val.is_null() { + enumerate_instance_layer_properties + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[allow(non_camel_case_types)] +pub type PFN_vkDestroyInstance = + unsafe extern "system" fn(instance: Instance, p_allocator: *const AllocationCallbacks); +#[allow(non_camel_case_types)] +pub type PFN_vkEnumeratePhysicalDevices = unsafe extern "system" fn( + instance: Instance, + p_physical_device_count: *mut u32, + p_physical_devices: *mut PhysicalDevice, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetPhysicalDeviceFeatures = unsafe extern "system" fn( + physical_device: PhysicalDevice, + p_features: *mut PhysicalDeviceFeatures, +); +#[allow(non_camel_case_types)] +pub type PFN_vkGetPhysicalDeviceFormatProperties = unsafe extern "system" fn( + physical_device: PhysicalDevice, + format: Format, + p_format_properties: *mut FormatProperties, +); +#[allow(non_camel_case_types)] +pub type PFN_vkGetPhysicalDeviceImageFormatProperties = unsafe extern "system" fn( + physical_device: PhysicalDevice, + format: Format, + ty: ImageType, + tiling: ImageTiling, + usage: ImageUsageFlags, + flags: ImageCreateFlags, + p_image_format_properties: *mut ImageFormatProperties, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetPhysicalDeviceProperties = unsafe extern "system" fn( + physical_device: PhysicalDevice, + p_properties: *mut PhysicalDeviceProperties, +); +#[allow(non_camel_case_types)] +pub type PFN_vkGetPhysicalDeviceQueueFamilyProperties = unsafe extern "system" fn( + physical_device: PhysicalDevice, + p_queue_family_property_count: *mut u32, + p_queue_family_properties: *mut QueueFamilyProperties, +); +#[allow(non_camel_case_types)] +pub type PFN_vkGetPhysicalDeviceMemoryProperties = unsafe extern "system" fn( + physical_device: PhysicalDevice, + p_memory_properties: *mut PhysicalDeviceMemoryProperties, +); +#[allow(non_camel_case_types)] +pub type PFN_vkGetDeviceProcAddr = + unsafe extern "system" fn(device: Device, p_name: *const c_char) -> PFN_vkVoidFunction; +#[allow(non_camel_case_types)] +pub type PFN_vkCreateDevice = unsafe extern "system" fn( + physical_device: PhysicalDevice, + p_create_info: *const DeviceCreateInfo, + p_allocator: *const AllocationCallbacks, + p_device: *mut Device, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkEnumerateDeviceExtensionProperties = unsafe extern "system" fn( + physical_device: PhysicalDevice, + p_layer_name: *const c_char, + p_property_count: *mut u32, + p_properties: *mut ExtensionProperties, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkEnumerateDeviceLayerProperties = unsafe extern "system" fn( + physical_device: PhysicalDevice, + p_property_count: *mut u32, + p_properties: *mut LayerProperties, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetPhysicalDeviceSparseImageFormatProperties = unsafe extern "system" fn( + physical_device: PhysicalDevice, + format: Format, + ty: ImageType, + samples: SampleCountFlags, + usage: ImageUsageFlags, + tiling: ImageTiling, + p_property_count: *mut u32, + p_properties: *mut SparseImageFormatProperties, +); +#[derive(Clone)] +pub struct InstanceFnV1_0 { + pub destroy_instance: PFN_vkDestroyInstance, + pub enumerate_physical_devices: PFN_vkEnumeratePhysicalDevices, + pub get_physical_device_features: PFN_vkGetPhysicalDeviceFeatures, + pub get_physical_device_format_properties: PFN_vkGetPhysicalDeviceFormatProperties, + pub get_physical_device_image_format_properties: PFN_vkGetPhysicalDeviceImageFormatProperties, + pub get_physical_device_properties: PFN_vkGetPhysicalDeviceProperties, + pub get_physical_device_queue_family_properties: PFN_vkGetPhysicalDeviceQueueFamilyProperties, + pub get_physical_device_memory_properties: PFN_vkGetPhysicalDeviceMemoryProperties, + pub get_device_proc_addr: PFN_vkGetDeviceProcAddr, + pub create_device: PFN_vkCreateDevice, + pub enumerate_device_extension_properties: PFN_vkEnumerateDeviceExtensionProperties, + pub enumerate_device_layer_properties: PFN_vkEnumerateDeviceLayerProperties, + pub get_physical_device_sparse_image_format_properties: + PFN_vkGetPhysicalDeviceSparseImageFormatProperties, +} +unsafe impl Send for InstanceFnV1_0 {} +unsafe impl Sync for InstanceFnV1_0 {} +impl InstanceFnV1_0 { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + destroy_instance: unsafe { + unsafe extern "system" fn destroy_instance( + _instance: Instance, + _p_allocator: *const AllocationCallbacks, + ) { + panic!(concat!("Unable to load ", stringify!(destroy_instance))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyInstance\0"); + let val = _f(cname); + if val.is_null() { + destroy_instance + } else { + ::std::mem::transmute(val) + } + }, + enumerate_physical_devices: unsafe { + unsafe extern "system" fn enumerate_physical_devices( + _instance: Instance, + _p_physical_device_count: *mut u32, + _p_physical_devices: *mut PhysicalDevice, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(enumerate_physical_devices) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkEnumeratePhysicalDevices\0", + ); + let val = _f(cname); + if val.is_null() { + enumerate_physical_devices + } else { + ::std::mem::transmute(val) + } + }, + get_physical_device_features: unsafe { + unsafe extern "system" fn get_physical_device_features( + _physical_device: PhysicalDevice, + _p_features: *mut PhysicalDeviceFeatures, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_features) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPhysicalDeviceFeatures\0", + ); + let val = _f(cname); + if val.is_null() { + get_physical_device_features + } else { + ::std::mem::transmute(val) + } + }, + get_physical_device_format_properties: unsafe { + unsafe extern "system" fn get_physical_device_format_properties( + _physical_device: PhysicalDevice, + _format: Format, + _p_format_properties: *mut FormatProperties, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_format_properties) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPhysicalDeviceFormatProperties\0", + ); + let val = _f(cname); + if val.is_null() { + get_physical_device_format_properties + } else { + ::std::mem::transmute(val) + } + }, + get_physical_device_image_format_properties: unsafe { + unsafe extern "system" fn get_physical_device_image_format_properties( + _physical_device: PhysicalDevice, + _format: Format, + _ty: ImageType, + _tiling: ImageTiling, + _usage: ImageUsageFlags, + _flags: ImageCreateFlags, + _p_image_format_properties: *mut ImageFormatProperties, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_image_format_properties) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPhysicalDeviceImageFormatProperties\0", + ); + let val = _f(cname); + if val.is_null() { + get_physical_device_image_format_properties + } else { + ::std::mem::transmute(val) + } + }, + get_physical_device_properties: unsafe { + unsafe extern "system" fn get_physical_device_properties( + _physical_device: PhysicalDevice, + _p_properties: *mut PhysicalDeviceProperties, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_properties) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPhysicalDeviceProperties\0", + ); + let val = _f(cname); + if val.is_null() { + get_physical_device_properties + } else { + ::std::mem::transmute(val) + } + }, + get_physical_device_queue_family_properties: unsafe { + unsafe extern "system" fn get_physical_device_queue_family_properties( + _physical_device: PhysicalDevice, + _p_queue_family_property_count: *mut u32, + _p_queue_family_properties: *mut QueueFamilyProperties, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_queue_family_properties) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPhysicalDeviceQueueFamilyProperties\0", + ); + let val = _f(cname); + if val.is_null() { + get_physical_device_queue_family_properties + } else { + ::std::mem::transmute(val) + } + }, + get_physical_device_memory_properties: unsafe { + unsafe extern "system" fn get_physical_device_memory_properties( + _physical_device: PhysicalDevice, + _p_memory_properties: *mut PhysicalDeviceMemoryProperties, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_memory_properties) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPhysicalDeviceMemoryProperties\0", + ); + let val = _f(cname); + if val.is_null() { + get_physical_device_memory_properties + } else { + ::std::mem::transmute(val) + } + }, + get_device_proc_addr: unsafe { + unsafe extern "system" fn get_device_proc_addr( + _device: Device, + _p_name: *const c_char, + ) -> PFN_vkVoidFunction { + panic!(concat!("Unable to load ", stringify!(get_device_proc_addr))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetDeviceProcAddr\0"); + let val = _f(cname); + if val.is_null() { + get_device_proc_addr + } else { + ::std::mem::transmute(val) + } + }, + create_device: unsafe { + unsafe extern "system" fn create_device( + _physical_device: PhysicalDevice, + _p_create_info: *const DeviceCreateInfo, + _p_allocator: *const AllocationCallbacks, + _p_device: *mut Device, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(create_device))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateDevice\0"); + let val = _f(cname); + if val.is_null() { + create_device + } else { + ::std::mem::transmute(val) + } + }, + enumerate_device_extension_properties: unsafe { + unsafe extern "system" fn enumerate_device_extension_properties( + _physical_device: PhysicalDevice, + _p_layer_name: *const c_char, + _p_property_count: *mut u32, + _p_properties: *mut ExtensionProperties, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(enumerate_device_extension_properties) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkEnumerateDeviceExtensionProperties\0", + ); + let val = _f(cname); + if val.is_null() { + enumerate_device_extension_properties + } else { + ::std::mem::transmute(val) + } + }, + enumerate_device_layer_properties: unsafe { + unsafe extern "system" fn enumerate_device_layer_properties( + _physical_device: PhysicalDevice, + _p_property_count: *mut u32, + _p_properties: *mut LayerProperties, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(enumerate_device_layer_properties) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkEnumerateDeviceLayerProperties\0", + ); + let val = _f(cname); + if val.is_null() { + enumerate_device_layer_properties + } else { + ::std::mem::transmute(val) + } + }, + get_physical_device_sparse_image_format_properties: unsafe { + unsafe extern "system" fn get_physical_device_sparse_image_format_properties( + _physical_device: PhysicalDevice, + _format: Format, + _ty: ImageType, + _samples: SampleCountFlags, + _usage: ImageUsageFlags, + _tiling: ImageTiling, + _p_property_count: *mut u32, + _p_properties: *mut SparseImageFormatProperties, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_sparse_image_format_properties) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPhysicalDeviceSparseImageFormatProperties\0", + ); + let val = _f(cname); + if val.is_null() { + get_physical_device_sparse_image_format_properties + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[allow(non_camel_case_types)] +pub type PFN_vkDestroyDevice = + unsafe extern "system" fn(device: Device, p_allocator: *const AllocationCallbacks); +#[allow(non_camel_case_types)] +pub type PFN_vkGetDeviceQueue = unsafe extern "system" fn( + device: Device, + queue_family_index: u32, + queue_index: u32, + p_queue: *mut Queue, +); +#[allow(non_camel_case_types)] +pub type PFN_vkQueueSubmit = unsafe extern "system" fn( + queue: Queue, + submit_count: u32, + p_submits: *const SubmitInfo, + fence: Fence, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkQueueWaitIdle = unsafe extern "system" fn(queue: Queue) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkDeviceWaitIdle = unsafe extern "system" fn(device: Device) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkAllocateMemory = unsafe extern "system" fn( + device: Device, + p_allocate_info: *const MemoryAllocateInfo, + p_allocator: *const AllocationCallbacks, + p_memory: *mut DeviceMemory, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkFreeMemory = unsafe extern "system" fn( + device: Device, + memory: DeviceMemory, + p_allocator: *const AllocationCallbacks, +); +#[allow(non_camel_case_types)] +pub type PFN_vkMapMemory = unsafe extern "system" fn( + device: Device, + memory: DeviceMemory, + offset: DeviceSize, + size: DeviceSize, + flags: MemoryMapFlags, + pp_data: *mut *mut c_void, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkUnmapMemory = unsafe extern "system" fn(device: Device, memory: DeviceMemory); +#[allow(non_camel_case_types)] +pub type PFN_vkFlushMappedMemoryRanges = unsafe extern "system" fn( + device: Device, + memory_range_count: u32, + p_memory_ranges: *const MappedMemoryRange, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkInvalidateMappedMemoryRanges = unsafe extern "system" fn( + device: Device, + memory_range_count: u32, + p_memory_ranges: *const MappedMemoryRange, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetDeviceMemoryCommitment = unsafe extern "system" fn( + device: Device, + memory: DeviceMemory, + p_committed_memory_in_bytes: *mut DeviceSize, +); +#[allow(non_camel_case_types)] +pub type PFN_vkBindBufferMemory = unsafe extern "system" fn( + device: Device, + buffer: Buffer, + memory: DeviceMemory, + memory_offset: DeviceSize, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkBindImageMemory = unsafe extern "system" fn( + device: Device, + image: Image, + memory: DeviceMemory, + memory_offset: DeviceSize, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetBufferMemoryRequirements = unsafe extern "system" fn( + device: Device, + buffer: Buffer, + p_memory_requirements: *mut MemoryRequirements, +); +#[allow(non_camel_case_types)] +pub type PFN_vkGetImageMemoryRequirements = unsafe extern "system" fn( + device: Device, + image: Image, + p_memory_requirements: *mut MemoryRequirements, +); +#[allow(non_camel_case_types)] +pub type PFN_vkGetImageSparseMemoryRequirements = unsafe extern "system" fn( + device: Device, + image: Image, + p_sparse_memory_requirement_count: *mut u32, + p_sparse_memory_requirements: *mut SparseImageMemoryRequirements, +); +#[allow(non_camel_case_types)] +pub type PFN_vkQueueBindSparse = unsafe extern "system" fn( + queue: Queue, + bind_info_count: u32, + p_bind_info: *const BindSparseInfo, + fence: Fence, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkCreateFence = unsafe extern "system" fn( + device: Device, + p_create_info: *const FenceCreateInfo, + p_allocator: *const AllocationCallbacks, + p_fence: *mut Fence, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkDestroyFence = unsafe extern "system" fn( + device: Device, + fence: Fence, + p_allocator: *const AllocationCallbacks, +); +#[allow(non_camel_case_types)] +pub type PFN_vkResetFences = + unsafe extern "system" fn(device: Device, fence_count: u32, p_fences: *const Fence) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetFenceStatus = unsafe extern "system" fn(device: Device, fence: Fence) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkWaitForFences = unsafe extern "system" fn( + device: Device, + fence_count: u32, + p_fences: *const Fence, + wait_all: Bool32, + timeout: u64, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkCreateSemaphore = unsafe extern "system" fn( + device: Device, + p_create_info: *const SemaphoreCreateInfo, + p_allocator: *const AllocationCallbacks, + p_semaphore: *mut Semaphore, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkDestroySemaphore = unsafe extern "system" fn( + device: Device, + semaphore: Semaphore, + p_allocator: *const AllocationCallbacks, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCreateEvent = unsafe extern "system" fn( + device: Device, + p_create_info: *const EventCreateInfo, + p_allocator: *const AllocationCallbacks, + p_event: *mut Event, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkDestroyEvent = unsafe extern "system" fn( + device: Device, + event: Event, + p_allocator: *const AllocationCallbacks, +); +#[allow(non_camel_case_types)] +pub type PFN_vkGetEventStatus = unsafe extern "system" fn(device: Device, event: Event) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkSetEvent = unsafe extern "system" fn(device: Device, event: Event) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkResetEvent = unsafe extern "system" fn(device: Device, event: Event) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkCreateQueryPool = unsafe extern "system" fn( + device: Device, + p_create_info: *const QueryPoolCreateInfo, + p_allocator: *const AllocationCallbacks, + p_query_pool: *mut QueryPool, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkDestroyQueryPool = unsafe extern "system" fn( + device: Device, + query_pool: QueryPool, + p_allocator: *const AllocationCallbacks, +); +#[allow(non_camel_case_types)] +pub type PFN_vkGetQueryPoolResults = unsafe extern "system" fn( + device: Device, + query_pool: QueryPool, + first_query: u32, + query_count: u32, + data_size: usize, + p_data: *mut c_void, + stride: DeviceSize, + flags: QueryResultFlags, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkCreateBuffer = unsafe extern "system" fn( + device: Device, + p_create_info: *const BufferCreateInfo, + p_allocator: *const AllocationCallbacks, + p_buffer: *mut Buffer, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkDestroyBuffer = unsafe extern "system" fn( + device: Device, + buffer: Buffer, + p_allocator: *const AllocationCallbacks, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCreateBufferView = unsafe extern "system" fn( + device: Device, + p_create_info: *const BufferViewCreateInfo, + p_allocator: *const AllocationCallbacks, + p_view: *mut BufferView, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkDestroyBufferView = unsafe extern "system" fn( + device: Device, + buffer_view: BufferView, + p_allocator: *const AllocationCallbacks, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCreateImage = unsafe extern "system" fn( + device: Device, + p_create_info: *const ImageCreateInfo, + p_allocator: *const AllocationCallbacks, + p_image: *mut Image, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkDestroyImage = unsafe extern "system" fn( + device: Device, + image: Image, + p_allocator: *const AllocationCallbacks, +); +#[allow(non_camel_case_types)] +pub type PFN_vkGetImageSubresourceLayout = unsafe extern "system" fn( + device: Device, + image: Image, + p_subresource: *const ImageSubresource, + p_layout: *mut SubresourceLayout, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCreateImageView = unsafe extern "system" fn( + device: Device, + p_create_info: *const ImageViewCreateInfo, + p_allocator: *const AllocationCallbacks, + p_view: *mut ImageView, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkDestroyImageView = unsafe extern "system" fn( + device: Device, + image_view: ImageView, + p_allocator: *const AllocationCallbacks, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCreateShaderModule = unsafe extern "system" fn( + device: Device, + p_create_info: *const ShaderModuleCreateInfo, + p_allocator: *const AllocationCallbacks, + p_shader_module: *mut ShaderModule, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkDestroyShaderModule = unsafe extern "system" fn( + device: Device, + shader_module: ShaderModule, + p_allocator: *const AllocationCallbacks, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCreatePipelineCache = unsafe extern "system" fn( + device: Device, + p_create_info: *const PipelineCacheCreateInfo, + p_allocator: *const AllocationCallbacks, + p_pipeline_cache: *mut PipelineCache, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkDestroyPipelineCache = unsafe extern "system" fn( + device: Device, + pipeline_cache: PipelineCache, + p_allocator: *const AllocationCallbacks, +); +#[allow(non_camel_case_types)] +pub type PFN_vkGetPipelineCacheData = unsafe extern "system" fn( + device: Device, + pipeline_cache: PipelineCache, + p_data_size: *mut usize, + p_data: *mut c_void, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkMergePipelineCaches = unsafe extern "system" fn( + device: Device, + dst_cache: PipelineCache, + src_cache_count: u32, + p_src_caches: *const PipelineCache, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkCreateGraphicsPipelines = unsafe extern "system" fn( + device: Device, + pipeline_cache: PipelineCache, + create_info_count: u32, + p_create_infos: *const GraphicsPipelineCreateInfo, + p_allocator: *const AllocationCallbacks, + p_pipelines: *mut Pipeline, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkCreateComputePipelines = unsafe extern "system" fn( + device: Device, + pipeline_cache: PipelineCache, + create_info_count: u32, + p_create_infos: *const ComputePipelineCreateInfo, + p_allocator: *const AllocationCallbacks, + p_pipelines: *mut Pipeline, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkDestroyPipeline = unsafe extern "system" fn( + device: Device, + pipeline: Pipeline, + p_allocator: *const AllocationCallbacks, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCreatePipelineLayout = unsafe extern "system" fn( + device: Device, + p_create_info: *const PipelineLayoutCreateInfo, + p_allocator: *const AllocationCallbacks, + p_pipeline_layout: *mut PipelineLayout, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkDestroyPipelineLayout = unsafe extern "system" fn( + device: Device, + pipeline_layout: PipelineLayout, + p_allocator: *const AllocationCallbacks, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCreateSampler = unsafe extern "system" fn( + device: Device, + p_create_info: *const SamplerCreateInfo, + p_allocator: *const AllocationCallbacks, + p_sampler: *mut Sampler, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkDestroySampler = unsafe extern "system" fn( + device: Device, + sampler: Sampler, + p_allocator: *const AllocationCallbacks, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCreateDescriptorSetLayout = unsafe extern "system" fn( + device: Device, + p_create_info: *const DescriptorSetLayoutCreateInfo, + p_allocator: *const AllocationCallbacks, + p_set_layout: *mut DescriptorSetLayout, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkDestroyDescriptorSetLayout = unsafe extern "system" fn( + device: Device, + descriptor_set_layout: DescriptorSetLayout, + p_allocator: *const AllocationCallbacks, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCreateDescriptorPool = unsafe extern "system" fn( + device: Device, + p_create_info: *const DescriptorPoolCreateInfo, + p_allocator: *const AllocationCallbacks, + p_descriptor_pool: *mut DescriptorPool, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkDestroyDescriptorPool = unsafe extern "system" fn( + device: Device, + descriptor_pool: DescriptorPool, + p_allocator: *const AllocationCallbacks, +); +#[allow(non_camel_case_types)] +pub type PFN_vkResetDescriptorPool = unsafe extern "system" fn( + device: Device, + descriptor_pool: DescriptorPool, + flags: DescriptorPoolResetFlags, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkAllocateDescriptorSets = unsafe extern "system" fn( + device: Device, + p_allocate_info: *const DescriptorSetAllocateInfo, + p_descriptor_sets: *mut DescriptorSet, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkFreeDescriptorSets = unsafe extern "system" fn( + device: Device, + descriptor_pool: DescriptorPool, + descriptor_set_count: u32, + p_descriptor_sets: *const DescriptorSet, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkUpdateDescriptorSets = unsafe extern "system" fn( + device: Device, + descriptor_write_count: u32, + p_descriptor_writes: *const WriteDescriptorSet, + descriptor_copy_count: u32, + p_descriptor_copies: *const CopyDescriptorSet, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCreateFramebuffer = unsafe extern "system" fn( + device: Device, + p_create_info: *const FramebufferCreateInfo, + p_allocator: *const AllocationCallbacks, + p_framebuffer: *mut Framebuffer, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkDestroyFramebuffer = unsafe extern "system" fn( + device: Device, + framebuffer: Framebuffer, + p_allocator: *const AllocationCallbacks, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCreateRenderPass = unsafe extern "system" fn( + device: Device, + p_create_info: *const RenderPassCreateInfo, + p_allocator: *const AllocationCallbacks, + p_render_pass: *mut RenderPass, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkDestroyRenderPass = unsafe extern "system" fn( + device: Device, + render_pass: RenderPass, + p_allocator: *const AllocationCallbacks, +); +#[allow(non_camel_case_types)] +pub type PFN_vkGetRenderAreaGranularity = unsafe extern "system" fn( + device: Device, + render_pass: RenderPass, + p_granularity: *mut Extent2D, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCreateCommandPool = unsafe extern "system" fn( + device: Device, + p_create_info: *const CommandPoolCreateInfo, + p_allocator: *const AllocationCallbacks, + p_command_pool: *mut CommandPool, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkDestroyCommandPool = unsafe extern "system" fn( + device: Device, + command_pool: CommandPool, + p_allocator: *const AllocationCallbacks, +); +#[allow(non_camel_case_types)] +pub type PFN_vkResetCommandPool = unsafe extern "system" fn( + device: Device, + command_pool: CommandPool, + flags: CommandPoolResetFlags, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkAllocateCommandBuffers = unsafe extern "system" fn( + device: Device, + p_allocate_info: *const CommandBufferAllocateInfo, + p_command_buffers: *mut CommandBuffer, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkFreeCommandBuffers = unsafe extern "system" fn( + device: Device, + command_pool: CommandPool, + command_buffer_count: u32, + p_command_buffers: *const CommandBuffer, +); +#[allow(non_camel_case_types)] +pub type PFN_vkBeginCommandBuffer = unsafe extern "system" fn( + command_buffer: CommandBuffer, + p_begin_info: *const CommandBufferBeginInfo, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkEndCommandBuffer = + unsafe extern "system" fn(command_buffer: CommandBuffer) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkResetCommandBuffer = unsafe extern "system" fn( + command_buffer: CommandBuffer, + flags: CommandBufferResetFlags, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkCmdBindPipeline = unsafe extern "system" fn( + command_buffer: CommandBuffer, + pipeline_bind_point: PipelineBindPoint, + pipeline: Pipeline, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetViewport = unsafe extern "system" fn( + command_buffer: CommandBuffer, + first_viewport: u32, + viewport_count: u32, + p_viewports: *const Viewport, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetScissor = unsafe extern "system" fn( + command_buffer: CommandBuffer, + first_scissor: u32, + scissor_count: u32, + p_scissors: *const Rect2D, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetLineWidth = + unsafe extern "system" fn(command_buffer: CommandBuffer, line_width: f32); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetDepthBias = unsafe extern "system" fn( + command_buffer: CommandBuffer, + depth_bias_constant_factor: f32, + depth_bias_clamp: f32, + depth_bias_slope_factor: f32, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetBlendConstants = + unsafe extern "system" fn(command_buffer: CommandBuffer, blend_constants: *const [f32; 4]); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetDepthBounds = unsafe extern "system" fn( + command_buffer: CommandBuffer, + min_depth_bounds: f32, + max_depth_bounds: f32, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetStencilCompareMask = unsafe extern "system" fn( + command_buffer: CommandBuffer, + face_mask: StencilFaceFlags, + compare_mask: u32, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetStencilWriteMask = unsafe extern "system" fn( + command_buffer: CommandBuffer, + face_mask: StencilFaceFlags, + write_mask: u32, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetStencilReference = unsafe extern "system" fn( + command_buffer: CommandBuffer, + face_mask: StencilFaceFlags, + reference: u32, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdBindDescriptorSets = unsafe extern "system" fn( + command_buffer: CommandBuffer, + pipeline_bind_point: PipelineBindPoint, + layout: PipelineLayout, + first_set: u32, + descriptor_set_count: u32, + p_descriptor_sets: *const DescriptorSet, + dynamic_offset_count: u32, + p_dynamic_offsets: *const u32, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdBindIndexBuffer = unsafe extern "system" fn( + command_buffer: CommandBuffer, + buffer: Buffer, + offset: DeviceSize, + index_type: IndexType, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdBindVertexBuffers = unsafe extern "system" fn( + command_buffer: CommandBuffer, + first_binding: u32, + binding_count: u32, + p_buffers: *const Buffer, + p_offsets: *const DeviceSize, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdDraw = unsafe extern "system" fn( + command_buffer: CommandBuffer, + vertex_count: u32, + instance_count: u32, + first_vertex: u32, + first_instance: u32, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdDrawIndexed = unsafe extern "system" fn( + command_buffer: CommandBuffer, + index_count: u32, + instance_count: u32, + first_index: u32, + vertex_offset: i32, + first_instance: u32, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdDrawIndirect = unsafe extern "system" fn( + command_buffer: CommandBuffer, + buffer: Buffer, + offset: DeviceSize, + draw_count: u32, + stride: u32, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdDrawIndexedIndirect = unsafe extern "system" fn( + command_buffer: CommandBuffer, + buffer: Buffer, + offset: DeviceSize, + draw_count: u32, + stride: u32, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdDispatch = unsafe extern "system" fn( + command_buffer: CommandBuffer, + group_count_x: u32, + group_count_y: u32, + group_count_z: u32, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdDispatchIndirect = + unsafe extern "system" fn(command_buffer: CommandBuffer, buffer: Buffer, offset: DeviceSize); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdCopyBuffer = unsafe extern "system" fn( + command_buffer: CommandBuffer, + src_buffer: Buffer, + dst_buffer: Buffer, + region_count: u32, + p_regions: *const BufferCopy, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdCopyImage = unsafe extern "system" fn( + command_buffer: CommandBuffer, + src_image: Image, + src_image_layout: ImageLayout, + dst_image: Image, + dst_image_layout: ImageLayout, + region_count: u32, + p_regions: *const ImageCopy, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdBlitImage = unsafe extern "system" fn( + command_buffer: CommandBuffer, + src_image: Image, + src_image_layout: ImageLayout, + dst_image: Image, + dst_image_layout: ImageLayout, + region_count: u32, + p_regions: *const ImageBlit, + filter: Filter, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdCopyBufferToImage = unsafe extern "system" fn( + command_buffer: CommandBuffer, + src_buffer: Buffer, + dst_image: Image, + dst_image_layout: ImageLayout, + region_count: u32, + p_regions: *const BufferImageCopy, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdCopyImageToBuffer = unsafe extern "system" fn( + command_buffer: CommandBuffer, + src_image: Image, + src_image_layout: ImageLayout, + dst_buffer: Buffer, + region_count: u32, + p_regions: *const BufferImageCopy, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdUpdateBuffer = unsafe extern "system" fn( + command_buffer: CommandBuffer, + dst_buffer: Buffer, + dst_offset: DeviceSize, + data_size: DeviceSize, + p_data: *const c_void, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdFillBuffer = unsafe extern "system" fn( + command_buffer: CommandBuffer, + dst_buffer: Buffer, + dst_offset: DeviceSize, + size: DeviceSize, + data: u32, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdClearColorImage = unsafe extern "system" fn( + command_buffer: CommandBuffer, + image: Image, + image_layout: ImageLayout, + p_color: *const ClearColorValue, + range_count: u32, + p_ranges: *const ImageSubresourceRange, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdClearDepthStencilImage = unsafe extern "system" fn( + command_buffer: CommandBuffer, + image: Image, + image_layout: ImageLayout, + p_depth_stencil: *const ClearDepthStencilValue, + range_count: u32, + p_ranges: *const ImageSubresourceRange, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdClearAttachments = unsafe extern "system" fn( + command_buffer: CommandBuffer, + attachment_count: u32, + p_attachments: *const ClearAttachment, + rect_count: u32, + p_rects: *const ClearRect, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdResolveImage = unsafe extern "system" fn( + command_buffer: CommandBuffer, + src_image: Image, + src_image_layout: ImageLayout, + dst_image: Image, + dst_image_layout: ImageLayout, + region_count: u32, + p_regions: *const ImageResolve, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetEvent = unsafe extern "system" fn( + command_buffer: CommandBuffer, + event: Event, + stage_mask: PipelineStageFlags, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdResetEvent = unsafe extern "system" fn( + command_buffer: CommandBuffer, + event: Event, + stage_mask: PipelineStageFlags, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdWaitEvents = unsafe extern "system" fn( + command_buffer: CommandBuffer, + event_count: u32, + p_events: *const Event, + src_stage_mask: PipelineStageFlags, + dst_stage_mask: PipelineStageFlags, + memory_barrier_count: u32, + p_memory_barriers: *const MemoryBarrier, + buffer_memory_barrier_count: u32, + p_buffer_memory_barriers: *const BufferMemoryBarrier, + image_memory_barrier_count: u32, + p_image_memory_barriers: *const ImageMemoryBarrier, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdPipelineBarrier = unsafe extern "system" fn( + command_buffer: CommandBuffer, + src_stage_mask: PipelineStageFlags, + dst_stage_mask: PipelineStageFlags, + dependency_flags: DependencyFlags, + memory_barrier_count: u32, + p_memory_barriers: *const MemoryBarrier, + buffer_memory_barrier_count: u32, + p_buffer_memory_barriers: *const BufferMemoryBarrier, + image_memory_barrier_count: u32, + p_image_memory_barriers: *const ImageMemoryBarrier, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdBeginQuery = unsafe extern "system" fn( + command_buffer: CommandBuffer, + query_pool: QueryPool, + query: u32, + flags: QueryControlFlags, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdEndQuery = + unsafe extern "system" fn(command_buffer: CommandBuffer, query_pool: QueryPool, query: u32); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdResetQueryPool = unsafe extern "system" fn( + command_buffer: CommandBuffer, + query_pool: QueryPool, + first_query: u32, + query_count: u32, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdWriteTimestamp = unsafe extern "system" fn( + command_buffer: CommandBuffer, + pipeline_stage: PipelineStageFlags, + query_pool: QueryPool, + query: u32, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdCopyQueryPoolResults = unsafe extern "system" fn( + command_buffer: CommandBuffer, + query_pool: QueryPool, + first_query: u32, + query_count: u32, + dst_buffer: Buffer, + dst_offset: DeviceSize, + stride: DeviceSize, + flags: QueryResultFlags, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdPushConstants = unsafe extern "system" fn( + command_buffer: CommandBuffer, + layout: PipelineLayout, + stage_flags: ShaderStageFlags, + offset: u32, + size: u32, + p_values: *const c_void, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdBeginRenderPass = unsafe extern "system" fn( + command_buffer: CommandBuffer, + p_render_pass_begin: *const RenderPassBeginInfo, + contents: SubpassContents, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdNextSubpass = + unsafe extern "system" fn(command_buffer: CommandBuffer, contents: SubpassContents); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdEndRenderPass = unsafe extern "system" fn(command_buffer: CommandBuffer); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdExecuteCommands = unsafe extern "system" fn( + command_buffer: CommandBuffer, + command_buffer_count: u32, + p_command_buffers: *const CommandBuffer, +); +#[derive(Clone)] +pub struct DeviceFnV1_0 { + pub destroy_device: PFN_vkDestroyDevice, + pub get_device_queue: PFN_vkGetDeviceQueue, + pub queue_submit: PFN_vkQueueSubmit, + pub queue_wait_idle: PFN_vkQueueWaitIdle, + pub device_wait_idle: PFN_vkDeviceWaitIdle, + pub allocate_memory: PFN_vkAllocateMemory, + pub free_memory: PFN_vkFreeMemory, + pub map_memory: PFN_vkMapMemory, + pub unmap_memory: PFN_vkUnmapMemory, + pub flush_mapped_memory_ranges: PFN_vkFlushMappedMemoryRanges, + pub invalidate_mapped_memory_ranges: PFN_vkInvalidateMappedMemoryRanges, + pub get_device_memory_commitment: PFN_vkGetDeviceMemoryCommitment, + pub bind_buffer_memory: PFN_vkBindBufferMemory, + pub bind_image_memory: PFN_vkBindImageMemory, + pub get_buffer_memory_requirements: PFN_vkGetBufferMemoryRequirements, + pub get_image_memory_requirements: PFN_vkGetImageMemoryRequirements, + pub get_image_sparse_memory_requirements: PFN_vkGetImageSparseMemoryRequirements, + pub queue_bind_sparse: PFN_vkQueueBindSparse, + pub create_fence: PFN_vkCreateFence, + pub destroy_fence: PFN_vkDestroyFence, + pub reset_fences: PFN_vkResetFences, + pub get_fence_status: PFN_vkGetFenceStatus, + pub wait_for_fences: PFN_vkWaitForFences, + pub create_semaphore: PFN_vkCreateSemaphore, + pub destroy_semaphore: PFN_vkDestroySemaphore, + pub create_event: PFN_vkCreateEvent, + pub destroy_event: PFN_vkDestroyEvent, + pub get_event_status: PFN_vkGetEventStatus, + pub set_event: PFN_vkSetEvent, + pub reset_event: PFN_vkResetEvent, + pub create_query_pool: PFN_vkCreateQueryPool, + pub destroy_query_pool: PFN_vkDestroyQueryPool, + pub get_query_pool_results: PFN_vkGetQueryPoolResults, + pub create_buffer: PFN_vkCreateBuffer, + pub destroy_buffer: PFN_vkDestroyBuffer, + pub create_buffer_view: PFN_vkCreateBufferView, + pub destroy_buffer_view: PFN_vkDestroyBufferView, + pub create_image: PFN_vkCreateImage, + pub destroy_image: PFN_vkDestroyImage, + pub get_image_subresource_layout: PFN_vkGetImageSubresourceLayout, + pub create_image_view: PFN_vkCreateImageView, + pub destroy_image_view: PFN_vkDestroyImageView, + pub create_shader_module: PFN_vkCreateShaderModule, + pub destroy_shader_module: PFN_vkDestroyShaderModule, + pub create_pipeline_cache: PFN_vkCreatePipelineCache, + pub destroy_pipeline_cache: PFN_vkDestroyPipelineCache, + pub get_pipeline_cache_data: PFN_vkGetPipelineCacheData, + pub merge_pipeline_caches: PFN_vkMergePipelineCaches, + pub create_graphics_pipelines: PFN_vkCreateGraphicsPipelines, + pub create_compute_pipelines: PFN_vkCreateComputePipelines, + pub destroy_pipeline: PFN_vkDestroyPipeline, + pub create_pipeline_layout: PFN_vkCreatePipelineLayout, + pub destroy_pipeline_layout: PFN_vkDestroyPipelineLayout, + pub create_sampler: PFN_vkCreateSampler, + pub destroy_sampler: PFN_vkDestroySampler, + pub create_descriptor_set_layout: PFN_vkCreateDescriptorSetLayout, + pub destroy_descriptor_set_layout: PFN_vkDestroyDescriptorSetLayout, + pub create_descriptor_pool: PFN_vkCreateDescriptorPool, + pub destroy_descriptor_pool: PFN_vkDestroyDescriptorPool, + pub reset_descriptor_pool: PFN_vkResetDescriptorPool, + pub allocate_descriptor_sets: PFN_vkAllocateDescriptorSets, + pub free_descriptor_sets: PFN_vkFreeDescriptorSets, + pub update_descriptor_sets: PFN_vkUpdateDescriptorSets, + pub create_framebuffer: PFN_vkCreateFramebuffer, + pub destroy_framebuffer: PFN_vkDestroyFramebuffer, + pub create_render_pass: PFN_vkCreateRenderPass, + pub destroy_render_pass: PFN_vkDestroyRenderPass, + pub get_render_area_granularity: PFN_vkGetRenderAreaGranularity, + pub create_command_pool: PFN_vkCreateCommandPool, + pub destroy_command_pool: PFN_vkDestroyCommandPool, + pub reset_command_pool: PFN_vkResetCommandPool, + pub allocate_command_buffers: PFN_vkAllocateCommandBuffers, + pub free_command_buffers: PFN_vkFreeCommandBuffers, + pub begin_command_buffer: PFN_vkBeginCommandBuffer, + pub end_command_buffer: PFN_vkEndCommandBuffer, + pub reset_command_buffer: PFN_vkResetCommandBuffer, + pub cmd_bind_pipeline: PFN_vkCmdBindPipeline, + pub cmd_set_viewport: PFN_vkCmdSetViewport, + pub cmd_set_scissor: PFN_vkCmdSetScissor, + pub cmd_set_line_width: PFN_vkCmdSetLineWidth, + pub cmd_set_depth_bias: PFN_vkCmdSetDepthBias, + pub cmd_set_blend_constants: PFN_vkCmdSetBlendConstants, + pub cmd_set_depth_bounds: PFN_vkCmdSetDepthBounds, + pub cmd_set_stencil_compare_mask: PFN_vkCmdSetStencilCompareMask, + pub cmd_set_stencil_write_mask: PFN_vkCmdSetStencilWriteMask, + pub cmd_set_stencil_reference: PFN_vkCmdSetStencilReference, + pub cmd_bind_descriptor_sets: PFN_vkCmdBindDescriptorSets, + pub cmd_bind_index_buffer: PFN_vkCmdBindIndexBuffer, + pub cmd_bind_vertex_buffers: PFN_vkCmdBindVertexBuffers, + pub cmd_draw: PFN_vkCmdDraw, + pub cmd_draw_indexed: PFN_vkCmdDrawIndexed, + pub cmd_draw_indirect: PFN_vkCmdDrawIndirect, + pub cmd_draw_indexed_indirect: PFN_vkCmdDrawIndexedIndirect, + pub cmd_dispatch: PFN_vkCmdDispatch, + pub cmd_dispatch_indirect: PFN_vkCmdDispatchIndirect, + pub cmd_copy_buffer: PFN_vkCmdCopyBuffer, + pub cmd_copy_image: PFN_vkCmdCopyImage, + pub cmd_blit_image: PFN_vkCmdBlitImage, + pub cmd_copy_buffer_to_image: PFN_vkCmdCopyBufferToImage, + pub cmd_copy_image_to_buffer: PFN_vkCmdCopyImageToBuffer, + pub cmd_update_buffer: PFN_vkCmdUpdateBuffer, + pub cmd_fill_buffer: PFN_vkCmdFillBuffer, + pub cmd_clear_color_image: PFN_vkCmdClearColorImage, + pub cmd_clear_depth_stencil_image: PFN_vkCmdClearDepthStencilImage, + pub cmd_clear_attachments: PFN_vkCmdClearAttachments, + pub cmd_resolve_image: PFN_vkCmdResolveImage, + pub cmd_set_event: PFN_vkCmdSetEvent, + pub cmd_reset_event: PFN_vkCmdResetEvent, + pub cmd_wait_events: PFN_vkCmdWaitEvents, + pub cmd_pipeline_barrier: PFN_vkCmdPipelineBarrier, + pub cmd_begin_query: PFN_vkCmdBeginQuery, + pub cmd_end_query: PFN_vkCmdEndQuery, + pub cmd_reset_query_pool: PFN_vkCmdResetQueryPool, + pub cmd_write_timestamp: PFN_vkCmdWriteTimestamp, + pub cmd_copy_query_pool_results: PFN_vkCmdCopyQueryPoolResults, + pub cmd_push_constants: PFN_vkCmdPushConstants, + pub cmd_begin_render_pass: PFN_vkCmdBeginRenderPass, + pub cmd_next_subpass: PFN_vkCmdNextSubpass, + pub cmd_end_render_pass: PFN_vkCmdEndRenderPass, + pub cmd_execute_commands: PFN_vkCmdExecuteCommands, +} +unsafe impl Send for DeviceFnV1_0 {} +unsafe impl Sync for DeviceFnV1_0 {} +impl DeviceFnV1_0 { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + destroy_device: unsafe { + unsafe extern "system" fn destroy_device( + _device: Device, + _p_allocator: *const AllocationCallbacks, + ) { + panic!(concat!("Unable to load ", stringify!(destroy_device))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyDevice\0"); + let val = _f(cname); + if val.is_null() { + destroy_device + } else { + ::std::mem::transmute(val) + } + }, + get_device_queue: unsafe { + unsafe extern "system" fn get_device_queue( + _device: Device, + _queue_family_index: u32, + _queue_index: u32, + _p_queue: *mut Queue, + ) { + panic!(concat!("Unable to load ", stringify!(get_device_queue))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetDeviceQueue\0"); + let val = _f(cname); + if val.is_null() { + get_device_queue + } else { + ::std::mem::transmute(val) + } + }, + queue_submit: unsafe { + unsafe extern "system" fn queue_submit( + _queue: Queue, + _submit_count: u32, + _p_submits: *const SubmitInfo, + _fence: Fence, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(queue_submit))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkQueueSubmit\0"); + let val = _f(cname); + if val.is_null() { + queue_submit + } else { + ::std::mem::transmute(val) + } + }, + queue_wait_idle: unsafe { + unsafe extern "system" fn queue_wait_idle(_queue: Queue) -> Result { + panic!(concat!("Unable to load ", stringify!(queue_wait_idle))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkQueueWaitIdle\0"); + let val = _f(cname); + if val.is_null() { + queue_wait_idle + } else { + ::std::mem::transmute(val) + } + }, + device_wait_idle: unsafe { + unsafe extern "system" fn device_wait_idle(_device: Device) -> Result { + panic!(concat!("Unable to load ", stringify!(device_wait_idle))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDeviceWaitIdle\0"); + let val = _f(cname); + if val.is_null() { + device_wait_idle + } else { + ::std::mem::transmute(val) + } + }, + allocate_memory: unsafe { + unsafe extern "system" fn allocate_memory( + _device: Device, + _p_allocate_info: *const MemoryAllocateInfo, + _p_allocator: *const AllocationCallbacks, + _p_memory: *mut DeviceMemory, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(allocate_memory))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkAllocateMemory\0"); + let val = _f(cname); + if val.is_null() { + allocate_memory + } else { + ::std::mem::transmute(val) + } + }, + free_memory: unsafe { + unsafe extern "system" fn free_memory( + _device: Device, + _memory: DeviceMemory, + _p_allocator: *const AllocationCallbacks, + ) { + panic!(concat!("Unable to load ", stringify!(free_memory))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkFreeMemory\0"); + let val = _f(cname); + if val.is_null() { + free_memory + } else { + ::std::mem::transmute(val) + } + }, + map_memory: unsafe { + unsafe extern "system" fn map_memory( + _device: Device, + _memory: DeviceMemory, + _offset: DeviceSize, + _size: DeviceSize, + _flags: MemoryMapFlags, + _pp_data: *mut *mut c_void, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(map_memory))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkMapMemory\0"); + let val = _f(cname); + if val.is_null() { + map_memory + } else { + ::std::mem::transmute(val) + } + }, + unmap_memory: unsafe { + unsafe extern "system" fn unmap_memory(_device: Device, _memory: DeviceMemory) { + panic!(concat!("Unable to load ", stringify!(unmap_memory))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkUnmapMemory\0"); + let val = _f(cname); + if val.is_null() { + unmap_memory + } else { + ::std::mem::transmute(val) + } + }, + flush_mapped_memory_ranges: unsafe { + unsafe extern "system" fn flush_mapped_memory_ranges( + _device: Device, + _memory_range_count: u32, + _p_memory_ranges: *const MappedMemoryRange, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(flush_mapped_memory_ranges) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkFlushMappedMemoryRanges\0"); + let val = _f(cname); + if val.is_null() { + flush_mapped_memory_ranges + } else { + ::std::mem::transmute(val) + } + }, + invalidate_mapped_memory_ranges: unsafe { + unsafe extern "system" fn invalidate_mapped_memory_ranges( + _device: Device, + _memory_range_count: u32, + _p_memory_ranges: *const MappedMemoryRange, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(invalidate_mapped_memory_ranges) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkInvalidateMappedMemoryRanges\0", + ); + let val = _f(cname); + if val.is_null() { + invalidate_mapped_memory_ranges + } else { + ::std::mem::transmute(val) + } + }, + get_device_memory_commitment: unsafe { + unsafe extern "system" fn get_device_memory_commitment( + _device: Device, + _memory: DeviceMemory, + _p_committed_memory_in_bytes: *mut DeviceSize, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_device_memory_commitment) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetDeviceMemoryCommitment\0", + ); + let val = _f(cname); + if val.is_null() { + get_device_memory_commitment + } else { + ::std::mem::transmute(val) + } + }, + bind_buffer_memory: unsafe { + unsafe extern "system" fn bind_buffer_memory( + _device: Device, + _buffer: Buffer, + _memory: DeviceMemory, + _memory_offset: DeviceSize, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(bind_buffer_memory))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkBindBufferMemory\0"); + let val = _f(cname); + if val.is_null() { + bind_buffer_memory + } else { + ::std::mem::transmute(val) + } + }, + bind_image_memory: unsafe { + unsafe extern "system" fn bind_image_memory( + _device: Device, + _image: Image, + _memory: DeviceMemory, + _memory_offset: DeviceSize, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(bind_image_memory))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkBindImageMemory\0"); + let val = _f(cname); + if val.is_null() { + bind_image_memory + } else { + ::std::mem::transmute(val) + } + }, + get_buffer_memory_requirements: unsafe { + unsafe extern "system" fn get_buffer_memory_requirements( + _device: Device, + _buffer: Buffer, + _p_memory_requirements: *mut MemoryRequirements, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_buffer_memory_requirements) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetBufferMemoryRequirements\0", + ); + let val = _f(cname); + if val.is_null() { + get_buffer_memory_requirements + } else { + ::std::mem::transmute(val) + } + }, + get_image_memory_requirements: unsafe { + unsafe extern "system" fn get_image_memory_requirements( + _device: Device, + _image: Image, + _p_memory_requirements: *mut MemoryRequirements, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_image_memory_requirements) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetImageMemoryRequirements\0", + ); + let val = _f(cname); + if val.is_null() { + get_image_memory_requirements + } else { + ::std::mem::transmute(val) + } + }, + get_image_sparse_memory_requirements: unsafe { + unsafe extern "system" fn get_image_sparse_memory_requirements( + _device: Device, + _image: Image, + _p_sparse_memory_requirement_count: *mut u32, + _p_sparse_memory_requirements: *mut SparseImageMemoryRequirements, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_image_sparse_memory_requirements) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetImageSparseMemoryRequirements\0", + ); + let val = _f(cname); + if val.is_null() { + get_image_sparse_memory_requirements + } else { + ::std::mem::transmute(val) + } + }, + queue_bind_sparse: unsafe { + unsafe extern "system" fn queue_bind_sparse( + _queue: Queue, + _bind_info_count: u32, + _p_bind_info: *const BindSparseInfo, + _fence: Fence, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(queue_bind_sparse))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkQueueBindSparse\0"); + let val = _f(cname); + if val.is_null() { + queue_bind_sparse + } else { + ::std::mem::transmute(val) + } + }, + create_fence: unsafe { + unsafe extern "system" fn create_fence( + _device: Device, + _p_create_info: *const FenceCreateInfo, + _p_allocator: *const AllocationCallbacks, + _p_fence: *mut Fence, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(create_fence))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateFence\0"); + let val = _f(cname); + if val.is_null() { + create_fence + } else { + ::std::mem::transmute(val) + } + }, + destroy_fence: unsafe { + unsafe extern "system" fn destroy_fence( + _device: Device, + _fence: Fence, + _p_allocator: *const AllocationCallbacks, + ) { + panic!(concat!("Unable to load ", stringify!(destroy_fence))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyFence\0"); + let val = _f(cname); + if val.is_null() { + destroy_fence + } else { + ::std::mem::transmute(val) + } + }, + reset_fences: unsafe { + unsafe extern "system" fn reset_fences( + _device: Device, + _fence_count: u32, + _p_fences: *const Fence, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(reset_fences))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkResetFences\0"); + let val = _f(cname); + if val.is_null() { + reset_fences + } else { + ::std::mem::transmute(val) + } + }, + get_fence_status: unsafe { + unsafe extern "system" fn get_fence_status( + _device: Device, + _fence: Fence, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(get_fence_status))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetFenceStatus\0"); + let val = _f(cname); + if val.is_null() { + get_fence_status + } else { + ::std::mem::transmute(val) + } + }, + wait_for_fences: unsafe { + unsafe extern "system" fn wait_for_fences( + _device: Device, + _fence_count: u32, + _p_fences: *const Fence, + _wait_all: Bool32, + _timeout: u64, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(wait_for_fences))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkWaitForFences\0"); + let val = _f(cname); + if val.is_null() { + wait_for_fences + } else { + ::std::mem::transmute(val) + } + }, + create_semaphore: unsafe { + unsafe extern "system" fn create_semaphore( + _device: Device, + _p_create_info: *const SemaphoreCreateInfo, + _p_allocator: *const AllocationCallbacks, + _p_semaphore: *mut Semaphore, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(create_semaphore))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateSemaphore\0"); + let val = _f(cname); + if val.is_null() { + create_semaphore + } else { + ::std::mem::transmute(val) + } + }, + destroy_semaphore: unsafe { + unsafe extern "system" fn destroy_semaphore( + _device: Device, + _semaphore: Semaphore, + _p_allocator: *const AllocationCallbacks, + ) { + panic!(concat!("Unable to load ", stringify!(destroy_semaphore))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroySemaphore\0"); + let val = _f(cname); + if val.is_null() { + destroy_semaphore + } else { + ::std::mem::transmute(val) + } + }, + create_event: unsafe { + unsafe extern "system" fn create_event( + _device: Device, + _p_create_info: *const EventCreateInfo, + _p_allocator: *const AllocationCallbacks, + _p_event: *mut Event, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(create_event))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateEvent\0"); + let val = _f(cname); + if val.is_null() { + create_event + } else { + ::std::mem::transmute(val) + } + }, + destroy_event: unsafe { + unsafe extern "system" fn destroy_event( + _device: Device, + _event: Event, + _p_allocator: *const AllocationCallbacks, + ) { + panic!(concat!("Unable to load ", stringify!(destroy_event))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyEvent\0"); + let val = _f(cname); + if val.is_null() { + destroy_event + } else { + ::std::mem::transmute(val) + } + }, + get_event_status: unsafe { + unsafe extern "system" fn get_event_status( + _device: Device, + _event: Event, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(get_event_status))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetEventStatus\0"); + let val = _f(cname); + if val.is_null() { + get_event_status + } else { + ::std::mem::transmute(val) + } + }, + set_event: unsafe { + unsafe extern "system" fn set_event(_device: Device, _event: Event) -> Result { + panic!(concat!("Unable to load ", stringify!(set_event))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkSetEvent\0"); + let val = _f(cname); + if val.is_null() { + set_event + } else { + ::std::mem::transmute(val) + } + }, + reset_event: unsafe { + unsafe extern "system" fn reset_event(_device: Device, _event: Event) -> Result { + panic!(concat!("Unable to load ", stringify!(reset_event))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkResetEvent\0"); + let val = _f(cname); + if val.is_null() { + reset_event + } else { + ::std::mem::transmute(val) + } + }, + create_query_pool: unsafe { + unsafe extern "system" fn create_query_pool( + _device: Device, + _p_create_info: *const QueryPoolCreateInfo, + _p_allocator: *const AllocationCallbacks, + _p_query_pool: *mut QueryPool, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(create_query_pool))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateQueryPool\0"); + let val = _f(cname); + if val.is_null() { + create_query_pool + } else { + ::std::mem::transmute(val) + } + }, + destroy_query_pool: unsafe { + unsafe extern "system" fn destroy_query_pool( + _device: Device, + _query_pool: QueryPool, + _p_allocator: *const AllocationCallbacks, + ) { + panic!(concat!("Unable to load ", stringify!(destroy_query_pool))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyQueryPool\0"); + let val = _f(cname); + if val.is_null() { + destroy_query_pool + } else { + ::std::mem::transmute(val) + } + }, + get_query_pool_results: unsafe { + unsafe extern "system" fn get_query_pool_results( + _device: Device, + _query_pool: QueryPool, + _first_query: u32, + _query_count: u32, + _data_size: usize, + _p_data: *mut c_void, + _stride: DeviceSize, + _flags: QueryResultFlags, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_query_pool_results) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetQueryPoolResults\0"); + let val = _f(cname); + if val.is_null() { + get_query_pool_results + } else { + ::std::mem::transmute(val) + } + }, + create_buffer: unsafe { + unsafe extern "system" fn create_buffer( + _device: Device, + _p_create_info: *const BufferCreateInfo, + _p_allocator: *const AllocationCallbacks, + _p_buffer: *mut Buffer, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(create_buffer))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateBuffer\0"); + let val = _f(cname); + if val.is_null() { + create_buffer + } else { + ::std::mem::transmute(val) + } + }, + destroy_buffer: unsafe { + unsafe extern "system" fn destroy_buffer( + _device: Device, + _buffer: Buffer, + _p_allocator: *const AllocationCallbacks, + ) { + panic!(concat!("Unable to load ", stringify!(destroy_buffer))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyBuffer\0"); + let val = _f(cname); + if val.is_null() { + destroy_buffer + } else { + ::std::mem::transmute(val) + } + }, + create_buffer_view: unsafe { + unsafe extern "system" fn create_buffer_view( + _device: Device, + _p_create_info: *const BufferViewCreateInfo, + _p_allocator: *const AllocationCallbacks, + _p_view: *mut BufferView, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(create_buffer_view))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateBufferView\0"); + let val = _f(cname); + if val.is_null() { + create_buffer_view + } else { + ::std::mem::transmute(val) + } + }, + destroy_buffer_view: unsafe { + unsafe extern "system" fn destroy_buffer_view( + _device: Device, + _buffer_view: BufferView, + _p_allocator: *const AllocationCallbacks, + ) { + panic!(concat!("Unable to load ", stringify!(destroy_buffer_view))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyBufferView\0"); + let val = _f(cname); + if val.is_null() { + destroy_buffer_view + } else { + ::std::mem::transmute(val) + } + }, + create_image: unsafe { + unsafe extern "system" fn create_image( + _device: Device, + _p_create_info: *const ImageCreateInfo, + _p_allocator: *const AllocationCallbacks, + _p_image: *mut Image, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(create_image))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateImage\0"); + let val = _f(cname); + if val.is_null() { + create_image + } else { + ::std::mem::transmute(val) + } + }, + destroy_image: unsafe { + unsafe extern "system" fn destroy_image( + _device: Device, + _image: Image, + _p_allocator: *const AllocationCallbacks, + ) { + panic!(concat!("Unable to load ", stringify!(destroy_image))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyImage\0"); + let val = _f(cname); + if val.is_null() { + destroy_image + } else { + ::std::mem::transmute(val) + } + }, + get_image_subresource_layout: unsafe { + unsafe extern "system" fn get_image_subresource_layout( + _device: Device, + _image: Image, + _p_subresource: *const ImageSubresource, + _p_layout: *mut SubresourceLayout, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_image_subresource_layout) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetImageSubresourceLayout\0", + ); + let val = _f(cname); + if val.is_null() { + get_image_subresource_layout + } else { + ::std::mem::transmute(val) + } + }, + create_image_view: unsafe { + unsafe extern "system" fn create_image_view( + _device: Device, + _p_create_info: *const ImageViewCreateInfo, + _p_allocator: *const AllocationCallbacks, + _p_view: *mut ImageView, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(create_image_view))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateImageView\0"); + let val = _f(cname); + if val.is_null() { + create_image_view + } else { + ::std::mem::transmute(val) + } + }, + destroy_image_view: unsafe { + unsafe extern "system" fn destroy_image_view( + _device: Device, + _image_view: ImageView, + _p_allocator: *const AllocationCallbacks, + ) { + panic!(concat!("Unable to load ", stringify!(destroy_image_view))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyImageView\0"); + let val = _f(cname); + if val.is_null() { + destroy_image_view + } else { + ::std::mem::transmute(val) + } + }, + create_shader_module: unsafe { + unsafe extern "system" fn create_shader_module( + _device: Device, + _p_create_info: *const ShaderModuleCreateInfo, + _p_allocator: *const AllocationCallbacks, + _p_shader_module: *mut ShaderModule, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(create_shader_module))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateShaderModule\0"); + let val = _f(cname); + if val.is_null() { + create_shader_module + } else { + ::std::mem::transmute(val) + } + }, + destroy_shader_module: unsafe { + unsafe extern "system" fn destroy_shader_module( + _device: Device, + _shader_module: ShaderModule, + _p_allocator: *const AllocationCallbacks, + ) { + panic!(concat!( + "Unable to load ", + stringify!(destroy_shader_module) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyShaderModule\0"); + let val = _f(cname); + if val.is_null() { + destroy_shader_module + } else { + ::std::mem::transmute(val) + } + }, + create_pipeline_cache: unsafe { + unsafe extern "system" fn create_pipeline_cache( + _device: Device, + _p_create_info: *const PipelineCacheCreateInfo, + _p_allocator: *const AllocationCallbacks, + _p_pipeline_cache: *mut PipelineCache, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(create_pipeline_cache) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreatePipelineCache\0"); + let val = _f(cname); + if val.is_null() { + create_pipeline_cache + } else { + ::std::mem::transmute(val) + } + }, + destroy_pipeline_cache: unsafe { + unsafe extern "system" fn destroy_pipeline_cache( + _device: Device, + _pipeline_cache: PipelineCache, + _p_allocator: *const AllocationCallbacks, + ) { + panic!(concat!( + "Unable to load ", + stringify!(destroy_pipeline_cache) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyPipelineCache\0"); + let val = _f(cname); + if val.is_null() { + destroy_pipeline_cache + } else { + ::std::mem::transmute(val) + } + }, + get_pipeline_cache_data: unsafe { + unsafe extern "system" fn get_pipeline_cache_data( + _device: Device, + _pipeline_cache: PipelineCache, + _p_data_size: *mut usize, + _p_data: *mut c_void, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_pipeline_cache_data) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetPipelineCacheData\0"); + let val = _f(cname); + if val.is_null() { + get_pipeline_cache_data + } else { + ::std::mem::transmute(val) + } + }, + merge_pipeline_caches: unsafe { + unsafe extern "system" fn merge_pipeline_caches( + _device: Device, + _dst_cache: PipelineCache, + _src_cache_count: u32, + _p_src_caches: *const PipelineCache, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(merge_pipeline_caches) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkMergePipelineCaches\0"); + let val = _f(cname); + if val.is_null() { + merge_pipeline_caches + } else { + ::std::mem::transmute(val) + } + }, + create_graphics_pipelines: unsafe { + unsafe extern "system" fn create_graphics_pipelines( + _device: Device, + _pipeline_cache: PipelineCache, + _create_info_count: u32, + _p_create_infos: *const GraphicsPipelineCreateInfo, + _p_allocator: *const AllocationCallbacks, + _p_pipelines: *mut Pipeline, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(create_graphics_pipelines) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateGraphicsPipelines\0"); + let val = _f(cname); + if val.is_null() { + create_graphics_pipelines + } else { + ::std::mem::transmute(val) + } + }, + create_compute_pipelines: unsafe { + unsafe extern "system" fn create_compute_pipelines( + _device: Device, + _pipeline_cache: PipelineCache, + _create_info_count: u32, + _p_create_infos: *const ComputePipelineCreateInfo, + _p_allocator: *const AllocationCallbacks, + _p_pipelines: *mut Pipeline, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(create_compute_pipelines) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateComputePipelines\0"); + let val = _f(cname); + if val.is_null() { + create_compute_pipelines + } else { + ::std::mem::transmute(val) + } + }, + destroy_pipeline: unsafe { + unsafe extern "system" fn destroy_pipeline( + _device: Device, + _pipeline: Pipeline, + _p_allocator: *const AllocationCallbacks, + ) { + panic!(concat!("Unable to load ", stringify!(destroy_pipeline))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyPipeline\0"); + let val = _f(cname); + if val.is_null() { + destroy_pipeline + } else { + ::std::mem::transmute(val) + } + }, + create_pipeline_layout: unsafe { + unsafe extern "system" fn create_pipeline_layout( + _device: Device, + _p_create_info: *const PipelineLayoutCreateInfo, + _p_allocator: *const AllocationCallbacks, + _p_pipeline_layout: *mut PipelineLayout, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(create_pipeline_layout) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreatePipelineLayout\0"); + let val = _f(cname); + if val.is_null() { + create_pipeline_layout + } else { + ::std::mem::transmute(val) + } + }, + destroy_pipeline_layout: unsafe { + unsafe extern "system" fn destroy_pipeline_layout( + _device: Device, + _pipeline_layout: PipelineLayout, + _p_allocator: *const AllocationCallbacks, + ) { + panic!(concat!( + "Unable to load ", + stringify!(destroy_pipeline_layout) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyPipelineLayout\0"); + let val = _f(cname); + if val.is_null() { + destroy_pipeline_layout + } else { + ::std::mem::transmute(val) + } + }, + create_sampler: unsafe { + unsafe extern "system" fn create_sampler( + _device: Device, + _p_create_info: *const SamplerCreateInfo, + _p_allocator: *const AllocationCallbacks, + _p_sampler: *mut Sampler, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(create_sampler))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateSampler\0"); + let val = _f(cname); + if val.is_null() { + create_sampler + } else { + ::std::mem::transmute(val) + } + }, + destroy_sampler: unsafe { + unsafe extern "system" fn destroy_sampler( + _device: Device, + _sampler: Sampler, + _p_allocator: *const AllocationCallbacks, + ) { + panic!(concat!("Unable to load ", stringify!(destroy_sampler))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroySampler\0"); + let val = _f(cname); + if val.is_null() { + destroy_sampler + } else { + ::std::mem::transmute(val) + } + }, + create_descriptor_set_layout: unsafe { + unsafe extern "system" fn create_descriptor_set_layout( + _device: Device, + _p_create_info: *const DescriptorSetLayoutCreateInfo, + _p_allocator: *const AllocationCallbacks, + _p_set_layout: *mut DescriptorSetLayout, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(create_descriptor_set_layout) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCreateDescriptorSetLayout\0", + ); + let val = _f(cname); + if val.is_null() { + create_descriptor_set_layout + } else { + ::std::mem::transmute(val) + } + }, + destroy_descriptor_set_layout: unsafe { + unsafe extern "system" fn destroy_descriptor_set_layout( + _device: Device, + _descriptor_set_layout: DescriptorSetLayout, + _p_allocator: *const AllocationCallbacks, + ) { + panic!(concat!( + "Unable to load ", + stringify!(destroy_descriptor_set_layout) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkDestroyDescriptorSetLayout\0", + ); + let val = _f(cname); + if val.is_null() { + destroy_descriptor_set_layout + } else { + ::std::mem::transmute(val) + } + }, + create_descriptor_pool: unsafe { + unsafe extern "system" fn create_descriptor_pool( + _device: Device, + _p_create_info: *const DescriptorPoolCreateInfo, + _p_allocator: *const AllocationCallbacks, + _p_descriptor_pool: *mut DescriptorPool, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(create_descriptor_pool) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateDescriptorPool\0"); + let val = _f(cname); + if val.is_null() { + create_descriptor_pool + } else { + ::std::mem::transmute(val) + } + }, + destroy_descriptor_pool: unsafe { + unsafe extern "system" fn destroy_descriptor_pool( + _device: Device, + _descriptor_pool: DescriptorPool, + _p_allocator: *const AllocationCallbacks, + ) { + panic!(concat!( + "Unable to load ", + stringify!(destroy_descriptor_pool) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyDescriptorPool\0"); + let val = _f(cname); + if val.is_null() { + destroy_descriptor_pool + } else { + ::std::mem::transmute(val) + } + }, + reset_descriptor_pool: unsafe { + unsafe extern "system" fn reset_descriptor_pool( + _device: Device, + _descriptor_pool: DescriptorPool, + _flags: DescriptorPoolResetFlags, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(reset_descriptor_pool) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkResetDescriptorPool\0"); + let val = _f(cname); + if val.is_null() { + reset_descriptor_pool + } else { + ::std::mem::transmute(val) + } + }, + allocate_descriptor_sets: unsafe { + unsafe extern "system" fn allocate_descriptor_sets( + _device: Device, + _p_allocate_info: *const DescriptorSetAllocateInfo, + _p_descriptor_sets: *mut DescriptorSet, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(allocate_descriptor_sets) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkAllocateDescriptorSets\0"); + let val = _f(cname); + if val.is_null() { + allocate_descriptor_sets + } else { + ::std::mem::transmute(val) + } + }, + free_descriptor_sets: unsafe { + unsafe extern "system" fn free_descriptor_sets( + _device: Device, + _descriptor_pool: DescriptorPool, + _descriptor_set_count: u32, + _p_descriptor_sets: *const DescriptorSet, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(free_descriptor_sets))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkFreeDescriptorSets\0"); + let val = _f(cname); + if val.is_null() { + free_descriptor_sets + } else { + ::std::mem::transmute(val) + } + }, + update_descriptor_sets: unsafe { + unsafe extern "system" fn update_descriptor_sets( + _device: Device, + _descriptor_write_count: u32, + _p_descriptor_writes: *const WriteDescriptorSet, + _descriptor_copy_count: u32, + _p_descriptor_copies: *const CopyDescriptorSet, + ) { + panic!(concat!( + "Unable to load ", + stringify!(update_descriptor_sets) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkUpdateDescriptorSets\0"); + let val = _f(cname); + if val.is_null() { + update_descriptor_sets + } else { + ::std::mem::transmute(val) + } + }, + create_framebuffer: unsafe { + unsafe extern "system" fn create_framebuffer( + _device: Device, + _p_create_info: *const FramebufferCreateInfo, + _p_allocator: *const AllocationCallbacks, + _p_framebuffer: *mut Framebuffer, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(create_framebuffer))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateFramebuffer\0"); + let val = _f(cname); + if val.is_null() { + create_framebuffer + } else { + ::std::mem::transmute(val) + } + }, + destroy_framebuffer: unsafe { + unsafe extern "system" fn destroy_framebuffer( + _device: Device, + _framebuffer: Framebuffer, + _p_allocator: *const AllocationCallbacks, + ) { + panic!(concat!("Unable to load ", stringify!(destroy_framebuffer))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyFramebuffer\0"); + let val = _f(cname); + if val.is_null() { + destroy_framebuffer + } else { + ::std::mem::transmute(val) + } + }, + create_render_pass: unsafe { + unsafe extern "system" fn create_render_pass( + _device: Device, + _p_create_info: *const RenderPassCreateInfo, + _p_allocator: *const AllocationCallbacks, + _p_render_pass: *mut RenderPass, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(create_render_pass))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateRenderPass\0"); + let val = _f(cname); + if val.is_null() { + create_render_pass + } else { + ::std::mem::transmute(val) + } + }, + destroy_render_pass: unsafe { + unsafe extern "system" fn destroy_render_pass( + _device: Device, + _render_pass: RenderPass, + _p_allocator: *const AllocationCallbacks, + ) { + panic!(concat!("Unable to load ", stringify!(destroy_render_pass))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyRenderPass\0"); + let val = _f(cname); + if val.is_null() { + destroy_render_pass + } else { + ::std::mem::transmute(val) + } + }, + get_render_area_granularity: unsafe { + unsafe extern "system" fn get_render_area_granularity( + _device: Device, + _render_pass: RenderPass, + _p_granularity: *mut Extent2D, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_render_area_granularity) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetRenderAreaGranularity\0", + ); + let val = _f(cname); + if val.is_null() { + get_render_area_granularity + } else { + ::std::mem::transmute(val) + } + }, + create_command_pool: unsafe { + unsafe extern "system" fn create_command_pool( + _device: Device, + _p_create_info: *const CommandPoolCreateInfo, + _p_allocator: *const AllocationCallbacks, + _p_command_pool: *mut CommandPool, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(create_command_pool))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateCommandPool\0"); + let val = _f(cname); + if val.is_null() { + create_command_pool + } else { + ::std::mem::transmute(val) + } + }, + destroy_command_pool: unsafe { + unsafe extern "system" fn destroy_command_pool( + _device: Device, + _command_pool: CommandPool, + _p_allocator: *const AllocationCallbacks, + ) { + panic!(concat!("Unable to load ", stringify!(destroy_command_pool))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyCommandPool\0"); + let val = _f(cname); + if val.is_null() { + destroy_command_pool + } else { + ::std::mem::transmute(val) + } + }, + reset_command_pool: unsafe { + unsafe extern "system" fn reset_command_pool( + _device: Device, + _command_pool: CommandPool, + _flags: CommandPoolResetFlags, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(reset_command_pool))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkResetCommandPool\0"); + let val = _f(cname); + if val.is_null() { + reset_command_pool + } else { + ::std::mem::transmute(val) + } + }, + allocate_command_buffers: unsafe { + unsafe extern "system" fn allocate_command_buffers( + _device: Device, + _p_allocate_info: *const CommandBufferAllocateInfo, + _p_command_buffers: *mut CommandBuffer, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(allocate_command_buffers) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkAllocateCommandBuffers\0"); + let val = _f(cname); + if val.is_null() { + allocate_command_buffers + } else { + ::std::mem::transmute(val) + } + }, + free_command_buffers: unsafe { + unsafe extern "system" fn free_command_buffers( + _device: Device, + _command_pool: CommandPool, + _command_buffer_count: u32, + _p_command_buffers: *const CommandBuffer, + ) { + panic!(concat!("Unable to load ", stringify!(free_command_buffers))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkFreeCommandBuffers\0"); + let val = _f(cname); + if val.is_null() { + free_command_buffers + } else { + ::std::mem::transmute(val) + } + }, + begin_command_buffer: unsafe { + unsafe extern "system" fn begin_command_buffer( + _command_buffer: CommandBuffer, + _p_begin_info: *const CommandBufferBeginInfo, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(begin_command_buffer))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkBeginCommandBuffer\0"); + let val = _f(cname); + if val.is_null() { + begin_command_buffer + } else { + ::std::mem::transmute(val) + } + }, + end_command_buffer: unsafe { + unsafe extern "system" fn end_command_buffer( + _command_buffer: CommandBuffer, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(end_command_buffer))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkEndCommandBuffer\0"); + let val = _f(cname); + if val.is_null() { + end_command_buffer + } else { + ::std::mem::transmute(val) + } + }, + reset_command_buffer: unsafe { + unsafe extern "system" fn reset_command_buffer( + _command_buffer: CommandBuffer, + _flags: CommandBufferResetFlags, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(reset_command_buffer))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkResetCommandBuffer\0"); + let val = _f(cname); + if val.is_null() { + reset_command_buffer + } else { + ::std::mem::transmute(val) + } + }, + cmd_bind_pipeline: unsafe { + unsafe extern "system" fn cmd_bind_pipeline( + _command_buffer: CommandBuffer, + _pipeline_bind_point: PipelineBindPoint, + _pipeline: Pipeline, + ) { + panic!(concat!("Unable to load ", stringify!(cmd_bind_pipeline))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdBindPipeline\0"); + let val = _f(cname); + if val.is_null() { + cmd_bind_pipeline + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_viewport: unsafe { + unsafe extern "system" fn cmd_set_viewport( + _command_buffer: CommandBuffer, + _first_viewport: u32, + _viewport_count: u32, + _p_viewports: *const Viewport, + ) { + panic!(concat!("Unable to load ", stringify!(cmd_set_viewport))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetViewport\0"); + let val = _f(cname); + if val.is_null() { + cmd_set_viewport + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_scissor: unsafe { + unsafe extern "system" fn cmd_set_scissor( + _command_buffer: CommandBuffer, + _first_scissor: u32, + _scissor_count: u32, + _p_scissors: *const Rect2D, + ) { + panic!(concat!("Unable to load ", stringify!(cmd_set_scissor))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetScissor\0"); + let val = _f(cname); + if val.is_null() { + cmd_set_scissor + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_line_width: unsafe { + unsafe extern "system" fn cmd_set_line_width( + _command_buffer: CommandBuffer, + _line_width: f32, + ) { + panic!(concat!("Unable to load ", stringify!(cmd_set_line_width))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetLineWidth\0"); + let val = _f(cname); + if val.is_null() { + cmd_set_line_width + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_depth_bias: unsafe { + unsafe extern "system" fn cmd_set_depth_bias( + _command_buffer: CommandBuffer, + _depth_bias_constant_factor: f32, + _depth_bias_clamp: f32, + _depth_bias_slope_factor: f32, + ) { + panic!(concat!("Unable to load ", stringify!(cmd_set_depth_bias))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetDepthBias\0"); + let val = _f(cname); + if val.is_null() { + cmd_set_depth_bias + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_blend_constants: unsafe { + unsafe extern "system" fn cmd_set_blend_constants( + _command_buffer: CommandBuffer, + _blend_constants: *const [f32; 4], + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_blend_constants) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetBlendConstants\0"); + let val = _f(cname); + if val.is_null() { + cmd_set_blend_constants + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_depth_bounds: unsafe { + unsafe extern "system" fn cmd_set_depth_bounds( + _command_buffer: CommandBuffer, + _min_depth_bounds: f32, + _max_depth_bounds: f32, + ) { + panic!(concat!("Unable to load ", stringify!(cmd_set_depth_bounds))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetDepthBounds\0"); + let val = _f(cname); + if val.is_null() { + cmd_set_depth_bounds + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_stencil_compare_mask: unsafe { + unsafe extern "system" fn cmd_set_stencil_compare_mask( + _command_buffer: CommandBuffer, + _face_mask: StencilFaceFlags, + _compare_mask: u32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_stencil_compare_mask) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetStencilCompareMask\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_stencil_compare_mask + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_stencil_write_mask: unsafe { + unsafe extern "system" fn cmd_set_stencil_write_mask( + _command_buffer: CommandBuffer, + _face_mask: StencilFaceFlags, + _write_mask: u32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_stencil_write_mask) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetStencilWriteMask\0"); + let val = _f(cname); + if val.is_null() { + cmd_set_stencil_write_mask + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_stencil_reference: unsafe { + unsafe extern "system" fn cmd_set_stencil_reference( + _command_buffer: CommandBuffer, + _face_mask: StencilFaceFlags, + _reference: u32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_stencil_reference) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetStencilReference\0"); + let val = _f(cname); + if val.is_null() { + cmd_set_stencil_reference + } else { + ::std::mem::transmute(val) + } + }, + cmd_bind_descriptor_sets: unsafe { + unsafe extern "system" fn cmd_bind_descriptor_sets( + _command_buffer: CommandBuffer, + _pipeline_bind_point: PipelineBindPoint, + _layout: PipelineLayout, + _first_set: u32, + _descriptor_set_count: u32, + _p_descriptor_sets: *const DescriptorSet, + _dynamic_offset_count: u32, + _p_dynamic_offsets: *const u32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_bind_descriptor_sets) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdBindDescriptorSets\0"); + let val = _f(cname); + if val.is_null() { + cmd_bind_descriptor_sets + } else { + ::std::mem::transmute(val) + } + }, + cmd_bind_index_buffer: unsafe { + unsafe extern "system" fn cmd_bind_index_buffer( + _command_buffer: CommandBuffer, + _buffer: Buffer, + _offset: DeviceSize, + _index_type: IndexType, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_bind_index_buffer) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdBindIndexBuffer\0"); + let val = _f(cname); + if val.is_null() { + cmd_bind_index_buffer + } else { + ::std::mem::transmute(val) + } + }, + cmd_bind_vertex_buffers: unsafe { + unsafe extern "system" fn cmd_bind_vertex_buffers( + _command_buffer: CommandBuffer, + _first_binding: u32, + _binding_count: u32, + _p_buffers: *const Buffer, + _p_offsets: *const DeviceSize, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_bind_vertex_buffers) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdBindVertexBuffers\0"); + let val = _f(cname); + if val.is_null() { + cmd_bind_vertex_buffers + } else { + ::std::mem::transmute(val) + } + }, + cmd_draw: unsafe { + unsafe extern "system" fn cmd_draw( + _command_buffer: CommandBuffer, + _vertex_count: u32, + _instance_count: u32, + _first_vertex: u32, + _first_instance: u32, + ) { + panic!(concat!("Unable to load ", stringify!(cmd_draw))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdDraw\0"); + let val = _f(cname); + if val.is_null() { + cmd_draw + } else { + ::std::mem::transmute(val) + } + }, + cmd_draw_indexed: unsafe { + unsafe extern "system" fn cmd_draw_indexed( + _command_buffer: CommandBuffer, + _index_count: u32, + _instance_count: u32, + _first_index: u32, + _vertex_offset: i32, + _first_instance: u32, + ) { + panic!(concat!("Unable to load ", stringify!(cmd_draw_indexed))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdDrawIndexed\0"); + let val = _f(cname); + if val.is_null() { + cmd_draw_indexed + } else { + ::std::mem::transmute(val) + } + }, + cmd_draw_indirect: unsafe { + unsafe extern "system" fn cmd_draw_indirect( + _command_buffer: CommandBuffer, + _buffer: Buffer, + _offset: DeviceSize, + _draw_count: u32, + _stride: u32, + ) { + panic!(concat!("Unable to load ", stringify!(cmd_draw_indirect))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdDrawIndirect\0"); + let val = _f(cname); + if val.is_null() { + cmd_draw_indirect + } else { + ::std::mem::transmute(val) + } + }, + cmd_draw_indexed_indirect: unsafe { + unsafe extern "system" fn cmd_draw_indexed_indirect( + _command_buffer: CommandBuffer, + _buffer: Buffer, + _offset: DeviceSize, + _draw_count: u32, + _stride: u32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_draw_indexed_indirect) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdDrawIndexedIndirect\0"); + let val = _f(cname); + if val.is_null() { + cmd_draw_indexed_indirect + } else { + ::std::mem::transmute(val) + } + }, + cmd_dispatch: unsafe { + unsafe extern "system" fn cmd_dispatch( + _command_buffer: CommandBuffer, + _group_count_x: u32, + _group_count_y: u32, + _group_count_z: u32, + ) { + panic!(concat!("Unable to load ", stringify!(cmd_dispatch))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdDispatch\0"); + let val = _f(cname); + if val.is_null() { + cmd_dispatch + } else { + ::std::mem::transmute(val) + } + }, + cmd_dispatch_indirect: unsafe { + unsafe extern "system" fn cmd_dispatch_indirect( + _command_buffer: CommandBuffer, + _buffer: Buffer, + _offset: DeviceSize, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_dispatch_indirect) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdDispatchIndirect\0"); + let val = _f(cname); + if val.is_null() { + cmd_dispatch_indirect + } else { + ::std::mem::transmute(val) + } + }, + cmd_copy_buffer: unsafe { + unsafe extern "system" fn cmd_copy_buffer( + _command_buffer: CommandBuffer, + _src_buffer: Buffer, + _dst_buffer: Buffer, + _region_count: u32, + _p_regions: *const BufferCopy, + ) { + panic!(concat!("Unable to load ", stringify!(cmd_copy_buffer))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdCopyBuffer\0"); + let val = _f(cname); + if val.is_null() { + cmd_copy_buffer + } else { + ::std::mem::transmute(val) + } + }, + cmd_copy_image: unsafe { + unsafe extern "system" fn cmd_copy_image( + _command_buffer: CommandBuffer, + _src_image: Image, + _src_image_layout: ImageLayout, + _dst_image: Image, + _dst_image_layout: ImageLayout, + _region_count: u32, + _p_regions: *const ImageCopy, + ) { + panic!(concat!("Unable to load ", stringify!(cmd_copy_image))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdCopyImage\0"); + let val = _f(cname); + if val.is_null() { + cmd_copy_image + } else { + ::std::mem::transmute(val) + } + }, + cmd_blit_image: unsafe { + unsafe extern "system" fn cmd_blit_image( + _command_buffer: CommandBuffer, + _src_image: Image, + _src_image_layout: ImageLayout, + _dst_image: Image, + _dst_image_layout: ImageLayout, + _region_count: u32, + _p_regions: *const ImageBlit, + _filter: Filter, + ) { + panic!(concat!("Unable to load ", stringify!(cmd_blit_image))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdBlitImage\0"); + let val = _f(cname); + if val.is_null() { + cmd_blit_image + } else { + ::std::mem::transmute(val) + } + }, + cmd_copy_buffer_to_image: unsafe { + unsafe extern "system" fn cmd_copy_buffer_to_image( + _command_buffer: CommandBuffer, + _src_buffer: Buffer, + _dst_image: Image, + _dst_image_layout: ImageLayout, + _region_count: u32, + _p_regions: *const BufferImageCopy, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_copy_buffer_to_image) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdCopyBufferToImage\0"); + let val = _f(cname); + if val.is_null() { + cmd_copy_buffer_to_image + } else { + ::std::mem::transmute(val) + } + }, + cmd_copy_image_to_buffer: unsafe { + unsafe extern "system" fn cmd_copy_image_to_buffer( + _command_buffer: CommandBuffer, + _src_image: Image, + _src_image_layout: ImageLayout, + _dst_buffer: Buffer, + _region_count: u32, + _p_regions: *const BufferImageCopy, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_copy_image_to_buffer) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdCopyImageToBuffer\0"); + let val = _f(cname); + if val.is_null() { + cmd_copy_image_to_buffer + } else { + ::std::mem::transmute(val) + } + }, + cmd_update_buffer: unsafe { + unsafe extern "system" fn cmd_update_buffer( + _command_buffer: CommandBuffer, + _dst_buffer: Buffer, + _dst_offset: DeviceSize, + _data_size: DeviceSize, + _p_data: *const c_void, + ) { + panic!(concat!("Unable to load ", stringify!(cmd_update_buffer))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdUpdateBuffer\0"); + let val = _f(cname); + if val.is_null() { + cmd_update_buffer + } else { + ::std::mem::transmute(val) + } + }, + cmd_fill_buffer: unsafe { + unsafe extern "system" fn cmd_fill_buffer( + _command_buffer: CommandBuffer, + _dst_buffer: Buffer, + _dst_offset: DeviceSize, + _size: DeviceSize, + _data: u32, + ) { + panic!(concat!("Unable to load ", stringify!(cmd_fill_buffer))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdFillBuffer\0"); + let val = _f(cname); + if val.is_null() { + cmd_fill_buffer + } else { + ::std::mem::transmute(val) + } + }, + cmd_clear_color_image: unsafe { + unsafe extern "system" fn cmd_clear_color_image( + _command_buffer: CommandBuffer, + _image: Image, + _image_layout: ImageLayout, + _p_color: *const ClearColorValue, + _range_count: u32, + _p_ranges: *const ImageSubresourceRange, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_clear_color_image) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdClearColorImage\0"); + let val = _f(cname); + if val.is_null() { + cmd_clear_color_image + } else { + ::std::mem::transmute(val) + } + }, + cmd_clear_depth_stencil_image: unsafe { + unsafe extern "system" fn cmd_clear_depth_stencil_image( + _command_buffer: CommandBuffer, + _image: Image, + _image_layout: ImageLayout, + _p_depth_stencil: *const ClearDepthStencilValue, + _range_count: u32, + _p_ranges: *const ImageSubresourceRange, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_clear_depth_stencil_image) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdClearDepthStencilImage\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_clear_depth_stencil_image + } else { + ::std::mem::transmute(val) + } + }, + cmd_clear_attachments: unsafe { + unsafe extern "system" fn cmd_clear_attachments( + _command_buffer: CommandBuffer, + _attachment_count: u32, + _p_attachments: *const ClearAttachment, + _rect_count: u32, + _p_rects: *const ClearRect, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_clear_attachments) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdClearAttachments\0"); + let val = _f(cname); + if val.is_null() { + cmd_clear_attachments + } else { + ::std::mem::transmute(val) + } + }, + cmd_resolve_image: unsafe { + unsafe extern "system" fn cmd_resolve_image( + _command_buffer: CommandBuffer, + _src_image: Image, + _src_image_layout: ImageLayout, + _dst_image: Image, + _dst_image_layout: ImageLayout, + _region_count: u32, + _p_regions: *const ImageResolve, + ) { + panic!(concat!("Unable to load ", stringify!(cmd_resolve_image))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdResolveImage\0"); + let val = _f(cname); + if val.is_null() { + cmd_resolve_image + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_event: unsafe { + unsafe extern "system" fn cmd_set_event( + _command_buffer: CommandBuffer, + _event: Event, + _stage_mask: PipelineStageFlags, + ) { + panic!(concat!("Unable to load ", stringify!(cmd_set_event))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetEvent\0"); + let val = _f(cname); + if val.is_null() { + cmd_set_event + } else { + ::std::mem::transmute(val) + } + }, + cmd_reset_event: unsafe { + unsafe extern "system" fn cmd_reset_event( + _command_buffer: CommandBuffer, + _event: Event, + _stage_mask: PipelineStageFlags, + ) { + panic!(concat!("Unable to load ", stringify!(cmd_reset_event))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdResetEvent\0"); + let val = _f(cname); + if val.is_null() { + cmd_reset_event + } else { + ::std::mem::transmute(val) + } + }, + cmd_wait_events: unsafe { + unsafe extern "system" fn cmd_wait_events( + _command_buffer: CommandBuffer, + _event_count: u32, + _p_events: *const Event, + _src_stage_mask: PipelineStageFlags, + _dst_stage_mask: PipelineStageFlags, + _memory_barrier_count: u32, + _p_memory_barriers: *const MemoryBarrier, + _buffer_memory_barrier_count: u32, + _p_buffer_memory_barriers: *const BufferMemoryBarrier, + _image_memory_barrier_count: u32, + _p_image_memory_barriers: *const ImageMemoryBarrier, + ) { + panic!(concat!("Unable to load ", stringify!(cmd_wait_events))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdWaitEvents\0"); + let val = _f(cname); + if val.is_null() { + cmd_wait_events + } else { + ::std::mem::transmute(val) + } + }, + cmd_pipeline_barrier: unsafe { + unsafe extern "system" fn cmd_pipeline_barrier( + _command_buffer: CommandBuffer, + _src_stage_mask: PipelineStageFlags, + _dst_stage_mask: PipelineStageFlags, + _dependency_flags: DependencyFlags, + _memory_barrier_count: u32, + _p_memory_barriers: *const MemoryBarrier, + _buffer_memory_barrier_count: u32, + _p_buffer_memory_barriers: *const BufferMemoryBarrier, + _image_memory_barrier_count: u32, + _p_image_memory_barriers: *const ImageMemoryBarrier, + ) { + panic!(concat!("Unable to load ", stringify!(cmd_pipeline_barrier))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdPipelineBarrier\0"); + let val = _f(cname); + if val.is_null() { + cmd_pipeline_barrier + } else { + ::std::mem::transmute(val) + } + }, + cmd_begin_query: unsafe { + unsafe extern "system" fn cmd_begin_query( + _command_buffer: CommandBuffer, + _query_pool: QueryPool, + _query: u32, + _flags: QueryControlFlags, + ) { + panic!(concat!("Unable to load ", stringify!(cmd_begin_query))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdBeginQuery\0"); + let val = _f(cname); + if val.is_null() { + cmd_begin_query + } else { + ::std::mem::transmute(val) + } + }, + cmd_end_query: unsafe { + unsafe extern "system" fn cmd_end_query( + _command_buffer: CommandBuffer, + _query_pool: QueryPool, + _query: u32, + ) { + panic!(concat!("Unable to load ", stringify!(cmd_end_query))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdEndQuery\0"); + let val = _f(cname); + if val.is_null() { + cmd_end_query + } else { + ::std::mem::transmute(val) + } + }, + cmd_reset_query_pool: unsafe { + unsafe extern "system" fn cmd_reset_query_pool( + _command_buffer: CommandBuffer, + _query_pool: QueryPool, + _first_query: u32, + _query_count: u32, + ) { + panic!(concat!("Unable to load ", stringify!(cmd_reset_query_pool))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdResetQueryPool\0"); + let val = _f(cname); + if val.is_null() { + cmd_reset_query_pool + } else { + ::std::mem::transmute(val) + } + }, + cmd_write_timestamp: unsafe { + unsafe extern "system" fn cmd_write_timestamp( + _command_buffer: CommandBuffer, + _pipeline_stage: PipelineStageFlags, + _query_pool: QueryPool, + _query: u32, + ) { + panic!(concat!("Unable to load ", stringify!(cmd_write_timestamp))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdWriteTimestamp\0"); + let val = _f(cname); + if val.is_null() { + cmd_write_timestamp + } else { + ::std::mem::transmute(val) + } + }, + cmd_copy_query_pool_results: unsafe { + unsafe extern "system" fn cmd_copy_query_pool_results( + _command_buffer: CommandBuffer, + _query_pool: QueryPool, + _first_query: u32, + _query_count: u32, + _dst_buffer: Buffer, + _dst_offset: DeviceSize, + _stride: DeviceSize, + _flags: QueryResultFlags, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_copy_query_pool_results) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdCopyQueryPoolResults\0"); + let val = _f(cname); + if val.is_null() { + cmd_copy_query_pool_results + } else { + ::std::mem::transmute(val) + } + }, + cmd_push_constants: unsafe { + unsafe extern "system" fn cmd_push_constants( + _command_buffer: CommandBuffer, + _layout: PipelineLayout, + _stage_flags: ShaderStageFlags, + _offset: u32, + _size: u32, + _p_values: *const c_void, + ) { + panic!(concat!("Unable to load ", stringify!(cmd_push_constants))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdPushConstants\0"); + let val = _f(cname); + if val.is_null() { + cmd_push_constants + } else { + ::std::mem::transmute(val) + } + }, + cmd_begin_render_pass: unsafe { + unsafe extern "system" fn cmd_begin_render_pass( + _command_buffer: CommandBuffer, + _p_render_pass_begin: *const RenderPassBeginInfo, + _contents: SubpassContents, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_begin_render_pass) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdBeginRenderPass\0"); + let val = _f(cname); + if val.is_null() { + cmd_begin_render_pass + } else { + ::std::mem::transmute(val) + } + }, + cmd_next_subpass: unsafe { + unsafe extern "system" fn cmd_next_subpass( + _command_buffer: CommandBuffer, + _contents: SubpassContents, + ) { + panic!(concat!("Unable to load ", stringify!(cmd_next_subpass))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdNextSubpass\0"); + let val = _f(cname); + if val.is_null() { + cmd_next_subpass + } else { + ::std::mem::transmute(val) + } + }, + cmd_end_render_pass: unsafe { + unsafe extern "system" fn cmd_end_render_pass(_command_buffer: CommandBuffer) { + panic!(concat!("Unable to load ", stringify!(cmd_end_render_pass))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdEndRenderPass\0"); + let val = _f(cname); + if val.is_null() { + cmd_end_render_pass + } else { + ::std::mem::transmute(val) + } + }, + cmd_execute_commands: unsafe { + unsafe extern "system" fn cmd_execute_commands( + _command_buffer: CommandBuffer, + _command_buffer_count: u32, + _p_command_buffers: *const CommandBuffer, + ) { + panic!(concat!("Unable to load ", stringify!(cmd_execute_commands))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdExecuteCommands\0"); + let val = _f(cname); + if val.is_null() { + cmd_execute_commands + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[allow(non_camel_case_types)] +pub type PFN_vkEnumerateInstanceVersion = + unsafe extern "system" fn(p_api_version: *mut u32) -> Result; +#[derive(Clone)] +pub struct EntryFnV1_1 { + pub enumerate_instance_version: PFN_vkEnumerateInstanceVersion, +} +unsafe impl Send for EntryFnV1_1 {} +unsafe impl Sync for EntryFnV1_1 {} +impl EntryFnV1_1 { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + enumerate_instance_version: unsafe { + unsafe extern "system" fn enumerate_instance_version( + _p_api_version: *mut u32, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(enumerate_instance_version) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkEnumerateInstanceVersion\0", + ); + let val = _f(cname); + if val.is_null() { + enumerate_instance_version + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[derive(Clone)] +pub struct InstanceFnV1_1 { + pub enumerate_physical_device_groups: crate::vk::PFN_vkEnumeratePhysicalDeviceGroups, + pub get_physical_device_features2: crate::vk::PFN_vkGetPhysicalDeviceFeatures2, + pub get_physical_device_properties2: crate::vk::PFN_vkGetPhysicalDeviceProperties2, + pub get_physical_device_format_properties2: crate::vk::PFN_vkGetPhysicalDeviceFormatProperties2, + pub get_physical_device_image_format_properties2: + crate::vk::PFN_vkGetPhysicalDeviceImageFormatProperties2, + pub get_physical_device_queue_family_properties2: + crate::vk::PFN_vkGetPhysicalDeviceQueueFamilyProperties2, + pub get_physical_device_memory_properties2: crate::vk::PFN_vkGetPhysicalDeviceMemoryProperties2, + pub get_physical_device_sparse_image_format_properties2: + crate::vk::PFN_vkGetPhysicalDeviceSparseImageFormatProperties2, + pub get_physical_device_external_buffer_properties: + crate::vk::PFN_vkGetPhysicalDeviceExternalBufferProperties, + pub get_physical_device_external_fence_properties: + crate::vk::PFN_vkGetPhysicalDeviceExternalFenceProperties, + pub get_physical_device_external_semaphore_properties: + crate::vk::PFN_vkGetPhysicalDeviceExternalSemaphoreProperties, +} +unsafe impl Send for InstanceFnV1_1 {} +unsafe impl Sync for InstanceFnV1_1 {} +impl InstanceFnV1_1 { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + enumerate_physical_device_groups: unsafe { + unsafe extern "system" fn enumerate_physical_device_groups( + _instance: Instance, + _p_physical_device_group_count: *mut u32, + _p_physical_device_group_properties: *mut PhysicalDeviceGroupProperties, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(enumerate_physical_device_groups) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkEnumeratePhysicalDeviceGroups\0", + ); + let val = _f(cname); + if val.is_null() { + enumerate_physical_device_groups + } else { + ::std::mem::transmute(val) + } + }, + get_physical_device_features2: unsafe { + unsafe extern "system" fn get_physical_device_features2( + _physical_device: PhysicalDevice, + _p_features: *mut PhysicalDeviceFeatures2, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_features2) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPhysicalDeviceFeatures2\0", + ); + let val = _f(cname); + if val.is_null() { + get_physical_device_features2 + } else { + ::std::mem::transmute(val) + } + }, + get_physical_device_properties2: unsafe { + unsafe extern "system" fn get_physical_device_properties2( + _physical_device: PhysicalDevice, + _p_properties: *mut PhysicalDeviceProperties2, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_properties2) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPhysicalDeviceProperties2\0", + ); + let val = _f(cname); + if val.is_null() { + get_physical_device_properties2 + } else { + ::std::mem::transmute(val) + } + }, + get_physical_device_format_properties2: unsafe { + unsafe extern "system" fn get_physical_device_format_properties2( + _physical_device: PhysicalDevice, + _format: Format, + _p_format_properties: *mut FormatProperties2, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_format_properties2) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPhysicalDeviceFormatProperties2\0", + ); + let val = _f(cname); + if val.is_null() { + get_physical_device_format_properties2 + } else { + ::std::mem::transmute(val) + } + }, + get_physical_device_image_format_properties2: unsafe { + unsafe extern "system" fn get_physical_device_image_format_properties2( + _physical_device: PhysicalDevice, + _p_image_format_info: *const PhysicalDeviceImageFormatInfo2, + _p_image_format_properties: *mut ImageFormatProperties2, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_image_format_properties2) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPhysicalDeviceImageFormatProperties2\0", + ); + let val = _f(cname); + if val.is_null() { + get_physical_device_image_format_properties2 + } else { + ::std::mem::transmute(val) + } + }, + get_physical_device_queue_family_properties2: unsafe { + unsafe extern "system" fn get_physical_device_queue_family_properties2( + _physical_device: PhysicalDevice, + _p_queue_family_property_count: *mut u32, + _p_queue_family_properties: *mut QueueFamilyProperties2, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_queue_family_properties2) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPhysicalDeviceQueueFamilyProperties2\0", + ); + let val = _f(cname); + if val.is_null() { + get_physical_device_queue_family_properties2 + } else { + ::std::mem::transmute(val) + } + }, + get_physical_device_memory_properties2: unsafe { + unsafe extern "system" fn get_physical_device_memory_properties2( + _physical_device: PhysicalDevice, + _p_memory_properties: *mut PhysicalDeviceMemoryProperties2, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_memory_properties2) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPhysicalDeviceMemoryProperties2\0", + ); + let val = _f(cname); + if val.is_null() { + get_physical_device_memory_properties2 + } else { + ::std::mem::transmute(val) + } + }, + get_physical_device_sparse_image_format_properties2: unsafe { + unsafe extern "system" fn get_physical_device_sparse_image_format_properties2( + _physical_device: PhysicalDevice, + _p_format_info: *const PhysicalDeviceSparseImageFormatInfo2, + _p_property_count: *mut u32, + _p_properties: *mut SparseImageFormatProperties2, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_sparse_image_format_properties2) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPhysicalDeviceSparseImageFormatProperties2\0", + ); + let val = _f(cname); + if val.is_null() { + get_physical_device_sparse_image_format_properties2 + } else { + ::std::mem::transmute(val) + } + }, + get_physical_device_external_buffer_properties: unsafe { + unsafe extern "system" fn get_physical_device_external_buffer_properties( + _physical_device: PhysicalDevice, + _p_external_buffer_info: *const PhysicalDeviceExternalBufferInfo, + _p_external_buffer_properties: *mut ExternalBufferProperties, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_external_buffer_properties) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPhysicalDeviceExternalBufferProperties\0", + ); + let val = _f(cname); + if val.is_null() { + get_physical_device_external_buffer_properties + } else { + ::std::mem::transmute(val) + } + }, + get_physical_device_external_fence_properties: unsafe { + unsafe extern "system" fn get_physical_device_external_fence_properties( + _physical_device: PhysicalDevice, + _p_external_fence_info: *const PhysicalDeviceExternalFenceInfo, + _p_external_fence_properties: *mut ExternalFenceProperties, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_external_fence_properties) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPhysicalDeviceExternalFenceProperties\0", + ); + let val = _f(cname); + if val.is_null() { + get_physical_device_external_fence_properties + } else { + ::std::mem::transmute(val) + } + }, + get_physical_device_external_semaphore_properties: unsafe { + unsafe extern "system" fn get_physical_device_external_semaphore_properties( + _physical_device: PhysicalDevice, + _p_external_semaphore_info: *const PhysicalDeviceExternalSemaphoreInfo, + _p_external_semaphore_properties: *mut ExternalSemaphoreProperties, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_external_semaphore_properties) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPhysicalDeviceExternalSemaphoreProperties\0", + ); + let val = _f(cname); + if val.is_null() { + get_physical_device_external_semaphore_properties + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[allow(non_camel_case_types)] +pub type PFN_vkGetDeviceQueue2 = unsafe extern "system" fn( + device: Device, + p_queue_info: *const DeviceQueueInfo2, + p_queue: *mut Queue, +); +#[derive(Clone)] +pub struct DeviceFnV1_1 { + pub bind_buffer_memory2: crate::vk::PFN_vkBindBufferMemory2, + pub bind_image_memory2: crate::vk::PFN_vkBindImageMemory2, + pub get_device_group_peer_memory_features: crate::vk::PFN_vkGetDeviceGroupPeerMemoryFeatures, + pub cmd_set_device_mask: crate::vk::PFN_vkCmdSetDeviceMask, + pub cmd_dispatch_base: crate::vk::PFN_vkCmdDispatchBase, + pub get_image_memory_requirements2: crate::vk::PFN_vkGetImageMemoryRequirements2, + pub get_buffer_memory_requirements2: crate::vk::PFN_vkGetBufferMemoryRequirements2, + pub get_image_sparse_memory_requirements2: crate::vk::PFN_vkGetImageSparseMemoryRequirements2, + pub trim_command_pool: crate::vk::PFN_vkTrimCommandPool, + pub get_device_queue2: PFN_vkGetDeviceQueue2, + pub create_sampler_ycbcr_conversion: crate::vk::PFN_vkCreateSamplerYcbcrConversion, + pub destroy_sampler_ycbcr_conversion: crate::vk::PFN_vkDestroySamplerYcbcrConversion, + pub create_descriptor_update_template: crate::vk::PFN_vkCreateDescriptorUpdateTemplate, + pub destroy_descriptor_update_template: crate::vk::PFN_vkDestroyDescriptorUpdateTemplate, + pub update_descriptor_set_with_template: crate::vk::PFN_vkUpdateDescriptorSetWithTemplate, + pub get_descriptor_set_layout_support: crate::vk::PFN_vkGetDescriptorSetLayoutSupport, +} +unsafe impl Send for DeviceFnV1_1 {} +unsafe impl Sync for DeviceFnV1_1 {} +impl DeviceFnV1_1 { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + bind_buffer_memory2: unsafe { + unsafe extern "system" fn bind_buffer_memory2( + _device: Device, + _bind_info_count: u32, + _p_bind_infos: *const BindBufferMemoryInfo, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(bind_buffer_memory2))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkBindBufferMemory2\0"); + let val = _f(cname); + if val.is_null() { + bind_buffer_memory2 + } else { + ::std::mem::transmute(val) + } + }, + bind_image_memory2: unsafe { + unsafe extern "system" fn bind_image_memory2( + _device: Device, + _bind_info_count: u32, + _p_bind_infos: *const BindImageMemoryInfo, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(bind_image_memory2))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkBindImageMemory2\0"); + let val = _f(cname); + if val.is_null() { + bind_image_memory2 + } else { + ::std::mem::transmute(val) + } + }, + get_device_group_peer_memory_features: unsafe { + unsafe extern "system" fn get_device_group_peer_memory_features( + _device: Device, + _heap_index: u32, + _local_device_index: u32, + _remote_device_index: u32, + _p_peer_memory_features: *mut PeerMemoryFeatureFlags, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_device_group_peer_memory_features) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetDeviceGroupPeerMemoryFeatures\0", + ); + let val = _f(cname); + if val.is_null() { + get_device_group_peer_memory_features + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_device_mask: unsafe { + unsafe extern "system" fn cmd_set_device_mask( + _command_buffer: CommandBuffer, + _device_mask: u32, + ) { + panic!(concat!("Unable to load ", stringify!(cmd_set_device_mask))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetDeviceMask\0"); + let val = _f(cname); + if val.is_null() { + cmd_set_device_mask + } else { + ::std::mem::transmute(val) + } + }, + cmd_dispatch_base: unsafe { + unsafe extern "system" fn cmd_dispatch_base( + _command_buffer: CommandBuffer, + _base_group_x: u32, + _base_group_y: u32, + _base_group_z: u32, + _group_count_x: u32, + _group_count_y: u32, + _group_count_z: u32, + ) { + panic!(concat!("Unable to load ", stringify!(cmd_dispatch_base))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdDispatchBase\0"); + let val = _f(cname); + if val.is_null() { + cmd_dispatch_base + } else { + ::std::mem::transmute(val) + } + }, + get_image_memory_requirements2: unsafe { + unsafe extern "system" fn get_image_memory_requirements2( + _device: Device, + _p_info: *const ImageMemoryRequirementsInfo2, + _p_memory_requirements: *mut MemoryRequirements2, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_image_memory_requirements2) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetImageMemoryRequirements2\0", + ); + let val = _f(cname); + if val.is_null() { + get_image_memory_requirements2 + } else { + ::std::mem::transmute(val) + } + }, + get_buffer_memory_requirements2: unsafe { + unsafe extern "system" fn get_buffer_memory_requirements2( + _device: Device, + _p_info: *const BufferMemoryRequirementsInfo2, + _p_memory_requirements: *mut MemoryRequirements2, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_buffer_memory_requirements2) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetBufferMemoryRequirements2\0", + ); + let val = _f(cname); + if val.is_null() { + get_buffer_memory_requirements2 + } else { + ::std::mem::transmute(val) + } + }, + get_image_sparse_memory_requirements2: unsafe { + unsafe extern "system" fn get_image_sparse_memory_requirements2( + _device: Device, + _p_info: *const ImageSparseMemoryRequirementsInfo2, + _p_sparse_memory_requirement_count: *mut u32, + _p_sparse_memory_requirements: *mut SparseImageMemoryRequirements2, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_image_sparse_memory_requirements2) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetImageSparseMemoryRequirements2\0", + ); + let val = _f(cname); + if val.is_null() { + get_image_sparse_memory_requirements2 + } else { + ::std::mem::transmute(val) + } + }, + trim_command_pool: unsafe { + unsafe extern "system" fn trim_command_pool( + _device: Device, + _command_pool: CommandPool, + _flags: CommandPoolTrimFlags, + ) { + panic!(concat!("Unable to load ", stringify!(trim_command_pool))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkTrimCommandPool\0"); + let val = _f(cname); + if val.is_null() { + trim_command_pool + } else { + ::std::mem::transmute(val) + } + }, + get_device_queue2: unsafe { + unsafe extern "system" fn get_device_queue2( + _device: Device, + _p_queue_info: *const DeviceQueueInfo2, + _p_queue: *mut Queue, + ) { + panic!(concat!("Unable to load ", stringify!(get_device_queue2))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetDeviceQueue2\0"); + let val = _f(cname); + if val.is_null() { + get_device_queue2 + } else { + ::std::mem::transmute(val) + } + }, + create_sampler_ycbcr_conversion: unsafe { + unsafe extern "system" fn create_sampler_ycbcr_conversion( + _device: Device, + _p_create_info: *const SamplerYcbcrConversionCreateInfo, + _p_allocator: *const AllocationCallbacks, + _p_ycbcr_conversion: *mut SamplerYcbcrConversion, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(create_sampler_ycbcr_conversion) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCreateSamplerYcbcrConversion\0", + ); + let val = _f(cname); + if val.is_null() { + create_sampler_ycbcr_conversion + } else { + ::std::mem::transmute(val) + } + }, + destroy_sampler_ycbcr_conversion: unsafe { + unsafe extern "system" fn destroy_sampler_ycbcr_conversion( + _device: Device, + _ycbcr_conversion: SamplerYcbcrConversion, + _p_allocator: *const AllocationCallbacks, + ) { + panic!(concat!( + "Unable to load ", + stringify!(destroy_sampler_ycbcr_conversion) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkDestroySamplerYcbcrConversion\0", + ); + let val = _f(cname); + if val.is_null() { + destroy_sampler_ycbcr_conversion + } else { + ::std::mem::transmute(val) + } + }, + create_descriptor_update_template: unsafe { + unsafe extern "system" fn create_descriptor_update_template( + _device: Device, + _p_create_info: *const DescriptorUpdateTemplateCreateInfo, + _p_allocator: *const AllocationCallbacks, + _p_descriptor_update_template: *mut DescriptorUpdateTemplate, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(create_descriptor_update_template) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCreateDescriptorUpdateTemplate\0", + ); + let val = _f(cname); + if val.is_null() { + create_descriptor_update_template + } else { + ::std::mem::transmute(val) + } + }, + destroy_descriptor_update_template: unsafe { + unsafe extern "system" fn destroy_descriptor_update_template( + _device: Device, + _descriptor_update_template: DescriptorUpdateTemplate, + _p_allocator: *const AllocationCallbacks, + ) { + panic!(concat!( + "Unable to load ", + stringify!(destroy_descriptor_update_template) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkDestroyDescriptorUpdateTemplate\0", + ); + let val = _f(cname); + if val.is_null() { + destroy_descriptor_update_template + } else { + ::std::mem::transmute(val) + } + }, + update_descriptor_set_with_template: unsafe { + unsafe extern "system" fn update_descriptor_set_with_template( + _device: Device, + _descriptor_set: DescriptorSet, + _descriptor_update_template: DescriptorUpdateTemplate, + _p_data: *const c_void, + ) { + panic!(concat!( + "Unable to load ", + stringify!(update_descriptor_set_with_template) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkUpdateDescriptorSetWithTemplate\0", + ); + let val = _f(cname); + if val.is_null() { + update_descriptor_set_with_template + } else { + ::std::mem::transmute(val) + } + }, + get_descriptor_set_layout_support: unsafe { + unsafe extern "system" fn get_descriptor_set_layout_support( + _device: Device, + _p_create_info: *const DescriptorSetLayoutCreateInfo, + _p_support: *mut DescriptorSetLayoutSupport, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_descriptor_set_layout_support) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetDescriptorSetLayoutSupport\0", + ); + let val = _f(cname); + if val.is_null() { + get_descriptor_set_layout_support + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[derive(Clone)] +pub struct EntryFnV1_2 {} +unsafe impl Send for EntryFnV1_2 {} +unsafe impl Sync for EntryFnV1_2 {} +impl EntryFnV1_2 { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[derive(Clone)] +pub struct InstanceFnV1_2 {} +unsafe impl Send for InstanceFnV1_2 {} +unsafe impl Sync for InstanceFnV1_2 {} +impl InstanceFnV1_2 { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[derive(Clone)] +pub struct DeviceFnV1_2 { + pub cmd_draw_indirect_count: crate::vk::PFN_vkCmdDrawIndirectCount, + pub cmd_draw_indexed_indirect_count: crate::vk::PFN_vkCmdDrawIndexedIndirectCount, + pub create_render_pass2: crate::vk::PFN_vkCreateRenderPass2, + pub cmd_begin_render_pass2: crate::vk::PFN_vkCmdBeginRenderPass2, + pub cmd_next_subpass2: crate::vk::PFN_vkCmdNextSubpass2, + pub cmd_end_render_pass2: crate::vk::PFN_vkCmdEndRenderPass2, + pub reset_query_pool: crate::vk::PFN_vkResetQueryPool, + pub get_semaphore_counter_value: crate::vk::PFN_vkGetSemaphoreCounterValue, + pub wait_semaphores: crate::vk::PFN_vkWaitSemaphores, + pub signal_semaphore: crate::vk::PFN_vkSignalSemaphore, + pub get_buffer_device_address: crate::vk::PFN_vkGetBufferDeviceAddress, + pub get_buffer_opaque_capture_address: crate::vk::PFN_vkGetBufferOpaqueCaptureAddress, + pub get_device_memory_opaque_capture_address: + crate::vk::PFN_vkGetDeviceMemoryOpaqueCaptureAddress, +} +unsafe impl Send for DeviceFnV1_2 {} +unsafe impl Sync for DeviceFnV1_2 {} +impl DeviceFnV1_2 { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + cmd_draw_indirect_count: unsafe { + unsafe extern "system" fn cmd_draw_indirect_count( + _command_buffer: CommandBuffer, + _buffer: Buffer, + _offset: DeviceSize, + _count_buffer: Buffer, + _count_buffer_offset: DeviceSize, + _max_draw_count: u32, + _stride: u32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_draw_indirect_count) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdDrawIndirectCount\0"); + let val = _f(cname); + if val.is_null() { + cmd_draw_indirect_count + } else { + ::std::mem::transmute(val) + } + }, + cmd_draw_indexed_indirect_count: unsafe { + unsafe extern "system" fn cmd_draw_indexed_indirect_count( + _command_buffer: CommandBuffer, + _buffer: Buffer, + _offset: DeviceSize, + _count_buffer: Buffer, + _count_buffer_offset: DeviceSize, + _max_draw_count: u32, + _stride: u32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_draw_indexed_indirect_count) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdDrawIndexedIndirectCount\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_draw_indexed_indirect_count + } else { + ::std::mem::transmute(val) + } + }, + create_render_pass2: unsafe { + unsafe extern "system" fn create_render_pass2( + _device: Device, + _p_create_info: *const RenderPassCreateInfo2, + _p_allocator: *const AllocationCallbacks, + _p_render_pass: *mut RenderPass, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(create_render_pass2))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateRenderPass2\0"); + let val = _f(cname); + if val.is_null() { + create_render_pass2 + } else { + ::std::mem::transmute(val) + } + }, + cmd_begin_render_pass2: unsafe { + unsafe extern "system" fn cmd_begin_render_pass2( + _command_buffer: CommandBuffer, + _p_render_pass_begin: *const RenderPassBeginInfo, + _p_subpass_begin_info: *const SubpassBeginInfo, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_begin_render_pass2) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdBeginRenderPass2\0"); + let val = _f(cname); + if val.is_null() { + cmd_begin_render_pass2 + } else { + ::std::mem::transmute(val) + } + }, + cmd_next_subpass2: unsafe { + unsafe extern "system" fn cmd_next_subpass2( + _command_buffer: CommandBuffer, + _p_subpass_begin_info: *const SubpassBeginInfo, + _p_subpass_end_info: *const SubpassEndInfo, + ) { + panic!(concat!("Unable to load ", stringify!(cmd_next_subpass2))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdNextSubpass2\0"); + let val = _f(cname); + if val.is_null() { + cmd_next_subpass2 + } else { + ::std::mem::transmute(val) + } + }, + cmd_end_render_pass2: unsafe { + unsafe extern "system" fn cmd_end_render_pass2( + _command_buffer: CommandBuffer, + _p_subpass_end_info: *const SubpassEndInfo, + ) { + panic!(concat!("Unable to load ", stringify!(cmd_end_render_pass2))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdEndRenderPass2\0"); + let val = _f(cname); + if val.is_null() { + cmd_end_render_pass2 + } else { + ::std::mem::transmute(val) + } + }, + reset_query_pool: unsafe { + unsafe extern "system" fn reset_query_pool( + _device: Device, + _query_pool: QueryPool, + _first_query: u32, + _query_count: u32, + ) { + panic!(concat!("Unable to load ", stringify!(reset_query_pool))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkResetQueryPool\0"); + let val = _f(cname); + if val.is_null() { + reset_query_pool + } else { + ::std::mem::transmute(val) + } + }, + get_semaphore_counter_value: unsafe { + unsafe extern "system" fn get_semaphore_counter_value( + _device: Device, + _semaphore: Semaphore, + _p_value: *mut u64, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_semaphore_counter_value) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetSemaphoreCounterValue\0", + ); + let val = _f(cname); + if val.is_null() { + get_semaphore_counter_value + } else { + ::std::mem::transmute(val) + } + }, + wait_semaphores: unsafe { + unsafe extern "system" fn wait_semaphores( + _device: Device, + _p_wait_info: *const SemaphoreWaitInfo, + _timeout: u64, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(wait_semaphores))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkWaitSemaphores\0"); + let val = _f(cname); + if val.is_null() { + wait_semaphores + } else { + ::std::mem::transmute(val) + } + }, + signal_semaphore: unsafe { + unsafe extern "system" fn signal_semaphore( + _device: Device, + _p_signal_info: *const SemaphoreSignalInfo, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(signal_semaphore))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkSignalSemaphore\0"); + let val = _f(cname); + if val.is_null() { + signal_semaphore + } else { + ::std::mem::transmute(val) + } + }, + get_buffer_device_address: unsafe { + unsafe extern "system" fn get_buffer_device_address( + _device: Device, + _p_info: *const BufferDeviceAddressInfo, + ) -> DeviceAddress { + panic!(concat!( + "Unable to load ", + stringify!(get_buffer_device_address) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetBufferDeviceAddress\0"); + let val = _f(cname); + if val.is_null() { + get_buffer_device_address + } else { + ::std::mem::transmute(val) + } + }, + get_buffer_opaque_capture_address: unsafe { + unsafe extern "system" fn get_buffer_opaque_capture_address( + _device: Device, + _p_info: *const BufferDeviceAddressInfo, + ) -> u64 { + panic!(concat!( + "Unable to load ", + stringify!(get_buffer_opaque_capture_address) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetBufferOpaqueCaptureAddress\0", + ); + let val = _f(cname); + if val.is_null() { + get_buffer_opaque_capture_address + } else { + ::std::mem::transmute(val) + } + }, + get_device_memory_opaque_capture_address: unsafe { + unsafe extern "system" fn get_device_memory_opaque_capture_address( + _device: Device, + _p_info: *const DeviceMemoryOpaqueCaptureAddressInfo, + ) -> u64 { + panic!(concat!( + "Unable to load ", + stringify!(get_device_memory_opaque_capture_address) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetDeviceMemoryOpaqueCaptureAddress\0", + ); + let val = _f(cname); + if val.is_null() { + get_device_memory_opaque_capture_address + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[derive(Clone)] +pub struct EntryFnV1_3 {} +unsafe impl Send for EntryFnV1_3 {} +unsafe impl Sync for EntryFnV1_3 {} +impl EntryFnV1_3 { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[derive(Clone)] +pub struct InstanceFnV1_3 { + pub get_physical_device_tool_properties: crate::vk::PFN_vkGetPhysicalDeviceToolProperties, +} +unsafe impl Send for InstanceFnV1_3 {} +unsafe impl Sync for InstanceFnV1_3 {} +impl InstanceFnV1_3 { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + get_physical_device_tool_properties: unsafe { + unsafe extern "system" fn get_physical_device_tool_properties( + _physical_device: PhysicalDevice, + _p_tool_count: *mut u32, + _p_tool_properties: *mut PhysicalDeviceToolProperties, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_tool_properties) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPhysicalDeviceToolProperties\0", + ); + let val = _f(cname); + if val.is_null() { + get_physical_device_tool_properties + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[derive(Clone)] +pub struct DeviceFnV1_3 { + pub create_private_data_slot: crate::vk::PFN_vkCreatePrivateDataSlot, + pub destroy_private_data_slot: crate::vk::PFN_vkDestroyPrivateDataSlot, + pub set_private_data: crate::vk::PFN_vkSetPrivateData, + pub get_private_data: crate::vk::PFN_vkGetPrivateData, + pub cmd_set_event2: crate::vk::PFN_vkCmdSetEvent2, + pub cmd_reset_event2: crate::vk::PFN_vkCmdResetEvent2, + pub cmd_wait_events2: crate::vk::PFN_vkCmdWaitEvents2, + pub cmd_pipeline_barrier2: crate::vk::PFN_vkCmdPipelineBarrier2, + pub cmd_write_timestamp2: crate::vk::PFN_vkCmdWriteTimestamp2, + pub queue_submit2: crate::vk::PFN_vkQueueSubmit2, + pub cmd_copy_buffer2: crate::vk::PFN_vkCmdCopyBuffer2, + pub cmd_copy_image2: crate::vk::PFN_vkCmdCopyImage2, + pub cmd_copy_buffer_to_image2: crate::vk::PFN_vkCmdCopyBufferToImage2, + pub cmd_copy_image_to_buffer2: crate::vk::PFN_vkCmdCopyImageToBuffer2, + pub cmd_blit_image2: crate::vk::PFN_vkCmdBlitImage2, + pub cmd_resolve_image2: crate::vk::PFN_vkCmdResolveImage2, + pub cmd_begin_rendering: crate::vk::PFN_vkCmdBeginRendering, + pub cmd_end_rendering: crate::vk::PFN_vkCmdEndRendering, + pub cmd_set_cull_mode: crate::vk::PFN_vkCmdSetCullMode, + pub cmd_set_front_face: crate::vk::PFN_vkCmdSetFrontFace, + pub cmd_set_primitive_topology: crate::vk::PFN_vkCmdSetPrimitiveTopology, + pub cmd_set_viewport_with_count: crate::vk::PFN_vkCmdSetViewportWithCount, + pub cmd_set_scissor_with_count: crate::vk::PFN_vkCmdSetScissorWithCount, + pub cmd_bind_vertex_buffers2: crate::vk::PFN_vkCmdBindVertexBuffers2, + pub cmd_set_depth_test_enable: crate::vk::PFN_vkCmdSetDepthTestEnable, + pub cmd_set_depth_write_enable: crate::vk::PFN_vkCmdSetDepthWriteEnable, + pub cmd_set_depth_compare_op: crate::vk::PFN_vkCmdSetDepthCompareOp, + pub cmd_set_depth_bounds_test_enable: crate::vk::PFN_vkCmdSetDepthBoundsTestEnable, + pub cmd_set_stencil_test_enable: crate::vk::PFN_vkCmdSetStencilTestEnable, + pub cmd_set_stencil_op: crate::vk::PFN_vkCmdSetStencilOp, + pub cmd_set_rasterizer_discard_enable: crate::vk::PFN_vkCmdSetRasterizerDiscardEnable, + pub cmd_set_depth_bias_enable: crate::vk::PFN_vkCmdSetDepthBiasEnable, + pub cmd_set_primitive_restart_enable: crate::vk::PFN_vkCmdSetPrimitiveRestartEnable, + pub get_device_buffer_memory_requirements: crate::vk::PFN_vkGetDeviceBufferMemoryRequirements, + pub get_device_image_memory_requirements: crate::vk::PFN_vkGetDeviceImageMemoryRequirements, + pub get_device_image_sparse_memory_requirements: + crate::vk::PFN_vkGetDeviceImageSparseMemoryRequirements, +} +unsafe impl Send for DeviceFnV1_3 {} +unsafe impl Sync for DeviceFnV1_3 {} +impl DeviceFnV1_3 { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + create_private_data_slot: unsafe { + unsafe extern "system" fn create_private_data_slot( + _device: Device, + _p_create_info: *const PrivateDataSlotCreateInfo, + _p_allocator: *const AllocationCallbacks, + _p_private_data_slot: *mut PrivateDataSlot, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(create_private_data_slot) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreatePrivateDataSlot\0"); + let val = _f(cname); + if val.is_null() { + create_private_data_slot + } else { + ::std::mem::transmute(val) + } + }, + destroy_private_data_slot: unsafe { + unsafe extern "system" fn destroy_private_data_slot( + _device: Device, + _private_data_slot: PrivateDataSlot, + _p_allocator: *const AllocationCallbacks, + ) { + panic!(concat!( + "Unable to load ", + stringify!(destroy_private_data_slot) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyPrivateDataSlot\0"); + let val = _f(cname); + if val.is_null() { + destroy_private_data_slot + } else { + ::std::mem::transmute(val) + } + }, + set_private_data: unsafe { + unsafe extern "system" fn set_private_data( + _device: Device, + _object_type: ObjectType, + _object_handle: u64, + _private_data_slot: PrivateDataSlot, + _data: u64, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(set_private_data))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkSetPrivateData\0"); + let val = _f(cname); + if val.is_null() { + set_private_data + } else { + ::std::mem::transmute(val) + } + }, + get_private_data: unsafe { + unsafe extern "system" fn get_private_data( + _device: Device, + _object_type: ObjectType, + _object_handle: u64, + _private_data_slot: PrivateDataSlot, + _p_data: *mut u64, + ) { + panic!(concat!("Unable to load ", stringify!(get_private_data))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetPrivateData\0"); + let val = _f(cname); + if val.is_null() { + get_private_data + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_event2: unsafe { + unsafe extern "system" fn cmd_set_event2( + _command_buffer: CommandBuffer, + _event: Event, + _p_dependency_info: *const DependencyInfo, + ) { + panic!(concat!("Unable to load ", stringify!(cmd_set_event2))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetEvent2\0"); + let val = _f(cname); + if val.is_null() { + cmd_set_event2 + } else { + ::std::mem::transmute(val) + } + }, + cmd_reset_event2: unsafe { + unsafe extern "system" fn cmd_reset_event2( + _command_buffer: CommandBuffer, + _event: Event, + _stage_mask: PipelineStageFlags2, + ) { + panic!(concat!("Unable to load ", stringify!(cmd_reset_event2))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdResetEvent2\0"); + let val = _f(cname); + if val.is_null() { + cmd_reset_event2 + } else { + ::std::mem::transmute(val) + } + }, + cmd_wait_events2: unsafe { + unsafe extern "system" fn cmd_wait_events2( + _command_buffer: CommandBuffer, + _event_count: u32, + _p_events: *const Event, + _p_dependency_infos: *const DependencyInfo, + ) { + panic!(concat!("Unable to load ", stringify!(cmd_wait_events2))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdWaitEvents2\0"); + let val = _f(cname); + if val.is_null() { + cmd_wait_events2 + } else { + ::std::mem::transmute(val) + } + }, + cmd_pipeline_barrier2: unsafe { + unsafe extern "system" fn cmd_pipeline_barrier2( + _command_buffer: CommandBuffer, + _p_dependency_info: *const DependencyInfo, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_pipeline_barrier2) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdPipelineBarrier2\0"); + let val = _f(cname); + if val.is_null() { + cmd_pipeline_barrier2 + } else { + ::std::mem::transmute(val) + } + }, + cmd_write_timestamp2: unsafe { + unsafe extern "system" fn cmd_write_timestamp2( + _command_buffer: CommandBuffer, + _stage: PipelineStageFlags2, + _query_pool: QueryPool, + _query: u32, + ) { + panic!(concat!("Unable to load ", stringify!(cmd_write_timestamp2))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdWriteTimestamp2\0"); + let val = _f(cname); + if val.is_null() { + cmd_write_timestamp2 + } else { + ::std::mem::transmute(val) + } + }, + queue_submit2: unsafe { + unsafe extern "system" fn queue_submit2( + _queue: Queue, + _submit_count: u32, + _p_submits: *const SubmitInfo2, + _fence: Fence, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(queue_submit2))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkQueueSubmit2\0"); + let val = _f(cname); + if val.is_null() { + queue_submit2 + } else { + ::std::mem::transmute(val) + } + }, + cmd_copy_buffer2: unsafe { + unsafe extern "system" fn cmd_copy_buffer2( + _command_buffer: CommandBuffer, + _p_copy_buffer_info: *const CopyBufferInfo2, + ) { + panic!(concat!("Unable to load ", stringify!(cmd_copy_buffer2))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdCopyBuffer2\0"); + let val = _f(cname); + if val.is_null() { + cmd_copy_buffer2 + } else { + ::std::mem::transmute(val) + } + }, + cmd_copy_image2: unsafe { + unsafe extern "system" fn cmd_copy_image2( + _command_buffer: CommandBuffer, + _p_copy_image_info: *const CopyImageInfo2, + ) { + panic!(concat!("Unable to load ", stringify!(cmd_copy_image2))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdCopyImage2\0"); + let val = _f(cname); + if val.is_null() { + cmd_copy_image2 + } else { + ::std::mem::transmute(val) + } + }, + cmd_copy_buffer_to_image2: unsafe { + unsafe extern "system" fn cmd_copy_buffer_to_image2( + _command_buffer: CommandBuffer, + _p_copy_buffer_to_image_info: *const CopyBufferToImageInfo2, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_copy_buffer_to_image2) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdCopyBufferToImage2\0"); + let val = _f(cname); + if val.is_null() { + cmd_copy_buffer_to_image2 + } else { + ::std::mem::transmute(val) + } + }, + cmd_copy_image_to_buffer2: unsafe { + unsafe extern "system" fn cmd_copy_image_to_buffer2( + _command_buffer: CommandBuffer, + _p_copy_image_to_buffer_info: *const CopyImageToBufferInfo2, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_copy_image_to_buffer2) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdCopyImageToBuffer2\0"); + let val = _f(cname); + if val.is_null() { + cmd_copy_image_to_buffer2 + } else { + ::std::mem::transmute(val) + } + }, + cmd_blit_image2: unsafe { + unsafe extern "system" fn cmd_blit_image2( + _command_buffer: CommandBuffer, + _p_blit_image_info: *const BlitImageInfo2, + ) { + panic!(concat!("Unable to load ", stringify!(cmd_blit_image2))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdBlitImage2\0"); + let val = _f(cname); + if val.is_null() { + cmd_blit_image2 + } else { + ::std::mem::transmute(val) + } + }, + cmd_resolve_image2: unsafe { + unsafe extern "system" fn cmd_resolve_image2( + _command_buffer: CommandBuffer, + _p_resolve_image_info: *const ResolveImageInfo2, + ) { + panic!(concat!("Unable to load ", stringify!(cmd_resolve_image2))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdResolveImage2\0"); + let val = _f(cname); + if val.is_null() { + cmd_resolve_image2 + } else { + ::std::mem::transmute(val) + } + }, + cmd_begin_rendering: unsafe { + unsafe extern "system" fn cmd_begin_rendering( + _command_buffer: CommandBuffer, + _p_rendering_info: *const RenderingInfo, + ) { + panic!(concat!("Unable to load ", stringify!(cmd_begin_rendering))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdBeginRendering\0"); + let val = _f(cname); + if val.is_null() { + cmd_begin_rendering + } else { + ::std::mem::transmute(val) + } + }, + cmd_end_rendering: unsafe { + unsafe extern "system" fn cmd_end_rendering(_command_buffer: CommandBuffer) { + panic!(concat!("Unable to load ", stringify!(cmd_end_rendering))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdEndRendering\0"); + let val = _f(cname); + if val.is_null() { + cmd_end_rendering + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_cull_mode: unsafe { + unsafe extern "system" fn cmd_set_cull_mode( + _command_buffer: CommandBuffer, + _cull_mode: CullModeFlags, + ) { + panic!(concat!("Unable to load ", stringify!(cmd_set_cull_mode))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetCullMode\0"); + let val = _f(cname); + if val.is_null() { + cmd_set_cull_mode + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_front_face: unsafe { + unsafe extern "system" fn cmd_set_front_face( + _command_buffer: CommandBuffer, + _front_face: FrontFace, + ) { + panic!(concat!("Unable to load ", stringify!(cmd_set_front_face))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetFrontFace\0"); + let val = _f(cname); + if val.is_null() { + cmd_set_front_face + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_primitive_topology: unsafe { + unsafe extern "system" fn cmd_set_primitive_topology( + _command_buffer: CommandBuffer, + _primitive_topology: PrimitiveTopology, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_primitive_topology) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetPrimitiveTopology\0"); + let val = _f(cname); + if val.is_null() { + cmd_set_primitive_topology + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_viewport_with_count: unsafe { + unsafe extern "system" fn cmd_set_viewport_with_count( + _command_buffer: CommandBuffer, + _viewport_count: u32, + _p_viewports: *const Viewport, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_viewport_with_count) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetViewportWithCount\0"); + let val = _f(cname); + if val.is_null() { + cmd_set_viewport_with_count + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_scissor_with_count: unsafe { + unsafe extern "system" fn cmd_set_scissor_with_count( + _command_buffer: CommandBuffer, + _scissor_count: u32, + _p_scissors: *const Rect2D, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_scissor_with_count) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetScissorWithCount\0"); + let val = _f(cname); + if val.is_null() { + cmd_set_scissor_with_count + } else { + ::std::mem::transmute(val) + } + }, + cmd_bind_vertex_buffers2: unsafe { + unsafe extern "system" fn cmd_bind_vertex_buffers2( + _command_buffer: CommandBuffer, + _first_binding: u32, + _binding_count: u32, + _p_buffers: *const Buffer, + _p_offsets: *const DeviceSize, + _p_sizes: *const DeviceSize, + _p_strides: *const DeviceSize, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_bind_vertex_buffers2) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdBindVertexBuffers2\0"); + let val = _f(cname); + if val.is_null() { + cmd_bind_vertex_buffers2 + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_depth_test_enable: unsafe { + unsafe extern "system" fn cmd_set_depth_test_enable( + _command_buffer: CommandBuffer, + _depth_test_enable: Bool32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_depth_test_enable) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetDepthTestEnable\0"); + let val = _f(cname); + if val.is_null() { + cmd_set_depth_test_enable + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_depth_write_enable: unsafe { + unsafe extern "system" fn cmd_set_depth_write_enable( + _command_buffer: CommandBuffer, + _depth_write_enable: Bool32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_depth_write_enable) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetDepthWriteEnable\0"); + let val = _f(cname); + if val.is_null() { + cmd_set_depth_write_enable + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_depth_compare_op: unsafe { + unsafe extern "system" fn cmd_set_depth_compare_op( + _command_buffer: CommandBuffer, + _depth_compare_op: CompareOp, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_depth_compare_op) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetDepthCompareOp\0"); + let val = _f(cname); + if val.is_null() { + cmd_set_depth_compare_op + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_depth_bounds_test_enable: unsafe { + unsafe extern "system" fn cmd_set_depth_bounds_test_enable( + _command_buffer: CommandBuffer, + _depth_bounds_test_enable: Bool32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_depth_bounds_test_enable) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetDepthBoundsTestEnable\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_depth_bounds_test_enable + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_stencil_test_enable: unsafe { + unsafe extern "system" fn cmd_set_stencil_test_enable( + _command_buffer: CommandBuffer, + _stencil_test_enable: Bool32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_stencil_test_enable) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetStencilTestEnable\0"); + let val = _f(cname); + if val.is_null() { + cmd_set_stencil_test_enable + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_stencil_op: unsafe { + unsafe extern "system" fn cmd_set_stencil_op( + _command_buffer: CommandBuffer, + _face_mask: StencilFaceFlags, + _fail_op: StencilOp, + _pass_op: StencilOp, + _depth_fail_op: StencilOp, + _compare_op: CompareOp, + ) { + panic!(concat!("Unable to load ", stringify!(cmd_set_stencil_op))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetStencilOp\0"); + let val = _f(cname); + if val.is_null() { + cmd_set_stencil_op + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_rasterizer_discard_enable: unsafe { + unsafe extern "system" fn cmd_set_rasterizer_discard_enable( + _command_buffer: CommandBuffer, + _rasterizer_discard_enable: Bool32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_rasterizer_discard_enable) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetRasterizerDiscardEnable\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_rasterizer_discard_enable + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_depth_bias_enable: unsafe { + unsafe extern "system" fn cmd_set_depth_bias_enable( + _command_buffer: CommandBuffer, + _depth_bias_enable: Bool32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_depth_bias_enable) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetDepthBiasEnable\0"); + let val = _f(cname); + if val.is_null() { + cmd_set_depth_bias_enable + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_primitive_restart_enable: unsafe { + unsafe extern "system" fn cmd_set_primitive_restart_enable( + _command_buffer: CommandBuffer, + _primitive_restart_enable: Bool32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_primitive_restart_enable) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetPrimitiveRestartEnable\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_primitive_restart_enable + } else { + ::std::mem::transmute(val) + } + }, + get_device_buffer_memory_requirements: unsafe { + unsafe extern "system" fn get_device_buffer_memory_requirements( + _device: Device, + _p_info: *const DeviceBufferMemoryRequirements, + _p_memory_requirements: *mut MemoryRequirements2, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_device_buffer_memory_requirements) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetDeviceBufferMemoryRequirements\0", + ); + let val = _f(cname); + if val.is_null() { + get_device_buffer_memory_requirements + } else { + ::std::mem::transmute(val) + } + }, + get_device_image_memory_requirements: unsafe { + unsafe extern "system" fn get_device_image_memory_requirements( + _device: Device, + _p_info: *const DeviceImageMemoryRequirements, + _p_memory_requirements: *mut MemoryRequirements2, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_device_image_memory_requirements) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetDeviceImageMemoryRequirements\0", + ); + let val = _f(cname); + if val.is_null() { + get_device_image_memory_requirements + } else { + ::std::mem::transmute(val) + } + }, + get_device_image_sparse_memory_requirements: unsafe { + unsafe extern "system" fn get_device_image_sparse_memory_requirements( + _device: Device, + _p_info: *const DeviceImageMemoryRequirements, + _p_sparse_memory_requirement_count: *mut u32, + _p_sparse_memory_requirements: *mut SparseImageMemoryRequirements2, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_device_image_sparse_memory_requirements) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetDeviceImageSparseMemoryRequirements\0", + ); + let val = _f(cname); + if val.is_null() { + get_device_image_sparse_memory_requirements + } else { + ::std::mem::transmute(val) + } + }, + } + } +} diff --git a/third_party/rust/ash/src/vk/macros.rs b/third_party/rust/ash/src/vk/macros.rs new file mode 100644 index 0000000000..e986be3125 --- /dev/null +++ b/third_party/rust/ash/src/vk/macros.rs @@ -0,0 +1,162 @@ +#[macro_export] +macro_rules! vk_bitflags_wrapped { + ($ name : ident , $ flag_type : ty) => { + impl Default for $name { + fn default() -> Self { + Self(0) + } + } + impl $name { + #[inline] + pub const fn empty() -> Self { + Self(0) + } + #[inline] + pub const fn from_raw(x: $flag_type) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> $flag_type { + self.0 + } + #[inline] + pub const fn is_empty(self) -> bool { + self.0 == Self::empty().0 + } + #[inline] + pub const fn intersects(self, other: Self) -> bool { + !Self(self.0 & other.0).is_empty() + } + #[doc = r" Returns whether `other` is a subset of `self`"] + #[inline] + pub const fn contains(self, other: Self) -> bool { + self.0 & other.0 == other.0 + } + } + impl ::std::ops::BitOr for $name { + type Output = Self; + #[inline] + fn bitor(self, rhs: Self) -> Self { + Self(self.0 | rhs.0) + } + } + impl ::std::ops::BitOrAssign for $name { + #[inline] + fn bitor_assign(&mut self, rhs: Self) { + *self = *self | rhs + } + } + impl ::std::ops::BitAnd for $name { + type Output = Self; + #[inline] + fn bitand(self, rhs: Self) -> Self { + Self(self.0 & rhs.0) + } + } + impl ::std::ops::BitAndAssign for $name { + #[inline] + fn bitand_assign(&mut self, rhs: Self) { + *self = *self & rhs + } + } + impl ::std::ops::BitXor for $name { + type Output = Self; + #[inline] + fn bitxor(self, rhs: Self) -> Self { + Self(self.0 ^ rhs.0) + } + } + impl ::std::ops::BitXorAssign for $name { + #[inline] + fn bitxor_assign(&mut self, rhs: Self) { + *self = *self ^ rhs + } + } + impl ::std::ops::Not for $name { + type Output = Self; + #[inline] + fn not(self) -> Self { + Self(!self.0) + } + } + }; +} +#[macro_export] +macro_rules! handle_nondispatchable { + ($ name : ident , $ ty : ident) => { + handle_nondispatchable!($name, $ty, doc = ""); + }; + ($ name : ident , $ ty : ident , $ doc_link : meta) => { + #[repr(transparent)] + #[derive(Eq, PartialEq, Ord, PartialOrd, Clone, Copy, Hash, Default)] + #[$doc_link] + pub struct $name(u64); + impl Handle for $name { + const TYPE: ObjectType = ObjectType::$ty; + fn as_raw(self) -> u64 { + self.0 + } + fn from_raw(x: u64) -> Self { + Self(x) + } + } + impl $name { + pub const fn null() -> Self { + Self(0) + } + } + impl fmt::Pointer for $name { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + write!(f, "0x{:x}", self.0) + } + } + impl fmt::Debug for $name { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + write!(f, "0x{:x}", self.0) + } + } + }; +} +#[macro_export] +macro_rules! define_handle { + ($ name : ident , $ ty : ident) => { + define_handle!($name, $ty, doc = ""); + }; + ($ name : ident , $ ty : ident , $ doc_link : meta) => { + #[repr(transparent)] + #[derive(Eq, PartialEq, Ord, PartialOrd, Clone, Copy, Hash)] + #[$doc_link] + pub struct $name(*mut u8); + impl Default for $name { + fn default() -> Self { + Self::null() + } + } + impl Handle for $name { + const TYPE: ObjectType = ObjectType::$ty; + fn as_raw(self) -> u64 { + self.0 as u64 + } + fn from_raw(x: u64) -> Self { + Self(x as _) + } + } + unsafe impl Send for $name {} + unsafe impl Sync for $name {} + impl $name { + pub const fn null() -> Self { + Self(::std::ptr::null_mut()) + } + } + impl fmt::Pointer for $name { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fmt::Pointer::fmt(&self.0, f) + } + } + impl fmt::Debug for $name { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + fmt::Debug::fmt(&self.0, f) + } + } + }; +} diff --git a/third_party/rust/ash/src/vk/native.rs b/third_party/rust/ash/src/vk/native.rs new file mode 100644 index 0000000000..02edfba5c8 --- /dev/null +++ b/third_party/rust/ash/src/vk/native.rs @@ -0,0 +1,8998 @@ +/* automatically generated by rust-bindgen 0.61.0 */ + +#[repr(C)] +#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)] +pub struct __BindgenBitfieldUnit { + storage: Storage, +} +impl __BindgenBitfieldUnit { + #[inline] + pub const fn new(storage: Storage) -> Self { + Self { storage } + } +} +impl __BindgenBitfieldUnit +where + Storage: AsRef<[u8]> + AsMut<[u8]>, +{ + #[inline] + pub fn get_bit(&self, index: usize) -> bool { + debug_assert!(index / 8 < self.storage.as_ref().len()); + let byte_index = index / 8; + let byte = self.storage.as_ref()[byte_index]; + let bit_index = if cfg!(target_endian = "big") { + 7 - (index % 8) + } else { + index % 8 + }; + let mask = 1 << bit_index; + byte & mask == mask + } + #[inline] + pub fn set_bit(&mut self, index: usize, val: bool) { + debug_assert!(index / 8 < self.storage.as_ref().len()); + let byte_index = index / 8; + let byte = &mut self.storage.as_mut()[byte_index]; + let bit_index = if cfg!(target_endian = "big") { + 7 - (index % 8) + } else { + index % 8 + }; + let mask = 1 << bit_index; + if val { + *byte |= mask; + } else { + *byte &= !mask; + } + } + #[inline] + pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); + debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len()); + let mut val = 0; + for i in 0..(bit_width as usize) { + if self.get_bit(i + bit_offset) { + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + val |= 1 << index; + } + } + val + } + #[inline] + pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) { + debug_assert!(bit_width <= 64); + debug_assert!(bit_offset / 8 < self.storage.as_ref().len()); + debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len()); + for i in 0..(bit_width as usize) { + let mask = 1 << i; + let val_bit_is_set = val & mask == mask; + let index = if cfg!(target_endian = "big") { + bit_width as usize - 1 - i + } else { + i + }; + self.set_bit(index + bit_offset, val_bit_is_set); + } + } +} +pub const StdVideoH264ChromaFormatIdc_STD_VIDEO_H264_CHROMA_FORMAT_IDC_MONOCHROME: + StdVideoH264ChromaFormatIdc = 0; +pub const StdVideoH264ChromaFormatIdc_STD_VIDEO_H264_CHROMA_FORMAT_IDC_420: + StdVideoH264ChromaFormatIdc = 1; +pub const StdVideoH264ChromaFormatIdc_STD_VIDEO_H264_CHROMA_FORMAT_IDC_422: + StdVideoH264ChromaFormatIdc = 2; +pub const StdVideoH264ChromaFormatIdc_STD_VIDEO_H264_CHROMA_FORMAT_IDC_444: + StdVideoH264ChromaFormatIdc = 3; +pub const StdVideoH264ChromaFormatIdc_STD_VIDEO_H264_CHROMA_FORMAT_IDC_INVALID: + StdVideoH264ChromaFormatIdc = 2147483647; +pub type StdVideoH264ChromaFormatIdc = ::std::os::raw::c_uint; +pub const StdVideoH264ProfileIdc_STD_VIDEO_H264_PROFILE_IDC_BASELINE: StdVideoH264ProfileIdc = 66; +pub const StdVideoH264ProfileIdc_STD_VIDEO_H264_PROFILE_IDC_MAIN: StdVideoH264ProfileIdc = 77; +pub const StdVideoH264ProfileIdc_STD_VIDEO_H264_PROFILE_IDC_HIGH: StdVideoH264ProfileIdc = 100; +pub const StdVideoH264ProfileIdc_STD_VIDEO_H264_PROFILE_IDC_HIGH_444_PREDICTIVE: + StdVideoH264ProfileIdc = 244; +pub const StdVideoH264ProfileIdc_STD_VIDEO_H264_PROFILE_IDC_INVALID: StdVideoH264ProfileIdc = + 2147483647; +pub type StdVideoH264ProfileIdc = ::std::os::raw::c_uint; +pub const StdVideoH264LevelIdc_STD_VIDEO_H264_LEVEL_IDC_1_0: StdVideoH264LevelIdc = 0; +pub const StdVideoH264LevelIdc_STD_VIDEO_H264_LEVEL_IDC_1_1: StdVideoH264LevelIdc = 1; +pub const StdVideoH264LevelIdc_STD_VIDEO_H264_LEVEL_IDC_1_2: StdVideoH264LevelIdc = 2; +pub const StdVideoH264LevelIdc_STD_VIDEO_H264_LEVEL_IDC_1_3: StdVideoH264LevelIdc = 3; +pub const StdVideoH264LevelIdc_STD_VIDEO_H264_LEVEL_IDC_2_0: StdVideoH264LevelIdc = 4; +pub const StdVideoH264LevelIdc_STD_VIDEO_H264_LEVEL_IDC_2_1: StdVideoH264LevelIdc = 5; +pub const StdVideoH264LevelIdc_STD_VIDEO_H264_LEVEL_IDC_2_2: StdVideoH264LevelIdc = 6; +pub const StdVideoH264LevelIdc_STD_VIDEO_H264_LEVEL_IDC_3_0: StdVideoH264LevelIdc = 7; +pub const StdVideoH264LevelIdc_STD_VIDEO_H264_LEVEL_IDC_3_1: StdVideoH264LevelIdc = 8; +pub const StdVideoH264LevelIdc_STD_VIDEO_H264_LEVEL_IDC_3_2: StdVideoH264LevelIdc = 9; +pub const StdVideoH264LevelIdc_STD_VIDEO_H264_LEVEL_IDC_4_0: StdVideoH264LevelIdc = 10; +pub const StdVideoH264LevelIdc_STD_VIDEO_H264_LEVEL_IDC_4_1: StdVideoH264LevelIdc = 11; +pub const StdVideoH264LevelIdc_STD_VIDEO_H264_LEVEL_IDC_4_2: StdVideoH264LevelIdc = 12; +pub const StdVideoH264LevelIdc_STD_VIDEO_H264_LEVEL_IDC_5_0: StdVideoH264LevelIdc = 13; +pub const StdVideoH264LevelIdc_STD_VIDEO_H264_LEVEL_IDC_5_1: StdVideoH264LevelIdc = 14; +pub const StdVideoH264LevelIdc_STD_VIDEO_H264_LEVEL_IDC_5_2: StdVideoH264LevelIdc = 15; +pub const StdVideoH264LevelIdc_STD_VIDEO_H264_LEVEL_IDC_6_0: StdVideoH264LevelIdc = 16; +pub const StdVideoH264LevelIdc_STD_VIDEO_H264_LEVEL_IDC_6_1: StdVideoH264LevelIdc = 17; +pub const StdVideoH264LevelIdc_STD_VIDEO_H264_LEVEL_IDC_6_2: StdVideoH264LevelIdc = 18; +pub const StdVideoH264LevelIdc_STD_VIDEO_H264_LEVEL_IDC_INVALID: StdVideoH264LevelIdc = 2147483647; +pub type StdVideoH264LevelIdc = ::std::os::raw::c_uint; +pub const StdVideoH264PocType_STD_VIDEO_H264_POC_TYPE_0: StdVideoH264PocType = 0; +pub const StdVideoH264PocType_STD_VIDEO_H264_POC_TYPE_1: StdVideoH264PocType = 1; +pub const StdVideoH264PocType_STD_VIDEO_H264_POC_TYPE_2: StdVideoH264PocType = 2; +pub const StdVideoH264PocType_STD_VIDEO_H264_POC_TYPE_INVALID: StdVideoH264PocType = 2147483647; +pub type StdVideoH264PocType = ::std::os::raw::c_uint; +pub const StdVideoH264AspectRatioIdc_STD_VIDEO_H264_ASPECT_RATIO_IDC_UNSPECIFIED: + StdVideoH264AspectRatioIdc = 0; +pub const StdVideoH264AspectRatioIdc_STD_VIDEO_H264_ASPECT_RATIO_IDC_SQUARE: + StdVideoH264AspectRatioIdc = 1; +pub const StdVideoH264AspectRatioIdc_STD_VIDEO_H264_ASPECT_RATIO_IDC_12_11: + StdVideoH264AspectRatioIdc = 2; +pub const StdVideoH264AspectRatioIdc_STD_VIDEO_H264_ASPECT_RATIO_IDC_10_11: + StdVideoH264AspectRatioIdc = 3; +pub const StdVideoH264AspectRatioIdc_STD_VIDEO_H264_ASPECT_RATIO_IDC_16_11: + StdVideoH264AspectRatioIdc = 4; +pub const StdVideoH264AspectRatioIdc_STD_VIDEO_H264_ASPECT_RATIO_IDC_40_33: + StdVideoH264AspectRatioIdc = 5; +pub const StdVideoH264AspectRatioIdc_STD_VIDEO_H264_ASPECT_RATIO_IDC_24_11: + StdVideoH264AspectRatioIdc = 6; +pub const StdVideoH264AspectRatioIdc_STD_VIDEO_H264_ASPECT_RATIO_IDC_20_11: + StdVideoH264AspectRatioIdc = 7; +pub const StdVideoH264AspectRatioIdc_STD_VIDEO_H264_ASPECT_RATIO_IDC_32_11: + StdVideoH264AspectRatioIdc = 8; +pub const StdVideoH264AspectRatioIdc_STD_VIDEO_H264_ASPECT_RATIO_IDC_80_33: + StdVideoH264AspectRatioIdc = 9; +pub const StdVideoH264AspectRatioIdc_STD_VIDEO_H264_ASPECT_RATIO_IDC_18_11: + StdVideoH264AspectRatioIdc = 10; +pub const StdVideoH264AspectRatioIdc_STD_VIDEO_H264_ASPECT_RATIO_IDC_15_11: + StdVideoH264AspectRatioIdc = 11; +pub const StdVideoH264AspectRatioIdc_STD_VIDEO_H264_ASPECT_RATIO_IDC_64_33: + StdVideoH264AspectRatioIdc = 12; +pub const StdVideoH264AspectRatioIdc_STD_VIDEO_H264_ASPECT_RATIO_IDC_160_99: + StdVideoH264AspectRatioIdc = 13; +pub const StdVideoH264AspectRatioIdc_STD_VIDEO_H264_ASPECT_RATIO_IDC_4_3: + StdVideoH264AspectRatioIdc = 14; +pub const StdVideoH264AspectRatioIdc_STD_VIDEO_H264_ASPECT_RATIO_IDC_3_2: + StdVideoH264AspectRatioIdc = 15; +pub const StdVideoH264AspectRatioIdc_STD_VIDEO_H264_ASPECT_RATIO_IDC_2_1: + StdVideoH264AspectRatioIdc = 16; +pub const StdVideoH264AspectRatioIdc_STD_VIDEO_H264_ASPECT_RATIO_IDC_EXTENDED_SAR: + StdVideoH264AspectRatioIdc = 255; +pub const StdVideoH264AspectRatioIdc_STD_VIDEO_H264_ASPECT_RATIO_IDC_INVALID: + StdVideoH264AspectRatioIdc = 2147483647; +pub type StdVideoH264AspectRatioIdc = ::std::os::raw::c_uint; +pub const StdVideoH264WeightedBipredIdc_STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_DEFAULT: + StdVideoH264WeightedBipredIdc = 0; +pub const StdVideoH264WeightedBipredIdc_STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_EXPLICIT: + StdVideoH264WeightedBipredIdc = 1; +pub const StdVideoH264WeightedBipredIdc_STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_IMPLICIT: + StdVideoH264WeightedBipredIdc = 2; +pub const StdVideoH264WeightedBipredIdc_STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_INVALID: + StdVideoH264WeightedBipredIdc = 2147483647; +pub type StdVideoH264WeightedBipredIdc = ::std::os::raw::c_uint; +pub const StdVideoH264ModificationOfPicNumsIdc_STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_SHORT_TERM_SUBTRACT : StdVideoH264ModificationOfPicNumsIdc = 0 ; +pub const StdVideoH264ModificationOfPicNumsIdc_STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_SHORT_TERM_ADD : StdVideoH264ModificationOfPicNumsIdc = 1 ; +pub const StdVideoH264ModificationOfPicNumsIdc_STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_LONG_TERM : StdVideoH264ModificationOfPicNumsIdc = 2 ; +pub const StdVideoH264ModificationOfPicNumsIdc_STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_END: + StdVideoH264ModificationOfPicNumsIdc = 3; +pub const StdVideoH264ModificationOfPicNumsIdc_STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_INVALID : StdVideoH264ModificationOfPicNumsIdc = 2147483647 ; +pub type StdVideoH264ModificationOfPicNumsIdc = ::std::os::raw::c_uint; +pub const StdVideoH264MemMgmtControlOp_STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_END: + StdVideoH264MemMgmtControlOp = 0; +pub const StdVideoH264MemMgmtControlOp_STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_UNMARK_SHORT_TERM: + StdVideoH264MemMgmtControlOp = 1; +pub const StdVideoH264MemMgmtControlOp_STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_UNMARK_LONG_TERM: + StdVideoH264MemMgmtControlOp = 2; +pub const StdVideoH264MemMgmtControlOp_STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_MARK_LONG_TERM: + StdVideoH264MemMgmtControlOp = 3; +pub const StdVideoH264MemMgmtControlOp_STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_SET_MAX_LONG_TERM_INDEX : StdVideoH264MemMgmtControlOp = 4 ; +pub const StdVideoH264MemMgmtControlOp_STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_UNMARK_ALL: + StdVideoH264MemMgmtControlOp = 5; +pub const StdVideoH264MemMgmtControlOp_STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_MARK_CURRENT_AS_LONG_TERM : StdVideoH264MemMgmtControlOp = 6 ; +pub const StdVideoH264MemMgmtControlOp_STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_INVALID: + StdVideoH264MemMgmtControlOp = 2147483647; +pub type StdVideoH264MemMgmtControlOp = ::std::os::raw::c_uint; +pub const StdVideoH264CabacInitIdc_STD_VIDEO_H264_CABAC_INIT_IDC_0: StdVideoH264CabacInitIdc = 0; +pub const StdVideoH264CabacInitIdc_STD_VIDEO_H264_CABAC_INIT_IDC_1: StdVideoH264CabacInitIdc = 1; +pub const StdVideoH264CabacInitIdc_STD_VIDEO_H264_CABAC_INIT_IDC_2: StdVideoH264CabacInitIdc = 2; +pub const StdVideoH264CabacInitIdc_STD_VIDEO_H264_CABAC_INIT_IDC_INVALID: StdVideoH264CabacInitIdc = + 2147483647; +pub type StdVideoH264CabacInitIdc = ::std::os::raw::c_uint; +pub const StdVideoH264DisableDeblockingFilterIdc_STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_DISABLED : StdVideoH264DisableDeblockingFilterIdc = 0 ; +pub const StdVideoH264DisableDeblockingFilterIdc_STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_ENABLED : StdVideoH264DisableDeblockingFilterIdc = 1 ; +pub const StdVideoH264DisableDeblockingFilterIdc_STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_PARTIAL : StdVideoH264DisableDeblockingFilterIdc = 2 ; +pub const StdVideoH264DisableDeblockingFilterIdc_STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_INVALID : StdVideoH264DisableDeblockingFilterIdc = 2147483647 ; +pub type StdVideoH264DisableDeblockingFilterIdc = ::std::os::raw::c_uint; +pub const StdVideoH264SliceType_STD_VIDEO_H264_SLICE_TYPE_P: StdVideoH264SliceType = 0; +pub const StdVideoH264SliceType_STD_VIDEO_H264_SLICE_TYPE_B: StdVideoH264SliceType = 1; +pub const StdVideoH264SliceType_STD_VIDEO_H264_SLICE_TYPE_I: StdVideoH264SliceType = 2; +pub const StdVideoH264SliceType_STD_VIDEO_H264_SLICE_TYPE_INVALID: StdVideoH264SliceType = + 2147483647; +pub type StdVideoH264SliceType = ::std::os::raw::c_uint; +pub const StdVideoH264PictureType_STD_VIDEO_H264_PICTURE_TYPE_P: StdVideoH264PictureType = 0; +pub const StdVideoH264PictureType_STD_VIDEO_H264_PICTURE_TYPE_B: StdVideoH264PictureType = 1; +pub const StdVideoH264PictureType_STD_VIDEO_H264_PICTURE_TYPE_I: StdVideoH264PictureType = 2; +pub const StdVideoH264PictureType_STD_VIDEO_H264_PICTURE_TYPE_IDR: StdVideoH264PictureType = 5; +pub const StdVideoH264PictureType_STD_VIDEO_H264_PICTURE_TYPE_INVALID: StdVideoH264PictureType = + 2147483647; +pub type StdVideoH264PictureType = ::std::os::raw::c_uint; +#[repr(C)] +#[repr(align(4))] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoH264SpsVuiFlags { + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize]>, + pub __bindgen_padding_0: u16, +} +#[test] +fn bindgen_test_layout_StdVideoH264SpsVuiFlags() { + assert_eq!( + ::std::mem::size_of::(), + 4usize, + concat!("Size of: ", stringify!(StdVideoH264SpsVuiFlags)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!("Alignment of ", stringify!(StdVideoH264SpsVuiFlags)) + ); +} +impl StdVideoH264SpsVuiFlags { + #[inline] + pub fn aspect_ratio_info_present_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_aspect_ratio_info_present_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub fn overscan_info_present_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_overscan_info_present_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub fn overscan_appropriate_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } + } + #[inline] + pub fn set_overscan_appropriate_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 1u8, val as u64) + } + } + #[inline] + pub fn video_signal_type_present_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } + } + #[inline] + pub fn set_video_signal_type_present_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(3usize, 1u8, val as u64) + } + } + #[inline] + pub fn video_full_range_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } + } + #[inline] + pub fn set_video_full_range_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(4usize, 1u8, val as u64) + } + } + #[inline] + pub fn color_description_present_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) } + } + #[inline] + pub fn set_color_description_present_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(5usize, 1u8, val as u64) + } + } + #[inline] + pub fn chroma_loc_info_present_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) } + } + #[inline] + pub fn set_chroma_loc_info_present_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(6usize, 1u8, val as u64) + } + } + #[inline] + pub fn timing_info_present_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) } + } + #[inline] + pub fn set_timing_info_present_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(7usize, 1u8, val as u64) + } + } + #[inline] + pub fn fixed_frame_rate_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u32) } + } + #[inline] + pub fn set_fixed_frame_rate_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(8usize, 1u8, val as u64) + } + } + #[inline] + pub fn bitstream_restriction_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 1u8) as u32) } + } + #[inline] + pub fn set_bitstream_restriction_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(9usize, 1u8, val as u64) + } + } + #[inline] + pub fn nal_hrd_parameters_present_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 1u8) as u32) } + } + #[inline] + pub fn set_nal_hrd_parameters_present_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(10usize, 1u8, val as u64) + } + } + #[inline] + pub fn vcl_hrd_parameters_present_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u32) } + } + #[inline] + pub fn set_vcl_hrd_parameters_present_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(11usize, 1u8, val as u64) + } + } + #[inline] + pub fn new_bitfield_1( + aspect_ratio_info_present_flag: u32, + overscan_info_present_flag: u32, + overscan_appropriate_flag: u32, + video_signal_type_present_flag: u32, + video_full_range_flag: u32, + color_description_present_flag: u32, + chroma_loc_info_present_flag: u32, + timing_info_present_flag: u32, + fixed_frame_rate_flag: u32, + bitstream_restriction_flag: u32, + nal_hrd_parameters_present_flag: u32, + vcl_hrd_parameters_present_flag: u32, + ) -> __BindgenBitfieldUnit<[u8; 2usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let aspect_ratio_info_present_flag: u32 = + unsafe { ::std::mem::transmute(aspect_ratio_info_present_flag) }; + aspect_ratio_info_present_flag as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let overscan_info_present_flag: u32 = + unsafe { ::std::mem::transmute(overscan_info_present_flag) }; + overscan_info_present_flag as u64 + }); + __bindgen_bitfield_unit.set(2usize, 1u8, { + let overscan_appropriate_flag: u32 = + unsafe { ::std::mem::transmute(overscan_appropriate_flag) }; + overscan_appropriate_flag as u64 + }); + __bindgen_bitfield_unit.set(3usize, 1u8, { + let video_signal_type_present_flag: u32 = + unsafe { ::std::mem::transmute(video_signal_type_present_flag) }; + video_signal_type_present_flag as u64 + }); + __bindgen_bitfield_unit.set(4usize, 1u8, { + let video_full_range_flag: u32 = + unsafe { ::std::mem::transmute(video_full_range_flag) }; + video_full_range_flag as u64 + }); + __bindgen_bitfield_unit.set(5usize, 1u8, { + let color_description_present_flag: u32 = + unsafe { ::std::mem::transmute(color_description_present_flag) }; + color_description_present_flag as u64 + }); + __bindgen_bitfield_unit.set(6usize, 1u8, { + let chroma_loc_info_present_flag: u32 = + unsafe { ::std::mem::transmute(chroma_loc_info_present_flag) }; + chroma_loc_info_present_flag as u64 + }); + __bindgen_bitfield_unit.set(7usize, 1u8, { + let timing_info_present_flag: u32 = + unsafe { ::std::mem::transmute(timing_info_present_flag) }; + timing_info_present_flag as u64 + }); + __bindgen_bitfield_unit.set(8usize, 1u8, { + let fixed_frame_rate_flag: u32 = + unsafe { ::std::mem::transmute(fixed_frame_rate_flag) }; + fixed_frame_rate_flag as u64 + }); + __bindgen_bitfield_unit.set(9usize, 1u8, { + let bitstream_restriction_flag: u32 = + unsafe { ::std::mem::transmute(bitstream_restriction_flag) }; + bitstream_restriction_flag as u64 + }); + __bindgen_bitfield_unit.set(10usize, 1u8, { + let nal_hrd_parameters_present_flag: u32 = + unsafe { ::std::mem::transmute(nal_hrd_parameters_present_flag) }; + nal_hrd_parameters_present_flag as u64 + }); + __bindgen_bitfield_unit.set(11usize, 1u8, { + let vcl_hrd_parameters_present_flag: u32 = + unsafe { ::std::mem::transmute(vcl_hrd_parameters_present_flag) }; + vcl_hrd_parameters_present_flag as u64 + }); + __bindgen_bitfield_unit + } +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoH264HrdParameters { + pub cpb_cnt_minus1: u8, + pub bit_rate_scale: u8, + pub cpb_size_scale: u8, + pub reserved1: u8, + pub bit_rate_value_minus1: [u32; 32usize], + pub cpb_size_value_minus1: [u32; 32usize], + pub cbr_flag: [u8; 32usize], + pub initial_cpb_removal_delay_length_minus1: u32, + pub cpb_removal_delay_length_minus1: u32, + pub dpb_output_delay_length_minus1: u32, + pub time_offset_length: u32, +} +#[test] +fn bindgen_test_layout_StdVideoH264HrdParameters() { + const UNINIT: ::std::mem::MaybeUninit = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::(), + 308usize, + concat!("Size of: ", stringify!(StdVideoH264HrdParameters)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!("Alignment of ", stringify!(StdVideoH264HrdParameters)) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).cpb_cnt_minus1) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264HrdParameters), + "::", + stringify!(cpb_cnt_minus1) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).bit_rate_scale) as usize - ptr as usize }, + 1usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264HrdParameters), + "::", + stringify!(bit_rate_scale) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).cpb_size_scale) as usize - ptr as usize }, + 2usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264HrdParameters), + "::", + stringify!(cpb_size_scale) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).reserved1) as usize - ptr as usize }, + 3usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264HrdParameters), + "::", + stringify!(reserved1) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).bit_rate_value_minus1) as usize - ptr as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264HrdParameters), + "::", + stringify!(bit_rate_value_minus1) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).cpb_size_value_minus1) as usize - ptr as usize }, + 132usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264HrdParameters), + "::", + stringify!(cpb_size_value_minus1) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).cbr_flag) as usize - ptr as usize }, + 260usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264HrdParameters), + "::", + stringify!(cbr_flag) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).initial_cpb_removal_delay_length_minus1) as usize + - ptr as usize + }, + 292usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264HrdParameters), + "::", + stringify!(initial_cpb_removal_delay_length_minus1) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).cpb_removal_delay_length_minus1) as usize - ptr as usize + }, + 296usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264HrdParameters), + "::", + stringify!(cpb_removal_delay_length_minus1) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).dpb_output_delay_length_minus1) as usize - ptr as usize + }, + 300usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264HrdParameters), + "::", + stringify!(dpb_output_delay_length_minus1) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).time_offset_length) as usize - ptr as usize }, + 304usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264HrdParameters), + "::", + stringify!(time_offset_length) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoH264SequenceParameterSetVui { + pub flags: StdVideoH264SpsVuiFlags, + pub aspect_ratio_idc: StdVideoH264AspectRatioIdc, + pub sar_width: u16, + pub sar_height: u16, + pub video_format: u8, + pub colour_primaries: u8, + pub transfer_characteristics: u8, + pub matrix_coefficients: u8, + pub num_units_in_tick: u32, + pub time_scale: u32, + pub max_num_reorder_frames: u8, + pub max_dec_frame_buffering: u8, + pub chroma_sample_loc_type_top_field: u8, + pub chroma_sample_loc_type_bottom_field: u8, + pub reserved1: u32, + pub pHrdParameters: *const StdVideoH264HrdParameters, +} +#[test] +fn bindgen_test_layout_StdVideoH264SequenceParameterSetVui() { + const UNINIT: ::std::mem::MaybeUninit = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::(), + 40usize, + concat!("Size of: ", stringify!(StdVideoH264SequenceParameterSetVui)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!( + "Alignment of ", + stringify!(StdVideoH264SequenceParameterSetVui) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264SequenceParameterSetVui), + "::", + stringify!(flags) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).aspect_ratio_idc) as usize - ptr as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264SequenceParameterSetVui), + "::", + stringify!(aspect_ratio_idc) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).sar_width) as usize - ptr as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264SequenceParameterSetVui), + "::", + stringify!(sar_width) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).sar_height) as usize - ptr as usize }, + 10usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264SequenceParameterSetVui), + "::", + stringify!(sar_height) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).video_format) as usize - ptr as usize }, + 12usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264SequenceParameterSetVui), + "::", + stringify!(video_format) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).colour_primaries) as usize - ptr as usize }, + 13usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264SequenceParameterSetVui), + "::", + stringify!(colour_primaries) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).transfer_characteristics) as usize - ptr as usize }, + 14usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264SequenceParameterSetVui), + "::", + stringify!(transfer_characteristics) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).matrix_coefficients) as usize - ptr as usize }, + 15usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264SequenceParameterSetVui), + "::", + stringify!(matrix_coefficients) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).num_units_in_tick) as usize - ptr as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264SequenceParameterSetVui), + "::", + stringify!(num_units_in_tick) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).time_scale) as usize - ptr as usize }, + 20usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264SequenceParameterSetVui), + "::", + stringify!(time_scale) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).max_num_reorder_frames) as usize - ptr as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264SequenceParameterSetVui), + "::", + stringify!(max_num_reorder_frames) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).max_dec_frame_buffering) as usize - ptr as usize }, + 25usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264SequenceParameterSetVui), + "::", + stringify!(max_dec_frame_buffering) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).chroma_sample_loc_type_top_field) as usize - ptr as usize + }, + 26usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264SequenceParameterSetVui), + "::", + stringify!(chroma_sample_loc_type_top_field) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).chroma_sample_loc_type_bottom_field) as usize - ptr as usize + }, + 27usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264SequenceParameterSetVui), + "::", + stringify!(chroma_sample_loc_type_bottom_field) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).reserved1) as usize - ptr as usize }, + 28usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264SequenceParameterSetVui), + "::", + stringify!(reserved1) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pHrdParameters) as usize - ptr as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264SequenceParameterSetVui), + "::", + stringify!(pHrdParameters) + ) + ); +} +#[repr(C)] +#[repr(align(4))] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoH264SpsFlags { + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize]>, + pub __bindgen_padding_0: u16, +} +#[test] +fn bindgen_test_layout_StdVideoH264SpsFlags() { + assert_eq!( + ::std::mem::size_of::(), + 4usize, + concat!("Size of: ", stringify!(StdVideoH264SpsFlags)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!("Alignment of ", stringify!(StdVideoH264SpsFlags)) + ); +} +impl StdVideoH264SpsFlags { + #[inline] + pub fn constraint_set0_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_constraint_set0_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub fn constraint_set1_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_constraint_set1_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub fn constraint_set2_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } + } + #[inline] + pub fn set_constraint_set2_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 1u8, val as u64) + } + } + #[inline] + pub fn constraint_set3_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } + } + #[inline] + pub fn set_constraint_set3_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(3usize, 1u8, val as u64) + } + } + #[inline] + pub fn constraint_set4_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } + } + #[inline] + pub fn set_constraint_set4_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(4usize, 1u8, val as u64) + } + } + #[inline] + pub fn constraint_set5_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) } + } + #[inline] + pub fn set_constraint_set5_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(5usize, 1u8, val as u64) + } + } + #[inline] + pub fn direct_8x8_inference_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) } + } + #[inline] + pub fn set_direct_8x8_inference_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(6usize, 1u8, val as u64) + } + } + #[inline] + pub fn mb_adaptive_frame_field_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) } + } + #[inline] + pub fn set_mb_adaptive_frame_field_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(7usize, 1u8, val as u64) + } + } + #[inline] + pub fn frame_mbs_only_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u32) } + } + #[inline] + pub fn set_frame_mbs_only_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(8usize, 1u8, val as u64) + } + } + #[inline] + pub fn delta_pic_order_always_zero_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 1u8) as u32) } + } + #[inline] + pub fn set_delta_pic_order_always_zero_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(9usize, 1u8, val as u64) + } + } + #[inline] + pub fn separate_colour_plane_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 1u8) as u32) } + } + #[inline] + pub fn set_separate_colour_plane_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(10usize, 1u8, val as u64) + } + } + #[inline] + pub fn gaps_in_frame_num_value_allowed_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u32) } + } + #[inline] + pub fn set_gaps_in_frame_num_value_allowed_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(11usize, 1u8, val as u64) + } + } + #[inline] + pub fn qpprime_y_zero_transform_bypass_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u32) } + } + #[inline] + pub fn set_qpprime_y_zero_transform_bypass_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(12usize, 1u8, val as u64) + } + } + #[inline] + pub fn frame_cropping_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u32) } + } + #[inline] + pub fn set_frame_cropping_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(13usize, 1u8, val as u64) + } + } + #[inline] + pub fn seq_scaling_matrix_present_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 1u8) as u32) } + } + #[inline] + pub fn set_seq_scaling_matrix_present_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(14usize, 1u8, val as u64) + } + } + #[inline] + pub fn vui_parameters_present_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(15usize, 1u8) as u32) } + } + #[inline] + pub fn set_vui_parameters_present_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(15usize, 1u8, val as u64) + } + } + #[inline] + pub fn new_bitfield_1( + constraint_set0_flag: u32, + constraint_set1_flag: u32, + constraint_set2_flag: u32, + constraint_set3_flag: u32, + constraint_set4_flag: u32, + constraint_set5_flag: u32, + direct_8x8_inference_flag: u32, + mb_adaptive_frame_field_flag: u32, + frame_mbs_only_flag: u32, + delta_pic_order_always_zero_flag: u32, + separate_colour_plane_flag: u32, + gaps_in_frame_num_value_allowed_flag: u32, + qpprime_y_zero_transform_bypass_flag: u32, + frame_cropping_flag: u32, + seq_scaling_matrix_present_flag: u32, + vui_parameters_present_flag: u32, + ) -> __BindgenBitfieldUnit<[u8; 2usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let constraint_set0_flag: u32 = unsafe { ::std::mem::transmute(constraint_set0_flag) }; + constraint_set0_flag as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let constraint_set1_flag: u32 = unsafe { ::std::mem::transmute(constraint_set1_flag) }; + constraint_set1_flag as u64 + }); + __bindgen_bitfield_unit.set(2usize, 1u8, { + let constraint_set2_flag: u32 = unsafe { ::std::mem::transmute(constraint_set2_flag) }; + constraint_set2_flag as u64 + }); + __bindgen_bitfield_unit.set(3usize, 1u8, { + let constraint_set3_flag: u32 = unsafe { ::std::mem::transmute(constraint_set3_flag) }; + constraint_set3_flag as u64 + }); + __bindgen_bitfield_unit.set(4usize, 1u8, { + let constraint_set4_flag: u32 = unsafe { ::std::mem::transmute(constraint_set4_flag) }; + constraint_set4_flag as u64 + }); + __bindgen_bitfield_unit.set(5usize, 1u8, { + let constraint_set5_flag: u32 = unsafe { ::std::mem::transmute(constraint_set5_flag) }; + constraint_set5_flag as u64 + }); + __bindgen_bitfield_unit.set(6usize, 1u8, { + let direct_8x8_inference_flag: u32 = + unsafe { ::std::mem::transmute(direct_8x8_inference_flag) }; + direct_8x8_inference_flag as u64 + }); + __bindgen_bitfield_unit.set(7usize, 1u8, { + let mb_adaptive_frame_field_flag: u32 = + unsafe { ::std::mem::transmute(mb_adaptive_frame_field_flag) }; + mb_adaptive_frame_field_flag as u64 + }); + __bindgen_bitfield_unit.set(8usize, 1u8, { + let frame_mbs_only_flag: u32 = unsafe { ::std::mem::transmute(frame_mbs_only_flag) }; + frame_mbs_only_flag as u64 + }); + __bindgen_bitfield_unit.set(9usize, 1u8, { + let delta_pic_order_always_zero_flag: u32 = + unsafe { ::std::mem::transmute(delta_pic_order_always_zero_flag) }; + delta_pic_order_always_zero_flag as u64 + }); + __bindgen_bitfield_unit.set(10usize, 1u8, { + let separate_colour_plane_flag: u32 = + unsafe { ::std::mem::transmute(separate_colour_plane_flag) }; + separate_colour_plane_flag as u64 + }); + __bindgen_bitfield_unit.set(11usize, 1u8, { + let gaps_in_frame_num_value_allowed_flag: u32 = + unsafe { ::std::mem::transmute(gaps_in_frame_num_value_allowed_flag) }; + gaps_in_frame_num_value_allowed_flag as u64 + }); + __bindgen_bitfield_unit.set(12usize, 1u8, { + let qpprime_y_zero_transform_bypass_flag: u32 = + unsafe { ::std::mem::transmute(qpprime_y_zero_transform_bypass_flag) }; + qpprime_y_zero_transform_bypass_flag as u64 + }); + __bindgen_bitfield_unit.set(13usize, 1u8, { + let frame_cropping_flag: u32 = unsafe { ::std::mem::transmute(frame_cropping_flag) }; + frame_cropping_flag as u64 + }); + __bindgen_bitfield_unit.set(14usize, 1u8, { + let seq_scaling_matrix_present_flag: u32 = + unsafe { ::std::mem::transmute(seq_scaling_matrix_present_flag) }; + seq_scaling_matrix_present_flag as u64 + }); + __bindgen_bitfield_unit.set(15usize, 1u8, { + let vui_parameters_present_flag: u32 = + unsafe { ::std::mem::transmute(vui_parameters_present_flag) }; + vui_parameters_present_flag as u64 + }); + __bindgen_bitfield_unit + } +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoH264ScalingLists { + pub scaling_list_present_mask: u16, + pub use_default_scaling_matrix_mask: u16, + pub ScalingList4x4: [[u8; 16usize]; 6usize], + pub ScalingList8x8: [[u8; 64usize]; 6usize], +} +#[test] +fn bindgen_test_layout_StdVideoH264ScalingLists() { + const UNINIT: ::std::mem::MaybeUninit = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::(), + 484usize, + concat!("Size of: ", stringify!(StdVideoH264ScalingLists)) + ); + assert_eq!( + ::std::mem::align_of::(), + 2usize, + concat!("Alignment of ", stringify!(StdVideoH264ScalingLists)) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).scaling_list_present_mask) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264ScalingLists), + "::", + stringify!(scaling_list_present_mask) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).use_default_scaling_matrix_mask) as usize - ptr as usize + }, + 2usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264ScalingLists), + "::", + stringify!(use_default_scaling_matrix_mask) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).ScalingList4x4) as usize - ptr as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264ScalingLists), + "::", + stringify!(ScalingList4x4) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).ScalingList8x8) as usize - ptr as usize }, + 100usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264ScalingLists), + "::", + stringify!(ScalingList8x8) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoH264SequenceParameterSet { + pub flags: StdVideoH264SpsFlags, + pub profile_idc: StdVideoH264ProfileIdc, + pub level_idc: StdVideoH264LevelIdc, + pub chroma_format_idc: StdVideoH264ChromaFormatIdc, + pub seq_parameter_set_id: u8, + pub bit_depth_luma_minus8: u8, + pub bit_depth_chroma_minus8: u8, + pub log2_max_frame_num_minus4: u8, + pub pic_order_cnt_type: StdVideoH264PocType, + pub offset_for_non_ref_pic: i32, + pub offset_for_top_to_bottom_field: i32, + pub log2_max_pic_order_cnt_lsb_minus4: u8, + pub num_ref_frames_in_pic_order_cnt_cycle: u8, + pub max_num_ref_frames: u8, + pub reserved1: u8, + pub pic_width_in_mbs_minus1: u32, + pub pic_height_in_map_units_minus1: u32, + pub frame_crop_left_offset: u32, + pub frame_crop_right_offset: u32, + pub frame_crop_top_offset: u32, + pub frame_crop_bottom_offset: u32, + pub reserved2: u32, + pub pOffsetForRefFrame: *const i32, + pub pScalingLists: *const StdVideoH264ScalingLists, + pub pSequenceParameterSetVui: *const StdVideoH264SequenceParameterSetVui, +} +#[test] +fn bindgen_test_layout_StdVideoH264SequenceParameterSet() { + const UNINIT: ::std::mem::MaybeUninit = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::(), + 88usize, + concat!("Size of: ", stringify!(StdVideoH264SequenceParameterSet)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!( + "Alignment of ", + stringify!(StdVideoH264SequenceParameterSet) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264SequenceParameterSet), + "::", + stringify!(flags) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).profile_idc) as usize - ptr as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264SequenceParameterSet), + "::", + stringify!(profile_idc) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).level_idc) as usize - ptr as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264SequenceParameterSet), + "::", + stringify!(level_idc) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).chroma_format_idc) as usize - ptr as usize }, + 12usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264SequenceParameterSet), + "::", + stringify!(chroma_format_idc) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).seq_parameter_set_id) as usize - ptr as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264SequenceParameterSet), + "::", + stringify!(seq_parameter_set_id) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).bit_depth_luma_minus8) as usize - ptr as usize }, + 17usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264SequenceParameterSet), + "::", + stringify!(bit_depth_luma_minus8) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).bit_depth_chroma_minus8) as usize - ptr as usize }, + 18usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264SequenceParameterSet), + "::", + stringify!(bit_depth_chroma_minus8) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).log2_max_frame_num_minus4) as usize - ptr as usize }, + 19usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264SequenceParameterSet), + "::", + stringify!(log2_max_frame_num_minus4) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pic_order_cnt_type) as usize - ptr as usize }, + 20usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264SequenceParameterSet), + "::", + stringify!(pic_order_cnt_type) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).offset_for_non_ref_pic) as usize - ptr as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264SequenceParameterSet), + "::", + stringify!(offset_for_non_ref_pic) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).offset_for_top_to_bottom_field) as usize - ptr as usize + }, + 28usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264SequenceParameterSet), + "::", + stringify!(offset_for_top_to_bottom_field) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).log2_max_pic_order_cnt_lsb_minus4) as usize - ptr as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264SequenceParameterSet), + "::", + stringify!(log2_max_pic_order_cnt_lsb_minus4) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).num_ref_frames_in_pic_order_cnt_cycle) as usize + - ptr as usize + }, + 33usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264SequenceParameterSet), + "::", + stringify!(num_ref_frames_in_pic_order_cnt_cycle) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).max_num_ref_frames) as usize - ptr as usize }, + 34usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264SequenceParameterSet), + "::", + stringify!(max_num_ref_frames) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).reserved1) as usize - ptr as usize }, + 35usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264SequenceParameterSet), + "::", + stringify!(reserved1) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pic_width_in_mbs_minus1) as usize - ptr as usize }, + 36usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264SequenceParameterSet), + "::", + stringify!(pic_width_in_mbs_minus1) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).pic_height_in_map_units_minus1) as usize - ptr as usize + }, + 40usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264SequenceParameterSet), + "::", + stringify!(pic_height_in_map_units_minus1) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).frame_crop_left_offset) as usize - ptr as usize }, + 44usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264SequenceParameterSet), + "::", + stringify!(frame_crop_left_offset) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).frame_crop_right_offset) as usize - ptr as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264SequenceParameterSet), + "::", + stringify!(frame_crop_right_offset) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).frame_crop_top_offset) as usize - ptr as usize }, + 52usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264SequenceParameterSet), + "::", + stringify!(frame_crop_top_offset) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).frame_crop_bottom_offset) as usize - ptr as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264SequenceParameterSet), + "::", + stringify!(frame_crop_bottom_offset) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).reserved2) as usize - ptr as usize }, + 60usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264SequenceParameterSet), + "::", + stringify!(reserved2) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pOffsetForRefFrame) as usize - ptr as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264SequenceParameterSet), + "::", + stringify!(pOffsetForRefFrame) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pScalingLists) as usize - ptr as usize }, + 72usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264SequenceParameterSet), + "::", + stringify!(pScalingLists) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pSequenceParameterSetVui) as usize - ptr as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264SequenceParameterSet), + "::", + stringify!(pSequenceParameterSetVui) + ) + ); +} +#[repr(C)] +#[repr(align(4))] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoH264PpsFlags { + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, + pub __bindgen_padding_0: [u8; 3usize], +} +#[test] +fn bindgen_test_layout_StdVideoH264PpsFlags() { + assert_eq!( + ::std::mem::size_of::(), + 4usize, + concat!("Size of: ", stringify!(StdVideoH264PpsFlags)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!("Alignment of ", stringify!(StdVideoH264PpsFlags)) + ); +} +impl StdVideoH264PpsFlags { + #[inline] + pub fn transform_8x8_mode_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_transform_8x8_mode_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub fn redundant_pic_cnt_present_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_redundant_pic_cnt_present_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub fn constrained_intra_pred_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } + } + #[inline] + pub fn set_constrained_intra_pred_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 1u8, val as u64) + } + } + #[inline] + pub fn deblocking_filter_control_present_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } + } + #[inline] + pub fn set_deblocking_filter_control_present_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(3usize, 1u8, val as u64) + } + } + #[inline] + pub fn weighted_pred_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } + } + #[inline] + pub fn set_weighted_pred_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(4usize, 1u8, val as u64) + } + } + #[inline] + pub fn bottom_field_pic_order_in_frame_present_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) } + } + #[inline] + pub fn set_bottom_field_pic_order_in_frame_present_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(5usize, 1u8, val as u64) + } + } + #[inline] + pub fn entropy_coding_mode_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) } + } + #[inline] + pub fn set_entropy_coding_mode_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(6usize, 1u8, val as u64) + } + } + #[inline] + pub fn pic_scaling_matrix_present_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) } + } + #[inline] + pub fn set_pic_scaling_matrix_present_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(7usize, 1u8, val as u64) + } + } + #[inline] + pub fn new_bitfield_1( + transform_8x8_mode_flag: u32, + redundant_pic_cnt_present_flag: u32, + constrained_intra_pred_flag: u32, + deblocking_filter_control_present_flag: u32, + weighted_pred_flag: u32, + bottom_field_pic_order_in_frame_present_flag: u32, + entropy_coding_mode_flag: u32, + pic_scaling_matrix_present_flag: u32, + ) -> __BindgenBitfieldUnit<[u8; 1usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let transform_8x8_mode_flag: u32 = + unsafe { ::std::mem::transmute(transform_8x8_mode_flag) }; + transform_8x8_mode_flag as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let redundant_pic_cnt_present_flag: u32 = + unsafe { ::std::mem::transmute(redundant_pic_cnt_present_flag) }; + redundant_pic_cnt_present_flag as u64 + }); + __bindgen_bitfield_unit.set(2usize, 1u8, { + let constrained_intra_pred_flag: u32 = + unsafe { ::std::mem::transmute(constrained_intra_pred_flag) }; + constrained_intra_pred_flag as u64 + }); + __bindgen_bitfield_unit.set(3usize, 1u8, { + let deblocking_filter_control_present_flag: u32 = + unsafe { ::std::mem::transmute(deblocking_filter_control_present_flag) }; + deblocking_filter_control_present_flag as u64 + }); + __bindgen_bitfield_unit.set(4usize, 1u8, { + let weighted_pred_flag: u32 = unsafe { ::std::mem::transmute(weighted_pred_flag) }; + weighted_pred_flag as u64 + }); + __bindgen_bitfield_unit.set(5usize, 1u8, { + let bottom_field_pic_order_in_frame_present_flag: u32 = + unsafe { ::std::mem::transmute(bottom_field_pic_order_in_frame_present_flag) }; + bottom_field_pic_order_in_frame_present_flag as u64 + }); + __bindgen_bitfield_unit.set(6usize, 1u8, { + let entropy_coding_mode_flag: u32 = + unsafe { ::std::mem::transmute(entropy_coding_mode_flag) }; + entropy_coding_mode_flag as u64 + }); + __bindgen_bitfield_unit.set(7usize, 1u8, { + let pic_scaling_matrix_present_flag: u32 = + unsafe { ::std::mem::transmute(pic_scaling_matrix_present_flag) }; + pic_scaling_matrix_present_flag as u64 + }); + __bindgen_bitfield_unit + } +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoH264PictureParameterSet { + pub flags: StdVideoH264PpsFlags, + pub seq_parameter_set_id: u8, + pub pic_parameter_set_id: u8, + pub num_ref_idx_l0_default_active_minus1: u8, + pub num_ref_idx_l1_default_active_minus1: u8, + pub weighted_bipred_idc: StdVideoH264WeightedBipredIdc, + pub pic_init_qp_minus26: i8, + pub pic_init_qs_minus26: i8, + pub chroma_qp_index_offset: i8, + pub second_chroma_qp_index_offset: i8, + pub pScalingLists: *const StdVideoH264ScalingLists, +} +#[test] +fn bindgen_test_layout_StdVideoH264PictureParameterSet() { + const UNINIT: ::std::mem::MaybeUninit = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::(), + 24usize, + concat!("Size of: ", stringify!(StdVideoH264PictureParameterSet)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(StdVideoH264PictureParameterSet)) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264PictureParameterSet), + "::", + stringify!(flags) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).seq_parameter_set_id) as usize - ptr as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264PictureParameterSet), + "::", + stringify!(seq_parameter_set_id) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pic_parameter_set_id) as usize - ptr as usize }, + 5usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264PictureParameterSet), + "::", + stringify!(pic_parameter_set_id) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).num_ref_idx_l0_default_active_minus1) as usize + - ptr as usize + }, + 6usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264PictureParameterSet), + "::", + stringify!(num_ref_idx_l0_default_active_minus1) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).num_ref_idx_l1_default_active_minus1) as usize + - ptr as usize + }, + 7usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264PictureParameterSet), + "::", + stringify!(num_ref_idx_l1_default_active_minus1) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).weighted_bipred_idc) as usize - ptr as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264PictureParameterSet), + "::", + stringify!(weighted_bipred_idc) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pic_init_qp_minus26) as usize - ptr as usize }, + 12usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264PictureParameterSet), + "::", + stringify!(pic_init_qp_minus26) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pic_init_qs_minus26) as usize - ptr as usize }, + 13usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264PictureParameterSet), + "::", + stringify!(pic_init_qs_minus26) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).chroma_qp_index_offset) as usize - ptr as usize }, + 14usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264PictureParameterSet), + "::", + stringify!(chroma_qp_index_offset) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).second_chroma_qp_index_offset) as usize - ptr as usize + }, + 15usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264PictureParameterSet), + "::", + stringify!(second_chroma_qp_index_offset) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pScalingLists) as usize - ptr as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264PictureParameterSet), + "::", + stringify!(pScalingLists) + ) + ); +} +#[repr(C)] +#[repr(align(4))] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoDecodeH264PictureInfoFlags { + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, + pub __bindgen_padding_0: [u8; 3usize], +} +#[test] +fn bindgen_test_layout_StdVideoDecodeH264PictureInfoFlags() { + assert_eq!( + ::std::mem::size_of::(), + 4usize, + concat!("Size of: ", stringify!(StdVideoDecodeH264PictureInfoFlags)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(StdVideoDecodeH264PictureInfoFlags) + ) + ); +} +impl StdVideoDecodeH264PictureInfoFlags { + #[inline] + pub fn field_pic_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_field_pic_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub fn is_intra(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_is_intra(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub fn IdrPicFlag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } + } + #[inline] + pub fn set_IdrPicFlag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 1u8, val as u64) + } + } + #[inline] + pub fn bottom_field_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } + } + #[inline] + pub fn set_bottom_field_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(3usize, 1u8, val as u64) + } + } + #[inline] + pub fn is_reference(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } + } + #[inline] + pub fn set_is_reference(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(4usize, 1u8, val as u64) + } + } + #[inline] + pub fn complementary_field_pair(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) } + } + #[inline] + pub fn set_complementary_field_pair(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(5usize, 1u8, val as u64) + } + } + #[inline] + pub fn new_bitfield_1( + field_pic_flag: u32, + is_intra: u32, + IdrPicFlag: u32, + bottom_field_flag: u32, + is_reference: u32, + complementary_field_pair: u32, + ) -> __BindgenBitfieldUnit<[u8; 1usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let field_pic_flag: u32 = unsafe { ::std::mem::transmute(field_pic_flag) }; + field_pic_flag as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let is_intra: u32 = unsafe { ::std::mem::transmute(is_intra) }; + is_intra as u64 + }); + __bindgen_bitfield_unit.set(2usize, 1u8, { + let IdrPicFlag: u32 = unsafe { ::std::mem::transmute(IdrPicFlag) }; + IdrPicFlag as u64 + }); + __bindgen_bitfield_unit.set(3usize, 1u8, { + let bottom_field_flag: u32 = unsafe { ::std::mem::transmute(bottom_field_flag) }; + bottom_field_flag as u64 + }); + __bindgen_bitfield_unit.set(4usize, 1u8, { + let is_reference: u32 = unsafe { ::std::mem::transmute(is_reference) }; + is_reference as u64 + }); + __bindgen_bitfield_unit.set(5usize, 1u8, { + let complementary_field_pair: u32 = + unsafe { ::std::mem::transmute(complementary_field_pair) }; + complementary_field_pair as u64 + }); + __bindgen_bitfield_unit + } +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoDecodeH264PictureInfo { + pub flags: StdVideoDecodeH264PictureInfoFlags, + pub seq_parameter_set_id: u8, + pub pic_parameter_set_id: u8, + pub reserved1: u8, + pub reserved2: u8, + pub frame_num: u16, + pub idr_pic_id: u16, + pub PicOrderCnt: [i32; 2usize], +} +#[test] +fn bindgen_test_layout_StdVideoDecodeH264PictureInfo() { + const UNINIT: ::std::mem::MaybeUninit = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::(), + 20usize, + concat!("Size of: ", stringify!(StdVideoDecodeH264PictureInfo)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!("Alignment of ", stringify!(StdVideoDecodeH264PictureInfo)) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(StdVideoDecodeH264PictureInfo), + "::", + stringify!(flags) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).seq_parameter_set_id) as usize - ptr as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(StdVideoDecodeH264PictureInfo), + "::", + stringify!(seq_parameter_set_id) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pic_parameter_set_id) as usize - ptr as usize }, + 5usize, + concat!( + "Offset of field: ", + stringify!(StdVideoDecodeH264PictureInfo), + "::", + stringify!(pic_parameter_set_id) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).reserved1) as usize - ptr as usize }, + 6usize, + concat!( + "Offset of field: ", + stringify!(StdVideoDecodeH264PictureInfo), + "::", + stringify!(reserved1) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).reserved2) as usize - ptr as usize }, + 7usize, + concat!( + "Offset of field: ", + stringify!(StdVideoDecodeH264PictureInfo), + "::", + stringify!(reserved2) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).frame_num) as usize - ptr as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(StdVideoDecodeH264PictureInfo), + "::", + stringify!(frame_num) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).idr_pic_id) as usize - ptr as usize }, + 10usize, + concat!( + "Offset of field: ", + stringify!(StdVideoDecodeH264PictureInfo), + "::", + stringify!(idr_pic_id) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).PicOrderCnt) as usize - ptr as usize }, + 12usize, + concat!( + "Offset of field: ", + stringify!(StdVideoDecodeH264PictureInfo), + "::", + stringify!(PicOrderCnt) + ) + ); +} +#[repr(C)] +#[repr(align(4))] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoDecodeH264ReferenceInfoFlags { + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, + pub __bindgen_padding_0: [u8; 3usize], +} +#[test] +fn bindgen_test_layout_StdVideoDecodeH264ReferenceInfoFlags() { + assert_eq!( + ::std::mem::size_of::(), + 4usize, + concat!( + "Size of: ", + stringify!(StdVideoDecodeH264ReferenceInfoFlags) + ) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(StdVideoDecodeH264ReferenceInfoFlags) + ) + ); +} +impl StdVideoDecodeH264ReferenceInfoFlags { + #[inline] + pub fn top_field_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_top_field_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub fn bottom_field_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_bottom_field_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub fn used_for_long_term_reference(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } + } + #[inline] + pub fn set_used_for_long_term_reference(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 1u8, val as u64) + } + } + #[inline] + pub fn is_non_existing(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } + } + #[inline] + pub fn set_is_non_existing(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(3usize, 1u8, val as u64) + } + } + #[inline] + pub fn new_bitfield_1( + top_field_flag: u32, + bottom_field_flag: u32, + used_for_long_term_reference: u32, + is_non_existing: u32, + ) -> __BindgenBitfieldUnit<[u8; 1usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let top_field_flag: u32 = unsafe { ::std::mem::transmute(top_field_flag) }; + top_field_flag as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let bottom_field_flag: u32 = unsafe { ::std::mem::transmute(bottom_field_flag) }; + bottom_field_flag as u64 + }); + __bindgen_bitfield_unit.set(2usize, 1u8, { + let used_for_long_term_reference: u32 = + unsafe { ::std::mem::transmute(used_for_long_term_reference) }; + used_for_long_term_reference as u64 + }); + __bindgen_bitfield_unit.set(3usize, 1u8, { + let is_non_existing: u32 = unsafe { ::std::mem::transmute(is_non_existing) }; + is_non_existing as u64 + }); + __bindgen_bitfield_unit + } +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoDecodeH264ReferenceInfo { + pub flags: StdVideoDecodeH264ReferenceInfoFlags, + pub FrameNum: u16, + pub reserved: u16, + pub PicOrderCnt: [i32; 2usize], +} +#[test] +fn bindgen_test_layout_StdVideoDecodeH264ReferenceInfo() { + const UNINIT: ::std::mem::MaybeUninit = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::(), + 16usize, + concat!("Size of: ", stringify!(StdVideoDecodeH264ReferenceInfo)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!("Alignment of ", stringify!(StdVideoDecodeH264ReferenceInfo)) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(StdVideoDecodeH264ReferenceInfo), + "::", + stringify!(flags) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).FrameNum) as usize - ptr as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(StdVideoDecodeH264ReferenceInfo), + "::", + stringify!(FrameNum) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).reserved) as usize - ptr as usize }, + 6usize, + concat!( + "Offset of field: ", + stringify!(StdVideoDecodeH264ReferenceInfo), + "::", + stringify!(reserved) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).PicOrderCnt) as usize - ptr as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(StdVideoDecodeH264ReferenceInfo), + "::", + stringify!(PicOrderCnt) + ) + ); +} +pub const StdVideoH265ChromaFormatIdc_STD_VIDEO_H265_CHROMA_FORMAT_IDC_MONOCHROME: + StdVideoH265ChromaFormatIdc = 0; +pub const StdVideoH265ChromaFormatIdc_STD_VIDEO_H265_CHROMA_FORMAT_IDC_420: + StdVideoH265ChromaFormatIdc = 1; +pub const StdVideoH265ChromaFormatIdc_STD_VIDEO_H265_CHROMA_FORMAT_IDC_422: + StdVideoH265ChromaFormatIdc = 2; +pub const StdVideoH265ChromaFormatIdc_STD_VIDEO_H265_CHROMA_FORMAT_IDC_444: + StdVideoH265ChromaFormatIdc = 3; +pub const StdVideoH265ChromaFormatIdc_STD_VIDEO_H265_CHROMA_FORMAT_IDC_INVALID: + StdVideoH265ChromaFormatIdc = 2147483647; +pub type StdVideoH265ChromaFormatIdc = ::std::os::raw::c_uint; +pub const StdVideoH265ProfileIdc_STD_VIDEO_H265_PROFILE_IDC_MAIN: StdVideoH265ProfileIdc = 1; +pub const StdVideoH265ProfileIdc_STD_VIDEO_H265_PROFILE_IDC_MAIN_10: StdVideoH265ProfileIdc = 2; +pub const StdVideoH265ProfileIdc_STD_VIDEO_H265_PROFILE_IDC_MAIN_STILL_PICTURE: + StdVideoH265ProfileIdc = 3; +pub const StdVideoH265ProfileIdc_STD_VIDEO_H265_PROFILE_IDC_FORMAT_RANGE_EXTENSIONS: + StdVideoH265ProfileIdc = 4; +pub const StdVideoH265ProfileIdc_STD_VIDEO_H265_PROFILE_IDC_SCC_EXTENSIONS: StdVideoH265ProfileIdc = + 9; +pub const StdVideoH265ProfileIdc_STD_VIDEO_H265_PROFILE_IDC_INVALID: StdVideoH265ProfileIdc = + 2147483647; +pub type StdVideoH265ProfileIdc = ::std::os::raw::c_uint; +pub const StdVideoH265LevelIdc_STD_VIDEO_H265_LEVEL_IDC_1_0: StdVideoH265LevelIdc = 0; +pub const StdVideoH265LevelIdc_STD_VIDEO_H265_LEVEL_IDC_2_0: StdVideoH265LevelIdc = 1; +pub const StdVideoH265LevelIdc_STD_VIDEO_H265_LEVEL_IDC_2_1: StdVideoH265LevelIdc = 2; +pub const StdVideoH265LevelIdc_STD_VIDEO_H265_LEVEL_IDC_3_0: StdVideoH265LevelIdc = 3; +pub const StdVideoH265LevelIdc_STD_VIDEO_H265_LEVEL_IDC_3_1: StdVideoH265LevelIdc = 4; +pub const StdVideoH265LevelIdc_STD_VIDEO_H265_LEVEL_IDC_4_0: StdVideoH265LevelIdc = 5; +pub const StdVideoH265LevelIdc_STD_VIDEO_H265_LEVEL_IDC_4_1: StdVideoH265LevelIdc = 6; +pub const StdVideoH265LevelIdc_STD_VIDEO_H265_LEVEL_IDC_5_0: StdVideoH265LevelIdc = 7; +pub const StdVideoH265LevelIdc_STD_VIDEO_H265_LEVEL_IDC_5_1: StdVideoH265LevelIdc = 8; +pub const StdVideoH265LevelIdc_STD_VIDEO_H265_LEVEL_IDC_5_2: StdVideoH265LevelIdc = 9; +pub const StdVideoH265LevelIdc_STD_VIDEO_H265_LEVEL_IDC_6_0: StdVideoH265LevelIdc = 10; +pub const StdVideoH265LevelIdc_STD_VIDEO_H265_LEVEL_IDC_6_1: StdVideoH265LevelIdc = 11; +pub const StdVideoH265LevelIdc_STD_VIDEO_H265_LEVEL_IDC_6_2: StdVideoH265LevelIdc = 12; +pub const StdVideoH265LevelIdc_STD_VIDEO_H265_LEVEL_IDC_INVALID: StdVideoH265LevelIdc = 2147483647; +pub type StdVideoH265LevelIdc = ::std::os::raw::c_uint; +pub const StdVideoH265SliceType_STD_VIDEO_H265_SLICE_TYPE_B: StdVideoH265SliceType = 0; +pub const StdVideoH265SliceType_STD_VIDEO_H265_SLICE_TYPE_P: StdVideoH265SliceType = 1; +pub const StdVideoH265SliceType_STD_VIDEO_H265_SLICE_TYPE_I: StdVideoH265SliceType = 2; +pub const StdVideoH265SliceType_STD_VIDEO_H265_SLICE_TYPE_INVALID: StdVideoH265SliceType = + 2147483647; +pub type StdVideoH265SliceType = ::std::os::raw::c_uint; +pub const StdVideoH265PictureType_STD_VIDEO_H265_PICTURE_TYPE_P: StdVideoH265PictureType = 0; +pub const StdVideoH265PictureType_STD_VIDEO_H265_PICTURE_TYPE_B: StdVideoH265PictureType = 1; +pub const StdVideoH265PictureType_STD_VIDEO_H265_PICTURE_TYPE_I: StdVideoH265PictureType = 2; +pub const StdVideoH265PictureType_STD_VIDEO_H265_PICTURE_TYPE_IDR: StdVideoH265PictureType = 3; +pub const StdVideoH265PictureType_STD_VIDEO_H265_PICTURE_TYPE_INVALID: StdVideoH265PictureType = + 2147483647; +pub type StdVideoH265PictureType = ::std::os::raw::c_uint; +pub const StdVideoH265AspectRatioIdc_STD_VIDEO_H265_ASPECT_RATIO_IDC_UNSPECIFIED: + StdVideoH265AspectRatioIdc = 0; +pub const StdVideoH265AspectRatioIdc_STD_VIDEO_H265_ASPECT_RATIO_IDC_SQUARE: + StdVideoH265AspectRatioIdc = 1; +pub const StdVideoH265AspectRatioIdc_STD_VIDEO_H265_ASPECT_RATIO_IDC_12_11: + StdVideoH265AspectRatioIdc = 2; +pub const StdVideoH265AspectRatioIdc_STD_VIDEO_H265_ASPECT_RATIO_IDC_10_11: + StdVideoH265AspectRatioIdc = 3; +pub const StdVideoH265AspectRatioIdc_STD_VIDEO_H265_ASPECT_RATIO_IDC_16_11: + StdVideoH265AspectRatioIdc = 4; +pub const StdVideoH265AspectRatioIdc_STD_VIDEO_H265_ASPECT_RATIO_IDC_40_33: + StdVideoH265AspectRatioIdc = 5; +pub const StdVideoH265AspectRatioIdc_STD_VIDEO_H265_ASPECT_RATIO_IDC_24_11: + StdVideoH265AspectRatioIdc = 6; +pub const StdVideoH265AspectRatioIdc_STD_VIDEO_H265_ASPECT_RATIO_IDC_20_11: + StdVideoH265AspectRatioIdc = 7; +pub const StdVideoH265AspectRatioIdc_STD_VIDEO_H265_ASPECT_RATIO_IDC_32_11: + StdVideoH265AspectRatioIdc = 8; +pub const StdVideoH265AspectRatioIdc_STD_VIDEO_H265_ASPECT_RATIO_IDC_80_33: + StdVideoH265AspectRatioIdc = 9; +pub const StdVideoH265AspectRatioIdc_STD_VIDEO_H265_ASPECT_RATIO_IDC_18_11: + StdVideoH265AspectRatioIdc = 10; +pub const StdVideoH265AspectRatioIdc_STD_VIDEO_H265_ASPECT_RATIO_IDC_15_11: + StdVideoH265AspectRatioIdc = 11; +pub const StdVideoH265AspectRatioIdc_STD_VIDEO_H265_ASPECT_RATIO_IDC_64_33: + StdVideoH265AspectRatioIdc = 12; +pub const StdVideoH265AspectRatioIdc_STD_VIDEO_H265_ASPECT_RATIO_IDC_160_99: + StdVideoH265AspectRatioIdc = 13; +pub const StdVideoH265AspectRatioIdc_STD_VIDEO_H265_ASPECT_RATIO_IDC_4_3: + StdVideoH265AspectRatioIdc = 14; +pub const StdVideoH265AspectRatioIdc_STD_VIDEO_H265_ASPECT_RATIO_IDC_3_2: + StdVideoH265AspectRatioIdc = 15; +pub const StdVideoH265AspectRatioIdc_STD_VIDEO_H265_ASPECT_RATIO_IDC_2_1: + StdVideoH265AspectRatioIdc = 16; +pub const StdVideoH265AspectRatioIdc_STD_VIDEO_H265_ASPECT_RATIO_IDC_EXTENDED_SAR: + StdVideoH265AspectRatioIdc = 255; +pub const StdVideoH265AspectRatioIdc_STD_VIDEO_H265_ASPECT_RATIO_IDC_INVALID: + StdVideoH265AspectRatioIdc = 2147483647; +pub type StdVideoH265AspectRatioIdc = ::std::os::raw::c_uint; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoH265DecPicBufMgr { + pub max_latency_increase_plus1: [u32; 7usize], + pub max_dec_pic_buffering_minus1: [u8; 7usize], + pub max_num_reorder_pics: [u8; 7usize], +} +#[test] +fn bindgen_test_layout_StdVideoH265DecPicBufMgr() { + const UNINIT: ::std::mem::MaybeUninit = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::(), + 44usize, + concat!("Size of: ", stringify!(StdVideoH265DecPicBufMgr)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!("Alignment of ", stringify!(StdVideoH265DecPicBufMgr)) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).max_latency_increase_plus1) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265DecPicBufMgr), + "::", + stringify!(max_latency_increase_plus1) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).max_dec_pic_buffering_minus1) as usize - ptr as usize + }, + 28usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265DecPicBufMgr), + "::", + stringify!(max_dec_pic_buffering_minus1) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).max_num_reorder_pics) as usize - ptr as usize }, + 35usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265DecPicBufMgr), + "::", + stringify!(max_num_reorder_pics) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoH265SubLayerHrdParameters { + pub bit_rate_value_minus1: [u32; 32usize], + pub cpb_size_value_minus1: [u32; 32usize], + pub cpb_size_du_value_minus1: [u32; 32usize], + pub bit_rate_du_value_minus1: [u32; 32usize], + pub cbr_flag: u32, +} +#[test] +fn bindgen_test_layout_StdVideoH265SubLayerHrdParameters() { + const UNINIT: ::std::mem::MaybeUninit = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::(), + 516usize, + concat!("Size of: ", stringify!(StdVideoH265SubLayerHrdParameters)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(StdVideoH265SubLayerHrdParameters) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).bit_rate_value_minus1) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SubLayerHrdParameters), + "::", + stringify!(bit_rate_value_minus1) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).cpb_size_value_minus1) as usize - ptr as usize }, + 128usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SubLayerHrdParameters), + "::", + stringify!(cpb_size_value_minus1) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).cpb_size_du_value_minus1) as usize - ptr as usize }, + 256usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SubLayerHrdParameters), + "::", + stringify!(cpb_size_du_value_minus1) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).bit_rate_du_value_minus1) as usize - ptr as usize }, + 384usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SubLayerHrdParameters), + "::", + stringify!(bit_rate_du_value_minus1) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).cbr_flag) as usize - ptr as usize }, + 512usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SubLayerHrdParameters), + "::", + stringify!(cbr_flag) + ) + ); +} +#[repr(C)] +#[repr(align(4))] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoH265HrdFlags { + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, +} +#[test] +fn bindgen_test_layout_StdVideoH265HrdFlags() { + assert_eq!( + ::std::mem::size_of::(), + 4usize, + concat!("Size of: ", stringify!(StdVideoH265HrdFlags)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!("Alignment of ", stringify!(StdVideoH265HrdFlags)) + ); +} +impl StdVideoH265HrdFlags { + #[inline] + pub fn nal_hrd_parameters_present_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_nal_hrd_parameters_present_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub fn vcl_hrd_parameters_present_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_vcl_hrd_parameters_present_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub fn sub_pic_hrd_params_present_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } + } + #[inline] + pub fn set_sub_pic_hrd_params_present_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 1u8, val as u64) + } + } + #[inline] + pub fn sub_pic_cpb_params_in_pic_timing_sei_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } + } + #[inline] + pub fn set_sub_pic_cpb_params_in_pic_timing_sei_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(3usize, 1u8, val as u64) + } + } + #[inline] + pub fn fixed_pic_rate_general_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 8u8) as u32) } + } + #[inline] + pub fn set_fixed_pic_rate_general_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(4usize, 8u8, val as u64) + } + } + #[inline] + pub fn fixed_pic_rate_within_cvs_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 8u8) as u32) } + } + #[inline] + pub fn set_fixed_pic_rate_within_cvs_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(12usize, 8u8, val as u64) + } + } + #[inline] + pub fn low_delay_hrd_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(20usize, 8u8) as u32) } + } + #[inline] + pub fn set_low_delay_hrd_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(20usize, 8u8, val as u64) + } + } + #[inline] + pub fn new_bitfield_1( + nal_hrd_parameters_present_flag: u32, + vcl_hrd_parameters_present_flag: u32, + sub_pic_hrd_params_present_flag: u32, + sub_pic_cpb_params_in_pic_timing_sei_flag: u32, + fixed_pic_rate_general_flag: u32, + fixed_pic_rate_within_cvs_flag: u32, + low_delay_hrd_flag: u32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let nal_hrd_parameters_present_flag: u32 = + unsafe { ::std::mem::transmute(nal_hrd_parameters_present_flag) }; + nal_hrd_parameters_present_flag as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let vcl_hrd_parameters_present_flag: u32 = + unsafe { ::std::mem::transmute(vcl_hrd_parameters_present_flag) }; + vcl_hrd_parameters_present_flag as u64 + }); + __bindgen_bitfield_unit.set(2usize, 1u8, { + let sub_pic_hrd_params_present_flag: u32 = + unsafe { ::std::mem::transmute(sub_pic_hrd_params_present_flag) }; + sub_pic_hrd_params_present_flag as u64 + }); + __bindgen_bitfield_unit.set(3usize, 1u8, { + let sub_pic_cpb_params_in_pic_timing_sei_flag: u32 = + unsafe { ::std::mem::transmute(sub_pic_cpb_params_in_pic_timing_sei_flag) }; + sub_pic_cpb_params_in_pic_timing_sei_flag as u64 + }); + __bindgen_bitfield_unit.set(4usize, 8u8, { + let fixed_pic_rate_general_flag: u32 = + unsafe { ::std::mem::transmute(fixed_pic_rate_general_flag) }; + fixed_pic_rate_general_flag as u64 + }); + __bindgen_bitfield_unit.set(12usize, 8u8, { + let fixed_pic_rate_within_cvs_flag: u32 = + unsafe { ::std::mem::transmute(fixed_pic_rate_within_cvs_flag) }; + fixed_pic_rate_within_cvs_flag as u64 + }); + __bindgen_bitfield_unit.set(20usize, 8u8, { + let low_delay_hrd_flag: u32 = unsafe { ::std::mem::transmute(low_delay_hrd_flag) }; + low_delay_hrd_flag as u64 + }); + __bindgen_bitfield_unit + } +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoH265HrdParameters { + pub flags: StdVideoH265HrdFlags, + pub tick_divisor_minus2: u8, + pub du_cpb_removal_delay_increment_length_minus1: u8, + pub dpb_output_delay_du_length_minus1: u8, + pub bit_rate_scale: u8, + pub cpb_size_scale: u8, + pub cpb_size_du_scale: u8, + pub initial_cpb_removal_delay_length_minus1: u8, + pub au_cpb_removal_delay_length_minus1: u8, + pub dpb_output_delay_length_minus1: u8, + pub cpb_cnt_minus1: [u8; 7usize], + pub elemental_duration_in_tc_minus1: [u16; 7usize], + pub reserved: [u16; 3usize], + pub pSubLayerHrdParametersNal: *const StdVideoH265SubLayerHrdParameters, + pub pSubLayerHrdParametersVcl: *const StdVideoH265SubLayerHrdParameters, +} +#[test] +fn bindgen_test_layout_StdVideoH265HrdParameters() { + const UNINIT: ::std::mem::MaybeUninit = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::(), + 56usize, + concat!("Size of: ", stringify!(StdVideoH265HrdParameters)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(StdVideoH265HrdParameters)) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265HrdParameters), + "::", + stringify!(flags) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).tick_divisor_minus2) as usize - ptr as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265HrdParameters), + "::", + stringify!(tick_divisor_minus2) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).du_cpb_removal_delay_increment_length_minus1) as usize + - ptr as usize + }, + 5usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265HrdParameters), + "::", + stringify!(du_cpb_removal_delay_increment_length_minus1) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).dpb_output_delay_du_length_minus1) as usize - ptr as usize + }, + 6usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265HrdParameters), + "::", + stringify!(dpb_output_delay_du_length_minus1) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).bit_rate_scale) as usize - ptr as usize }, + 7usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265HrdParameters), + "::", + stringify!(bit_rate_scale) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).cpb_size_scale) as usize - ptr as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265HrdParameters), + "::", + stringify!(cpb_size_scale) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).cpb_size_du_scale) as usize - ptr as usize }, + 9usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265HrdParameters), + "::", + stringify!(cpb_size_du_scale) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).initial_cpb_removal_delay_length_minus1) as usize + - ptr as usize + }, + 10usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265HrdParameters), + "::", + stringify!(initial_cpb_removal_delay_length_minus1) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).au_cpb_removal_delay_length_minus1) as usize - ptr as usize + }, + 11usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265HrdParameters), + "::", + stringify!(au_cpb_removal_delay_length_minus1) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).dpb_output_delay_length_minus1) as usize - ptr as usize + }, + 12usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265HrdParameters), + "::", + stringify!(dpb_output_delay_length_minus1) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).cpb_cnt_minus1) as usize - ptr as usize }, + 13usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265HrdParameters), + "::", + stringify!(cpb_cnt_minus1) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).elemental_duration_in_tc_minus1) as usize - ptr as usize + }, + 20usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265HrdParameters), + "::", + stringify!(elemental_duration_in_tc_minus1) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).reserved) as usize - ptr as usize }, + 34usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265HrdParameters), + "::", + stringify!(reserved) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pSubLayerHrdParametersNal) as usize - ptr as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265HrdParameters), + "::", + stringify!(pSubLayerHrdParametersNal) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pSubLayerHrdParametersVcl) as usize - ptr as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265HrdParameters), + "::", + stringify!(pSubLayerHrdParametersVcl) + ) + ); +} +#[repr(C)] +#[repr(align(4))] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoH265VpsFlags { + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, + pub __bindgen_padding_0: [u8; 3usize], +} +#[test] +fn bindgen_test_layout_StdVideoH265VpsFlags() { + assert_eq!( + ::std::mem::size_of::(), + 4usize, + concat!("Size of: ", stringify!(StdVideoH265VpsFlags)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!("Alignment of ", stringify!(StdVideoH265VpsFlags)) + ); +} +impl StdVideoH265VpsFlags { + #[inline] + pub fn vps_temporal_id_nesting_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_vps_temporal_id_nesting_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub fn vps_sub_layer_ordering_info_present_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_vps_sub_layer_ordering_info_present_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub fn vps_timing_info_present_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } + } + #[inline] + pub fn set_vps_timing_info_present_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 1u8, val as u64) + } + } + #[inline] + pub fn vps_poc_proportional_to_timing_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } + } + #[inline] + pub fn set_vps_poc_proportional_to_timing_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(3usize, 1u8, val as u64) + } + } + #[inline] + pub fn new_bitfield_1( + vps_temporal_id_nesting_flag: u32, + vps_sub_layer_ordering_info_present_flag: u32, + vps_timing_info_present_flag: u32, + vps_poc_proportional_to_timing_flag: u32, + ) -> __BindgenBitfieldUnit<[u8; 1usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let vps_temporal_id_nesting_flag: u32 = + unsafe { ::std::mem::transmute(vps_temporal_id_nesting_flag) }; + vps_temporal_id_nesting_flag as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let vps_sub_layer_ordering_info_present_flag: u32 = + unsafe { ::std::mem::transmute(vps_sub_layer_ordering_info_present_flag) }; + vps_sub_layer_ordering_info_present_flag as u64 + }); + __bindgen_bitfield_unit.set(2usize, 1u8, { + let vps_timing_info_present_flag: u32 = + unsafe { ::std::mem::transmute(vps_timing_info_present_flag) }; + vps_timing_info_present_flag as u64 + }); + __bindgen_bitfield_unit.set(3usize, 1u8, { + let vps_poc_proportional_to_timing_flag: u32 = + unsafe { ::std::mem::transmute(vps_poc_proportional_to_timing_flag) }; + vps_poc_proportional_to_timing_flag as u64 + }); + __bindgen_bitfield_unit + } +} +#[repr(C)] +#[repr(align(4))] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoH265ProfileTierLevelFlags { + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, + pub __bindgen_padding_0: [u8; 3usize], +} +#[test] +fn bindgen_test_layout_StdVideoH265ProfileTierLevelFlags() { + assert_eq!( + ::std::mem::size_of::(), + 4usize, + concat!("Size of: ", stringify!(StdVideoH265ProfileTierLevelFlags)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(StdVideoH265ProfileTierLevelFlags) + ) + ); +} +impl StdVideoH265ProfileTierLevelFlags { + #[inline] + pub fn general_tier_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_general_tier_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub fn general_progressive_source_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_general_progressive_source_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub fn general_interlaced_source_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } + } + #[inline] + pub fn set_general_interlaced_source_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 1u8, val as u64) + } + } + #[inline] + pub fn general_non_packed_constraint_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } + } + #[inline] + pub fn set_general_non_packed_constraint_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(3usize, 1u8, val as u64) + } + } + #[inline] + pub fn general_frame_only_constraint_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } + } + #[inline] + pub fn set_general_frame_only_constraint_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(4usize, 1u8, val as u64) + } + } + #[inline] + pub fn new_bitfield_1( + general_tier_flag: u32, + general_progressive_source_flag: u32, + general_interlaced_source_flag: u32, + general_non_packed_constraint_flag: u32, + general_frame_only_constraint_flag: u32, + ) -> __BindgenBitfieldUnit<[u8; 1usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let general_tier_flag: u32 = unsafe { ::std::mem::transmute(general_tier_flag) }; + general_tier_flag as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let general_progressive_source_flag: u32 = + unsafe { ::std::mem::transmute(general_progressive_source_flag) }; + general_progressive_source_flag as u64 + }); + __bindgen_bitfield_unit.set(2usize, 1u8, { + let general_interlaced_source_flag: u32 = + unsafe { ::std::mem::transmute(general_interlaced_source_flag) }; + general_interlaced_source_flag as u64 + }); + __bindgen_bitfield_unit.set(3usize, 1u8, { + let general_non_packed_constraint_flag: u32 = + unsafe { ::std::mem::transmute(general_non_packed_constraint_flag) }; + general_non_packed_constraint_flag as u64 + }); + __bindgen_bitfield_unit.set(4usize, 1u8, { + let general_frame_only_constraint_flag: u32 = + unsafe { ::std::mem::transmute(general_frame_only_constraint_flag) }; + general_frame_only_constraint_flag as u64 + }); + __bindgen_bitfield_unit + } +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoH265ProfileTierLevel { + pub flags: StdVideoH265ProfileTierLevelFlags, + pub general_profile_idc: StdVideoH265ProfileIdc, + pub general_level_idc: StdVideoH265LevelIdc, +} +#[test] +fn bindgen_test_layout_StdVideoH265ProfileTierLevel() { + const UNINIT: ::std::mem::MaybeUninit = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::(), + 12usize, + concat!("Size of: ", stringify!(StdVideoH265ProfileTierLevel)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!("Alignment of ", stringify!(StdVideoH265ProfileTierLevel)) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265ProfileTierLevel), + "::", + stringify!(flags) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).general_profile_idc) as usize - ptr as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265ProfileTierLevel), + "::", + stringify!(general_profile_idc) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).general_level_idc) as usize - ptr as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265ProfileTierLevel), + "::", + stringify!(general_level_idc) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoH265VideoParameterSet { + pub flags: StdVideoH265VpsFlags, + pub vps_video_parameter_set_id: u8, + pub vps_max_sub_layers_minus1: u8, + pub reserved1: u8, + pub reserved2: u8, + pub vps_num_units_in_tick: u32, + pub vps_time_scale: u32, + pub vps_num_ticks_poc_diff_one_minus1: u32, + pub reserved3: u32, + pub pDecPicBufMgr: *const StdVideoH265DecPicBufMgr, + pub pHrdParameters: *const StdVideoH265HrdParameters, + pub pProfileTierLevel: *const StdVideoH265ProfileTierLevel, +} +#[test] +fn bindgen_test_layout_StdVideoH265VideoParameterSet() { + const UNINIT: ::std::mem::MaybeUninit = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::(), + 48usize, + concat!("Size of: ", stringify!(StdVideoH265VideoParameterSet)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(StdVideoH265VideoParameterSet)) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265VideoParameterSet), + "::", + stringify!(flags) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).vps_video_parameter_set_id) as usize - ptr as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265VideoParameterSet), + "::", + stringify!(vps_video_parameter_set_id) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).vps_max_sub_layers_minus1) as usize - ptr as usize }, + 5usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265VideoParameterSet), + "::", + stringify!(vps_max_sub_layers_minus1) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).reserved1) as usize - ptr as usize }, + 6usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265VideoParameterSet), + "::", + stringify!(reserved1) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).reserved2) as usize - ptr as usize }, + 7usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265VideoParameterSet), + "::", + stringify!(reserved2) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).vps_num_units_in_tick) as usize - ptr as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265VideoParameterSet), + "::", + stringify!(vps_num_units_in_tick) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).vps_time_scale) as usize - ptr as usize }, + 12usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265VideoParameterSet), + "::", + stringify!(vps_time_scale) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).vps_num_ticks_poc_diff_one_minus1) as usize - ptr as usize + }, + 16usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265VideoParameterSet), + "::", + stringify!(vps_num_ticks_poc_diff_one_minus1) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).reserved3) as usize - ptr as usize }, + 20usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265VideoParameterSet), + "::", + stringify!(reserved3) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pDecPicBufMgr) as usize - ptr as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265VideoParameterSet), + "::", + stringify!(pDecPicBufMgr) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pHrdParameters) as usize - ptr as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265VideoParameterSet), + "::", + stringify!(pHrdParameters) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pProfileTierLevel) as usize - ptr as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265VideoParameterSet), + "::", + stringify!(pProfileTierLevel) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoH265ScalingLists { + pub ScalingList4x4: [[u8; 16usize]; 6usize], + pub ScalingList8x8: [[u8; 64usize]; 6usize], + pub ScalingList16x16: [[u8; 64usize]; 6usize], + pub ScalingList32x32: [[u8; 64usize]; 2usize], + pub ScalingListDCCoef16x16: [u8; 6usize], + pub ScalingListDCCoef32x32: [u8; 2usize], +} +#[test] +fn bindgen_test_layout_StdVideoH265ScalingLists() { + const UNINIT: ::std::mem::MaybeUninit = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::(), + 1000usize, + concat!("Size of: ", stringify!(StdVideoH265ScalingLists)) + ); + assert_eq!( + ::std::mem::align_of::(), + 1usize, + concat!("Alignment of ", stringify!(StdVideoH265ScalingLists)) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).ScalingList4x4) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265ScalingLists), + "::", + stringify!(ScalingList4x4) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).ScalingList8x8) as usize - ptr as usize }, + 96usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265ScalingLists), + "::", + stringify!(ScalingList8x8) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).ScalingList16x16) as usize - ptr as usize }, + 480usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265ScalingLists), + "::", + stringify!(ScalingList16x16) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).ScalingList32x32) as usize - ptr as usize }, + 864usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265ScalingLists), + "::", + stringify!(ScalingList32x32) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).ScalingListDCCoef16x16) as usize - ptr as usize }, + 992usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265ScalingLists), + "::", + stringify!(ScalingListDCCoef16x16) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).ScalingListDCCoef32x32) as usize - ptr as usize }, + 998usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265ScalingLists), + "::", + stringify!(ScalingListDCCoef32x32) + ) + ); +} +#[repr(C)] +#[repr(align(4))] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoH265SpsVuiFlags { + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 3usize]>, + pub __bindgen_padding_0: u8, +} +#[test] +fn bindgen_test_layout_StdVideoH265SpsVuiFlags() { + assert_eq!( + ::std::mem::size_of::(), + 4usize, + concat!("Size of: ", stringify!(StdVideoH265SpsVuiFlags)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!("Alignment of ", stringify!(StdVideoH265SpsVuiFlags)) + ); +} +impl StdVideoH265SpsVuiFlags { + #[inline] + pub fn aspect_ratio_info_present_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_aspect_ratio_info_present_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub fn overscan_info_present_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_overscan_info_present_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub fn overscan_appropriate_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } + } + #[inline] + pub fn set_overscan_appropriate_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 1u8, val as u64) + } + } + #[inline] + pub fn video_signal_type_present_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } + } + #[inline] + pub fn set_video_signal_type_present_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(3usize, 1u8, val as u64) + } + } + #[inline] + pub fn video_full_range_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } + } + #[inline] + pub fn set_video_full_range_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(4usize, 1u8, val as u64) + } + } + #[inline] + pub fn colour_description_present_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) } + } + #[inline] + pub fn set_colour_description_present_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(5usize, 1u8, val as u64) + } + } + #[inline] + pub fn chroma_loc_info_present_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) } + } + #[inline] + pub fn set_chroma_loc_info_present_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(6usize, 1u8, val as u64) + } + } + #[inline] + pub fn neutral_chroma_indication_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) } + } + #[inline] + pub fn set_neutral_chroma_indication_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(7usize, 1u8, val as u64) + } + } + #[inline] + pub fn field_seq_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u32) } + } + #[inline] + pub fn set_field_seq_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(8usize, 1u8, val as u64) + } + } + #[inline] + pub fn frame_field_info_present_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 1u8) as u32) } + } + #[inline] + pub fn set_frame_field_info_present_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(9usize, 1u8, val as u64) + } + } + #[inline] + pub fn default_display_window_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 1u8) as u32) } + } + #[inline] + pub fn set_default_display_window_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(10usize, 1u8, val as u64) + } + } + #[inline] + pub fn vui_timing_info_present_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u32) } + } + #[inline] + pub fn set_vui_timing_info_present_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(11usize, 1u8, val as u64) + } + } + #[inline] + pub fn vui_poc_proportional_to_timing_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u32) } + } + #[inline] + pub fn set_vui_poc_proportional_to_timing_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(12usize, 1u8, val as u64) + } + } + #[inline] + pub fn vui_hrd_parameters_present_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u32) } + } + #[inline] + pub fn set_vui_hrd_parameters_present_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(13usize, 1u8, val as u64) + } + } + #[inline] + pub fn bitstream_restriction_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 1u8) as u32) } + } + #[inline] + pub fn set_bitstream_restriction_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(14usize, 1u8, val as u64) + } + } + #[inline] + pub fn tiles_fixed_structure_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(15usize, 1u8) as u32) } + } + #[inline] + pub fn set_tiles_fixed_structure_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(15usize, 1u8, val as u64) + } + } + #[inline] + pub fn motion_vectors_over_pic_boundaries_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 1u8) as u32) } + } + #[inline] + pub fn set_motion_vectors_over_pic_boundaries_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(16usize, 1u8, val as u64) + } + } + #[inline] + pub fn restricted_ref_pic_lists_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(17usize, 1u8) as u32) } + } + #[inline] + pub fn set_restricted_ref_pic_lists_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(17usize, 1u8, val as u64) + } + } + #[inline] + pub fn new_bitfield_1( + aspect_ratio_info_present_flag: u32, + overscan_info_present_flag: u32, + overscan_appropriate_flag: u32, + video_signal_type_present_flag: u32, + video_full_range_flag: u32, + colour_description_present_flag: u32, + chroma_loc_info_present_flag: u32, + neutral_chroma_indication_flag: u32, + field_seq_flag: u32, + frame_field_info_present_flag: u32, + default_display_window_flag: u32, + vui_timing_info_present_flag: u32, + vui_poc_proportional_to_timing_flag: u32, + vui_hrd_parameters_present_flag: u32, + bitstream_restriction_flag: u32, + tiles_fixed_structure_flag: u32, + motion_vectors_over_pic_boundaries_flag: u32, + restricted_ref_pic_lists_flag: u32, + ) -> __BindgenBitfieldUnit<[u8; 3usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 3usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let aspect_ratio_info_present_flag: u32 = + unsafe { ::std::mem::transmute(aspect_ratio_info_present_flag) }; + aspect_ratio_info_present_flag as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let overscan_info_present_flag: u32 = + unsafe { ::std::mem::transmute(overscan_info_present_flag) }; + overscan_info_present_flag as u64 + }); + __bindgen_bitfield_unit.set(2usize, 1u8, { + let overscan_appropriate_flag: u32 = + unsafe { ::std::mem::transmute(overscan_appropriate_flag) }; + overscan_appropriate_flag as u64 + }); + __bindgen_bitfield_unit.set(3usize, 1u8, { + let video_signal_type_present_flag: u32 = + unsafe { ::std::mem::transmute(video_signal_type_present_flag) }; + video_signal_type_present_flag as u64 + }); + __bindgen_bitfield_unit.set(4usize, 1u8, { + let video_full_range_flag: u32 = + unsafe { ::std::mem::transmute(video_full_range_flag) }; + video_full_range_flag as u64 + }); + __bindgen_bitfield_unit.set(5usize, 1u8, { + let colour_description_present_flag: u32 = + unsafe { ::std::mem::transmute(colour_description_present_flag) }; + colour_description_present_flag as u64 + }); + __bindgen_bitfield_unit.set(6usize, 1u8, { + let chroma_loc_info_present_flag: u32 = + unsafe { ::std::mem::transmute(chroma_loc_info_present_flag) }; + chroma_loc_info_present_flag as u64 + }); + __bindgen_bitfield_unit.set(7usize, 1u8, { + let neutral_chroma_indication_flag: u32 = + unsafe { ::std::mem::transmute(neutral_chroma_indication_flag) }; + neutral_chroma_indication_flag as u64 + }); + __bindgen_bitfield_unit.set(8usize, 1u8, { + let field_seq_flag: u32 = unsafe { ::std::mem::transmute(field_seq_flag) }; + field_seq_flag as u64 + }); + __bindgen_bitfield_unit.set(9usize, 1u8, { + let frame_field_info_present_flag: u32 = + unsafe { ::std::mem::transmute(frame_field_info_present_flag) }; + frame_field_info_present_flag as u64 + }); + __bindgen_bitfield_unit.set(10usize, 1u8, { + let default_display_window_flag: u32 = + unsafe { ::std::mem::transmute(default_display_window_flag) }; + default_display_window_flag as u64 + }); + __bindgen_bitfield_unit.set(11usize, 1u8, { + let vui_timing_info_present_flag: u32 = + unsafe { ::std::mem::transmute(vui_timing_info_present_flag) }; + vui_timing_info_present_flag as u64 + }); + __bindgen_bitfield_unit.set(12usize, 1u8, { + let vui_poc_proportional_to_timing_flag: u32 = + unsafe { ::std::mem::transmute(vui_poc_proportional_to_timing_flag) }; + vui_poc_proportional_to_timing_flag as u64 + }); + __bindgen_bitfield_unit.set(13usize, 1u8, { + let vui_hrd_parameters_present_flag: u32 = + unsafe { ::std::mem::transmute(vui_hrd_parameters_present_flag) }; + vui_hrd_parameters_present_flag as u64 + }); + __bindgen_bitfield_unit.set(14usize, 1u8, { + let bitstream_restriction_flag: u32 = + unsafe { ::std::mem::transmute(bitstream_restriction_flag) }; + bitstream_restriction_flag as u64 + }); + __bindgen_bitfield_unit.set(15usize, 1u8, { + let tiles_fixed_structure_flag: u32 = + unsafe { ::std::mem::transmute(tiles_fixed_structure_flag) }; + tiles_fixed_structure_flag as u64 + }); + __bindgen_bitfield_unit.set(16usize, 1u8, { + let motion_vectors_over_pic_boundaries_flag: u32 = + unsafe { ::std::mem::transmute(motion_vectors_over_pic_boundaries_flag) }; + motion_vectors_over_pic_boundaries_flag as u64 + }); + __bindgen_bitfield_unit.set(17usize, 1u8, { + let restricted_ref_pic_lists_flag: u32 = + unsafe { ::std::mem::transmute(restricted_ref_pic_lists_flag) }; + restricted_ref_pic_lists_flag as u64 + }); + __bindgen_bitfield_unit + } +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoH265SequenceParameterSetVui { + pub flags: StdVideoH265SpsVuiFlags, + pub aspect_ratio_idc: StdVideoH265AspectRatioIdc, + pub sar_width: u16, + pub sar_height: u16, + pub video_format: u8, + pub colour_primaries: u8, + pub transfer_characteristics: u8, + pub matrix_coeffs: u8, + pub chroma_sample_loc_type_top_field: u8, + pub chroma_sample_loc_type_bottom_field: u8, + pub reserved1: u8, + pub reserved2: u8, + pub def_disp_win_left_offset: u16, + pub def_disp_win_right_offset: u16, + pub def_disp_win_top_offset: u16, + pub def_disp_win_bottom_offset: u16, + pub vui_num_units_in_tick: u32, + pub vui_time_scale: u32, + pub vui_num_ticks_poc_diff_one_minus1: u32, + pub min_spatial_segmentation_idc: u16, + pub reserved3: u16, + pub max_bytes_per_pic_denom: u8, + pub max_bits_per_min_cu_denom: u8, + pub log2_max_mv_length_horizontal: u8, + pub log2_max_mv_length_vertical: u8, + pub pHrdParameters: *const StdVideoH265HrdParameters, +} +#[test] +fn bindgen_test_layout_StdVideoH265SequenceParameterSetVui() { + const UNINIT: ::std::mem::MaybeUninit = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::(), + 56usize, + concat!("Size of: ", stringify!(StdVideoH265SequenceParameterSetVui)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!( + "Alignment of ", + stringify!(StdVideoH265SequenceParameterSetVui) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSetVui), + "::", + stringify!(flags) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).aspect_ratio_idc) as usize - ptr as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSetVui), + "::", + stringify!(aspect_ratio_idc) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).sar_width) as usize - ptr as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSetVui), + "::", + stringify!(sar_width) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).sar_height) as usize - ptr as usize }, + 10usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSetVui), + "::", + stringify!(sar_height) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).video_format) as usize - ptr as usize }, + 12usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSetVui), + "::", + stringify!(video_format) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).colour_primaries) as usize - ptr as usize }, + 13usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSetVui), + "::", + stringify!(colour_primaries) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).transfer_characteristics) as usize - ptr as usize }, + 14usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSetVui), + "::", + stringify!(transfer_characteristics) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).matrix_coeffs) as usize - ptr as usize }, + 15usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSetVui), + "::", + stringify!(matrix_coeffs) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).chroma_sample_loc_type_top_field) as usize - ptr as usize + }, + 16usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSetVui), + "::", + stringify!(chroma_sample_loc_type_top_field) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).chroma_sample_loc_type_bottom_field) as usize - ptr as usize + }, + 17usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSetVui), + "::", + stringify!(chroma_sample_loc_type_bottom_field) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).reserved1) as usize - ptr as usize }, + 18usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSetVui), + "::", + stringify!(reserved1) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).reserved2) as usize - ptr as usize }, + 19usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSetVui), + "::", + stringify!(reserved2) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).def_disp_win_left_offset) as usize - ptr as usize }, + 20usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSetVui), + "::", + stringify!(def_disp_win_left_offset) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).def_disp_win_right_offset) as usize - ptr as usize }, + 22usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSetVui), + "::", + stringify!(def_disp_win_right_offset) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).def_disp_win_top_offset) as usize - ptr as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSetVui), + "::", + stringify!(def_disp_win_top_offset) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).def_disp_win_bottom_offset) as usize - ptr as usize }, + 26usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSetVui), + "::", + stringify!(def_disp_win_bottom_offset) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).vui_num_units_in_tick) as usize - ptr as usize }, + 28usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSetVui), + "::", + stringify!(vui_num_units_in_tick) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).vui_time_scale) as usize - ptr as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSetVui), + "::", + stringify!(vui_time_scale) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).vui_num_ticks_poc_diff_one_minus1) as usize - ptr as usize + }, + 36usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSetVui), + "::", + stringify!(vui_num_ticks_poc_diff_one_minus1) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).min_spatial_segmentation_idc) as usize - ptr as usize + }, + 40usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSetVui), + "::", + stringify!(min_spatial_segmentation_idc) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).reserved3) as usize - ptr as usize }, + 42usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSetVui), + "::", + stringify!(reserved3) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).max_bytes_per_pic_denom) as usize - ptr as usize }, + 44usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSetVui), + "::", + stringify!(max_bytes_per_pic_denom) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).max_bits_per_min_cu_denom) as usize - ptr as usize }, + 45usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSetVui), + "::", + stringify!(max_bits_per_min_cu_denom) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).log2_max_mv_length_horizontal) as usize - ptr as usize + }, + 46usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSetVui), + "::", + stringify!(log2_max_mv_length_horizontal) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).log2_max_mv_length_vertical) as usize - ptr as usize }, + 47usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSetVui), + "::", + stringify!(log2_max_mv_length_vertical) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pHrdParameters) as usize - ptr as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSetVui), + "::", + stringify!(pHrdParameters) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoH265PredictorPaletteEntries { + pub PredictorPaletteEntries: [[u16; 128usize]; 3usize], +} +#[test] +fn bindgen_test_layout_StdVideoH265PredictorPaletteEntries() { + const UNINIT: ::std::mem::MaybeUninit = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::(), + 768usize, + concat!("Size of: ", stringify!(StdVideoH265PredictorPaletteEntries)) + ); + assert_eq!( + ::std::mem::align_of::(), + 2usize, + concat!( + "Alignment of ", + stringify!(StdVideoH265PredictorPaletteEntries) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).PredictorPaletteEntries) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265PredictorPaletteEntries), + "::", + stringify!(PredictorPaletteEntries) + ) + ); +} +#[repr(C)] +#[repr(align(4))] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoH265SpsFlags { + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, +} +#[test] +fn bindgen_test_layout_StdVideoH265SpsFlags() { + assert_eq!( + ::std::mem::size_of::(), + 4usize, + concat!("Size of: ", stringify!(StdVideoH265SpsFlags)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!("Alignment of ", stringify!(StdVideoH265SpsFlags)) + ); +} +impl StdVideoH265SpsFlags { + #[inline] + pub fn sps_temporal_id_nesting_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_sps_temporal_id_nesting_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub fn separate_colour_plane_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_separate_colour_plane_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub fn conformance_window_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } + } + #[inline] + pub fn set_conformance_window_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 1u8, val as u64) + } + } + #[inline] + pub fn sps_sub_layer_ordering_info_present_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } + } + #[inline] + pub fn set_sps_sub_layer_ordering_info_present_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(3usize, 1u8, val as u64) + } + } + #[inline] + pub fn scaling_list_enabled_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } + } + #[inline] + pub fn set_scaling_list_enabled_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(4usize, 1u8, val as u64) + } + } + #[inline] + pub fn sps_scaling_list_data_present_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) } + } + #[inline] + pub fn set_sps_scaling_list_data_present_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(5usize, 1u8, val as u64) + } + } + #[inline] + pub fn amp_enabled_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) } + } + #[inline] + pub fn set_amp_enabled_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(6usize, 1u8, val as u64) + } + } + #[inline] + pub fn sample_adaptive_offset_enabled_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) } + } + #[inline] + pub fn set_sample_adaptive_offset_enabled_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(7usize, 1u8, val as u64) + } + } + #[inline] + pub fn pcm_enabled_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u32) } + } + #[inline] + pub fn set_pcm_enabled_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(8usize, 1u8, val as u64) + } + } + #[inline] + pub fn pcm_loop_filter_disabled_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 1u8) as u32) } + } + #[inline] + pub fn set_pcm_loop_filter_disabled_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(9usize, 1u8, val as u64) + } + } + #[inline] + pub fn long_term_ref_pics_present_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 1u8) as u32) } + } + #[inline] + pub fn set_long_term_ref_pics_present_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(10usize, 1u8, val as u64) + } + } + #[inline] + pub fn sps_temporal_mvp_enabled_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u32) } + } + #[inline] + pub fn set_sps_temporal_mvp_enabled_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(11usize, 1u8, val as u64) + } + } + #[inline] + pub fn strong_intra_smoothing_enabled_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u32) } + } + #[inline] + pub fn set_strong_intra_smoothing_enabled_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(12usize, 1u8, val as u64) + } + } + #[inline] + pub fn vui_parameters_present_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u32) } + } + #[inline] + pub fn set_vui_parameters_present_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(13usize, 1u8, val as u64) + } + } + #[inline] + pub fn sps_extension_present_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 1u8) as u32) } + } + #[inline] + pub fn set_sps_extension_present_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(14usize, 1u8, val as u64) + } + } + #[inline] + pub fn sps_range_extension_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(15usize, 1u8) as u32) } + } + #[inline] + pub fn set_sps_range_extension_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(15usize, 1u8, val as u64) + } + } + #[inline] + pub fn transform_skip_rotation_enabled_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 1u8) as u32) } + } + #[inline] + pub fn set_transform_skip_rotation_enabled_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(16usize, 1u8, val as u64) + } + } + #[inline] + pub fn transform_skip_context_enabled_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(17usize, 1u8) as u32) } + } + #[inline] + pub fn set_transform_skip_context_enabled_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(17usize, 1u8, val as u64) + } + } + #[inline] + pub fn implicit_rdpcm_enabled_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(18usize, 1u8) as u32) } + } + #[inline] + pub fn set_implicit_rdpcm_enabled_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(18usize, 1u8, val as u64) + } + } + #[inline] + pub fn explicit_rdpcm_enabled_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(19usize, 1u8) as u32) } + } + #[inline] + pub fn set_explicit_rdpcm_enabled_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(19usize, 1u8, val as u64) + } + } + #[inline] + pub fn extended_precision_processing_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(20usize, 1u8) as u32) } + } + #[inline] + pub fn set_extended_precision_processing_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(20usize, 1u8, val as u64) + } + } + #[inline] + pub fn intra_smoothing_disabled_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(21usize, 1u8) as u32) } + } + #[inline] + pub fn set_intra_smoothing_disabled_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(21usize, 1u8, val as u64) + } + } + #[inline] + pub fn high_precision_offsets_enabled_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(22usize, 1u8) as u32) } + } + #[inline] + pub fn set_high_precision_offsets_enabled_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(22usize, 1u8, val as u64) + } + } + #[inline] + pub fn persistent_rice_adaptation_enabled_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(23usize, 1u8) as u32) } + } + #[inline] + pub fn set_persistent_rice_adaptation_enabled_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(23usize, 1u8, val as u64) + } + } + #[inline] + pub fn cabac_bypass_alignment_enabled_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(24usize, 1u8) as u32) } + } + #[inline] + pub fn set_cabac_bypass_alignment_enabled_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(24usize, 1u8, val as u64) + } + } + #[inline] + pub fn sps_scc_extension_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(25usize, 1u8) as u32) } + } + #[inline] + pub fn set_sps_scc_extension_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(25usize, 1u8, val as u64) + } + } + #[inline] + pub fn sps_curr_pic_ref_enabled_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(26usize, 1u8) as u32) } + } + #[inline] + pub fn set_sps_curr_pic_ref_enabled_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(26usize, 1u8, val as u64) + } + } + #[inline] + pub fn palette_mode_enabled_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(27usize, 1u8) as u32) } + } + #[inline] + pub fn set_palette_mode_enabled_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(27usize, 1u8, val as u64) + } + } + #[inline] + pub fn sps_palette_predictor_initializers_present_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(28usize, 1u8) as u32) } + } + #[inline] + pub fn set_sps_palette_predictor_initializers_present_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(28usize, 1u8, val as u64) + } + } + #[inline] + pub fn intra_boundary_filtering_disabled_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(29usize, 1u8) as u32) } + } + #[inline] + pub fn set_intra_boundary_filtering_disabled_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(29usize, 1u8, val as u64) + } + } + #[inline] + pub fn new_bitfield_1( + sps_temporal_id_nesting_flag: u32, + separate_colour_plane_flag: u32, + conformance_window_flag: u32, + sps_sub_layer_ordering_info_present_flag: u32, + scaling_list_enabled_flag: u32, + sps_scaling_list_data_present_flag: u32, + amp_enabled_flag: u32, + sample_adaptive_offset_enabled_flag: u32, + pcm_enabled_flag: u32, + pcm_loop_filter_disabled_flag: u32, + long_term_ref_pics_present_flag: u32, + sps_temporal_mvp_enabled_flag: u32, + strong_intra_smoothing_enabled_flag: u32, + vui_parameters_present_flag: u32, + sps_extension_present_flag: u32, + sps_range_extension_flag: u32, + transform_skip_rotation_enabled_flag: u32, + transform_skip_context_enabled_flag: u32, + implicit_rdpcm_enabled_flag: u32, + explicit_rdpcm_enabled_flag: u32, + extended_precision_processing_flag: u32, + intra_smoothing_disabled_flag: u32, + high_precision_offsets_enabled_flag: u32, + persistent_rice_adaptation_enabled_flag: u32, + cabac_bypass_alignment_enabled_flag: u32, + sps_scc_extension_flag: u32, + sps_curr_pic_ref_enabled_flag: u32, + palette_mode_enabled_flag: u32, + sps_palette_predictor_initializers_present_flag: u32, + intra_boundary_filtering_disabled_flag: u32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let sps_temporal_id_nesting_flag: u32 = + unsafe { ::std::mem::transmute(sps_temporal_id_nesting_flag) }; + sps_temporal_id_nesting_flag as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let separate_colour_plane_flag: u32 = + unsafe { ::std::mem::transmute(separate_colour_plane_flag) }; + separate_colour_plane_flag as u64 + }); + __bindgen_bitfield_unit.set(2usize, 1u8, { + let conformance_window_flag: u32 = + unsafe { ::std::mem::transmute(conformance_window_flag) }; + conformance_window_flag as u64 + }); + __bindgen_bitfield_unit.set(3usize, 1u8, { + let sps_sub_layer_ordering_info_present_flag: u32 = + unsafe { ::std::mem::transmute(sps_sub_layer_ordering_info_present_flag) }; + sps_sub_layer_ordering_info_present_flag as u64 + }); + __bindgen_bitfield_unit.set(4usize, 1u8, { + let scaling_list_enabled_flag: u32 = + unsafe { ::std::mem::transmute(scaling_list_enabled_flag) }; + scaling_list_enabled_flag as u64 + }); + __bindgen_bitfield_unit.set(5usize, 1u8, { + let sps_scaling_list_data_present_flag: u32 = + unsafe { ::std::mem::transmute(sps_scaling_list_data_present_flag) }; + sps_scaling_list_data_present_flag as u64 + }); + __bindgen_bitfield_unit.set(6usize, 1u8, { + let amp_enabled_flag: u32 = unsafe { ::std::mem::transmute(amp_enabled_flag) }; + amp_enabled_flag as u64 + }); + __bindgen_bitfield_unit.set(7usize, 1u8, { + let sample_adaptive_offset_enabled_flag: u32 = + unsafe { ::std::mem::transmute(sample_adaptive_offset_enabled_flag) }; + sample_adaptive_offset_enabled_flag as u64 + }); + __bindgen_bitfield_unit.set(8usize, 1u8, { + let pcm_enabled_flag: u32 = unsafe { ::std::mem::transmute(pcm_enabled_flag) }; + pcm_enabled_flag as u64 + }); + __bindgen_bitfield_unit.set(9usize, 1u8, { + let pcm_loop_filter_disabled_flag: u32 = + unsafe { ::std::mem::transmute(pcm_loop_filter_disabled_flag) }; + pcm_loop_filter_disabled_flag as u64 + }); + __bindgen_bitfield_unit.set(10usize, 1u8, { + let long_term_ref_pics_present_flag: u32 = + unsafe { ::std::mem::transmute(long_term_ref_pics_present_flag) }; + long_term_ref_pics_present_flag as u64 + }); + __bindgen_bitfield_unit.set(11usize, 1u8, { + let sps_temporal_mvp_enabled_flag: u32 = + unsafe { ::std::mem::transmute(sps_temporal_mvp_enabled_flag) }; + sps_temporal_mvp_enabled_flag as u64 + }); + __bindgen_bitfield_unit.set(12usize, 1u8, { + let strong_intra_smoothing_enabled_flag: u32 = + unsafe { ::std::mem::transmute(strong_intra_smoothing_enabled_flag) }; + strong_intra_smoothing_enabled_flag as u64 + }); + __bindgen_bitfield_unit.set(13usize, 1u8, { + let vui_parameters_present_flag: u32 = + unsafe { ::std::mem::transmute(vui_parameters_present_flag) }; + vui_parameters_present_flag as u64 + }); + __bindgen_bitfield_unit.set(14usize, 1u8, { + let sps_extension_present_flag: u32 = + unsafe { ::std::mem::transmute(sps_extension_present_flag) }; + sps_extension_present_flag as u64 + }); + __bindgen_bitfield_unit.set(15usize, 1u8, { + let sps_range_extension_flag: u32 = + unsafe { ::std::mem::transmute(sps_range_extension_flag) }; + sps_range_extension_flag as u64 + }); + __bindgen_bitfield_unit.set(16usize, 1u8, { + let transform_skip_rotation_enabled_flag: u32 = + unsafe { ::std::mem::transmute(transform_skip_rotation_enabled_flag) }; + transform_skip_rotation_enabled_flag as u64 + }); + __bindgen_bitfield_unit.set(17usize, 1u8, { + let transform_skip_context_enabled_flag: u32 = + unsafe { ::std::mem::transmute(transform_skip_context_enabled_flag) }; + transform_skip_context_enabled_flag as u64 + }); + __bindgen_bitfield_unit.set(18usize, 1u8, { + let implicit_rdpcm_enabled_flag: u32 = + unsafe { ::std::mem::transmute(implicit_rdpcm_enabled_flag) }; + implicit_rdpcm_enabled_flag as u64 + }); + __bindgen_bitfield_unit.set(19usize, 1u8, { + let explicit_rdpcm_enabled_flag: u32 = + unsafe { ::std::mem::transmute(explicit_rdpcm_enabled_flag) }; + explicit_rdpcm_enabled_flag as u64 + }); + __bindgen_bitfield_unit.set(20usize, 1u8, { + let extended_precision_processing_flag: u32 = + unsafe { ::std::mem::transmute(extended_precision_processing_flag) }; + extended_precision_processing_flag as u64 + }); + __bindgen_bitfield_unit.set(21usize, 1u8, { + let intra_smoothing_disabled_flag: u32 = + unsafe { ::std::mem::transmute(intra_smoothing_disabled_flag) }; + intra_smoothing_disabled_flag as u64 + }); + __bindgen_bitfield_unit.set(22usize, 1u8, { + let high_precision_offsets_enabled_flag: u32 = + unsafe { ::std::mem::transmute(high_precision_offsets_enabled_flag) }; + high_precision_offsets_enabled_flag as u64 + }); + __bindgen_bitfield_unit.set(23usize, 1u8, { + let persistent_rice_adaptation_enabled_flag: u32 = + unsafe { ::std::mem::transmute(persistent_rice_adaptation_enabled_flag) }; + persistent_rice_adaptation_enabled_flag as u64 + }); + __bindgen_bitfield_unit.set(24usize, 1u8, { + let cabac_bypass_alignment_enabled_flag: u32 = + unsafe { ::std::mem::transmute(cabac_bypass_alignment_enabled_flag) }; + cabac_bypass_alignment_enabled_flag as u64 + }); + __bindgen_bitfield_unit.set(25usize, 1u8, { + let sps_scc_extension_flag: u32 = + unsafe { ::std::mem::transmute(sps_scc_extension_flag) }; + sps_scc_extension_flag as u64 + }); + __bindgen_bitfield_unit.set(26usize, 1u8, { + let sps_curr_pic_ref_enabled_flag: u32 = + unsafe { ::std::mem::transmute(sps_curr_pic_ref_enabled_flag) }; + sps_curr_pic_ref_enabled_flag as u64 + }); + __bindgen_bitfield_unit.set(27usize, 1u8, { + let palette_mode_enabled_flag: u32 = + unsafe { ::std::mem::transmute(palette_mode_enabled_flag) }; + palette_mode_enabled_flag as u64 + }); + __bindgen_bitfield_unit.set(28usize, 1u8, { + let sps_palette_predictor_initializers_present_flag: u32 = + unsafe { ::std::mem::transmute(sps_palette_predictor_initializers_present_flag) }; + sps_palette_predictor_initializers_present_flag as u64 + }); + __bindgen_bitfield_unit.set(29usize, 1u8, { + let intra_boundary_filtering_disabled_flag: u32 = + unsafe { ::std::mem::transmute(intra_boundary_filtering_disabled_flag) }; + intra_boundary_filtering_disabled_flag as u64 + }); + __bindgen_bitfield_unit + } +} +#[repr(C)] +#[repr(align(4))] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoH265ShortTermRefPicSetFlags { + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, + pub __bindgen_padding_0: [u8; 3usize], +} +#[test] +fn bindgen_test_layout_StdVideoH265ShortTermRefPicSetFlags() { + assert_eq!( + ::std::mem::size_of::(), + 4usize, + concat!("Size of: ", stringify!(StdVideoH265ShortTermRefPicSetFlags)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(StdVideoH265ShortTermRefPicSetFlags) + ) + ); +} +impl StdVideoH265ShortTermRefPicSetFlags { + #[inline] + pub fn inter_ref_pic_set_prediction_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_inter_ref_pic_set_prediction_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub fn delta_rps_sign(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_delta_rps_sign(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub fn new_bitfield_1( + inter_ref_pic_set_prediction_flag: u32, + delta_rps_sign: u32, + ) -> __BindgenBitfieldUnit<[u8; 1usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let inter_ref_pic_set_prediction_flag: u32 = + unsafe { ::std::mem::transmute(inter_ref_pic_set_prediction_flag) }; + inter_ref_pic_set_prediction_flag as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let delta_rps_sign: u32 = unsafe { ::std::mem::transmute(delta_rps_sign) }; + delta_rps_sign as u64 + }); + __bindgen_bitfield_unit + } +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoH265ShortTermRefPicSet { + pub flags: StdVideoH265ShortTermRefPicSetFlags, + pub delta_idx_minus1: u32, + pub use_delta_flag: u16, + pub abs_delta_rps_minus1: u16, + pub used_by_curr_pic_flag: u16, + pub used_by_curr_pic_s0_flag: u16, + pub used_by_curr_pic_s1_flag: u16, + pub reserved1: u16, + pub reserved2: u8, + pub reserved3: u8, + pub num_negative_pics: u8, + pub num_positive_pics: u8, + pub delta_poc_s0_minus1: [u16; 16usize], + pub delta_poc_s1_minus1: [u16; 16usize], +} +#[test] +fn bindgen_test_layout_StdVideoH265ShortTermRefPicSet() { + const UNINIT: ::std::mem::MaybeUninit = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::(), + 88usize, + concat!("Size of: ", stringify!(StdVideoH265ShortTermRefPicSet)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!("Alignment of ", stringify!(StdVideoH265ShortTermRefPicSet)) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265ShortTermRefPicSet), + "::", + stringify!(flags) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).delta_idx_minus1) as usize - ptr as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265ShortTermRefPicSet), + "::", + stringify!(delta_idx_minus1) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).use_delta_flag) as usize - ptr as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265ShortTermRefPicSet), + "::", + stringify!(use_delta_flag) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).abs_delta_rps_minus1) as usize - ptr as usize }, + 10usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265ShortTermRefPicSet), + "::", + stringify!(abs_delta_rps_minus1) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).used_by_curr_pic_flag) as usize - ptr as usize }, + 12usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265ShortTermRefPicSet), + "::", + stringify!(used_by_curr_pic_flag) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).used_by_curr_pic_s0_flag) as usize - ptr as usize }, + 14usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265ShortTermRefPicSet), + "::", + stringify!(used_by_curr_pic_s0_flag) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).used_by_curr_pic_s1_flag) as usize - ptr as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265ShortTermRefPicSet), + "::", + stringify!(used_by_curr_pic_s1_flag) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).reserved1) as usize - ptr as usize }, + 18usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265ShortTermRefPicSet), + "::", + stringify!(reserved1) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).reserved2) as usize - ptr as usize }, + 20usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265ShortTermRefPicSet), + "::", + stringify!(reserved2) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).reserved3) as usize - ptr as usize }, + 21usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265ShortTermRefPicSet), + "::", + stringify!(reserved3) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).num_negative_pics) as usize - ptr as usize }, + 22usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265ShortTermRefPicSet), + "::", + stringify!(num_negative_pics) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).num_positive_pics) as usize - ptr as usize }, + 23usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265ShortTermRefPicSet), + "::", + stringify!(num_positive_pics) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).delta_poc_s0_minus1) as usize - ptr as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265ShortTermRefPicSet), + "::", + stringify!(delta_poc_s0_minus1) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).delta_poc_s1_minus1) as usize - ptr as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265ShortTermRefPicSet), + "::", + stringify!(delta_poc_s1_minus1) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoH265LongTermRefPicsSps { + pub used_by_curr_pic_lt_sps_flag: u32, + pub lt_ref_pic_poc_lsb_sps: [u32; 32usize], +} +#[test] +fn bindgen_test_layout_StdVideoH265LongTermRefPicsSps() { + const UNINIT: ::std::mem::MaybeUninit = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::(), + 132usize, + concat!("Size of: ", stringify!(StdVideoH265LongTermRefPicsSps)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!("Alignment of ", stringify!(StdVideoH265LongTermRefPicsSps)) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).used_by_curr_pic_lt_sps_flag) as usize - ptr as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265LongTermRefPicsSps), + "::", + stringify!(used_by_curr_pic_lt_sps_flag) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).lt_ref_pic_poc_lsb_sps) as usize - ptr as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265LongTermRefPicsSps), + "::", + stringify!(lt_ref_pic_poc_lsb_sps) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoH265SequenceParameterSet { + pub flags: StdVideoH265SpsFlags, + pub chroma_format_idc: StdVideoH265ChromaFormatIdc, + pub pic_width_in_luma_samples: u32, + pub pic_height_in_luma_samples: u32, + pub sps_video_parameter_set_id: u8, + pub sps_max_sub_layers_minus1: u8, + pub sps_seq_parameter_set_id: u8, + pub bit_depth_luma_minus8: u8, + pub bit_depth_chroma_minus8: u8, + pub log2_max_pic_order_cnt_lsb_minus4: u8, + pub log2_min_luma_coding_block_size_minus3: u8, + pub log2_diff_max_min_luma_coding_block_size: u8, + pub log2_min_luma_transform_block_size_minus2: u8, + pub log2_diff_max_min_luma_transform_block_size: u8, + pub max_transform_hierarchy_depth_inter: u8, + pub max_transform_hierarchy_depth_intra: u8, + pub num_short_term_ref_pic_sets: u8, + pub num_long_term_ref_pics_sps: u8, + pub pcm_sample_bit_depth_luma_minus1: u8, + pub pcm_sample_bit_depth_chroma_minus1: u8, + pub log2_min_pcm_luma_coding_block_size_minus3: u8, + pub log2_diff_max_min_pcm_luma_coding_block_size: u8, + pub reserved1: u8, + pub reserved2: u8, + pub palette_max_size: u8, + pub delta_palette_max_predictor_size: u8, + pub motion_vector_resolution_control_idc: u8, + pub sps_num_palette_predictor_initializers_minus1: u8, + pub conf_win_left_offset: u32, + pub conf_win_right_offset: u32, + pub conf_win_top_offset: u32, + pub conf_win_bottom_offset: u32, + pub pProfileTierLevel: *const StdVideoH265ProfileTierLevel, + pub pDecPicBufMgr: *const StdVideoH265DecPicBufMgr, + pub pScalingLists: *const StdVideoH265ScalingLists, + pub pShortTermRefPicSet: *const StdVideoH265ShortTermRefPicSet, + pub pLongTermRefPicsSps: *const StdVideoH265LongTermRefPicsSps, + pub pSequenceParameterSetVui: *const StdVideoH265SequenceParameterSetVui, + pub pPredictorPaletteEntries: *const StdVideoH265PredictorPaletteEntries, +} +#[test] +fn bindgen_test_layout_StdVideoH265SequenceParameterSet() { + const UNINIT: ::std::mem::MaybeUninit = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::(), + 112usize, + concat!("Size of: ", stringify!(StdVideoH265SequenceParameterSet)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!( + "Alignment of ", + stringify!(StdVideoH265SequenceParameterSet) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSet), + "::", + stringify!(flags) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).chroma_format_idc) as usize - ptr as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSet), + "::", + stringify!(chroma_format_idc) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pic_width_in_luma_samples) as usize - ptr as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSet), + "::", + stringify!(pic_width_in_luma_samples) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pic_height_in_luma_samples) as usize - ptr as usize }, + 12usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSet), + "::", + stringify!(pic_height_in_luma_samples) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).sps_video_parameter_set_id) as usize - ptr as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSet), + "::", + stringify!(sps_video_parameter_set_id) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).sps_max_sub_layers_minus1) as usize - ptr as usize }, + 17usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSet), + "::", + stringify!(sps_max_sub_layers_minus1) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).sps_seq_parameter_set_id) as usize - ptr as usize }, + 18usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSet), + "::", + stringify!(sps_seq_parameter_set_id) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).bit_depth_luma_minus8) as usize - ptr as usize }, + 19usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSet), + "::", + stringify!(bit_depth_luma_minus8) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).bit_depth_chroma_minus8) as usize - ptr as usize }, + 20usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSet), + "::", + stringify!(bit_depth_chroma_minus8) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).log2_max_pic_order_cnt_lsb_minus4) as usize - ptr as usize + }, + 21usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSet), + "::", + stringify!(log2_max_pic_order_cnt_lsb_minus4) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).log2_min_luma_coding_block_size_minus3) as usize + - ptr as usize + }, + 22usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSet), + "::", + stringify!(log2_min_luma_coding_block_size_minus3) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).log2_diff_max_min_luma_coding_block_size) as usize + - ptr as usize + }, + 23usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSet), + "::", + stringify!(log2_diff_max_min_luma_coding_block_size) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).log2_min_luma_transform_block_size_minus2) as usize + - ptr as usize + }, + 24usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSet), + "::", + stringify!(log2_min_luma_transform_block_size_minus2) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).log2_diff_max_min_luma_transform_block_size) as usize + - ptr as usize + }, + 25usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSet), + "::", + stringify!(log2_diff_max_min_luma_transform_block_size) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).max_transform_hierarchy_depth_inter) as usize - ptr as usize + }, + 26usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSet), + "::", + stringify!(max_transform_hierarchy_depth_inter) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).max_transform_hierarchy_depth_intra) as usize - ptr as usize + }, + 27usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSet), + "::", + stringify!(max_transform_hierarchy_depth_intra) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).num_short_term_ref_pic_sets) as usize - ptr as usize }, + 28usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSet), + "::", + stringify!(num_short_term_ref_pic_sets) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).num_long_term_ref_pics_sps) as usize - ptr as usize }, + 29usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSet), + "::", + stringify!(num_long_term_ref_pics_sps) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).pcm_sample_bit_depth_luma_minus1) as usize - ptr as usize + }, + 30usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSet), + "::", + stringify!(pcm_sample_bit_depth_luma_minus1) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).pcm_sample_bit_depth_chroma_minus1) as usize - ptr as usize + }, + 31usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSet), + "::", + stringify!(pcm_sample_bit_depth_chroma_minus1) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).log2_min_pcm_luma_coding_block_size_minus3) as usize + - ptr as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSet), + "::", + stringify!(log2_min_pcm_luma_coding_block_size_minus3) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).log2_diff_max_min_pcm_luma_coding_block_size) as usize + - ptr as usize + }, + 33usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSet), + "::", + stringify!(log2_diff_max_min_pcm_luma_coding_block_size) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).reserved1) as usize - ptr as usize }, + 34usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSet), + "::", + stringify!(reserved1) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).reserved2) as usize - ptr as usize }, + 35usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSet), + "::", + stringify!(reserved2) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).palette_max_size) as usize - ptr as usize }, + 36usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSet), + "::", + stringify!(palette_max_size) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).delta_palette_max_predictor_size) as usize - ptr as usize + }, + 37usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSet), + "::", + stringify!(delta_palette_max_predictor_size) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).motion_vector_resolution_control_idc) as usize + - ptr as usize + }, + 38usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSet), + "::", + stringify!(motion_vector_resolution_control_idc) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).sps_num_palette_predictor_initializers_minus1) as usize + - ptr as usize + }, + 39usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSet), + "::", + stringify!(sps_num_palette_predictor_initializers_minus1) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).conf_win_left_offset) as usize - ptr as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSet), + "::", + stringify!(conf_win_left_offset) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).conf_win_right_offset) as usize - ptr as usize }, + 44usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSet), + "::", + stringify!(conf_win_right_offset) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).conf_win_top_offset) as usize - ptr as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSet), + "::", + stringify!(conf_win_top_offset) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).conf_win_bottom_offset) as usize - ptr as usize }, + 52usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSet), + "::", + stringify!(conf_win_bottom_offset) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pProfileTierLevel) as usize - ptr as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSet), + "::", + stringify!(pProfileTierLevel) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pDecPicBufMgr) as usize - ptr as usize }, + 64usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSet), + "::", + stringify!(pDecPicBufMgr) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pScalingLists) as usize - ptr as usize }, + 72usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSet), + "::", + stringify!(pScalingLists) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pShortTermRefPicSet) as usize - ptr as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSet), + "::", + stringify!(pShortTermRefPicSet) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pLongTermRefPicsSps) as usize - ptr as usize }, + 88usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSet), + "::", + stringify!(pLongTermRefPicsSps) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pSequenceParameterSetVui) as usize - ptr as usize }, + 96usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSet), + "::", + stringify!(pSequenceParameterSetVui) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pPredictorPaletteEntries) as usize - ptr as usize }, + 104usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSet), + "::", + stringify!(pPredictorPaletteEntries) + ) + ); +} +#[repr(C)] +#[repr(align(4))] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoH265PpsFlags { + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>, +} +#[test] +fn bindgen_test_layout_StdVideoH265PpsFlags() { + assert_eq!( + ::std::mem::size_of::(), + 4usize, + concat!("Size of: ", stringify!(StdVideoH265PpsFlags)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!("Alignment of ", stringify!(StdVideoH265PpsFlags)) + ); +} +impl StdVideoH265PpsFlags { + #[inline] + pub fn dependent_slice_segments_enabled_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_dependent_slice_segments_enabled_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub fn output_flag_present_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_output_flag_present_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub fn sign_data_hiding_enabled_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } + } + #[inline] + pub fn set_sign_data_hiding_enabled_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 1u8, val as u64) + } + } + #[inline] + pub fn cabac_init_present_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } + } + #[inline] + pub fn set_cabac_init_present_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(3usize, 1u8, val as u64) + } + } + #[inline] + pub fn constrained_intra_pred_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } + } + #[inline] + pub fn set_constrained_intra_pred_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(4usize, 1u8, val as u64) + } + } + #[inline] + pub fn transform_skip_enabled_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) } + } + #[inline] + pub fn set_transform_skip_enabled_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(5usize, 1u8, val as u64) + } + } + #[inline] + pub fn cu_qp_delta_enabled_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) } + } + #[inline] + pub fn set_cu_qp_delta_enabled_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(6usize, 1u8, val as u64) + } + } + #[inline] + pub fn pps_slice_chroma_qp_offsets_present_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) } + } + #[inline] + pub fn set_pps_slice_chroma_qp_offsets_present_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(7usize, 1u8, val as u64) + } + } + #[inline] + pub fn weighted_pred_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u32) } + } + #[inline] + pub fn set_weighted_pred_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(8usize, 1u8, val as u64) + } + } + #[inline] + pub fn weighted_bipred_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 1u8) as u32) } + } + #[inline] + pub fn set_weighted_bipred_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(9usize, 1u8, val as u64) + } + } + #[inline] + pub fn transquant_bypass_enabled_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 1u8) as u32) } + } + #[inline] + pub fn set_transquant_bypass_enabled_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(10usize, 1u8, val as u64) + } + } + #[inline] + pub fn tiles_enabled_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u32) } + } + #[inline] + pub fn set_tiles_enabled_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(11usize, 1u8, val as u64) + } + } + #[inline] + pub fn entropy_coding_sync_enabled_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u32) } + } + #[inline] + pub fn set_entropy_coding_sync_enabled_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(12usize, 1u8, val as u64) + } + } + #[inline] + pub fn uniform_spacing_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u32) } + } + #[inline] + pub fn set_uniform_spacing_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(13usize, 1u8, val as u64) + } + } + #[inline] + pub fn loop_filter_across_tiles_enabled_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 1u8) as u32) } + } + #[inline] + pub fn set_loop_filter_across_tiles_enabled_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(14usize, 1u8, val as u64) + } + } + #[inline] + pub fn pps_loop_filter_across_slices_enabled_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(15usize, 1u8) as u32) } + } + #[inline] + pub fn set_pps_loop_filter_across_slices_enabled_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(15usize, 1u8, val as u64) + } + } + #[inline] + pub fn deblocking_filter_control_present_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 1u8) as u32) } + } + #[inline] + pub fn set_deblocking_filter_control_present_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(16usize, 1u8, val as u64) + } + } + #[inline] + pub fn deblocking_filter_override_enabled_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(17usize, 1u8) as u32) } + } + #[inline] + pub fn set_deblocking_filter_override_enabled_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(17usize, 1u8, val as u64) + } + } + #[inline] + pub fn pps_deblocking_filter_disabled_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(18usize, 1u8) as u32) } + } + #[inline] + pub fn set_pps_deblocking_filter_disabled_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(18usize, 1u8, val as u64) + } + } + #[inline] + pub fn pps_scaling_list_data_present_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(19usize, 1u8) as u32) } + } + #[inline] + pub fn set_pps_scaling_list_data_present_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(19usize, 1u8, val as u64) + } + } + #[inline] + pub fn lists_modification_present_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(20usize, 1u8) as u32) } + } + #[inline] + pub fn set_lists_modification_present_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(20usize, 1u8, val as u64) + } + } + #[inline] + pub fn slice_segment_header_extension_present_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(21usize, 1u8) as u32) } + } + #[inline] + pub fn set_slice_segment_header_extension_present_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(21usize, 1u8, val as u64) + } + } + #[inline] + pub fn pps_extension_present_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(22usize, 1u8) as u32) } + } + #[inline] + pub fn set_pps_extension_present_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(22usize, 1u8, val as u64) + } + } + #[inline] + pub fn cross_component_prediction_enabled_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(23usize, 1u8) as u32) } + } + #[inline] + pub fn set_cross_component_prediction_enabled_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(23usize, 1u8, val as u64) + } + } + #[inline] + pub fn chroma_qp_offset_list_enabled_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(24usize, 1u8) as u32) } + } + #[inline] + pub fn set_chroma_qp_offset_list_enabled_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(24usize, 1u8, val as u64) + } + } + #[inline] + pub fn pps_curr_pic_ref_enabled_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(25usize, 1u8) as u32) } + } + #[inline] + pub fn set_pps_curr_pic_ref_enabled_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(25usize, 1u8, val as u64) + } + } + #[inline] + pub fn residual_adaptive_colour_transform_enabled_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(26usize, 1u8) as u32) } + } + #[inline] + pub fn set_residual_adaptive_colour_transform_enabled_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(26usize, 1u8, val as u64) + } + } + #[inline] + pub fn pps_slice_act_qp_offsets_present_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(27usize, 1u8) as u32) } + } + #[inline] + pub fn set_pps_slice_act_qp_offsets_present_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(27usize, 1u8, val as u64) + } + } + #[inline] + pub fn pps_palette_predictor_initializers_present_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(28usize, 1u8) as u32) } + } + #[inline] + pub fn set_pps_palette_predictor_initializers_present_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(28usize, 1u8, val as u64) + } + } + #[inline] + pub fn monochrome_palette_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(29usize, 1u8) as u32) } + } + #[inline] + pub fn set_monochrome_palette_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(29usize, 1u8, val as u64) + } + } + #[inline] + pub fn pps_range_extension_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(30usize, 1u8) as u32) } + } + #[inline] + pub fn set_pps_range_extension_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(30usize, 1u8, val as u64) + } + } + #[inline] + pub fn new_bitfield_1( + dependent_slice_segments_enabled_flag: u32, + output_flag_present_flag: u32, + sign_data_hiding_enabled_flag: u32, + cabac_init_present_flag: u32, + constrained_intra_pred_flag: u32, + transform_skip_enabled_flag: u32, + cu_qp_delta_enabled_flag: u32, + pps_slice_chroma_qp_offsets_present_flag: u32, + weighted_pred_flag: u32, + weighted_bipred_flag: u32, + transquant_bypass_enabled_flag: u32, + tiles_enabled_flag: u32, + entropy_coding_sync_enabled_flag: u32, + uniform_spacing_flag: u32, + loop_filter_across_tiles_enabled_flag: u32, + pps_loop_filter_across_slices_enabled_flag: u32, + deblocking_filter_control_present_flag: u32, + deblocking_filter_override_enabled_flag: u32, + pps_deblocking_filter_disabled_flag: u32, + pps_scaling_list_data_present_flag: u32, + lists_modification_present_flag: u32, + slice_segment_header_extension_present_flag: u32, + pps_extension_present_flag: u32, + cross_component_prediction_enabled_flag: u32, + chroma_qp_offset_list_enabled_flag: u32, + pps_curr_pic_ref_enabled_flag: u32, + residual_adaptive_colour_transform_enabled_flag: u32, + pps_slice_act_qp_offsets_present_flag: u32, + pps_palette_predictor_initializers_present_flag: u32, + monochrome_palette_flag: u32, + pps_range_extension_flag: u32, + ) -> __BindgenBitfieldUnit<[u8; 4usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let dependent_slice_segments_enabled_flag: u32 = + unsafe { ::std::mem::transmute(dependent_slice_segments_enabled_flag) }; + dependent_slice_segments_enabled_flag as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let output_flag_present_flag: u32 = + unsafe { ::std::mem::transmute(output_flag_present_flag) }; + output_flag_present_flag as u64 + }); + __bindgen_bitfield_unit.set(2usize, 1u8, { + let sign_data_hiding_enabled_flag: u32 = + unsafe { ::std::mem::transmute(sign_data_hiding_enabled_flag) }; + sign_data_hiding_enabled_flag as u64 + }); + __bindgen_bitfield_unit.set(3usize, 1u8, { + let cabac_init_present_flag: u32 = + unsafe { ::std::mem::transmute(cabac_init_present_flag) }; + cabac_init_present_flag as u64 + }); + __bindgen_bitfield_unit.set(4usize, 1u8, { + let constrained_intra_pred_flag: u32 = + unsafe { ::std::mem::transmute(constrained_intra_pred_flag) }; + constrained_intra_pred_flag as u64 + }); + __bindgen_bitfield_unit.set(5usize, 1u8, { + let transform_skip_enabled_flag: u32 = + unsafe { ::std::mem::transmute(transform_skip_enabled_flag) }; + transform_skip_enabled_flag as u64 + }); + __bindgen_bitfield_unit.set(6usize, 1u8, { + let cu_qp_delta_enabled_flag: u32 = + unsafe { ::std::mem::transmute(cu_qp_delta_enabled_flag) }; + cu_qp_delta_enabled_flag as u64 + }); + __bindgen_bitfield_unit.set(7usize, 1u8, { + let pps_slice_chroma_qp_offsets_present_flag: u32 = + unsafe { ::std::mem::transmute(pps_slice_chroma_qp_offsets_present_flag) }; + pps_slice_chroma_qp_offsets_present_flag as u64 + }); + __bindgen_bitfield_unit.set(8usize, 1u8, { + let weighted_pred_flag: u32 = unsafe { ::std::mem::transmute(weighted_pred_flag) }; + weighted_pred_flag as u64 + }); + __bindgen_bitfield_unit.set(9usize, 1u8, { + let weighted_bipred_flag: u32 = unsafe { ::std::mem::transmute(weighted_bipred_flag) }; + weighted_bipred_flag as u64 + }); + __bindgen_bitfield_unit.set(10usize, 1u8, { + let transquant_bypass_enabled_flag: u32 = + unsafe { ::std::mem::transmute(transquant_bypass_enabled_flag) }; + transquant_bypass_enabled_flag as u64 + }); + __bindgen_bitfield_unit.set(11usize, 1u8, { + let tiles_enabled_flag: u32 = unsafe { ::std::mem::transmute(tiles_enabled_flag) }; + tiles_enabled_flag as u64 + }); + __bindgen_bitfield_unit.set(12usize, 1u8, { + let entropy_coding_sync_enabled_flag: u32 = + unsafe { ::std::mem::transmute(entropy_coding_sync_enabled_flag) }; + entropy_coding_sync_enabled_flag as u64 + }); + __bindgen_bitfield_unit.set(13usize, 1u8, { + let uniform_spacing_flag: u32 = unsafe { ::std::mem::transmute(uniform_spacing_flag) }; + uniform_spacing_flag as u64 + }); + __bindgen_bitfield_unit.set(14usize, 1u8, { + let loop_filter_across_tiles_enabled_flag: u32 = + unsafe { ::std::mem::transmute(loop_filter_across_tiles_enabled_flag) }; + loop_filter_across_tiles_enabled_flag as u64 + }); + __bindgen_bitfield_unit.set(15usize, 1u8, { + let pps_loop_filter_across_slices_enabled_flag: u32 = + unsafe { ::std::mem::transmute(pps_loop_filter_across_slices_enabled_flag) }; + pps_loop_filter_across_slices_enabled_flag as u64 + }); + __bindgen_bitfield_unit.set(16usize, 1u8, { + let deblocking_filter_control_present_flag: u32 = + unsafe { ::std::mem::transmute(deblocking_filter_control_present_flag) }; + deblocking_filter_control_present_flag as u64 + }); + __bindgen_bitfield_unit.set(17usize, 1u8, { + let deblocking_filter_override_enabled_flag: u32 = + unsafe { ::std::mem::transmute(deblocking_filter_override_enabled_flag) }; + deblocking_filter_override_enabled_flag as u64 + }); + __bindgen_bitfield_unit.set(18usize, 1u8, { + let pps_deblocking_filter_disabled_flag: u32 = + unsafe { ::std::mem::transmute(pps_deblocking_filter_disabled_flag) }; + pps_deblocking_filter_disabled_flag as u64 + }); + __bindgen_bitfield_unit.set(19usize, 1u8, { + let pps_scaling_list_data_present_flag: u32 = + unsafe { ::std::mem::transmute(pps_scaling_list_data_present_flag) }; + pps_scaling_list_data_present_flag as u64 + }); + __bindgen_bitfield_unit.set(20usize, 1u8, { + let lists_modification_present_flag: u32 = + unsafe { ::std::mem::transmute(lists_modification_present_flag) }; + lists_modification_present_flag as u64 + }); + __bindgen_bitfield_unit.set(21usize, 1u8, { + let slice_segment_header_extension_present_flag: u32 = + unsafe { ::std::mem::transmute(slice_segment_header_extension_present_flag) }; + slice_segment_header_extension_present_flag as u64 + }); + __bindgen_bitfield_unit.set(22usize, 1u8, { + let pps_extension_present_flag: u32 = + unsafe { ::std::mem::transmute(pps_extension_present_flag) }; + pps_extension_present_flag as u64 + }); + __bindgen_bitfield_unit.set(23usize, 1u8, { + let cross_component_prediction_enabled_flag: u32 = + unsafe { ::std::mem::transmute(cross_component_prediction_enabled_flag) }; + cross_component_prediction_enabled_flag as u64 + }); + __bindgen_bitfield_unit.set(24usize, 1u8, { + let chroma_qp_offset_list_enabled_flag: u32 = + unsafe { ::std::mem::transmute(chroma_qp_offset_list_enabled_flag) }; + chroma_qp_offset_list_enabled_flag as u64 + }); + __bindgen_bitfield_unit.set(25usize, 1u8, { + let pps_curr_pic_ref_enabled_flag: u32 = + unsafe { ::std::mem::transmute(pps_curr_pic_ref_enabled_flag) }; + pps_curr_pic_ref_enabled_flag as u64 + }); + __bindgen_bitfield_unit.set(26usize, 1u8, { + let residual_adaptive_colour_transform_enabled_flag: u32 = + unsafe { ::std::mem::transmute(residual_adaptive_colour_transform_enabled_flag) }; + residual_adaptive_colour_transform_enabled_flag as u64 + }); + __bindgen_bitfield_unit.set(27usize, 1u8, { + let pps_slice_act_qp_offsets_present_flag: u32 = + unsafe { ::std::mem::transmute(pps_slice_act_qp_offsets_present_flag) }; + pps_slice_act_qp_offsets_present_flag as u64 + }); + __bindgen_bitfield_unit.set(28usize, 1u8, { + let pps_palette_predictor_initializers_present_flag: u32 = + unsafe { ::std::mem::transmute(pps_palette_predictor_initializers_present_flag) }; + pps_palette_predictor_initializers_present_flag as u64 + }); + __bindgen_bitfield_unit.set(29usize, 1u8, { + let monochrome_palette_flag: u32 = + unsafe { ::std::mem::transmute(monochrome_palette_flag) }; + monochrome_palette_flag as u64 + }); + __bindgen_bitfield_unit.set(30usize, 1u8, { + let pps_range_extension_flag: u32 = + unsafe { ::std::mem::transmute(pps_range_extension_flag) }; + pps_range_extension_flag as u64 + }); + __bindgen_bitfield_unit + } +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoH265PictureParameterSet { + pub flags: StdVideoH265PpsFlags, + pub pps_pic_parameter_set_id: u8, + pub pps_seq_parameter_set_id: u8, + pub sps_video_parameter_set_id: u8, + pub num_extra_slice_header_bits: u8, + pub num_ref_idx_l0_default_active_minus1: u8, + pub num_ref_idx_l1_default_active_minus1: u8, + pub init_qp_minus26: i8, + pub diff_cu_qp_delta_depth: u8, + pub pps_cb_qp_offset: i8, + pub pps_cr_qp_offset: i8, + pub pps_beta_offset_div2: i8, + pub pps_tc_offset_div2: i8, + pub log2_parallel_merge_level_minus2: u8, + pub log2_max_transform_skip_block_size_minus2: u8, + pub diff_cu_chroma_qp_offset_depth: u8, + pub chroma_qp_offset_list_len_minus1: u8, + pub cb_qp_offset_list: [i8; 6usize], + pub cr_qp_offset_list: [i8; 6usize], + pub log2_sao_offset_scale_luma: u8, + pub log2_sao_offset_scale_chroma: u8, + pub pps_act_y_qp_offset_plus5: i8, + pub pps_act_cb_qp_offset_plus5: i8, + pub pps_act_cr_qp_offset_plus3: i8, + pub pps_num_palette_predictor_initializers: u8, + pub luma_bit_depth_entry_minus8: u8, + pub chroma_bit_depth_entry_minus8: u8, + pub num_tile_columns_minus1: u8, + pub num_tile_rows_minus1: u8, + pub reserved1: u8, + pub reserved2: u8, + pub column_width_minus1: [u16; 19usize], + pub row_height_minus1: [u16; 21usize], + pub reserved3: u32, + pub pScalingLists: *const StdVideoH265ScalingLists, + pub pPredictorPaletteEntries: *const StdVideoH265PredictorPaletteEntries, +} +#[test] +fn bindgen_test_layout_StdVideoH265PictureParameterSet() { + const UNINIT: ::std::mem::MaybeUninit = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::(), + 144usize, + concat!("Size of: ", stringify!(StdVideoH265PictureParameterSet)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(StdVideoH265PictureParameterSet)) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265PictureParameterSet), + "::", + stringify!(flags) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pps_pic_parameter_set_id) as usize - ptr as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265PictureParameterSet), + "::", + stringify!(pps_pic_parameter_set_id) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pps_seq_parameter_set_id) as usize - ptr as usize }, + 5usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265PictureParameterSet), + "::", + stringify!(pps_seq_parameter_set_id) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).sps_video_parameter_set_id) as usize - ptr as usize }, + 6usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265PictureParameterSet), + "::", + stringify!(sps_video_parameter_set_id) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).num_extra_slice_header_bits) as usize - ptr as usize }, + 7usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265PictureParameterSet), + "::", + stringify!(num_extra_slice_header_bits) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).num_ref_idx_l0_default_active_minus1) as usize + - ptr as usize + }, + 8usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265PictureParameterSet), + "::", + stringify!(num_ref_idx_l0_default_active_minus1) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).num_ref_idx_l1_default_active_minus1) as usize + - ptr as usize + }, + 9usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265PictureParameterSet), + "::", + stringify!(num_ref_idx_l1_default_active_minus1) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).init_qp_minus26) as usize - ptr as usize }, + 10usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265PictureParameterSet), + "::", + stringify!(init_qp_minus26) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).diff_cu_qp_delta_depth) as usize - ptr as usize }, + 11usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265PictureParameterSet), + "::", + stringify!(diff_cu_qp_delta_depth) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pps_cb_qp_offset) as usize - ptr as usize }, + 12usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265PictureParameterSet), + "::", + stringify!(pps_cb_qp_offset) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pps_cr_qp_offset) as usize - ptr as usize }, + 13usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265PictureParameterSet), + "::", + stringify!(pps_cr_qp_offset) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pps_beta_offset_div2) as usize - ptr as usize }, + 14usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265PictureParameterSet), + "::", + stringify!(pps_beta_offset_div2) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pps_tc_offset_div2) as usize - ptr as usize }, + 15usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265PictureParameterSet), + "::", + stringify!(pps_tc_offset_div2) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).log2_parallel_merge_level_minus2) as usize - ptr as usize + }, + 16usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265PictureParameterSet), + "::", + stringify!(log2_parallel_merge_level_minus2) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).log2_max_transform_skip_block_size_minus2) as usize + - ptr as usize + }, + 17usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265PictureParameterSet), + "::", + stringify!(log2_max_transform_skip_block_size_minus2) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).diff_cu_chroma_qp_offset_depth) as usize - ptr as usize + }, + 18usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265PictureParameterSet), + "::", + stringify!(diff_cu_chroma_qp_offset_depth) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).chroma_qp_offset_list_len_minus1) as usize - ptr as usize + }, + 19usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265PictureParameterSet), + "::", + stringify!(chroma_qp_offset_list_len_minus1) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).cb_qp_offset_list) as usize - ptr as usize }, + 20usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265PictureParameterSet), + "::", + stringify!(cb_qp_offset_list) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).cr_qp_offset_list) as usize - ptr as usize }, + 26usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265PictureParameterSet), + "::", + stringify!(cr_qp_offset_list) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).log2_sao_offset_scale_luma) as usize - ptr as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265PictureParameterSet), + "::", + stringify!(log2_sao_offset_scale_luma) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).log2_sao_offset_scale_chroma) as usize - ptr as usize + }, + 33usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265PictureParameterSet), + "::", + stringify!(log2_sao_offset_scale_chroma) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pps_act_y_qp_offset_plus5) as usize - ptr as usize }, + 34usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265PictureParameterSet), + "::", + stringify!(pps_act_y_qp_offset_plus5) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pps_act_cb_qp_offset_plus5) as usize - ptr as usize }, + 35usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265PictureParameterSet), + "::", + stringify!(pps_act_cb_qp_offset_plus5) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pps_act_cr_qp_offset_plus3) as usize - ptr as usize }, + 36usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265PictureParameterSet), + "::", + stringify!(pps_act_cr_qp_offset_plus3) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).pps_num_palette_predictor_initializers) as usize + - ptr as usize + }, + 37usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265PictureParameterSet), + "::", + stringify!(pps_num_palette_predictor_initializers) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).luma_bit_depth_entry_minus8) as usize - ptr as usize }, + 38usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265PictureParameterSet), + "::", + stringify!(luma_bit_depth_entry_minus8) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).chroma_bit_depth_entry_minus8) as usize - ptr as usize + }, + 39usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265PictureParameterSet), + "::", + stringify!(chroma_bit_depth_entry_minus8) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).num_tile_columns_minus1) as usize - ptr as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265PictureParameterSet), + "::", + stringify!(num_tile_columns_minus1) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).num_tile_rows_minus1) as usize - ptr as usize }, + 41usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265PictureParameterSet), + "::", + stringify!(num_tile_rows_minus1) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).reserved1) as usize - ptr as usize }, + 42usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265PictureParameterSet), + "::", + stringify!(reserved1) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).reserved2) as usize - ptr as usize }, + 43usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265PictureParameterSet), + "::", + stringify!(reserved2) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).column_width_minus1) as usize - ptr as usize }, + 44usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265PictureParameterSet), + "::", + stringify!(column_width_minus1) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).row_height_minus1) as usize - ptr as usize }, + 82usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265PictureParameterSet), + "::", + stringify!(row_height_minus1) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).reserved3) as usize - ptr as usize }, + 124usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265PictureParameterSet), + "::", + stringify!(reserved3) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pScalingLists) as usize - ptr as usize }, + 128usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265PictureParameterSet), + "::", + stringify!(pScalingLists) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pPredictorPaletteEntries) as usize - ptr as usize }, + 136usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265PictureParameterSet), + "::", + stringify!(pPredictorPaletteEntries) + ) + ); +} +#[repr(C)] +#[repr(align(4))] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoDecodeH265PictureInfoFlags { + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, + pub __bindgen_padding_0: [u8; 3usize], +} +#[test] +fn bindgen_test_layout_StdVideoDecodeH265PictureInfoFlags() { + assert_eq!( + ::std::mem::size_of::(), + 4usize, + concat!("Size of: ", stringify!(StdVideoDecodeH265PictureInfoFlags)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(StdVideoDecodeH265PictureInfoFlags) + ) + ); +} +impl StdVideoDecodeH265PictureInfoFlags { + #[inline] + pub fn IrapPicFlag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_IrapPicFlag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub fn IdrPicFlag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_IdrPicFlag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub fn IsReference(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } + } + #[inline] + pub fn set_IsReference(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 1u8, val as u64) + } + } + #[inline] + pub fn short_term_ref_pic_set_sps_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } + } + #[inline] + pub fn set_short_term_ref_pic_set_sps_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(3usize, 1u8, val as u64) + } + } + #[inline] + pub fn new_bitfield_1( + IrapPicFlag: u32, + IdrPicFlag: u32, + IsReference: u32, + short_term_ref_pic_set_sps_flag: u32, + ) -> __BindgenBitfieldUnit<[u8; 1usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let IrapPicFlag: u32 = unsafe { ::std::mem::transmute(IrapPicFlag) }; + IrapPicFlag as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let IdrPicFlag: u32 = unsafe { ::std::mem::transmute(IdrPicFlag) }; + IdrPicFlag as u64 + }); + __bindgen_bitfield_unit.set(2usize, 1u8, { + let IsReference: u32 = unsafe { ::std::mem::transmute(IsReference) }; + IsReference as u64 + }); + __bindgen_bitfield_unit.set(3usize, 1u8, { + let short_term_ref_pic_set_sps_flag: u32 = + unsafe { ::std::mem::transmute(short_term_ref_pic_set_sps_flag) }; + short_term_ref_pic_set_sps_flag as u64 + }); + __bindgen_bitfield_unit + } +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoDecodeH265PictureInfo { + pub flags: StdVideoDecodeH265PictureInfoFlags, + pub sps_video_parameter_set_id: u8, + pub pps_seq_parameter_set_id: u8, + pub pps_pic_parameter_set_id: u8, + pub NumDeltaPocsOfRefRpsIdx: u8, + pub PicOrderCntVal: i32, + pub NumBitsForSTRefPicSetInSlice: u16, + pub reserved: u16, + pub RefPicSetStCurrBefore: [u8; 8usize], + pub RefPicSetStCurrAfter: [u8; 8usize], + pub RefPicSetLtCurr: [u8; 8usize], +} +#[test] +fn bindgen_test_layout_StdVideoDecodeH265PictureInfo() { + const UNINIT: ::std::mem::MaybeUninit = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::(), + 40usize, + concat!("Size of: ", stringify!(StdVideoDecodeH265PictureInfo)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!("Alignment of ", stringify!(StdVideoDecodeH265PictureInfo)) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(StdVideoDecodeH265PictureInfo), + "::", + stringify!(flags) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).sps_video_parameter_set_id) as usize - ptr as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(StdVideoDecodeH265PictureInfo), + "::", + stringify!(sps_video_parameter_set_id) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pps_seq_parameter_set_id) as usize - ptr as usize }, + 5usize, + concat!( + "Offset of field: ", + stringify!(StdVideoDecodeH265PictureInfo), + "::", + stringify!(pps_seq_parameter_set_id) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pps_pic_parameter_set_id) as usize - ptr as usize }, + 6usize, + concat!( + "Offset of field: ", + stringify!(StdVideoDecodeH265PictureInfo), + "::", + stringify!(pps_pic_parameter_set_id) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).NumDeltaPocsOfRefRpsIdx) as usize - ptr as usize }, + 7usize, + concat!( + "Offset of field: ", + stringify!(StdVideoDecodeH265PictureInfo), + "::", + stringify!(NumDeltaPocsOfRefRpsIdx) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).PicOrderCntVal) as usize - ptr as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(StdVideoDecodeH265PictureInfo), + "::", + stringify!(PicOrderCntVal) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).NumBitsForSTRefPicSetInSlice) as usize - ptr as usize + }, + 12usize, + concat!( + "Offset of field: ", + stringify!(StdVideoDecodeH265PictureInfo), + "::", + stringify!(NumBitsForSTRefPicSetInSlice) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).reserved) as usize - ptr as usize }, + 14usize, + concat!( + "Offset of field: ", + stringify!(StdVideoDecodeH265PictureInfo), + "::", + stringify!(reserved) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).RefPicSetStCurrBefore) as usize - ptr as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(StdVideoDecodeH265PictureInfo), + "::", + stringify!(RefPicSetStCurrBefore) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).RefPicSetStCurrAfter) as usize - ptr as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(StdVideoDecodeH265PictureInfo), + "::", + stringify!(RefPicSetStCurrAfter) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).RefPicSetLtCurr) as usize - ptr as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(StdVideoDecodeH265PictureInfo), + "::", + stringify!(RefPicSetLtCurr) + ) + ); +} +#[repr(C)] +#[repr(align(4))] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoDecodeH265ReferenceInfoFlags { + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, + pub __bindgen_padding_0: [u8; 3usize], +} +#[test] +fn bindgen_test_layout_StdVideoDecodeH265ReferenceInfoFlags() { + assert_eq!( + ::std::mem::size_of::(), + 4usize, + concat!( + "Size of: ", + stringify!(StdVideoDecodeH265ReferenceInfoFlags) + ) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(StdVideoDecodeH265ReferenceInfoFlags) + ) + ); +} +impl StdVideoDecodeH265ReferenceInfoFlags { + #[inline] + pub fn used_for_long_term_reference(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_used_for_long_term_reference(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub fn unused_for_reference(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_unused_for_reference(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub fn new_bitfield_1( + used_for_long_term_reference: u32, + unused_for_reference: u32, + ) -> __BindgenBitfieldUnit<[u8; 1usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let used_for_long_term_reference: u32 = + unsafe { ::std::mem::transmute(used_for_long_term_reference) }; + used_for_long_term_reference as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let unused_for_reference: u32 = unsafe { ::std::mem::transmute(unused_for_reference) }; + unused_for_reference as u64 + }); + __bindgen_bitfield_unit + } +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoDecodeH265ReferenceInfo { + pub flags: StdVideoDecodeH265ReferenceInfoFlags, + pub PicOrderCntVal: i32, +} +#[test] +fn bindgen_test_layout_StdVideoDecodeH265ReferenceInfo() { + const UNINIT: ::std::mem::MaybeUninit = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!("Size of: ", stringify!(StdVideoDecodeH265ReferenceInfo)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!("Alignment of ", stringify!(StdVideoDecodeH265ReferenceInfo)) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(StdVideoDecodeH265ReferenceInfo), + "::", + stringify!(flags) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).PicOrderCntVal) as usize - ptr as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(StdVideoDecodeH265ReferenceInfo), + "::", + stringify!(PicOrderCntVal) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoEncodeH264WeightTableFlags { + pub luma_weight_l0_flag: u32, + pub chroma_weight_l0_flag: u32, + pub luma_weight_l1_flag: u32, + pub chroma_weight_l1_flag: u32, +} +#[test] +fn bindgen_test_layout_StdVideoEncodeH264WeightTableFlags() { + const UNINIT: ::std::mem::MaybeUninit = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::(), + 16usize, + concat!("Size of: ", stringify!(StdVideoEncodeH264WeightTableFlags)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(StdVideoEncodeH264WeightTableFlags) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).luma_weight_l0_flag) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264WeightTableFlags), + "::", + stringify!(luma_weight_l0_flag) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).chroma_weight_l0_flag) as usize - ptr as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264WeightTableFlags), + "::", + stringify!(chroma_weight_l0_flag) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).luma_weight_l1_flag) as usize - ptr as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264WeightTableFlags), + "::", + stringify!(luma_weight_l1_flag) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).chroma_weight_l1_flag) as usize - ptr as usize }, + 12usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264WeightTableFlags), + "::", + stringify!(chroma_weight_l1_flag) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoEncodeH264WeightTable { + pub flags: StdVideoEncodeH264WeightTableFlags, + pub luma_log2_weight_denom: u8, + pub chroma_log2_weight_denom: u8, + pub luma_weight_l0: [i8; 32usize], + pub luma_offset_l0: [i8; 32usize], + pub chroma_weight_l0: [[i8; 2usize]; 32usize], + pub chroma_offset_l0: [[i8; 2usize]; 32usize], + pub luma_weight_l1: [i8; 32usize], + pub luma_offset_l1: [i8; 32usize], + pub chroma_weight_l1: [[i8; 2usize]; 32usize], + pub chroma_offset_l1: [[i8; 2usize]; 32usize], +} +#[test] +fn bindgen_test_layout_StdVideoEncodeH264WeightTable() { + const UNINIT: ::std::mem::MaybeUninit = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::(), + 404usize, + concat!("Size of: ", stringify!(StdVideoEncodeH264WeightTable)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!("Alignment of ", stringify!(StdVideoEncodeH264WeightTable)) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264WeightTable), + "::", + stringify!(flags) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).luma_log2_weight_denom) as usize - ptr as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264WeightTable), + "::", + stringify!(luma_log2_weight_denom) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).chroma_log2_weight_denom) as usize - ptr as usize }, + 17usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264WeightTable), + "::", + stringify!(chroma_log2_weight_denom) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).luma_weight_l0) as usize - ptr as usize }, + 18usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264WeightTable), + "::", + stringify!(luma_weight_l0) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).luma_offset_l0) as usize - ptr as usize }, + 50usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264WeightTable), + "::", + stringify!(luma_offset_l0) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).chroma_weight_l0) as usize - ptr as usize }, + 82usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264WeightTable), + "::", + stringify!(chroma_weight_l0) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).chroma_offset_l0) as usize - ptr as usize }, + 146usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264WeightTable), + "::", + stringify!(chroma_offset_l0) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).luma_weight_l1) as usize - ptr as usize }, + 210usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264WeightTable), + "::", + stringify!(luma_weight_l1) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).luma_offset_l1) as usize - ptr as usize }, + 242usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264WeightTable), + "::", + stringify!(luma_offset_l1) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).chroma_weight_l1) as usize - ptr as usize }, + 274usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264WeightTable), + "::", + stringify!(chroma_weight_l1) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).chroma_offset_l1) as usize - ptr as usize }, + 338usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264WeightTable), + "::", + stringify!(chroma_offset_l1) + ) + ); +} +#[repr(C)] +#[repr(align(4))] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoEncodeH264SliceHeaderFlags { + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, + pub __bindgen_padding_0: [u8; 3usize], +} +#[test] +fn bindgen_test_layout_StdVideoEncodeH264SliceHeaderFlags() { + assert_eq!( + ::std::mem::size_of::(), + 4usize, + concat!("Size of: ", stringify!(StdVideoEncodeH264SliceHeaderFlags)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(StdVideoEncodeH264SliceHeaderFlags) + ) + ); +} +impl StdVideoEncodeH264SliceHeaderFlags { + #[inline] + pub fn direct_spatial_mv_pred_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_direct_spatial_mv_pred_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub fn num_ref_idx_active_override_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_num_ref_idx_active_override_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub fn no_output_of_prior_pics_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } + } + #[inline] + pub fn set_no_output_of_prior_pics_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 1u8, val as u64) + } + } + #[inline] + pub fn adaptive_ref_pic_marking_mode_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } + } + #[inline] + pub fn set_adaptive_ref_pic_marking_mode_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(3usize, 1u8, val as u64) + } + } + #[inline] + pub fn no_prior_references_available_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } + } + #[inline] + pub fn set_no_prior_references_available_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(4usize, 1u8, val as u64) + } + } + #[inline] + pub fn new_bitfield_1( + direct_spatial_mv_pred_flag: u32, + num_ref_idx_active_override_flag: u32, + no_output_of_prior_pics_flag: u32, + adaptive_ref_pic_marking_mode_flag: u32, + no_prior_references_available_flag: u32, + ) -> __BindgenBitfieldUnit<[u8; 1usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let direct_spatial_mv_pred_flag: u32 = + unsafe { ::std::mem::transmute(direct_spatial_mv_pred_flag) }; + direct_spatial_mv_pred_flag as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let num_ref_idx_active_override_flag: u32 = + unsafe { ::std::mem::transmute(num_ref_idx_active_override_flag) }; + num_ref_idx_active_override_flag as u64 + }); + __bindgen_bitfield_unit.set(2usize, 1u8, { + let no_output_of_prior_pics_flag: u32 = + unsafe { ::std::mem::transmute(no_output_of_prior_pics_flag) }; + no_output_of_prior_pics_flag as u64 + }); + __bindgen_bitfield_unit.set(3usize, 1u8, { + let adaptive_ref_pic_marking_mode_flag: u32 = + unsafe { ::std::mem::transmute(adaptive_ref_pic_marking_mode_flag) }; + adaptive_ref_pic_marking_mode_flag as u64 + }); + __bindgen_bitfield_unit.set(4usize, 1u8, { + let no_prior_references_available_flag: u32 = + unsafe { ::std::mem::transmute(no_prior_references_available_flag) }; + no_prior_references_available_flag as u64 + }); + __bindgen_bitfield_unit + } +} +#[repr(C)] +#[repr(align(4))] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoEncodeH264PictureInfoFlags { + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, + pub __bindgen_padding_0: [u8; 3usize], +} +#[test] +fn bindgen_test_layout_StdVideoEncodeH264PictureInfoFlags() { + assert_eq!( + ::std::mem::size_of::(), + 4usize, + concat!("Size of: ", stringify!(StdVideoEncodeH264PictureInfoFlags)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(StdVideoEncodeH264PictureInfoFlags) + ) + ); +} +impl StdVideoEncodeH264PictureInfoFlags { + #[inline] + pub fn idr_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_idr_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub fn is_reference_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_is_reference_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub fn used_for_long_term_reference(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } + } + #[inline] + pub fn set_used_for_long_term_reference(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 1u8, val as u64) + } + } + #[inline] + pub fn new_bitfield_1( + idr_flag: u32, + is_reference_flag: u32, + used_for_long_term_reference: u32, + ) -> __BindgenBitfieldUnit<[u8; 1usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let idr_flag: u32 = unsafe { ::std::mem::transmute(idr_flag) }; + idr_flag as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let is_reference_flag: u32 = unsafe { ::std::mem::transmute(is_reference_flag) }; + is_reference_flag as u64 + }); + __bindgen_bitfield_unit.set(2usize, 1u8, { + let used_for_long_term_reference: u32 = + unsafe { ::std::mem::transmute(used_for_long_term_reference) }; + used_for_long_term_reference as u64 + }); + __bindgen_bitfield_unit + } +} +#[repr(C)] +#[repr(align(4))] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoEncodeH264ReferenceInfoFlags { + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, + pub __bindgen_padding_0: [u8; 3usize], +} +#[test] +fn bindgen_test_layout_StdVideoEncodeH264ReferenceInfoFlags() { + assert_eq!( + ::std::mem::size_of::(), + 4usize, + concat!( + "Size of: ", + stringify!(StdVideoEncodeH264ReferenceInfoFlags) + ) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(StdVideoEncodeH264ReferenceInfoFlags) + ) + ); +} +impl StdVideoEncodeH264ReferenceInfoFlags { + #[inline] + pub fn used_for_long_term_reference(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_used_for_long_term_reference(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub fn new_bitfield_1( + used_for_long_term_reference: u32, + ) -> __BindgenBitfieldUnit<[u8; 1usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let used_for_long_term_reference: u32 = + unsafe { ::std::mem::transmute(used_for_long_term_reference) }; + used_for_long_term_reference as u64 + }); + __bindgen_bitfield_unit + } +} +#[repr(C)] +#[repr(align(4))] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoEncodeH264RefMgmtFlags { + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, + pub __bindgen_padding_0: [u8; 3usize], +} +#[test] +fn bindgen_test_layout_StdVideoEncodeH264RefMgmtFlags() { + assert_eq!( + ::std::mem::size_of::(), + 4usize, + concat!("Size of: ", stringify!(StdVideoEncodeH264RefMgmtFlags)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!("Alignment of ", stringify!(StdVideoEncodeH264RefMgmtFlags)) + ); +} +impl StdVideoEncodeH264RefMgmtFlags { + #[inline] + pub fn ref_pic_list_modification_l0_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_ref_pic_list_modification_l0_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub fn ref_pic_list_modification_l1_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_ref_pic_list_modification_l1_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub fn new_bitfield_1( + ref_pic_list_modification_l0_flag: u32, + ref_pic_list_modification_l1_flag: u32, + ) -> __BindgenBitfieldUnit<[u8; 1usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let ref_pic_list_modification_l0_flag: u32 = + unsafe { ::std::mem::transmute(ref_pic_list_modification_l0_flag) }; + ref_pic_list_modification_l0_flag as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let ref_pic_list_modification_l1_flag: u32 = + unsafe { ::std::mem::transmute(ref_pic_list_modification_l1_flag) }; + ref_pic_list_modification_l1_flag as u64 + }); + __bindgen_bitfield_unit + } +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoEncodeH264RefListModEntry { + pub modification_of_pic_nums_idc: StdVideoH264ModificationOfPicNumsIdc, + pub abs_diff_pic_num_minus1: u16, + pub long_term_pic_num: u16, +} +#[test] +fn bindgen_test_layout_StdVideoEncodeH264RefListModEntry() { + const UNINIT: ::std::mem::MaybeUninit = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!("Size of: ", stringify!(StdVideoEncodeH264RefListModEntry)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(StdVideoEncodeH264RefListModEntry) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).modification_of_pic_nums_idc) as usize - ptr as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264RefListModEntry), + "::", + stringify!(modification_of_pic_nums_idc) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).abs_diff_pic_num_minus1) as usize - ptr as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264RefListModEntry), + "::", + stringify!(abs_diff_pic_num_minus1) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).long_term_pic_num) as usize - ptr as usize }, + 6usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264RefListModEntry), + "::", + stringify!(long_term_pic_num) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoEncodeH264RefPicMarkingEntry { + pub operation: StdVideoH264MemMgmtControlOp, + pub difference_of_pic_nums_minus1: u16, + pub long_term_pic_num: u16, + pub long_term_frame_idx: u16, + pub max_long_term_frame_idx_plus1: u16, +} +#[test] +fn bindgen_test_layout_StdVideoEncodeH264RefPicMarkingEntry() { + const UNINIT: ::std::mem::MaybeUninit = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::(), + 12usize, + concat!( + "Size of: ", + stringify!(StdVideoEncodeH264RefPicMarkingEntry) + ) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(StdVideoEncodeH264RefPicMarkingEntry) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).operation) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264RefPicMarkingEntry), + "::", + stringify!(operation) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).difference_of_pic_nums_minus1) as usize - ptr as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264RefPicMarkingEntry), + "::", + stringify!(difference_of_pic_nums_minus1) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).long_term_pic_num) as usize - ptr as usize }, + 6usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264RefPicMarkingEntry), + "::", + stringify!(long_term_pic_num) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).long_term_frame_idx) as usize - ptr as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264RefPicMarkingEntry), + "::", + stringify!(long_term_frame_idx) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).max_long_term_frame_idx_plus1) as usize - ptr as usize + }, + 10usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264RefPicMarkingEntry), + "::", + stringify!(max_long_term_frame_idx_plus1) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoEncodeH264RefMemMgmtCtrlOperations { + pub flags: StdVideoEncodeH264RefMgmtFlags, + pub refList0ModOpCount: u8, + pub pRefList0ModOperations: *const StdVideoEncodeH264RefListModEntry, + pub refList1ModOpCount: u8, + pub pRefList1ModOperations: *const StdVideoEncodeH264RefListModEntry, + pub refPicMarkingOpCount: u8, + pub pRefPicMarkingOperations: *const StdVideoEncodeH264RefPicMarkingEntry, +} +#[test] +fn bindgen_test_layout_StdVideoEncodeH264RefMemMgmtCtrlOperations() { + const UNINIT: ::std::mem::MaybeUninit = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::(), + 48usize, + concat!( + "Size of: ", + stringify!(StdVideoEncodeH264RefMemMgmtCtrlOperations) + ) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!( + "Alignment of ", + stringify!(StdVideoEncodeH264RefMemMgmtCtrlOperations) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264RefMemMgmtCtrlOperations), + "::", + stringify!(flags) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).refList0ModOpCount) as usize - ptr as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264RefMemMgmtCtrlOperations), + "::", + stringify!(refList0ModOpCount) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pRefList0ModOperations) as usize - ptr as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264RefMemMgmtCtrlOperations), + "::", + stringify!(pRefList0ModOperations) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).refList1ModOpCount) as usize - ptr as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264RefMemMgmtCtrlOperations), + "::", + stringify!(refList1ModOpCount) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pRefList1ModOperations) as usize - ptr as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264RefMemMgmtCtrlOperations), + "::", + stringify!(pRefList1ModOperations) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).refPicMarkingOpCount) as usize - ptr as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264RefMemMgmtCtrlOperations), + "::", + stringify!(refPicMarkingOpCount) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pRefPicMarkingOperations) as usize - ptr as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264RefMemMgmtCtrlOperations), + "::", + stringify!(pRefPicMarkingOperations) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoEncodeH264PictureInfo { + pub flags: StdVideoEncodeH264PictureInfoFlags, + pub seq_parameter_set_id: u8, + pub pic_parameter_set_id: u8, + pub pictureType: StdVideoH264PictureType, + pub frame_num: u32, + pub PicOrderCnt: i32, +} +#[test] +fn bindgen_test_layout_StdVideoEncodeH264PictureInfo() { + const UNINIT: ::std::mem::MaybeUninit = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::(), + 20usize, + concat!("Size of: ", stringify!(StdVideoEncodeH264PictureInfo)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!("Alignment of ", stringify!(StdVideoEncodeH264PictureInfo)) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264PictureInfo), + "::", + stringify!(flags) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).seq_parameter_set_id) as usize - ptr as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264PictureInfo), + "::", + stringify!(seq_parameter_set_id) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pic_parameter_set_id) as usize - ptr as usize }, + 5usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264PictureInfo), + "::", + stringify!(pic_parameter_set_id) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pictureType) as usize - ptr as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264PictureInfo), + "::", + stringify!(pictureType) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).frame_num) as usize - ptr as usize }, + 12usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264PictureInfo), + "::", + stringify!(frame_num) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).PicOrderCnt) as usize - ptr as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264PictureInfo), + "::", + stringify!(PicOrderCnt) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoEncodeH264ReferenceInfo { + pub flags: StdVideoEncodeH264ReferenceInfoFlags, + pub FrameNum: u32, + pub PicOrderCnt: i32, + pub long_term_pic_num: u16, + pub long_term_frame_idx: u16, +} +#[test] +fn bindgen_test_layout_StdVideoEncodeH264ReferenceInfo() { + const UNINIT: ::std::mem::MaybeUninit = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::(), + 16usize, + concat!("Size of: ", stringify!(StdVideoEncodeH264ReferenceInfo)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!("Alignment of ", stringify!(StdVideoEncodeH264ReferenceInfo)) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264ReferenceInfo), + "::", + stringify!(flags) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).FrameNum) as usize - ptr as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264ReferenceInfo), + "::", + stringify!(FrameNum) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).PicOrderCnt) as usize - ptr as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264ReferenceInfo), + "::", + stringify!(PicOrderCnt) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).long_term_pic_num) as usize - ptr as usize }, + 12usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264ReferenceInfo), + "::", + stringify!(long_term_pic_num) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).long_term_frame_idx) as usize - ptr as usize }, + 14usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264ReferenceInfo), + "::", + stringify!(long_term_frame_idx) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoEncodeH264SliceHeader { + pub flags: StdVideoEncodeH264SliceHeaderFlags, + pub first_mb_in_slice: u32, + pub slice_type: StdVideoH264SliceType, + pub idr_pic_id: u16, + pub num_ref_idx_l0_active_minus1: u8, + pub num_ref_idx_l1_active_minus1: u8, + pub cabac_init_idc: StdVideoH264CabacInitIdc, + pub disable_deblocking_filter_idc: StdVideoH264DisableDeblockingFilterIdc, + pub slice_alpha_c0_offset_div2: i8, + pub slice_beta_offset_div2: i8, + pub pWeightTable: *const StdVideoEncodeH264WeightTable, +} +#[test] +fn bindgen_test_layout_StdVideoEncodeH264SliceHeader() { + const UNINIT: ::std::mem::MaybeUninit = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::(), + 40usize, + concat!("Size of: ", stringify!(StdVideoEncodeH264SliceHeader)) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!("Alignment of ", stringify!(StdVideoEncodeH264SliceHeader)) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264SliceHeader), + "::", + stringify!(flags) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).first_mb_in_slice) as usize - ptr as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264SliceHeader), + "::", + stringify!(first_mb_in_slice) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).slice_type) as usize - ptr as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264SliceHeader), + "::", + stringify!(slice_type) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).idr_pic_id) as usize - ptr as usize }, + 12usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264SliceHeader), + "::", + stringify!(idr_pic_id) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).num_ref_idx_l0_active_minus1) as usize - ptr as usize + }, + 14usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264SliceHeader), + "::", + stringify!(num_ref_idx_l0_active_minus1) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).num_ref_idx_l1_active_minus1) as usize - ptr as usize + }, + 15usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264SliceHeader), + "::", + stringify!(num_ref_idx_l1_active_minus1) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).cabac_init_idc) as usize - ptr as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264SliceHeader), + "::", + stringify!(cabac_init_idc) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).disable_deblocking_filter_idc) as usize - ptr as usize + }, + 20usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264SliceHeader), + "::", + stringify!(disable_deblocking_filter_idc) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).slice_alpha_c0_offset_div2) as usize - ptr as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264SliceHeader), + "::", + stringify!(slice_alpha_c0_offset_div2) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).slice_beta_offset_div2) as usize - ptr as usize }, + 25usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264SliceHeader), + "::", + stringify!(slice_beta_offset_div2) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pWeightTable) as usize - ptr as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264SliceHeader), + "::", + stringify!(pWeightTable) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoEncodeH265WeightTableFlags { + pub luma_weight_l0_flag: u16, + pub chroma_weight_l0_flag: u16, + pub luma_weight_l1_flag: u16, + pub chroma_weight_l1_flag: u16, +} +#[test] +fn bindgen_test_layout_StdVideoEncodeH265WeightTableFlags() { + const UNINIT: ::std::mem::MaybeUninit = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::(), + 8usize, + concat!("Size of: ", stringify!(StdVideoEncodeH265WeightTableFlags)) + ); + assert_eq!( + ::std::mem::align_of::(), + 2usize, + concat!( + "Alignment of ", + stringify!(StdVideoEncodeH265WeightTableFlags) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).luma_weight_l0_flag) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265WeightTableFlags), + "::", + stringify!(luma_weight_l0_flag) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).chroma_weight_l0_flag) as usize - ptr as usize }, + 2usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265WeightTableFlags), + "::", + stringify!(chroma_weight_l0_flag) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).luma_weight_l1_flag) as usize - ptr as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265WeightTableFlags), + "::", + stringify!(luma_weight_l1_flag) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).chroma_weight_l1_flag) as usize - ptr as usize }, + 6usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265WeightTableFlags), + "::", + stringify!(chroma_weight_l1_flag) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoEncodeH265WeightTable { + pub flags: StdVideoEncodeH265WeightTableFlags, + pub luma_log2_weight_denom: u8, + pub delta_chroma_log2_weight_denom: i8, + pub delta_luma_weight_l0: [i8; 15usize], + pub luma_offset_l0: [i8; 15usize], + pub delta_chroma_weight_l0: [[i8; 2usize]; 15usize], + pub delta_chroma_offset_l0: [[i8; 2usize]; 15usize], + pub delta_luma_weight_l1: [i8; 15usize], + pub luma_offset_l1: [i8; 15usize], + pub delta_chroma_weight_l1: [[i8; 2usize]; 15usize], + pub delta_chroma_offset_l1: [[i8; 2usize]; 15usize], +} +#[test] +fn bindgen_test_layout_StdVideoEncodeH265WeightTable() { + const UNINIT: ::std::mem::MaybeUninit = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::(), + 190usize, + concat!("Size of: ", stringify!(StdVideoEncodeH265WeightTable)) + ); + assert_eq!( + ::std::mem::align_of::(), + 2usize, + concat!("Alignment of ", stringify!(StdVideoEncodeH265WeightTable)) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265WeightTable), + "::", + stringify!(flags) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).luma_log2_weight_denom) as usize - ptr as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265WeightTable), + "::", + stringify!(luma_log2_weight_denom) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).delta_chroma_log2_weight_denom) as usize - ptr as usize + }, + 9usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265WeightTable), + "::", + stringify!(delta_chroma_log2_weight_denom) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).delta_luma_weight_l0) as usize - ptr as usize }, + 10usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265WeightTable), + "::", + stringify!(delta_luma_weight_l0) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).luma_offset_l0) as usize - ptr as usize }, + 25usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265WeightTable), + "::", + stringify!(luma_offset_l0) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).delta_chroma_weight_l0) as usize - ptr as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265WeightTable), + "::", + stringify!(delta_chroma_weight_l0) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).delta_chroma_offset_l0) as usize - ptr as usize }, + 70usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265WeightTable), + "::", + stringify!(delta_chroma_offset_l0) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).delta_luma_weight_l1) as usize - ptr as usize }, + 100usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265WeightTable), + "::", + stringify!(delta_luma_weight_l1) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).luma_offset_l1) as usize - ptr as usize }, + 115usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265WeightTable), + "::", + stringify!(luma_offset_l1) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).delta_chroma_weight_l1) as usize - ptr as usize }, + 130usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265WeightTable), + "::", + stringify!(delta_chroma_weight_l1) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).delta_chroma_offset_l1) as usize - ptr as usize }, + 160usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265WeightTable), + "::", + stringify!(delta_chroma_offset_l1) + ) + ); +} +#[repr(C)] +#[repr(align(4))] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoEncodeH265SliceSegmentHeaderFlags { + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize]>, + pub __bindgen_padding_0: u16, +} +#[test] +fn bindgen_test_layout_StdVideoEncodeH265SliceSegmentHeaderFlags() { + assert_eq!( + ::std::mem::size_of::(), + 4usize, + concat!( + "Size of: ", + stringify!(StdVideoEncodeH265SliceSegmentHeaderFlags) + ) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(StdVideoEncodeH265SliceSegmentHeaderFlags) + ) + ); +} +impl StdVideoEncodeH265SliceSegmentHeaderFlags { + #[inline] + pub fn first_slice_segment_in_pic_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_first_slice_segment_in_pic_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub fn no_output_of_prior_pics_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_no_output_of_prior_pics_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub fn dependent_slice_segment_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } + } + #[inline] + pub fn set_dependent_slice_segment_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 1u8, val as u64) + } + } + #[inline] + pub fn pic_output_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } + } + #[inline] + pub fn set_pic_output_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(3usize, 1u8, val as u64) + } + } + #[inline] + pub fn short_term_ref_pic_set_sps_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } + } + #[inline] + pub fn set_short_term_ref_pic_set_sps_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(4usize, 1u8, val as u64) + } + } + #[inline] + pub fn slice_temporal_mvp_enable_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) } + } + #[inline] + pub fn set_slice_temporal_mvp_enable_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(5usize, 1u8, val as u64) + } + } + #[inline] + pub fn slice_sao_luma_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) } + } + #[inline] + pub fn set_slice_sao_luma_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(6usize, 1u8, val as u64) + } + } + #[inline] + pub fn slice_sao_chroma_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) } + } + #[inline] + pub fn set_slice_sao_chroma_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(7usize, 1u8, val as u64) + } + } + #[inline] + pub fn num_ref_idx_active_override_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u32) } + } + #[inline] + pub fn set_num_ref_idx_active_override_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(8usize, 1u8, val as u64) + } + } + #[inline] + pub fn mvd_l1_zero_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 1u8) as u32) } + } + #[inline] + pub fn set_mvd_l1_zero_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(9usize, 1u8, val as u64) + } + } + #[inline] + pub fn cabac_init_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 1u8) as u32) } + } + #[inline] + pub fn set_cabac_init_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(10usize, 1u8, val as u64) + } + } + #[inline] + pub fn cu_chroma_qp_offset_enabled_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u32) } + } + #[inline] + pub fn set_cu_chroma_qp_offset_enabled_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(11usize, 1u8, val as u64) + } + } + #[inline] + pub fn deblocking_filter_override_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u32) } + } + #[inline] + pub fn set_deblocking_filter_override_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(12usize, 1u8, val as u64) + } + } + #[inline] + pub fn slice_deblocking_filter_disabled_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u32) } + } + #[inline] + pub fn set_slice_deblocking_filter_disabled_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(13usize, 1u8, val as u64) + } + } + #[inline] + pub fn collocated_from_l0_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 1u8) as u32) } + } + #[inline] + pub fn set_collocated_from_l0_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(14usize, 1u8, val as u64) + } + } + #[inline] + pub fn slice_loop_filter_across_slices_enabled_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(15usize, 1u8) as u32) } + } + #[inline] + pub fn set_slice_loop_filter_across_slices_enabled_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(15usize, 1u8, val as u64) + } + } + #[inline] + pub fn new_bitfield_1( + first_slice_segment_in_pic_flag: u32, + no_output_of_prior_pics_flag: u32, + dependent_slice_segment_flag: u32, + pic_output_flag: u32, + short_term_ref_pic_set_sps_flag: u32, + slice_temporal_mvp_enable_flag: u32, + slice_sao_luma_flag: u32, + slice_sao_chroma_flag: u32, + num_ref_idx_active_override_flag: u32, + mvd_l1_zero_flag: u32, + cabac_init_flag: u32, + cu_chroma_qp_offset_enabled_flag: u32, + deblocking_filter_override_flag: u32, + slice_deblocking_filter_disabled_flag: u32, + collocated_from_l0_flag: u32, + slice_loop_filter_across_slices_enabled_flag: u32, + ) -> __BindgenBitfieldUnit<[u8; 2usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let first_slice_segment_in_pic_flag: u32 = + unsafe { ::std::mem::transmute(first_slice_segment_in_pic_flag) }; + first_slice_segment_in_pic_flag as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let no_output_of_prior_pics_flag: u32 = + unsafe { ::std::mem::transmute(no_output_of_prior_pics_flag) }; + no_output_of_prior_pics_flag as u64 + }); + __bindgen_bitfield_unit.set(2usize, 1u8, { + let dependent_slice_segment_flag: u32 = + unsafe { ::std::mem::transmute(dependent_slice_segment_flag) }; + dependent_slice_segment_flag as u64 + }); + __bindgen_bitfield_unit.set(3usize, 1u8, { + let pic_output_flag: u32 = unsafe { ::std::mem::transmute(pic_output_flag) }; + pic_output_flag as u64 + }); + __bindgen_bitfield_unit.set(4usize, 1u8, { + let short_term_ref_pic_set_sps_flag: u32 = + unsafe { ::std::mem::transmute(short_term_ref_pic_set_sps_flag) }; + short_term_ref_pic_set_sps_flag as u64 + }); + __bindgen_bitfield_unit.set(5usize, 1u8, { + let slice_temporal_mvp_enable_flag: u32 = + unsafe { ::std::mem::transmute(slice_temporal_mvp_enable_flag) }; + slice_temporal_mvp_enable_flag as u64 + }); + __bindgen_bitfield_unit.set(6usize, 1u8, { + let slice_sao_luma_flag: u32 = unsafe { ::std::mem::transmute(slice_sao_luma_flag) }; + slice_sao_luma_flag as u64 + }); + __bindgen_bitfield_unit.set(7usize, 1u8, { + let slice_sao_chroma_flag: u32 = + unsafe { ::std::mem::transmute(slice_sao_chroma_flag) }; + slice_sao_chroma_flag as u64 + }); + __bindgen_bitfield_unit.set(8usize, 1u8, { + let num_ref_idx_active_override_flag: u32 = + unsafe { ::std::mem::transmute(num_ref_idx_active_override_flag) }; + num_ref_idx_active_override_flag as u64 + }); + __bindgen_bitfield_unit.set(9usize, 1u8, { + let mvd_l1_zero_flag: u32 = unsafe { ::std::mem::transmute(mvd_l1_zero_flag) }; + mvd_l1_zero_flag as u64 + }); + __bindgen_bitfield_unit.set(10usize, 1u8, { + let cabac_init_flag: u32 = unsafe { ::std::mem::transmute(cabac_init_flag) }; + cabac_init_flag as u64 + }); + __bindgen_bitfield_unit.set(11usize, 1u8, { + let cu_chroma_qp_offset_enabled_flag: u32 = + unsafe { ::std::mem::transmute(cu_chroma_qp_offset_enabled_flag) }; + cu_chroma_qp_offset_enabled_flag as u64 + }); + __bindgen_bitfield_unit.set(12usize, 1u8, { + let deblocking_filter_override_flag: u32 = + unsafe { ::std::mem::transmute(deblocking_filter_override_flag) }; + deblocking_filter_override_flag as u64 + }); + __bindgen_bitfield_unit.set(13usize, 1u8, { + let slice_deblocking_filter_disabled_flag: u32 = + unsafe { ::std::mem::transmute(slice_deblocking_filter_disabled_flag) }; + slice_deblocking_filter_disabled_flag as u64 + }); + __bindgen_bitfield_unit.set(14usize, 1u8, { + let collocated_from_l0_flag: u32 = + unsafe { ::std::mem::transmute(collocated_from_l0_flag) }; + collocated_from_l0_flag as u64 + }); + __bindgen_bitfield_unit.set(15usize, 1u8, { + let slice_loop_filter_across_slices_enabled_flag: u32 = + unsafe { ::std::mem::transmute(slice_loop_filter_across_slices_enabled_flag) }; + slice_loop_filter_across_slices_enabled_flag as u64 + }); + __bindgen_bitfield_unit + } +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoEncodeH265SliceSegmentLongTermRefPics { + pub num_long_term_sps: u8, + pub num_long_term_pics: u8, + pub lt_idx_sps: [u8; 32usize], + pub poc_lsb_lt: [u8; 16usize], + pub used_by_curr_pic_lt_flag: u16, + pub delta_poc_msb_present_flag: [u8; 48usize], + pub delta_poc_msb_cycle_lt: [u8; 48usize], +} +#[test] +fn bindgen_test_layout_StdVideoEncodeH265SliceSegmentLongTermRefPics() { + const UNINIT: ::std::mem::MaybeUninit = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::(), + 148usize, + concat!( + "Size of: ", + stringify!(StdVideoEncodeH265SliceSegmentLongTermRefPics) + ) + ); + assert_eq!( + ::std::mem::align_of::(), + 2usize, + concat!( + "Alignment of ", + stringify!(StdVideoEncodeH265SliceSegmentLongTermRefPics) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).num_long_term_sps) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265SliceSegmentLongTermRefPics), + "::", + stringify!(num_long_term_sps) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).num_long_term_pics) as usize - ptr as usize }, + 1usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265SliceSegmentLongTermRefPics), + "::", + stringify!(num_long_term_pics) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).lt_idx_sps) as usize - ptr as usize }, + 2usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265SliceSegmentLongTermRefPics), + "::", + stringify!(lt_idx_sps) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).poc_lsb_lt) as usize - ptr as usize }, + 34usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265SliceSegmentLongTermRefPics), + "::", + stringify!(poc_lsb_lt) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).used_by_curr_pic_lt_flag) as usize - ptr as usize }, + 50usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265SliceSegmentLongTermRefPics), + "::", + stringify!(used_by_curr_pic_lt_flag) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).delta_poc_msb_present_flag) as usize - ptr as usize }, + 52usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265SliceSegmentLongTermRefPics), + "::", + stringify!(delta_poc_msb_present_flag) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).delta_poc_msb_cycle_lt) as usize - ptr as usize }, + 100usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265SliceSegmentLongTermRefPics), + "::", + stringify!(delta_poc_msb_cycle_lt) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoEncodeH265SliceSegmentHeader { + pub flags: StdVideoEncodeH265SliceSegmentHeaderFlags, + pub slice_type: StdVideoH265SliceType, + pub slice_segment_address: u32, + pub short_term_ref_pic_set_idx: u8, + pub collocated_ref_idx: u8, + pub num_ref_idx_l0_active_minus1: u8, + pub num_ref_idx_l1_active_minus1: u8, + pub MaxNumMergeCand: u8, + pub slice_cb_qp_offset: i8, + pub slice_cr_qp_offset: i8, + pub slice_beta_offset_div2: i8, + pub slice_tc_offset_div2: i8, + pub slice_act_y_qp_offset: i8, + pub slice_act_cb_qp_offset: i8, + pub slice_act_cr_qp_offset: i8, + pub pShortTermRefPicSet: *const StdVideoH265ShortTermRefPicSet, + pub pLongTermRefPics: *const StdVideoEncodeH265SliceSegmentLongTermRefPics, + pub pWeightTable: *const StdVideoEncodeH265WeightTable, +} +#[test] +fn bindgen_test_layout_StdVideoEncodeH265SliceSegmentHeader() { + const UNINIT: ::std::mem::MaybeUninit = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::(), + 48usize, + concat!( + "Size of: ", + stringify!(StdVideoEncodeH265SliceSegmentHeader) + ) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!( + "Alignment of ", + stringify!(StdVideoEncodeH265SliceSegmentHeader) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265SliceSegmentHeader), + "::", + stringify!(flags) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).slice_type) as usize - ptr as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265SliceSegmentHeader), + "::", + stringify!(slice_type) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).slice_segment_address) as usize - ptr as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265SliceSegmentHeader), + "::", + stringify!(slice_segment_address) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).short_term_ref_pic_set_idx) as usize - ptr as usize }, + 12usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265SliceSegmentHeader), + "::", + stringify!(short_term_ref_pic_set_idx) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).collocated_ref_idx) as usize - ptr as usize }, + 13usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265SliceSegmentHeader), + "::", + stringify!(collocated_ref_idx) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).num_ref_idx_l0_active_minus1) as usize - ptr as usize + }, + 14usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265SliceSegmentHeader), + "::", + stringify!(num_ref_idx_l0_active_minus1) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).num_ref_idx_l1_active_minus1) as usize - ptr as usize + }, + 15usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265SliceSegmentHeader), + "::", + stringify!(num_ref_idx_l1_active_minus1) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).MaxNumMergeCand) as usize - ptr as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265SliceSegmentHeader), + "::", + stringify!(MaxNumMergeCand) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).slice_cb_qp_offset) as usize - ptr as usize }, + 17usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265SliceSegmentHeader), + "::", + stringify!(slice_cb_qp_offset) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).slice_cr_qp_offset) as usize - ptr as usize }, + 18usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265SliceSegmentHeader), + "::", + stringify!(slice_cr_qp_offset) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).slice_beta_offset_div2) as usize - ptr as usize }, + 19usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265SliceSegmentHeader), + "::", + stringify!(slice_beta_offset_div2) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).slice_tc_offset_div2) as usize - ptr as usize }, + 20usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265SliceSegmentHeader), + "::", + stringify!(slice_tc_offset_div2) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).slice_act_y_qp_offset) as usize - ptr as usize }, + 21usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265SliceSegmentHeader), + "::", + stringify!(slice_act_y_qp_offset) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).slice_act_cb_qp_offset) as usize - ptr as usize }, + 22usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265SliceSegmentHeader), + "::", + stringify!(slice_act_cb_qp_offset) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).slice_act_cr_qp_offset) as usize - ptr as usize }, + 23usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265SliceSegmentHeader), + "::", + stringify!(slice_act_cr_qp_offset) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pShortTermRefPicSet) as usize - ptr as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265SliceSegmentHeader), + "::", + stringify!(pShortTermRefPicSet) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pLongTermRefPics) as usize - ptr as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265SliceSegmentHeader), + "::", + stringify!(pLongTermRefPics) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pWeightTable) as usize - ptr as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265SliceSegmentHeader), + "::", + stringify!(pWeightTable) + ) + ); +} +#[repr(C)] +#[repr(align(4))] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoEncodeH265ReferenceModificationFlags { + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, + pub __bindgen_padding_0: [u8; 3usize], +} +#[test] +fn bindgen_test_layout_StdVideoEncodeH265ReferenceModificationFlags() { + assert_eq!( + ::std::mem::size_of::(), + 4usize, + concat!( + "Size of: ", + stringify!(StdVideoEncodeH265ReferenceModificationFlags) + ) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(StdVideoEncodeH265ReferenceModificationFlags) + ) + ); +} +impl StdVideoEncodeH265ReferenceModificationFlags { + #[inline] + pub fn ref_pic_list_modification_flag_l0(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_ref_pic_list_modification_flag_l0(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub fn ref_pic_list_modification_flag_l1(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_ref_pic_list_modification_flag_l1(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub fn new_bitfield_1( + ref_pic_list_modification_flag_l0: u32, + ref_pic_list_modification_flag_l1: u32, + ) -> __BindgenBitfieldUnit<[u8; 1usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let ref_pic_list_modification_flag_l0: u32 = + unsafe { ::std::mem::transmute(ref_pic_list_modification_flag_l0) }; + ref_pic_list_modification_flag_l0 as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let ref_pic_list_modification_flag_l1: u32 = + unsafe { ::std::mem::transmute(ref_pic_list_modification_flag_l1) }; + ref_pic_list_modification_flag_l1 as u64 + }); + __bindgen_bitfield_unit + } +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoEncodeH265ReferenceModifications { + pub flags: StdVideoEncodeH265ReferenceModificationFlags, + pub referenceList0ModificationsCount: u8, + pub pReferenceList0Modifications: *const u8, + pub referenceList1ModificationsCount: u8, + pub pReferenceList1Modifications: *const u8, +} +#[test] +fn bindgen_test_layout_StdVideoEncodeH265ReferenceModifications() { + const UNINIT: ::std::mem::MaybeUninit = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::(), + 32usize, + concat!( + "Size of: ", + stringify!(StdVideoEncodeH265ReferenceModifications) + ) + ); + assert_eq!( + ::std::mem::align_of::(), + 8usize, + concat!( + "Alignment of ", + stringify!(StdVideoEncodeH265ReferenceModifications) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265ReferenceModifications), + "::", + stringify!(flags) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).referenceList0ModificationsCount) as usize - ptr as usize + }, + 4usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265ReferenceModifications), + "::", + stringify!(referenceList0ModificationsCount) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).pReferenceList0Modifications) as usize - ptr as usize + }, + 8usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265ReferenceModifications), + "::", + stringify!(pReferenceList0Modifications) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).referenceList1ModificationsCount) as usize - ptr as usize + }, + 16usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265ReferenceModifications), + "::", + stringify!(referenceList1ModificationsCount) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).pReferenceList1Modifications) as usize - ptr as usize + }, + 24usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265ReferenceModifications), + "::", + stringify!(pReferenceList1Modifications) + ) + ); +} +#[repr(C)] +#[repr(align(4))] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoEncodeH265PictureInfoFlags { + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, + pub __bindgen_padding_0: [u8; 3usize], +} +#[test] +fn bindgen_test_layout_StdVideoEncodeH265PictureInfoFlags() { + assert_eq!( + ::std::mem::size_of::(), + 4usize, + concat!("Size of: ", stringify!(StdVideoEncodeH265PictureInfoFlags)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(StdVideoEncodeH265PictureInfoFlags) + ) + ); +} +impl StdVideoEncodeH265PictureInfoFlags { + #[inline] + pub fn is_reference_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_is_reference_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub fn IrapPicFlag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_IrapPicFlag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub fn long_term_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } + } + #[inline] + pub fn set_long_term_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(2usize, 1u8, val as u64) + } + } + #[inline] + pub fn discardable_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } + } + #[inline] + pub fn set_discardable_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(3usize, 1u8, val as u64) + } + } + #[inline] + pub fn cross_layer_bla_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } + } + #[inline] + pub fn set_cross_layer_bla_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(4usize, 1u8, val as u64) + } + } + #[inline] + pub fn new_bitfield_1( + is_reference_flag: u32, + IrapPicFlag: u32, + long_term_flag: u32, + discardable_flag: u32, + cross_layer_bla_flag: u32, + ) -> __BindgenBitfieldUnit<[u8; 1usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let is_reference_flag: u32 = unsafe { ::std::mem::transmute(is_reference_flag) }; + is_reference_flag as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let IrapPicFlag: u32 = unsafe { ::std::mem::transmute(IrapPicFlag) }; + IrapPicFlag as u64 + }); + __bindgen_bitfield_unit.set(2usize, 1u8, { + let long_term_flag: u32 = unsafe { ::std::mem::transmute(long_term_flag) }; + long_term_flag as u64 + }); + __bindgen_bitfield_unit.set(3usize, 1u8, { + let discardable_flag: u32 = unsafe { ::std::mem::transmute(discardable_flag) }; + discardable_flag as u64 + }); + __bindgen_bitfield_unit.set(4usize, 1u8, { + let cross_layer_bla_flag: u32 = unsafe { ::std::mem::transmute(cross_layer_bla_flag) }; + cross_layer_bla_flag as u64 + }); + __bindgen_bitfield_unit + } +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoEncodeH265PictureInfo { + pub flags: StdVideoEncodeH265PictureInfoFlags, + pub PictureType: StdVideoH265PictureType, + pub sps_video_parameter_set_id: u8, + pub pps_seq_parameter_set_id: u8, + pub pps_pic_parameter_set_id: u8, + pub PicOrderCntVal: i32, + pub TemporalId: u8, +} +#[test] +fn bindgen_test_layout_StdVideoEncodeH265PictureInfo() { + const UNINIT: ::std::mem::MaybeUninit = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::(), + 20usize, + concat!("Size of: ", stringify!(StdVideoEncodeH265PictureInfo)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!("Alignment of ", stringify!(StdVideoEncodeH265PictureInfo)) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265PictureInfo), + "::", + stringify!(flags) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).PictureType) as usize - ptr as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265PictureInfo), + "::", + stringify!(PictureType) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).sps_video_parameter_set_id) as usize - ptr as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265PictureInfo), + "::", + stringify!(sps_video_parameter_set_id) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pps_seq_parameter_set_id) as usize - ptr as usize }, + 9usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265PictureInfo), + "::", + stringify!(pps_seq_parameter_set_id) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pps_pic_parameter_set_id) as usize - ptr as usize }, + 10usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265PictureInfo), + "::", + stringify!(pps_pic_parameter_set_id) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).PicOrderCntVal) as usize - ptr as usize }, + 12usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265PictureInfo), + "::", + stringify!(PicOrderCntVal) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).TemporalId) as usize - ptr as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265PictureInfo), + "::", + stringify!(TemporalId) + ) + ); +} +#[repr(C)] +#[repr(align(4))] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoEncodeH265ReferenceInfoFlags { + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, + pub __bindgen_padding_0: [u8; 3usize], +} +#[test] +fn bindgen_test_layout_StdVideoEncodeH265ReferenceInfoFlags() { + assert_eq!( + ::std::mem::size_of::(), + 4usize, + concat!( + "Size of: ", + stringify!(StdVideoEncodeH265ReferenceInfoFlags) + ) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(StdVideoEncodeH265ReferenceInfoFlags) + ) + ); +} +impl StdVideoEncodeH265ReferenceInfoFlags { + #[inline] + pub fn used_for_long_term_reference(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_used_for_long_term_reference(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(0usize, 1u8, val as u64) + } + } + #[inline] + pub fn unused_for_reference(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_unused_for_reference(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(1usize, 1u8, val as u64) + } + } + #[inline] + pub fn new_bitfield_1( + used_for_long_term_reference: u32, + unused_for_reference: u32, + ) -> __BindgenBitfieldUnit<[u8; 1usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let used_for_long_term_reference: u32 = + unsafe { ::std::mem::transmute(used_for_long_term_reference) }; + used_for_long_term_reference as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let unused_for_reference: u32 = unsafe { ::std::mem::transmute(unused_for_reference) }; + unused_for_reference as u64 + }); + __bindgen_bitfield_unit + } +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoEncodeH265ReferenceInfo { + pub flags: StdVideoEncodeH265ReferenceInfoFlags, + pub PicOrderCntVal: i32, + pub TemporalId: u8, +} +#[test] +fn bindgen_test_layout_StdVideoEncodeH265ReferenceInfo() { + const UNINIT: ::std::mem::MaybeUninit = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::(), + 12usize, + concat!("Size of: ", stringify!(StdVideoEncodeH265ReferenceInfo)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!("Alignment of ", stringify!(StdVideoEncodeH265ReferenceInfo)) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265ReferenceInfo), + "::", + stringify!(flags) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).PicOrderCntVal) as usize - ptr as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265ReferenceInfo), + "::", + stringify!(PicOrderCntVal) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).TemporalId) as usize - ptr as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265ReferenceInfo), + "::", + stringify!(TemporalId) + ) + ); +} diff --git a/third_party/rust/ash/src/vk/platform_types.rs b/third_party/rust/ash/src/vk/platform_types.rs new file mode 100644 index 0000000000..4d6ffe0597 --- /dev/null +++ b/third_party/rust/ash/src/vk/platform_types.rs @@ -0,0 +1,41 @@ +#![allow(non_camel_case_types)] + +use std::os::raw::*; +pub type RROutput = c_ulong; +pub type VisualID = c_uint; +pub type Display = *const c_void; +pub type Window = c_ulong; +pub type xcb_connection_t = c_void; +pub type xcb_window_t = u32; +pub type xcb_visualid_t = u32; +pub type MirConnection = *const c_void; +pub type MirSurface = *const c_void; +pub type HINSTANCE = *const c_void; +pub type HWND = *const c_void; +pub type wl_display = c_void; +pub type wl_surface = c_void; +pub type HANDLE = *mut c_void; +pub type HMONITOR = HANDLE; +pub type DWORD = c_ulong; +pub type LPCWSTR = *const u16; +pub type zx_handle_t = u32; +pub type _screen_context = c_void; +pub type _screen_window = c_void; +pub type SECURITY_ATTRIBUTES = c_void; +// Opaque types +pub type ANativeWindow = c_void; +pub type AHardwareBuffer = c_void; +pub type CAMetalLayer = c_void; +// This definition is behind an NDA with a best effort guess from +// https://github.com/google/gapid/commit/22aafebec4638c6aaa77667096bca30f6e842d95#diff-ab3ab4a7d89b4fc8a344ff4e9332865f268ea1669ee379c1b516a954ecc2e7a6R20-R21 +pub type GgpStreamDescriptor = u32; +pub type GgpFrameToken = u64; +pub type IDirectFB = c_void; +pub type IDirectFBSurface = c_void; +pub type __IOSurface = c_void; +pub type IOSurfaceRef = *mut __IOSurface; +pub type MTLBuffer_id = *mut c_void; +pub type MTLCommandQueue_id = *mut c_void; +pub type MTLDevice_id = *mut c_void; +pub type MTLSharedEvent_id = *mut c_void; +pub type MTLTexture_id = *mut c_void; diff --git a/third_party/rust/ash/src/vk/prelude.rs b/third_party/rust/ash/src/vk/prelude.rs new file mode 100644 index 0000000000..cb2f17718c --- /dev/null +++ b/third_party/rust/ash/src/vk/prelude.rs @@ -0,0 +1,61 @@ +use crate::vk; + +/// Holds 24 bits in the least significant bits of memory, +/// and 8 bytes in the most significant bits of that memory, +/// occupying a single [`u32`] in total. This is commonly used in +/// [acceleration structure instances] such as +/// [`vk::AccelerationStructureInstanceKHR`], +/// [`vk::AccelerationStructureSRTMotionInstanceNV`] and +/// [`vk::AccelerationStructureMatrixMotionInstanceNV`]. +/// +/// [acceleration structure instances]: https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureInstanceKHR.html#_description +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Debug)] +#[repr(transparent)] +pub struct Packed24_8(u32); + +impl Packed24_8 { + pub fn new(low_24: u32, high_8: u8) -> Self { + Self((low_24 & 0x00ff_ffff) | (u32::from(high_8) << 24)) + } + + /// Extracts the least-significant 24 bits (3 bytes) of this integer + pub fn low_24(&self) -> u32 { + self.0 & 0xffffff + } + + /// Extracts the most significant 8 bits (single byte) of this integer + pub fn high_8(&self) -> u8 { + (self.0 >> 24) as u8 + } +} + +impl vk::ColorComponentFlags { + /// Contraction of [`R`][Self::R] | [`G`][Self::G] | [`B`][Self::B] | [`A`][Self::A] + pub const RGBA: Self = Self(Self::R.0 | Self::G.0 | Self::B.0 | Self::A.0); +} + +impl From for vk::Extent3D { + fn from(value: vk::Extent2D) -> Self { + Self { + width: value.width, + height: value.height, + depth: 1, + } + } +} + +impl From for vk::Rect2D { + fn from(extent: vk::Extent2D) -> Self { + Self { + offset: Default::default(), + extent, + } + } +} + +/// Structures implementing this trait are layout-compatible with [`vk::BaseInStructure`] and +/// [`vk::BaseOutStructure`]. Such structures have an `s_type` field indicating its type, which +/// must always match the value of [`TaggedStructure::STRUCTURE_TYPE`]. +pub unsafe trait TaggedStructure { + const STRUCTURE_TYPE: vk::StructureType; +} -- cgit v1.2.3