|
|
|
|
Quellverzeichnis extensions_generated.rs
Interaktion und
Portierbarkeitunbekannt
|
|
Spracherkennung für: .rs vermutete Sprache: Unknown {[0] [0] [0]} [Methode: Schwerpunktbildung, einfache Gewichte, sechs Dimensionen]
#![allow(unused_imports)]
use crate::vk::*;
use core::ffi::*;
#[doc = "Extensions tagged AMD"]
pub mod amd {
#[doc = "VK_AMD_rasterization_order"]
pub mod rasterization_order {
use super::super::*;
pub use {
crate::vk::AMD_RASTERIZATION_ORDER_NAME as NAME,
crate::vk::AMD_RASTERIZATION_ORDER_SPEC_VERSION as SPEC_VERSION,
};
}
#[doc = "VK_AMD_shader_trinary_minmax"]
pub mod shader_trinary_minmax {
use super::super::*;
pub use {
crate::vk::AMD_SHADER_TRINARY_MINMAX_NAME as NAME,
crate::vk::AMD_SHADER_TRINARY_MINMAX_SPEC_VERSION as SPEC_VERSION,
};
}
#[doc = "VK_AMD_shader_explicit_vertex_parameter"]
pub mod shader_explicit_vertex_parameter {
use super::super::*;
pub use {
crate::vk::AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_NAME as NAME,
crate::vk::AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_SPEC_VERSION as SPEC_VERSION,
};
}
#[doc = "VK_AMD_gcn_shader"]
pub mod gcn_shader {
use super::super::*;
pub use {
crate::vk::AMD_GCN_SHADER_NAME as NAME,
crate::vk::AMD_GCN_SHADER_SPEC_VERSION as SPEC_VERSION,
};
}
#[doc = "VK_AMD_draw_indirect_count"]
pub mod draw_indirect_count {
use super::super::*;
pub use {
crate::vk::AMD_DRAW_INDIRECT_COUNT_NAME as NAME,
crate::vk::AMD_DRAW_INDIRECT_COUNT_SPEC_VERSION as SPEC_VERSION,
};
#[doc = "VK_AMD_draw_indirect_count device-level functions"]
#[derive(Clone)]
pub struct Device {
pub(crate) fp: DeviceFn,
pub(crate) handle: crate::vk::Device,
}
impl Device {
pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
let handle = device.handle();
let fp = DeviceFn::load(|name| unsafe {
core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
});
Self { handle, fp }
}
#[inline]
pub fn fp(&self) -> &DeviceFn {
&self.fp
}
#[inline]
pub fn device(&self) -> crate::vk::Device {
self.handle
}
}
#[derive(Clone)]
#[doc = "Raw VK_AMD_draw_indirect_count device-level function pointers"]
pub struct DeviceFn {
pub cmd_draw_indirect_count_amd: PFN_vkCmdDrawIndirectCount,
pub cmd_draw_indexed_indirect_count_amd: PFN_vkCmdDrawIndexedIndirectCount,
}
unsafe impl Send for DeviceFn {}
unsafe impl Sync for DeviceFn {}
impl DeviceFn {
pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
Self::load_erased(&mut f)
}
fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
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 =
CStr::from_bytes_with_nul_unchecked(b"vkCmdDrawIndirectCountAMD\0");
let val = _f(cname);
if val.is_null() {
cmd_draw_indirect_count_amd
} else {
::core::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 = CStr::from_bytes_with_nul_unchecked(
b"vkCmdDrawIndexedIndirectCountAMD\0",
);
let val = _f(cname);
if val.is_null() {
cmd_draw_indexed_indirect_count_amd
} else {
::core::mem::transmute(val)
}
},
}
}
}
}
#[doc = "VK_AMD_negative_viewport_height"]
pub mod negative_viewport_height {
use super::super::*;
pub use {
crate::vk::AMD_NEGATIVE_VIEWPORT_HEIGHT_NAME as NAME,
crate::vk::AMD_NEGATIVE_VIEWPORT_HEIGHT_SPEC_VERSION as SPEC_VERSION,
};
}
#[doc = "VK_AMD_gpu_shader_half_float"]
pub mod gpu_shader_half_float {
use super::super::*;
pub use {
crate::vk::AMD_GPU_SHADER_HALF_FLOAT_NAME as NAME,
crate::vk::AMD_GPU_SHADER_HALF_FLOAT_SPEC_VERSION as SPEC_VERSION,
};
}
#[doc = "VK_AMD_shader_ballot"]
pub mod shader_ballot {
use super::super::*;
pub use {
crate::vk::AMD_SHADER_BALLOT_NAME as NAME,
crate::vk::AMD_SHADER_BALLOT_SPEC_VERSION as SPEC_VERSION,
};
}
#[doc = "VK_AMD_texture_gather_bias_lod"]
pub mod texture_gather_bias_lod {
use super::super::*;
pub use {
crate::vk::AMD_TEXTURE_GATHER_BIAS_LOD_NAME as NAME,
crate::vk::AMD_TEXTURE_GATHER_BIAS_LOD_SPEC_VERSION as SPEC_VERSION,
};
}
#[doc = "VK_AMD_shader_info"]
pub mod shader_info {
use super::super::*;
pub use {
crate::vk::AMD_SHADER_INFO_NAME as NAME,
crate::vk::AMD_SHADER_INFO_SPEC_VERSION as SPEC_VERSION,
};
#[doc = "VK_AMD_shader_info device-level functions"]
#[derive(Clone)]
pub struct Device {
pub(crate) fp: DeviceFn,
pub(crate) handle: crate::vk::Device,
}
impl Device {
pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
let handle = device.handle();
let fp = DeviceFn::load(|name| unsafe {
core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
});
Self { handle, fp }
}
#[inline]
pub fn fp(&self) -> &DeviceFn {
&self.fp
}
#[inline]
pub fn device(&self) -> crate::vk::Device {
self.handle
}
}
#[derive(Clone)]
#[doc = "Raw VK_AMD_shader_info device-level function pointers"]
pub struct DeviceFn {
pub get_shader_info_amd: PFN_vkGetShaderInfoAMD,
}
unsafe impl Send for DeviceFn {}
unsafe impl Sync for DeviceFn {}
impl DeviceFn {
pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
Self::load_erased(&mut f)
}
fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
Self {
get_shader_info_amd: unsafe {
unsafe extern "system" fn get_shader_info_amd(
_device: crate::vk::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 = CStr::from_bytes_with_nul_unchecked(b"vkGetShaderInfoAMD\0");
let val = _f(cname);
if val.is_null() {
get_shader_info_amd
} else {
::core::mem::transmute(val)
}
},
}
}
}
}
#[doc = "VK_AMD_shader_image_load_store_lod"]
pub mod shader_image_load_store_lod {
use super::super::*;
pub use {
crate::vk::AMD_SHADER_IMAGE_LOAD_STORE_LOD_NAME as NAME,
crate::vk::AMD_SHADER_IMAGE_LOAD_STORE_LOD_SPEC_VERSION as SPEC_VERSION,
};
}
#[doc = "VK_AMD_gpu_shader_int16"]
pub mod gpu_shader_int16 {
use super::super::*;
pub use {
crate::vk::AMD_GPU_SHADER_INT16_NAME as NAME,
crate::vk::AMD_GPU_SHADER_INT16_SPEC_VERSION as SPEC_VERSION,
};
}
#[doc = "VK_AMD_mixed_attachment_samples"]
pub mod mixed_attachment_samples {
use super::super::*;
pub use {
crate::vk::AMD_MIXED_ATTACHMENT_SAMPLES_NAME as NAME,
crate::vk::AMD_MIXED_ATTACHMENT_SAMPLES_SPEC_VERSION as SPEC_VERSION,
};
}
#[doc = "VK_AMD_shader_fragment_mask"]
pub mod shader_fragment_mask {
use super::super::*;
pub use {
crate::vk::AMD_SHADER_FRAGMENT_MASK_NAME as NAME,
crate::vk::AMD_SHADER_FRAGMENT_MASK_SPEC_VERSION as SPEC_VERSION,
};
}
#[doc = "VK_AMD_buffer_marker"]
pub mod buffer_marker {
use super::super::*;
pub use {
crate::vk::AMD_BUFFER_MARKER_NAME as NAME,
crate::vk::AMD_BUFFER_MARKER_SPEC_VERSION as SPEC_VERSION,
};
#[doc = "VK_AMD_buffer_marker device-level functions"]
#[derive(Clone)]
pub struct Device {
pub(crate) fp: DeviceFn,
pub(crate) handle: crate::vk::Device,
}
impl Device {
pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
let handle = device.handle();
let fp = DeviceFn::load(|name| unsafe {
core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
});
Self { handle, fp }
}
#[inline]
pub fn fp(&self) -> &DeviceFn {
&self.fp
}
#[inline]
pub fn device(&self) -> crate::vk::Device {
self.handle
}
}
#[derive(Clone)]
#[doc = "Raw VK_AMD_buffer_marker device-level function pointers"]
pub struct DeviceFn {
pub cmd_write_buffer_marker_amd: PFN_vkCmdWriteBufferMarkerAMD,
}
unsafe impl Send for DeviceFn {}
unsafe impl Sync for DeviceFn {}
impl DeviceFn {
pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
Self::load_erased(&mut f)
}
fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
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 =
CStr::from_bytes_with_nul_unchecked(b"vkCmdWriteBufferMarkerAMD\0");
let val = _f(cname);
if val.is_null() {
cmd_write_buffer_marker_amd
} else {
::core::mem::transmute(val)
}
},
}
}
}
}
#[doc = "VK_AMD_pipeline_compiler_control"]
pub mod pipeline_compiler_control {
use super::super::*;
pub use {
crate::vk::AMD_PIPELINE_COMPILER_CONTROL_NAME as NAME,
crate::vk::AMD_PIPELINE_COMPILER_CONTROL_SPEC_VERSION as SPEC_VERSION,
};
}
#[doc = "VK_AMD_shader_core_properties"]
pub mod shader_core_properties {
use super::super::*;
pub use {
crate::vk::AMD_SHADER_CORE_PROPERTIES_NAME as NAME,
crate::vk::AMD_SHADER_CORE_PROPERTIES_SPEC_VERSION as SPEC_VERSION,
};
}
#[doc = "VK_AMD_memory_overallocation_behavior"]
pub mod memory_overallocation_behavior {
use super::super::*;
pub use {
crate::vk::AMD_MEMORY_OVERALLOCATION_BEHAVIOR_NAME as NAME,
crate::vk::AMD_MEMORY_OVERALLOCATION_BEHAVIOR_SPEC_VERSION as SPEC_VERSION,
};
}
#[doc = "VK_AMD_display_native_hdr"]
pub mod display_native_hdr {
use super::super::*;
pub use {
crate::vk::AMD_DISPLAY_NATIVE_HDR_NAME as NAME,
crate::vk::AMD_DISPLAY_NATIVE_HDR_SPEC_VERSION as SPEC_VERSION,
};
#[doc = "VK_AMD_display_native_hdr device-level functions"]
#[derive(Clone)]
pub struct Device {
pub(crate) fp: DeviceFn,
pub(crate) handle: crate::vk::Device,
}
impl Device {
pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
let handle = device.handle();
let fp = DeviceFn::load(|name| unsafe {
core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
});
Self { handle, fp }
}
#[inline]
pub fn fp(&self) -> &DeviceFn {
&self.fp
}
#[inline]
pub fn device(&self) -> crate::vk::Device {
self.handle
}
}
#[derive(Clone)]
#[doc = "Raw VK_AMD_display_native_hdr device-level function pointers"]
pub struct DeviceFn {
pub set_local_dimming_amd: PFN_vkSetLocalDimmingAMD,
}
unsafe impl Send for DeviceFn {}
unsafe impl Sync for DeviceFn {}
impl DeviceFn {
pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
Self::load_erased(&mut f)
}
fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
Self {
set_local_dimming_amd: unsafe {
unsafe extern "system" fn set_local_dimming_amd(
_device: crate::vk::Device,
_swap_chain: SwapchainKHR,
_local_dimming_enable: Bool32,
) {
panic!(concat!(
"Unable to load ",
stringify!(set_local_dimming_amd)
))
}
let cname = CStr::from_bytes_with_nul_unchecked(b"vkSetLocalDimmingAMD\0");
let val = _f(cname);
if val.is_null() {
set_local_dimming_amd
} else {
::core::mem::transmute(val)
}
},
}
}
}
}
#[doc = "VK_AMD_shader_core_properties2"]
pub mod shader_core_properties2 {
use super::super::*;
pub use {
crate::vk::AMD_SHADER_CORE_PROPERTIES2_NAME as NAME,
crate::vk::AMD_SHADER_CORE_PROPERTIES2_SPEC_VERSION as SPEC_VERSION,
};
}
#[doc = "VK_AMD_device_coherent_memory"]
pub mod device_coherent_memory {
use super::super::*;
pub use {
crate::vk::AMD_DEVICE_COHERENT_MEMORY_NAME as NAME,
crate::vk::AMD_DEVICE_COHERENT_MEMORY_SPEC_VERSION as SPEC_VERSION,
};
}
#[doc = "VK_AMD_shader_early_and_late_fragment_tests"]
pub mod shader_early_and_late_fragment_tests {
use super::super::*;
pub use {
crate::vk::AMD_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_NAME as NAME,
crate::vk::AMD_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_SPEC_VERSION as SPEC_VERSION,
};
}
}
#[doc = "Extensions tagged AMDX"]
pub mod amdx {
#[doc = "VK_AMDX_shader_enqueue"]
pub mod shader_enqueue {
use super::super::*;
pub use {
crate::vk::AMDX_SHADER_ENQUEUE_NAME as NAME,
crate::vk::AMDX_SHADER_ENQUEUE_SPEC_VERSION as SPEC_VERSION,
};
#[doc = "VK_AMDX_shader_enqueue device-level functions"]
#[derive(Clone)]
pub struct Device {
pub(crate) fp: DeviceFn,
pub(crate) handle: crate::vk::Device,
}
impl Device {
pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
let handle = device.handle();
let fp = DeviceFn::load(|name| unsafe {
core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
});
Self { handle, fp }
}
#[inline]
pub fn fp(&self) -> &DeviceFn {
&self.fp
}
#[inline]
pub fn device(&self) -> crate::vk::Device {
self.handle
}
}
#[derive(Clone)]
#[doc = "Raw VK_AMDX_shader_enqueue device-level function pointers"]
pub struct DeviceFn {
pub create_execution_graph_pipelines_amdx: PFN_vkCreateExecutionGraphPipelinesAMDX,
pub get_execution_graph_pipeline_scratch_size_amdx:
PFN_vkGetExecutionGraphPipelineScratchSizeAMDX,
pub get_execution_graph_pipeline_node_index_amdx:
PFN_vkGetExecutionGraphPipelineNodeIndexAMDX,
pub cmd_initialize_graph_scratch_memory_amdx: PFN_vkCmdInitializeGraphScratchMemoryAMDX,
pub cmd_dispatch_graph_amdx: PFN_vkCmdDispatchGraphAMDX,
pub cmd_dispatch_graph_indirect_amdx: PFN_vkCmdDispatchGraphIndirectAMDX,
pub cmd_dispatch_graph_indirect_count_amdx: PFN_vkCmdDispatchGraphIndirectCountAMDX,
}
unsafe impl Send for DeviceFn {}
unsafe impl Sync for DeviceFn {}
impl DeviceFn {
pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
Self::load_erased(&mut f)
}
fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
Self {
create_execution_graph_pipelines_amdx: unsafe {
unsafe extern "system" fn create_execution_graph_pipelines_amdx(
_device: crate::vk::Device,
_pipeline_cache: PipelineCache,
_create_info_count: u32,
_p_create_infos: *const ExecutionGraphPipelineCreateInfoAMDX<'_>,
_p_allocator: *const AllocationCallbacks<'_>,
_p_pipelines: *mut Pipeline,
) -> Result {
panic!(concat!(
"Unable to load ",
stringify!(create_execution_graph_pipelines_amdx)
))
}
let cname = CStr::from_bytes_with_nul_unchecked(
b"vkCreateExecutionGraphPipelinesAMDX\0",
);
let val = _f(cname);
if val.is_null() {
create_execution_graph_pipelines_amdx
} else {
::core::mem::transmute(val)
}
},
get_execution_graph_pipeline_scratch_size_amdx: unsafe {
unsafe extern "system" fn get_execution_graph_pipeline_scratch_size_amdx(
_device: crate::vk::Device,
_execution_graph: Pipeline,
_p_size_info: *mut ExecutionGraphPipelineScratchSizeAMDX<'_>,
) -> Result {
panic!(concat!(
"Unable to load ",
stringify!(get_execution_graph_pipeline_scratch_size_amdx)
))
}
let cname = CStr::from_bytes_with_nul_unchecked(
b"vkGetExecutionGraphPipelineScratchSizeAMDX\0",
);
let val = _f(cname);
if val.is_null() {
get_execution_graph_pipeline_scratch_size_amdx
} else {
::core::mem::transmute(val)
}
},
get_execution_graph_pipeline_node_index_amdx: unsafe {
unsafe extern "system" fn get_execution_graph_pipeline_node_index_amdx(
_device: crate::vk::Device,
_execution_graph: Pipeline,
_p_node_info: *const PipelineShaderStageNodeCreateInfoAMDX<'_>,
_p_node_index: *mut u32,
) -> Result {
panic!(concat!(
"Unable to load ",
stringify!(get_execution_graph_pipeline_node_index_amdx)
))
}
let cname = CStr::from_bytes_with_nul_unchecked(
b"vkGetExecutionGraphPipelineNodeIndexAMDX\0",
);
let val = _f(cname);
if val.is_null() {
get_execution_graph_pipeline_node_index_amdx
} else {
::core::mem::transmute(val)
}
},
cmd_initialize_graph_scratch_memory_amdx: unsafe {
unsafe extern "system" fn cmd_initialize_graph_scratch_memory_amdx(
_command_buffer: CommandBuffer,
_scratch: DeviceAddress,
) {
panic!(concat!(
"Unable to load ",
stringify!(cmd_initialize_graph_scratch_memory_amdx)
))
}
let cname = CStr::from_bytes_with_nul_unchecked(
b"vkCmdInitializeGraphScratchMemoryAMDX\0",
);
let val = _f(cname);
if val.is_null() {
cmd_initialize_graph_scratch_memory_amdx
} else {
::core::mem::transmute(val)
}
},
cmd_dispatch_graph_amdx: unsafe {
unsafe extern "system" fn cmd_dispatch_graph_amdx(
_command_buffer: CommandBuffer,
_scratch: DeviceAddress,
_p_count_info: *const DispatchGraphCountInfoAMDX,
) {
panic!(concat!(
"Unable to load ",
stringify!(cmd_dispatch_graph_amdx)
))
}
let cname =
CStr::from_bytes_with_nul_unchecked(b"vkCmdDispatchGraphAMDX\0");
let val = _f(cname);
if val.is_null() {
cmd_dispatch_graph_amdx
} else {
::core::mem::transmute(val)
}
},
cmd_dispatch_graph_indirect_amdx: unsafe {
unsafe extern "system" fn cmd_dispatch_graph_indirect_amdx(
_command_buffer: CommandBuffer,
_scratch: DeviceAddress,
_p_count_info: *const DispatchGraphCountInfoAMDX,
) {
panic!(concat!(
"Unable to load ",
stringify!(cmd_dispatch_graph_indirect_amdx)
))
}
let cname = CStr::from_bytes_with_nul_unchecked(
b"vkCmdDispatchGraphIndirectAMDX\0",
);
let val = _f(cname);
if val.is_null() {
cmd_dispatch_graph_indirect_amdx
} else {
::core::mem::transmute(val)
}
},
cmd_dispatch_graph_indirect_count_amdx: unsafe {
unsafe extern "system" fn cmd_dispatch_graph_indirect_count_amdx(
_command_buffer: CommandBuffer,
_scratch: DeviceAddress,
_count_info: DeviceAddress,
) {
panic!(concat!(
"Unable to load ",
stringify!(cmd_dispatch_graph_indirect_count_amdx)
))
}
let cname = CStr::from_bytes_with_nul_unchecked(
b"vkCmdDispatchGraphIndirectCountAMDX\0",
);
let val = _f(cname);
if val.is_null() {
cmd_dispatch_graph_indirect_count_amdx
} else {
::core::mem::transmute(val)
}
},
}
}
}
}
}
#[doc = "Extensions tagged ANDROID"]
pub mod android {
#[doc = "VK_ANDROID_native_buffer"]
pub mod native_buffer {
use super::super::*;
pub use {
crate::vk::ANDROID_NATIVE_BUFFER_NAME as NAME,
crate::vk::ANDROID_NATIVE_BUFFER_SPEC_VERSION as SPEC_VERSION,
};
#[doc = "VK_ANDROID_native_buffer device-level functions"]
#[derive(Clone)]
pub struct Device {
pub(crate) fp: DeviceFn,
pub(crate) handle: crate::vk::Device,
}
impl Device {
pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
let handle = device.handle();
let fp = DeviceFn::load(|name| unsafe {
core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
});
Self { handle, fp }
}
#[inline]
pub fn fp(&self) -> &DeviceFn {
&self.fp
}
#[inline]
pub fn device(&self) -> crate::vk::Device {
self.handle
}
}
#[derive(Clone)]
#[doc = "Raw VK_ANDROID_native_buffer device-level function pointers"]
pub struct DeviceFn {
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 DeviceFn {}
unsafe impl Sync for DeviceFn {}
impl DeviceFn {
pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
Self::load_erased(&mut f)
}
fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
Self {
get_swapchain_gralloc_usage_android: unsafe {
unsafe extern "system" fn get_swapchain_gralloc_usage_android(
_device: crate::vk::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 = CStr::from_bytes_with_nul_unchecked(
b"vkGetSwapchainGrallocUsageANDROID\0",
);
let val = _f(cname);
if val.is_null() {
get_swapchain_gralloc_usage_android
} else {
::core::mem::transmute(val)
}
},
acquire_image_android: unsafe {
unsafe extern "system" fn acquire_image_android(
_device: crate::vk::Device,
_image: Image,
_native_fence_fd: c_int,
_semaphore: Semaphore,
_fence: Fence,
) -> Result {
panic!(concat!(
"Unable to load ",
stringify!(acquire_image_android)
))
}
let cname = CStr::from_bytes_with_nul_unchecked(b"vkAcquireImageANDROID\0");
let val = _f(cname);
if val.is_null() {
acquire_image_android
} else {
::core::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 = CStr::from_bytes_with_nul_unchecked(
b"vkQueueSignalReleaseImageANDROID\0",
);
let val = _f(cname);
if val.is_null() {
queue_signal_release_image_android
} else {
::core::mem::transmute(val)
}
},
get_swapchain_gralloc_usage2_android: unsafe {
unsafe extern "system" fn get_swapchain_gralloc_usage2_android(
_device: crate::vk::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 = CStr::from_bytes_with_nul_unchecked(
b"vkGetSwapchainGrallocUsage2ANDROID\0",
);
let val = _f(cname);
if val.is_null() {
get_swapchain_gralloc_usage2_android
} else {
::core::mem::transmute(val)
}
},
}
}
}
}
#[doc = "VK_ANDROID_external_memory_android_hardware_buffer"]
pub mod external_memory_android_hardware_buffer {
use super::super::*;
pub use {
crate::vk::ANDROID_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER_NAME as NAME,
crate::vk::ANDROID_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER_SPEC_VERSION as SPEC_VERSION,
};
#[doc = "VK_ANDROID_external_memory_android_hardware_buffer device-level functions"]
#[derive(Clone)]
pub struct Device {
pub(crate) fp: DeviceFn,
pub(crate) handle: crate::vk::Device,
}
impl Device {
pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
let handle = device.handle();
let fp = DeviceFn::load(|name| unsafe {
core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
});
Self { handle, fp }
}
#[inline]
pub fn fp(&self) -> &DeviceFn {
&self.fp
}
#[inline]
pub fn device(&self) -> crate::vk::Device {
self.handle
}
}
#[derive(Clone)]
#[doc = "Raw VK_ANDROID_external_memory_android_hardware_buffer device-level function pointers"]
pub struct DeviceFn {
pub get_android_hardware_buffer_properties_android:
PFN_vkGetAndroidHardwareBufferPropertiesANDROID,
pub get_memory_android_hardware_buffer_android:
PFN_vkGetMemoryAndroidHardwareBufferANDROID,
}
unsafe impl Send for DeviceFn {}
unsafe impl Sync for DeviceFn {}
impl DeviceFn {
pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
Self::load_erased(&mut f)
}
fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
Self {
get_android_hardware_buffer_properties_android: unsafe {
unsafe extern "system" fn get_android_hardware_buffer_properties_android(
_device: crate::vk::Device,
_buffer: *const AHardwareBuffer,
_p_properties: *mut AndroidHardwareBufferPropertiesANDROID<'_>,
) -> Result {
panic!(concat!(
"Unable to load ",
stringify!(get_android_hardware_buffer_properties_android)
))
}
let cname = CStr::from_bytes_with_nul_unchecked(
b"vkGetAndroidHardwareBufferPropertiesANDROID\0",
);
let val = _f(cname);
if val.is_null() {
get_android_hardware_buffer_properties_android
} else {
::core::mem::transmute(val)
}
},
get_memory_android_hardware_buffer_android: unsafe {
unsafe extern "system" fn get_memory_android_hardware_buffer_android(
_device: crate::vk::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 = CStr::from_bytes_with_nul_unchecked(
b"vkGetMemoryAndroidHardwareBufferANDROID\0",
);
let val = _f(cname);
if val.is_null() {
get_memory_android_hardware_buffer_android
} else {
::core::mem::transmute(val)
}
},
}
}
}
}
#[doc = "VK_ANDROID_external_format_resolve"]
pub mod external_format_resolve {
use super::super::*;
pub use {
crate::vk::ANDROID_EXTERNAL_FORMAT_RESOLVE_NAME as NAME,
crate::vk::ANDROID_EXTERNAL_FORMAT_RESOLVE_SPEC_VERSION as SPEC_VERSION,
};
}
}
#[doc = "Extensions tagged ARM"]
pub mod arm {
#[doc = "VK_ARM_rasterization_order_attachment_access"]
pub mod rasterization_order_attachment_access {
use super::super::*;
pub use {
crate::vk::ARM_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_NAME as NAME,
crate::vk::ARM_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_SPEC_VERSION as SPEC_VERSION,
};
}
#[doc = "VK_ARM_shader_core_properties"]
pub mod shader_core_properties {
use super::super::*;
pub use {
crate::vk::ARM_SHADER_CORE_PROPERTIES_NAME as NAME,
crate::vk::ARM_SHADER_CORE_PROPERTIES_SPEC_VERSION as SPEC_VERSION,
};
}
#[doc = "VK_ARM_scheduling_controls"]
pub mod scheduling_controls {
use super::super::*;
pub use {
crate::vk::ARM_SCHEDULING_CONTROLS_NAME as NAME,
crate::vk::ARM_SCHEDULING_CONTROLS_SPEC_VERSION as SPEC_VERSION,
};
}
#[doc = "VK_ARM_render_pass_striped"]
pub mod render_pass_striped {
use super::super::*;
pub use {
crate::vk::ARM_RENDER_PASS_STRIPED_NAME as NAME,
crate::vk::ARM_RENDER_PASS_STRIPED_SPEC_VERSION as SPEC_VERSION,
};
}
#[doc = "VK_ARM_shader_core_builtins"]
pub mod shader_core_builtins {
use super::super::*;
pub use {
crate::vk::ARM_SHADER_CORE_BUILTINS_NAME as NAME,
crate::vk::ARM_SHADER_CORE_BUILTINS_SPEC_VERSION as SPEC_VERSION,
};
}
}
#[doc = "Extensions tagged EXT"]
pub mod ext {
#[doc = "VK_EXT_debug_report"]
pub mod debug_report {
use super::super::*;
pub use {
crate::vk::EXT_DEBUG_REPORT_NAME as NAME,
crate::vk::EXT_DEBUG_REPORT_SPEC_VERSION as SPEC_VERSION,
};
#[doc = "VK_EXT_debug_report instance-level functions"]
#[derive(Clone)]
pub struct Instance {
pub(crate) fp: InstanceFn,
pub(crate) handle: crate::vk::Instance,
}
impl Instance {
pub fn new(entry: &crate::Entry, instance: &crate::Instance) -> Self {
let handle = instance.handle();
let fp = InstanceFn::load(|name| unsafe {
core::mem::transmute(entry.get_instance_proc_addr(handle, name.as_ptr()))
});
Self { handle, fp }
}
#[inline]
pub fn fp(&self) -> &InstanceFn {
&self.fp
}
#[inline]
pub fn instance(&self) -> crate::vk::Instance {
self.handle
}
}
#[derive(Clone)]
#[doc = "Raw VK_EXT_debug_report instance-level function pointers"]
pub struct InstanceFn {
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 InstanceFn {}
unsafe impl Sync for InstanceFn {}
impl InstanceFn {
pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
Self::load_erased(&mut f)
}
fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
Self {
create_debug_report_callback_ext: unsafe {
unsafe extern "system" fn create_debug_report_callback_ext(
_instance: crate::vk::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 = CStr::from_bytes_with_nul_unchecked(
b"vkCreateDebugReportCallbackEXT\0",
);
let val = _f(cname);
if val.is_null() {
create_debug_report_callback_ext
} else {
::core::mem::transmute(val)
}
},
destroy_debug_report_callback_ext: unsafe {
unsafe extern "system" fn destroy_debug_report_callback_ext(
_instance: crate::vk::Instance,
_callback: DebugReportCallbackEXT,
_p_allocator: *const AllocationCallbacks<'_>,
) {
panic!(concat!(
"Unable to load ",
stringify!(destroy_debug_report_callback_ext)
))
}
let cname = CStr::from_bytes_with_nul_unchecked(
b"vkDestroyDebugReportCallbackEXT\0",
);
let val = _f(cname);
if val.is_null() {
destroy_debug_report_callback_ext
} else {
::core::mem::transmute(val)
}
},
debug_report_message_ext: unsafe {
unsafe extern "system" fn debug_report_message_ext(
_instance: crate::vk::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 =
CStr::from_bytes_with_nul_unchecked(b"vkDebugReportMessageEXT\0");
let val = _f(cname);
if val.is_null() {
debug_report_message_ext
} else {
::core::mem::transmute(val)
}
},
}
}
}
}
#[doc = "VK_EXT_depth_range_unrestricted"]
pub mod depth_range_unrestricted {
use super::super::*;
pub use {
crate::vk::EXT_DEPTH_RANGE_UNRESTRICTED_NAME as NAME,
crate::vk::EXT_DEPTH_RANGE_UNRESTRICTED_SPEC_VERSION as SPEC_VERSION,
};
}
#[doc = "VK_EXT_debug_marker"]
pub mod debug_marker {
use super::super::*;
pub use {
crate::vk::EXT_DEBUG_MARKER_NAME as NAME,
crate::vk::EXT_DEBUG_MARKER_SPEC_VERSION as SPEC_VERSION,
};
#[doc = "VK_EXT_debug_marker device-level functions"]
#[derive(Clone)]
pub struct Device {
pub(crate) fp: DeviceFn,
pub(crate) handle: crate::vk::Device,
}
impl Device {
pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
let handle = device.handle();
let fp = DeviceFn::load(|name| unsafe {
core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
});
Self { handle, fp }
}
#[inline]
pub fn fp(&self) -> &DeviceFn {
&self.fp
}
#[inline]
pub fn device(&self) -> crate::vk::Device {
self.handle
}
}
#[derive(Clone)]
#[doc = "Raw VK_EXT_debug_marker device-level function pointers"]
pub struct DeviceFn {
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 DeviceFn {}
unsafe impl Sync for DeviceFn {}
impl DeviceFn {
pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
Self::load_erased(&mut f)
}
fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
Self {
debug_marker_set_object_tag_ext: unsafe {
unsafe extern "system" fn debug_marker_set_object_tag_ext(
_device: crate::vk::Device,
_p_tag_info: *const DebugMarkerObjectTagInfoEXT<'_>,
) -> Result {
panic!(concat!(
"Unable to load ",
stringify!(debug_marker_set_object_tag_ext)
))
}
let cname =
CStr::from_bytes_with_nul_unchecked(b"vkDebugMarkerSetObjectTagEXT\0");
let val = _f(cname);
if val.is_null() {
debug_marker_set_object_tag_ext
} else {
::core::mem::transmute(val)
}
},
debug_marker_set_object_name_ext: unsafe {
unsafe extern "system" fn debug_marker_set_object_name_ext(
_device: crate::vk::Device,
_p_name_info: *const DebugMarkerObjectNameInfoEXT<'_>,
) -> Result {
panic!(concat!(
"Unable to load ",
stringify!(debug_marker_set_object_name_ext)
))
}
let cname =
CStr::from_bytes_with_nul_unchecked(b"vkDebugMarkerSetObjectNameEXT\0");
let val = _f(cname);
if val.is_null() {
debug_marker_set_object_name_ext
} else {
::core::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 =
CStr::from_bytes_with_nul_unchecked(b"vkCmdDebugMarkerBeginEXT\0");
let val = _f(cname);
if val.is_null() {
cmd_debug_marker_begin_ext
} else {
::core::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 =
CStr::from_bytes_with_nul_unchecked(b"vkCmdDebugMarkerEndEXT\0");
let val = _f(cname);
if val.is_null() {
cmd_debug_marker_end_ext
} else {
::core::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 =
CStr::from_bytes_with_nul_unchecked(b"vkCmdDebugMarkerInsertEXT\0");
let val = _f(cname);
if val.is_null() {
cmd_debug_marker_insert_ext
} else {
::core::mem::transmute(val)
}
},
}
}
}
}
#[doc = "VK_EXT_transform_feedback"]
pub mod transform_feedback {
use super::super::*;
pub use {
crate::vk::EXT_TRANSFORM_FEEDBACK_NAME as NAME,
crate::vk::EXT_TRANSFORM_FEEDBACK_SPEC_VERSION as SPEC_VERSION,
};
#[doc = "VK_EXT_transform_feedback device-level functions"]
#[derive(Clone)]
pub struct Device {
pub(crate) fp: DeviceFn,
pub(crate) handle: crate::vk::Device,
}
impl Device {
pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
let handle = device.handle();
let fp = DeviceFn::load(|name| unsafe {
core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
});
Self { handle, fp }
}
#[inline]
pub fn fp(&self) -> &DeviceFn {
&self.fp
}
#[inline]
pub fn device(&self) -> crate::vk::Device {
self.handle
}
}
#[derive(Clone)]
#[doc = "Raw VK_EXT_transform_feedback device-level function pointers"]
pub struct DeviceFn {
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 DeviceFn {}
unsafe impl Sync for DeviceFn {}
impl DeviceFn {
pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
Self::load_erased(&mut f)
}
fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
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 = CStr::from_bytes_with_nul_unchecked(
b"vkCmdBindTransformFeedbackBuffersEXT\0",
);
let val = _f(cname);
if val.is_null() {
cmd_bind_transform_feedback_buffers_ext
} else {
::core::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 = CStr::from_bytes_with_nul_unchecked(
b"vkCmdBeginTransformFeedbackEXT\0",
);
let val = _f(cname);
if val.is_null() {
cmd_begin_transform_feedback_ext
} else {
::core::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 =
CStr::from_bytes_with_nul_unchecked(b"vkCmdEndTransformFeedbackEXT\0");
let val = _f(cname);
if val.is_null() {
cmd_end_transform_feedback_ext
} else {
::core::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 =
CStr::from_bytes_with_nul_unchecked(b"vkCmdBeginQueryIndexedEXT\0");
let val = _f(cname);
if val.is_null() {
cmd_begin_query_indexed_ext
} else {
::core::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 =
CStr::from_bytes_with_nul_unchecked(b"vkCmdEndQueryIndexedEXT\0");
let val = _f(cname);
if val.is_null() {
cmd_end_query_indexed_ext
} else {
::core::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 =
CStr::from_bytes_with_nul_unchecked(b"vkCmdDrawIndirectByteCountEXT\0");
let val = _f(cname);
if val.is_null() {
cmd_draw_indirect_byte_count_ext
} else {
::core::mem::transmute(val)
}
},
}
}
}
}
#[doc = "VK_EXT_validation_flags"]
pub mod validation_flags {
use super::super::*;
pub use {
crate::vk::EXT_VALIDATION_FLAGS_NAME as NAME,
crate::vk::EXT_VALIDATION_FLAGS_SPEC_VERSION as SPEC_VERSION,
};
}
#[doc = "VK_EXT_shader_subgroup_ballot"]
pub mod shader_subgroup_ballot {
use super::super::*;
pub use {
crate::vk::EXT_SHADER_SUBGROUP_BALLOT_NAME as NAME,
crate::vk::EXT_SHADER_SUBGROUP_BALLOT_SPEC_VERSION as SPEC_VERSION,
};
}
#[doc = "VK_EXT_shader_subgroup_vote"]
pub mod shader_subgroup_vote {
use super::super::*;
pub use {
crate::vk::EXT_SHADER_SUBGROUP_VOTE_NAME as NAME,
crate::vk::EXT_SHADER_SUBGROUP_VOTE_SPEC_VERSION as SPEC_VERSION,
};
}
#[doc = "VK_EXT_texture_compression_astc_hdr"]
pub mod texture_compression_astc_hdr {
use super::super::*;
pub use {
crate::vk::EXT_TEXTURE_COMPRESSION_ASTC_HDR_NAME as NAME,
crate::vk::EXT_TEXTURE_COMPRESSION_ASTC_HDR_SPEC_VERSION as SPEC_VERSION,
};
}
#[doc = "VK_EXT_astc_decode_mode"]
pub mod astc_decode_mode {
use super::super::*;
pub use {
crate::vk::EXT_ASTC_DECODE_MODE_NAME as NAME,
crate::vk::EXT_ASTC_DECODE_MODE_SPEC_VERSION as SPEC_VERSION,
};
}
#[doc = "VK_EXT_pipeline_robustness"]
pub mod pipeline_robustness {
use super::super::*;
pub use {
crate::vk::EXT_PIPELINE_ROBUSTNESS_NAME as NAME,
crate::vk::EXT_PIPELINE_ROBUSTNESS_SPEC_VERSION as SPEC_VERSION,
};
}
#[doc = "VK_EXT_conditional_rendering"]
pub mod conditional_rendering {
use super::super::*;
pub use {
crate::vk::EXT_CONDITIONAL_RENDERING_NAME as NAME,
crate::vk::EXT_CONDITIONAL_RENDERING_SPEC_VERSION as SPEC_VERSION,
};
#[doc = "VK_EXT_conditional_rendering device-level functions"]
#[derive(Clone)]
pub struct Device {
pub(crate) fp: DeviceFn,
pub(crate) handle: crate::vk::Device,
}
impl Device {
pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
let handle = device.handle();
let fp = DeviceFn::load(|name| unsafe {
core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
});
Self { handle, fp }
}
#[inline]
pub fn fp(&self) -> &DeviceFn {
&self.fp
}
#[inline]
pub fn device(&self) -> crate::vk::Device {
self.handle
}
}
#[derive(Clone)]
#[doc = "Raw VK_EXT_conditional_rendering device-level function pointers"]
pub struct DeviceFn {
pub cmd_begin_conditional_rendering_ext: PFN_vkCmdBeginConditionalRenderingEXT,
pub cmd_end_conditional_rendering_ext: PFN_vkCmdEndConditionalRenderingEXT,
}
unsafe impl Send for DeviceFn {}
unsafe impl Sync for DeviceFn {}
impl DeviceFn {
pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
Self::load_erased(&mut f)
}
fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
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 = CStr::from_bytes_with_nul_unchecked(
b"vkCmdBeginConditionalRenderingEXT\0",
);
let val = _f(cname);
if val.is_null() {
cmd_begin_conditional_rendering_ext
} else {
::core::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 = CStr::from_bytes_with_nul_unchecked(
b"vkCmdEndConditionalRenderingEXT\0",
);
let val = _f(cname);
if val.is_null() {
cmd_end_conditional_rendering_ext
} else {
::core::mem::transmute(val)
}
},
}
}
}
}
#[doc = "VK_EXT_direct_mode_display"]
pub mod direct_mode_display {
use super::super::*;
pub use {
crate::vk::EXT_DIRECT_MODE_DISPLAY_NAME as NAME,
crate::vk::EXT_DIRECT_MODE_DISPLAY_SPEC_VERSION as SPEC_VERSION,
};
#[doc = "VK_EXT_direct_mode_display instance-level functions"]
#[derive(Clone)]
pub struct Instance {
pub(crate) fp: InstanceFn,
pub(crate) handle: crate::vk::Instance,
}
impl Instance {
pub fn new(entry: &crate::Entry, instance: &crate::Instance) -> Self {
let handle = instance.handle();
let fp = InstanceFn::load(|name| unsafe {
core::mem::transmute(entry.get_instance_proc_addr(handle, name.as_ptr()))
});
Self { handle, fp }
}
#[inline]
pub fn fp(&self) -> &InstanceFn {
&self.fp
}
#[inline]
pub fn instance(&self) -> crate::vk::Instance {
self.handle
}
}
#[derive(Clone)]
#[doc = "Raw VK_EXT_direct_mode_display instance-level function pointers"]
pub struct InstanceFn {
pub release_display_ext: PFN_vkReleaseDisplayEXT,
}
unsafe impl Send for InstanceFn {}
unsafe impl Sync for InstanceFn {}
impl InstanceFn {
pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
Self::load_erased(&mut f)
}
fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
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 = CStr::from_bytes_with_nul_unchecked(b"vkReleaseDisplayEXT\0");
let val = _f(cname);
if val.is_null() {
release_display_ext
} else {
::core::mem::transmute(val)
}
},
}
}
}
}
#[doc = "VK_EXT_acquire_xlib_display"]
pub mod acquire_xlib_display {
use super::super::*;
pub use {
crate::vk::EXT_ACQUIRE_XLIB_DISPLAY_NAME as NAME,
crate::vk::EXT_ACQUIRE_XLIB_DISPLAY_SPEC_VERSION as SPEC_VERSION,
};
#[doc = "VK_EXT_acquire_xlib_display instance-level functions"]
#[derive(Clone)]
pub struct Instance {
pub(crate) fp: InstanceFn,
pub(crate) handle: crate::vk::Instance,
}
impl Instance {
pub fn new(entry: &crate::Entry, instance: &crate::Instance) -> Self {
let handle = instance.handle();
let fp = InstanceFn::load(|name| unsafe {
core::mem::transmute(entry.get_instance_proc_addr(handle, name.as_ptr()))
});
Self { handle, fp }
}
#[inline]
pub fn fp(&self) -> &InstanceFn {
&self.fp
}
#[inline]
pub fn instance(&self) -> crate::vk::Instance {
self.handle
}
}
#[derive(Clone)]
#[doc = "Raw VK_EXT_acquire_xlib_display instance-level function pointers"]
pub struct InstanceFn {
pub acquire_xlib_display_ext: PFN_vkAcquireXlibDisplayEXT,
pub get_rand_r_output_display_ext: PFN_vkGetRandROutputDisplayEXT,
}
unsafe impl Send for InstanceFn {}
unsafe impl Sync for InstanceFn {}
impl InstanceFn {
pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
Self::load_erased(&mut f)
}
fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
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 =
CStr::from_bytes_with_nul_unchecked(b"vkAcquireXlibDisplayEXT\0");
let val = _f(cname);
if val.is_null() {
acquire_xlib_display_ext
} else {
::core::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 =
CStr::from_bytes_with_nul_unchecked(b"vkGetRandROutputDisplayEXT\0");
let val = _f(cname);
if val.is_null() {
get_rand_r_output_display_ext
} else {
::core::mem::transmute(val)
}
},
}
}
}
}
#[doc = "VK_EXT_display_surface_counter"]
pub mod display_surface_counter {
use super::super::*;
pub use {
crate::vk::EXT_DISPLAY_SURFACE_COUNTER_NAME as NAME,
crate::vk::EXT_DISPLAY_SURFACE_COUNTER_SPEC_VERSION as SPEC_VERSION,
};
#[doc = "VK_EXT_display_surface_counter instance-level functions"]
#[derive(Clone)]
pub struct Instance {
pub(crate) fp: InstanceFn,
pub(crate) handle: crate::vk::Instance,
}
impl Instance {
pub fn new(entry: &crate::Entry, instance: &crate::Instance) -> Self {
let handle = instance.handle();
let fp = InstanceFn::load(|name| unsafe {
core::mem::transmute(entry.get_instance_proc_addr(handle, name.as_ptr()))
});
Self { handle, fp }
}
#[inline]
pub fn fp(&self) -> &InstanceFn {
&self.fp
}
#[inline]
pub fn instance(&self) -> crate::vk::Instance {
self.handle
}
}
#[derive(Clone)]
#[doc = "Raw VK_EXT_display_surface_counter instance-level function pointers"]
pub struct InstanceFn {
pub get_physical_device_surface_capabilities2_ext:
PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT,
}
unsafe impl Send for InstanceFn {}
unsafe impl Sync for InstanceFn {}
impl InstanceFn {
pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
Self::load_erased(&mut f)
}
fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
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 = CStr::from_bytes_with_nul_unchecked(
b"vkGetPhysicalDeviceSurfaceCapabilities2EXT\0",
);
let val = _f(cname);
if val.is_null() {
get_physical_device_surface_capabilities2_ext
} else {
::core::mem::transmute(val)
}
},
}
}
}
}
#[doc = "VK_EXT_display_control"]
pub mod display_control {
use super::super::*;
pub use {
crate::vk::EXT_DISPLAY_CONTROL_NAME as NAME,
crate::vk::EXT_DISPLAY_CONTROL_SPEC_VERSION as SPEC_VERSION,
};
#[doc = "VK_EXT_display_control device-level functions"]
#[derive(Clone)]
pub struct Device {
pub(crate) fp: DeviceFn,
pub(crate) handle: crate::vk::Device,
}
impl Device {
pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
let handle = device.handle();
let fp = DeviceFn::load(|name| unsafe {
core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
});
Self { handle, fp }
}
#[inline]
pub fn fp(&self) -> &DeviceFn {
&self.fp
}
#[inline]
pub fn device(&self) -> crate::vk::Device {
self.handle
}
}
#[derive(Clone)]
#[doc = "Raw VK_EXT_display_control device-level function pointers"]
pub struct DeviceFn {
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 DeviceFn {}
unsafe impl Sync for DeviceFn {}
impl DeviceFn {
pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
Self::load_erased(&mut f)
}
fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
Self {
display_power_control_ext: unsafe {
unsafe extern "system" fn display_power_control_ext(
_device: crate::vk::Device,
_display: DisplayKHR,
_p_display_power_info: *const DisplayPowerInfoEXT<'_>,
) -> Result {
panic!(concat!(
"Unable to load ",
stringify!(display_power_control_ext)
))
}
let cname =
CStr::from_bytes_with_nul_unchecked(b"vkDisplayPowerControlEXT\0");
let val = _f(cname);
if val.is_null() {
display_power_control_ext
} else {
::core::mem::transmute(val)
}
},
register_device_event_ext: unsafe {
unsafe extern "system" fn register_device_event_ext(
_device: crate::vk::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 =
CStr::from_bytes_with_nul_unchecked(b"vkRegisterDeviceEventEXT\0");
let val = _f(cname);
if val.is_null() {
register_device_event_ext
} else {
::core::mem::transmute(val)
}
},
register_display_event_ext: unsafe {
unsafe extern "system" fn register_display_event_ext(
_device: crate::vk::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 =
CStr::from_bytes_with_nul_unchecked(b"vkRegisterDisplayEventEXT\0");
let val = _f(cname);
if val.is_null() {
register_display_event_ext
} else {
::core::mem::transmute(val)
}
},
get_swapchain_counter_ext: unsafe {
unsafe extern "system" fn get_swapchain_counter_ext(
_device: crate::vk::Device,
_swapchain: SwapchainKHR,
_counter: SurfaceCounterFlagsEXT,
_p_counter_value: *mut u64,
) -> Result {
panic!(concat!(
"Unable to load ",
stringify!(get_swapchain_counter_ext)
))
}
let cname =
CStr::from_bytes_with_nul_unchecked(b"vkGetSwapchainCounterEXT\0");
let val = _f(cname);
if val.is_null() {
get_swapchain_counter_ext
} else {
::core::mem::transmute(val)
}
},
}
}
}
}
#[doc = "VK_EXT_discard_rectangles"]
pub mod discard_rectangles {
use super::super::*;
pub use {
crate::vk::EXT_DISCARD_RECTANGLES_NAME as NAME,
crate::vk::EXT_DISCARD_RECTANGLES_SPEC_VERSION as SPEC_VERSION,
};
#[doc = "VK_EXT_discard_rectangles device-level functions"]
#[derive(Clone)]
pub struct Device {
pub(crate) fp: DeviceFn,
pub(crate) handle: crate::vk::Device,
}
impl Device {
pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
let handle = device.handle();
let fp = DeviceFn::load(|name| unsafe {
core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
});
Self { handle, fp }
}
#[inline]
pub fn fp(&self) -> &DeviceFn {
&self.fp
}
#[inline]
pub fn device(&self) -> crate::vk::Device {
self.handle
}
}
#[derive(Clone)]
#[doc = "Raw VK_EXT_discard_rectangles device-level function pointers"]
pub struct DeviceFn {
pub cmd_set_discard_rectangle_ext: PFN_vkCmdSetDiscardRectangleEXT,
pub cmd_set_discard_rectangle_enable_ext: PFN_vkCmdSetDiscardRectangleEnableEXT,
pub cmd_set_discard_rectangle_mode_ext: PFN_vkCmdSetDiscardRectangleModeEXT,
}
unsafe impl Send for DeviceFn {}
unsafe impl Sync for DeviceFn {}
impl DeviceFn {
pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
Self::load_erased(&mut f)
}
fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
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 =
CStr::from_bytes_with_nul_unchecked(b"vkCmdSetDiscardRectangleEXT\0");
let val = _f(cname);
if val.is_null() {
cmd_set_discard_rectangle_ext
} else {
::core::mem::transmute(val)
}
},
cmd_set_discard_rectangle_enable_ext: unsafe {
unsafe extern "system" fn cmd_set_discard_rectangle_enable_ext(
_command_buffer: CommandBuffer,
_discard_rectangle_enable: Bool32,
) {
panic!(concat!(
"Unable to load ",
stringify!(cmd_set_discard_rectangle_enable_ext)
))
}
let cname = CStr::from_bytes_with_nul_unchecked(
b"vkCmdSetDiscardRectangleEnableEXT\0",
);
let val = _f(cname);
if val.is_null() {
cmd_set_discard_rectangle_enable_ext
} else {
::core::mem::transmute(val)
}
},
cmd_set_discard_rectangle_mode_ext: unsafe {
unsafe extern "system" fn cmd_set_discard_rectangle_mode_ext(
_command_buffer: CommandBuffer,
_discard_rectangle_mode: DiscardRectangleModeEXT,
) {
panic!(concat!(
"Unable to load ",
stringify!(cmd_set_discard_rectangle_mode_ext)
))
}
let cname = CStr::from_bytes_with_nul_unchecked(
b"vkCmdSetDiscardRectangleModeEXT\0",
);
let val = _f(cname);
if val.is_null() {
cmd_set_discard_rectangle_mode_ext
} else {
::core::mem::transmute(val)
}
},
}
}
}
}
#[doc = "VK_EXT_conservative_rasterization"]
pub mod conservative_rasterization {
use super::super::*;
pub use {
crate::vk::EXT_CONSERVATIVE_RASTERIZATION_NAME as NAME,
crate::vk::EXT_CONSERVATIVE_RASTERIZATION_SPEC_VERSION as SPEC_VERSION,
};
}
#[doc = "VK_EXT_depth_clip_enable"]
pub mod depth_clip_enable {
use super::super::*;
pub use {
crate::vk::EXT_DEPTH_CLIP_ENABLE_NAME as NAME,
crate::vk::EXT_DEPTH_CLIP_ENABLE_SPEC_VERSION as SPEC_VERSION,
};
}
#[doc = "VK_EXT_swapchain_colorspace"]
pub mod swapchain_colorspace {
use super::super::*;
pub use {
crate::vk::EXT_SWAPCHAIN_COLORSPACE_NAME as NAME,
crate::vk::EXT_SWAPCHAIN_COLORSPACE_SPEC_VERSION as SPEC_VERSION,
};
}
#[doc = "VK_EXT_hdr_metadata"]
pub mod hdr_metadata {
use super::super::*;
pub use {
crate::vk::EXT_HDR_METADATA_NAME as NAME,
crate::vk::EXT_HDR_METADATA_SPEC_VERSION as SPEC_VERSION,
};
#[doc = "VK_EXT_hdr_metadata device-level functions"]
#[derive(Clone)]
pub struct Device {
pub(crate) fp: DeviceFn,
pub(crate) handle: crate::vk::Device,
}
impl Device {
pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
let handle = device.handle();
let fp = DeviceFn::load(|name| unsafe {
core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
});
Self { handle, fp }
}
#[inline]
pub fn fp(&self) -> &DeviceFn {
&self.fp
}
#[inline]
pub fn device(&self) -> crate::vk::Device {
self.handle
}
}
#[derive(Clone)]
#[doc = "Raw VK_EXT_hdr_metadata device-level function pointers"]
pub struct DeviceFn {
pub set_hdr_metadata_ext: PFN_vkSetHdrMetadataEXT,
}
unsafe impl Send for DeviceFn {}
unsafe impl Sync for DeviceFn {}
impl DeviceFn {
pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
Self::load_erased(&mut f)
}
fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
Self {
set_hdr_metadata_ext: unsafe {
unsafe extern "system" fn set_hdr_metadata_ext(
_device: crate::vk::Device,
_swapchain_count: u32,
_p_swapchains: *const SwapchainKHR,
_p_metadata: *const HdrMetadataEXT<'_>,
) {
panic!(concat!("Unable to load ", stringify!(set_hdr_metadata_ext)))
}
let cname = CStr::from_bytes_with_nul_unchecked(b"vkSetHdrMetadataEXT\0");
let val = _f(cname);
if val.is_null() {
set_hdr_metadata_ext
} else {
::core::mem::transmute(val)
}
},
}
}
}
}
#[doc = "VK_EXT_external_memory_dma_buf"]
pub mod external_memory_dma_buf {
use super::super::*;
pub use {
crate::vk::EXT_EXTERNAL_MEMORY_DMA_BUF_NAME as NAME,
crate::vk::EXT_EXTERNAL_MEMORY_DMA_BUF_SPEC_VERSION as SPEC_VERSION,
};
}
#[doc = "VK_EXT_queue_family_foreign"]
pub mod queue_family_foreign {
use super::super::*;
pub use {
crate::vk::EXT_QUEUE_FAMILY_FOREIGN_NAME as NAME,
crate::vk::EXT_QUEUE_FAMILY_FOREIGN_SPEC_VERSION as SPEC_VERSION,
};
}
#[doc = "VK_EXT_debug_utils"]
pub mod debug_utils {
use super::super::*;
pub use {
crate::vk::EXT_DEBUG_UTILS_NAME as NAME,
crate::vk::EXT_DEBUG_UTILS_SPEC_VERSION as SPEC_VERSION,
};
#[doc = "VK_EXT_debug_utils instance-level functions"]
#[derive(Clone)]
pub struct Instance {
pub(crate) fp: InstanceFn,
pub(crate) handle: crate::vk::Instance,
}
impl Instance {
pub fn new(entry: &crate::Entry, instance: &crate::Instance) -> Self {
let handle = instance.handle();
let fp = InstanceFn::load(|name| unsafe {
core::mem::transmute(entry.get_instance_proc_addr(handle, name.as_ptr()))
});
Self { handle, fp }
}
#[inline]
pub fn fp(&self) -> &InstanceFn {
&self.fp
}
#[inline]
pub fn instance(&self) -> crate::vk::Instance {
self.handle
}
}
#[derive(Clone)]
#[doc = "Raw VK_EXT_debug_utils instance-level function pointers"]
pub struct InstanceFn {
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 InstanceFn {}
unsafe impl Sync for InstanceFn {}
impl InstanceFn {
pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
Self::load_erased(&mut f)
}
fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
Self {
create_debug_utils_messenger_ext: unsafe {
unsafe extern "system" fn create_debug_utils_messenger_ext(
_instance: crate::vk::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 = CStr::from_bytes_with_nul_unchecked(
b"vkCreateDebugUtilsMessengerEXT\0",
);
let val = _f(cname);
if val.is_null() {
create_debug_utils_messenger_ext
} else {
::core::mem::transmute(val)
}
},
destroy_debug_utils_messenger_ext: unsafe {
unsafe extern "system" fn destroy_debug_utils_messenger_ext(
_instance: crate::vk::Instance,
_messenger: DebugUtilsMessengerEXT,
_p_allocator: *const AllocationCallbacks<'_>,
) {
panic!(concat!(
"Unable to load ",
stringify!(destroy_debug_utils_messenger_ext)
))
}
let cname = CStr::from_bytes_with_nul_unchecked(
b"vkDestroyDebugUtilsMessengerEXT\0",
);
let val = _f(cname);
if val.is_null() {
destroy_debug_utils_messenger_ext
} else {
::core::mem::transmute(val)
}
},
submit_debug_utils_message_ext: unsafe {
unsafe extern "system" fn submit_debug_utils_message_ext(
_instance: crate::vk::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 =
CStr::from_bytes_with_nul_unchecked(b"vkSubmitDebugUtilsMessageEXT\0");
let val = _f(cname);
if val.is_null() {
submit_debug_utils_message_ext
} else {
::core::mem::transmute(val)
}
},
}
}
}
#[doc = "VK_EXT_debug_utils device-level functions"]
#[derive(Clone)]
pub struct Device {
pub(crate) fp: DeviceFn,
pub(crate) handle: crate::vk::Device,
}
impl Device {
pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
let handle = device.handle();
let fp = DeviceFn::load(|name| unsafe {
core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
});
Self { handle, fp }
}
#[inline]
pub fn fp(&self) -> &DeviceFn {
&self.fp
}
#[inline]
pub fn device(&self) -> crate::vk::Device {
self.handle
}
}
#[derive(Clone)]
#[doc = "Raw VK_EXT_debug_utils device-level function pointers"]
pub struct DeviceFn {
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,
}
unsafe impl Send for DeviceFn {}
unsafe impl Sync for DeviceFn {}
impl DeviceFn {
pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
Self::load_erased(&mut f)
}
fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
Self {
set_debug_utils_object_name_ext: unsafe {
unsafe extern "system" fn set_debug_utils_object_name_ext(
_device: crate::vk::Device,
_p_name_info: *const DebugUtilsObjectNameInfoEXT<'_>,
) -> Result {
panic!(concat!(
"Unable to load ",
stringify!(set_debug_utils_object_name_ext)
))
}
let cname =
CStr::from_bytes_with_nul_unchecked(b"vkSetDebugUtilsObjectNameEXT\0");
let val = _f(cname);
if val.is_null() {
set_debug_utils_object_name_ext
} else {
::core::mem::transmute(val)
}
},
set_debug_utils_object_tag_ext: unsafe {
unsafe extern "system" fn set_debug_utils_object_tag_ext(
_device: crate::vk::Device,
_p_tag_info: *const DebugUtilsObjectTagInfoEXT<'_>,
) -> Result {
panic!(concat!(
"Unable to load ",
stringify!(set_debug_utils_object_tag_ext)
))
}
let cname =
CStr::from_bytes_with_nul_unchecked(b"vkSetDebugUtilsObjectTagEXT\0");
let val = _f(cname);
if val.is_null() {
set_debug_utils_object_tag_ext
} else {
::core::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 = CStr::from_bytes_with_nul_unchecked(
b"vkQueueBeginDebugUtilsLabelEXT\0",
);
let val = _f(cname);
if val.is_null() {
queue_begin_debug_utils_label_ext
} else {
::core::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 =
CStr::from_bytes_with_nul_unchecked(b"vkQueueEndDebugUtilsLabelEXT\0");
let val = _f(cname);
if val.is_null() {
queue_end_debug_utils_label_ext
} else {
::core::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 = CStr::from_bytes_with_nul_unchecked(
b"vkQueueInsertDebugUtilsLabelEXT\0",
);
let val = _f(cname);
if val.is_null() {
queue_insert_debug_utils_label_ext
} else {
::core::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 =
CStr::from_bytes_with_nul_unchecked(b"vkCmdBeginDebugUtilsLabelEXT\0");
let val = _f(cname);
if val.is_null() {
cmd_begin_debug_utils_label_ext
} else {
::core::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 =
CStr::from_bytes_with_nul_unchecked(b"vkCmdEndDebugUtilsLabelEXT\0");
let val = _f(cname);
if val.is_null() {
cmd_end_debug_utils_label_ext
} else {
::core::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 =
CStr::from_bytes_with_nul_unchecked(b"vkCmdInsertDebugUtilsLabelEXT\0");
let val = _f(cname);
if val.is_null() {
cmd_insert_debug_utils_label_ext
} else {
::core::mem::transmute(val)
}
},
}
}
}
}
#[doc = "VK_EXT_sampler_filter_minmax"]
pub mod sampler_filter_minmax {
use super::super::*;
pub use {
crate::vk::EXT_SAMPLER_FILTER_MINMAX_NAME as NAME,
crate::vk::EXT_SAMPLER_FILTER_MINMAX_SPEC_VERSION as SPEC_VERSION,
};
}
#[doc = "VK_EXT_inline_uniform_block"]
pub mod inline_uniform_block {
use super::super::*;
pub use {
crate::vk::EXT_INLINE_UNIFORM_BLOCK_NAME as NAME,
crate::vk::EXT_INLINE_UNIFORM_BLOCK_SPEC_VERSION as SPEC_VERSION,
};
}
#[doc = "VK_EXT_shader_stencil_export"]
pub mod shader_stencil_export {
use super::super::*;
pub use {
crate::vk::EXT_SHADER_STENCIL_EXPORT_NAME as NAME,
crate::vk::EXT_SHADER_STENCIL_EXPORT_SPEC_VERSION as SPEC_VERSION,
};
}
#[doc = "VK_EXT_sample_locations"]
pub mod sample_locations {
use super::super::*;
pub use {
crate::vk::EXT_SAMPLE_LOCATIONS_NAME as NAME,
crate::vk::EXT_SAMPLE_LOCATIONS_SPEC_VERSION as SPEC_VERSION,
};
#[doc = "VK_EXT_sample_locations instance-level functions"]
#[derive(Clone)]
pub struct Instance {
pub(crate) fp: InstanceFn,
pub(crate) handle: crate::vk::Instance,
}
impl Instance {
pub fn new(entry: &crate::Entry, instance: &crate::Instance) -> Self {
let handle = instance.handle();
let fp = InstanceFn::load(|name| unsafe {
core::mem::transmute(entry.get_instance_proc_addr(handle, name.as_ptr()))
});
Self { handle, fp }
}
#[inline]
pub fn fp(&self) -> &InstanceFn {
&self.fp
}
#[inline]
pub fn instance(&self) -> crate::vk::Instance {
self.handle
}
}
#[derive(Clone)]
#[doc = "Raw VK_EXT_sample_locations instance-level function pointers"]
pub struct InstanceFn {
pub get_physical_device_multisample_properties_ext:
PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT,
}
unsafe impl Send for InstanceFn {}
unsafe impl Sync for InstanceFn {}
impl InstanceFn {
pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
Self::load_erased(&mut f)
}
fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
Self {
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 = CStr::from_bytes_with_nul_unchecked(
b"vkGetPhysicalDeviceMultisamplePropertiesEXT\0",
);
let val = _f(cname);
if val.is_null() {
get_physical_device_multisample_properties_ext
} else {
::core::mem::transmute(val)
}
},
}
}
}
#[doc = "VK_EXT_sample_locations device-level functions"]
#[derive(Clone)]
pub struct Device {
pub(crate) fp: DeviceFn,
pub(crate) handle: crate::vk::Device,
}
impl Device {
pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
let handle = device.handle();
let fp = DeviceFn::load(|name| unsafe {
core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
});
Self { handle, fp }
}
#[inline]
pub fn fp(&self) -> &DeviceFn {
&self.fp
}
#[inline]
pub fn device(&self) -> crate::vk::Device {
self.handle
}
}
#[derive(Clone)]
#[doc = "Raw VK_EXT_sample_locations device-level function pointers"]
pub struct DeviceFn {
pub cmd_set_sample_locations_ext: PFN_vkCmdSetSampleLocationsEXT,
}
unsafe impl Send for DeviceFn {}
unsafe impl Sync for DeviceFn {}
impl DeviceFn {
pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
Self::load_erased(&mut f)
}
fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
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 =
CStr::from_bytes_with_nul_unchecked(b"vkCmdSetSampleLocationsEXT\0");
let val = _f(cname);
if val.is_null() {
cmd_set_sample_locations_ext
} else {
::core::mem::transmute(val)
}
},
}
}
}
}
#[doc = "VK_EXT_blend_operation_advanced"]
pub mod blend_operation_advanced {
use super::super::*;
pub use {
crate::vk::EXT_BLEND_OPERATION_ADVANCED_NAME as NAME,
crate::vk::EXT_BLEND_OPERATION_ADVANCED_SPEC_VERSION as SPEC_VERSION,
};
}
#[doc = "VK_EXT_post_depth_coverage"]
pub mod post_depth_coverage {
use super::super::*;
pub use {
crate::vk::EXT_POST_DEPTH_COVERAGE_NAME as NAME,
crate::vk::EXT_POST_DEPTH_COVERAGE_SPEC_VERSION as SPEC_VERSION,
};
}
#[doc = "VK_EXT_image_drm_format_modifier"]
pub mod image_drm_format_modifier {
use super::super::*;
pub use {
crate::vk::EXT_IMAGE_DRM_FORMAT_MODIFIER_NAME as NAME,
crate::vk::EXT_IMAGE_DRM_FORMAT_MODIFIER_SPEC_VERSION as SPEC_VERSION,
};
#[doc = "VK_EXT_image_drm_format_modifier device-level functions"]
#[derive(Clone)]
pub struct Device {
pub(crate) fp: DeviceFn,
pub(crate) handle: crate::vk::Device,
}
impl Device {
pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
let handle = device.handle();
let fp = DeviceFn::load(|name| unsafe {
core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
});
Self { handle, fp }
}
#[inline]
pub fn fp(&self) -> &DeviceFn {
&self.fp
}
#[inline]
pub fn device(&self) -> crate::vk::Device {
self.handle
}
}
#[derive(Clone)]
#[doc = "Raw VK_EXT_image_drm_format_modifier device-level function pointers"]
pub struct DeviceFn {
pub get_image_drm_format_modifier_properties_ext:
PFN_vkGetImageDrmFormatModifierPropertiesEXT,
}
unsafe impl Send for DeviceFn {}
unsafe impl Sync for DeviceFn {}
impl DeviceFn {
pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
Self::load_erased(&mut f)
}
fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
Self {
get_image_drm_format_modifier_properties_ext: unsafe {
unsafe extern "system" fn get_image_drm_format_modifier_properties_ext(
_device: crate::vk::Device,
_image: Image,
_p_properties: *mut ImageDrmFormatModifierPropertiesEXT<'_>,
) -> Result {
panic!(concat!(
"Unable to load ",
stringify!(get_image_drm_format_modifier_properties_ext)
))
}
let cname = 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 {
::core::mem::transmute(val)
}
},
}
}
}
}
#[doc = "VK_EXT_validation_cache"]
pub mod validation_cache {
use super::super::*;
pub use {
crate::vk::EXT_VALIDATION_CACHE_NAME as NAME,
crate::vk::EXT_VALIDATION_CACHE_SPEC_VERSION as SPEC_VERSION,
};
#[doc = "VK_EXT_validation_cache device-level functions"]
#[derive(Clone)]
pub struct Device {
pub(crate) fp: DeviceFn,
pub(crate) handle: crate::vk::Device,
}
impl Device {
pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
let handle = device.handle();
let fp = DeviceFn::load(|name| unsafe {
core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
});
Self { handle, fp }
}
#[inline]
pub fn fp(&self) -> &DeviceFn {
&self.fp
}
#[inline]
pub fn device(&self) -> crate::vk::Device {
self.handle
}
}
#[derive(Clone)]
#[doc = "Raw VK_EXT_validation_cache device-level function pointers"]
pub struct DeviceFn {
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 DeviceFn {}
unsafe impl Sync for DeviceFn {}
impl DeviceFn {
pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
Self::load_erased(&mut f)
}
fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
Self {
create_validation_cache_ext: unsafe {
unsafe extern "system" fn create_validation_cache_ext(
_device: crate::vk::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 =
CStr::from_bytes_with_nul_unchecked(b"vkCreateValidationCacheEXT\0");
let val = _f(cname);
if val.is_null() {
create_validation_cache_ext
} else {
::core::mem::transmute(val)
}
},
destroy_validation_cache_ext: unsafe {
unsafe extern "system" fn destroy_validation_cache_ext(
_device: crate::vk::Device,
_validation_cache: ValidationCacheEXT,
_p_allocator: *const AllocationCallbacks<'_>,
) {
panic!(concat!(
"Unable to load ",
stringify!(destroy_validation_cache_ext)
))
}
let cname =
CStr::from_bytes_with_nul_unchecked(b"vkDestroyValidationCacheEXT\0");
let val = _f(cname);
if val.is_null() {
destroy_validation_cache_ext
} else {
::core::mem::transmute(val)
}
},
merge_validation_caches_ext: unsafe {
unsafe extern "system" fn merge_validation_caches_ext(
_device: crate::vk::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 =
CStr::from_bytes_with_nul_unchecked(b"vkMergeValidationCachesEXT\0");
let val = _f(cname);
if val.is_null() {
merge_validation_caches_ext
} else {
::core::mem::transmute(val)
}
},
get_validation_cache_data_ext: unsafe {
unsafe extern "system" fn get_validation_cache_data_ext(
_device: crate::vk::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 =
CStr::from_bytes_with_nul_unchecked(b"vkGetValidationCacheDataEXT\0");
let val = _f(cname);
if val.is_null() {
get_validation_cache_data_ext
} else {
::core::mem::transmute(val)
}
},
}
}
}
}
#[doc = "VK_EXT_descriptor_indexing"]
pub mod descriptor_indexing {
use super::super::*;
pub use {
crate::vk::EXT_DESCRIPTOR_INDEXING_NAME as NAME,
crate::vk::EXT_DESCRIPTOR_INDEXING_SPEC_VERSION as SPEC_VERSION,
};
}
#[doc = "VK_EXT_shader_viewport_index_layer"]
pub mod shader_viewport_index_layer {
use super::super::*;
pub use {
crate::vk::EXT_SHADER_VIEWPORT_INDEX_LAYER_NAME as NAME,
crate::vk::EXT_SHADER_VIEWPORT_INDEX_LAYER_SPEC_VERSION as SPEC_VERSION,
};
}
#[doc = "VK_EXT_filter_cubic"]
pub mod filter_cubic {
use super::super::*;
pub use {
crate::vk::EXT_FILTER_CUBIC_NAME as NAME,
crate::vk::EXT_FILTER_CUBIC_SPEC_VERSION as SPEC_VERSION,
};
}
#[doc = "VK_EXT_global_priority"]
pub mod global_priority {
use super::super::*;
pub use {
crate::vk::EXT_GLOBAL_PRIORITY_NAME as NAME,
crate::vk::EXT_GLOBAL_PRIORITY_SPEC_VERSION as SPEC_VERSION,
};
}
#[doc = "VK_EXT_external_memory_host"]
pub mod external_memory_host {
use super::super::*;
pub use {
crate::vk::EXT_EXTERNAL_MEMORY_HOST_NAME as NAME,
crate::vk::EXT_EXTERNAL_MEMORY_HOST_SPEC_VERSION as SPEC_VERSION,
};
#[doc = "VK_EXT_external_memory_host device-level functions"]
#[derive(Clone)]
pub struct Device {
pub(crate) fp: DeviceFn,
pub(crate) handle: crate::vk::Device,
}
impl Device {
pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
let handle = device.handle();
let fp = DeviceFn::load(|name| unsafe {
core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
});
Self { handle, fp }
}
#[inline]
pub fn fp(&self) -> &DeviceFn {
&self.fp
}
#[inline]
pub fn device(&self) -> crate::vk::Device {
self.handle
}
}
#[derive(Clone)]
#[doc = "Raw VK_EXT_external_memory_host device-level function pointers"]
pub struct DeviceFn {
pub get_memory_host_pointer_properties_ext: PFN_vkGetMemoryHostPointerPropertiesEXT,
}
unsafe impl Send for DeviceFn {}
unsafe impl Sync for DeviceFn {}
impl DeviceFn {
pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
Self::load_erased(&mut f)
}
fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
Self {
get_memory_host_pointer_properties_ext: unsafe {
unsafe extern "system" fn get_memory_host_pointer_properties_ext(
_device: crate::vk::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 = CStr::from_bytes_with_nul_unchecked(
b"vkGetMemoryHostPointerPropertiesEXT\0",
);
let val = _f(cname);
if val.is_null() {
get_memory_host_pointer_properties_ext
} else {
::core::mem::transmute(val)
}
},
}
}
}
}
#[doc = "VK_EXT_calibrated_timestamps"]
pub mod calibrated_timestamps {
use super::super::*;
pub use {
crate::vk::EXT_CALIBRATED_TIMESTAMPS_NAME as NAME,
crate::vk::EXT_CALIBRATED_TIMESTAMPS_SPEC_VERSION as SPEC_VERSION,
};
#[doc = "VK_EXT_calibrated_timestamps instance-level functions"]
#[derive(Clone)]
pub struct Instance {
pub(crate) fp: InstanceFn,
pub(crate) handle: crate::vk::Instance,
}
impl Instance {
pub fn new(entry: &crate::Entry, instance: &crate::Instance) -> Self {
let handle = instance.handle();
let fp = InstanceFn::load(|name| unsafe {
core::mem::transmute(entry.get_instance_proc_addr(handle, name.as_ptr()))
});
Self { handle, fp }
}
#[inline]
pub fn fp(&self) -> &InstanceFn {
&self.fp
}
#[inline]
pub fn instance(&self) -> crate::vk::Instance {
self.handle
}
}
#[derive(Clone)]
#[doc = "Raw VK_EXT_calibrated_timestamps instance-level function pointers"]
pub struct InstanceFn {
pub get_physical_device_calibrateable_time_domains_ext:
PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR,
}
unsafe impl Send for InstanceFn {}
unsafe impl Sync for InstanceFn {}
impl InstanceFn {
pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
Self::load_erased(&mut f)
}
fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
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 TimeDomainKHR,
) -> Result {
panic!(concat!(
"Unable to load ",
stringify!(get_physical_device_calibrateable_time_domains_ext)
))
}
let cname = 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 {
::core::mem::transmute(val)
}
},
}
}
}
#[doc = "VK_EXT_calibrated_timestamps device-level functions"]
#[derive(Clone)]
pub struct Device {
pub(crate) fp: DeviceFn,
pub(crate) handle: crate::vk::Device,
}
impl Device {
pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
let handle = device.handle();
let fp = DeviceFn::load(|name| unsafe {
core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
});
Self { handle, fp }
}
#[inline]
pub fn fp(&self) -> &DeviceFn {
&self.fp
}
#[inline]
pub fn device(&self) -> crate::vk::Device {
self.handle
}
}
#[derive(Clone)]
#[doc = "Raw VK_EXT_calibrated_timestamps device-level function pointers"]
pub struct DeviceFn {
pub get_calibrated_timestamps_ext: PFN_vkGetCalibratedTimestampsKHR,
}
unsafe impl Send for DeviceFn {}
unsafe impl Sync for DeviceFn {}
impl DeviceFn {
pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
Self::load_erased(&mut f)
}
fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
Self {
get_calibrated_timestamps_ext: unsafe {
unsafe extern "system" fn get_calibrated_timestamps_ext(
_device: crate::vk::Device,
_timestamp_count: u32,
_p_timestamp_infos: *const CalibratedTimestampInfoKHR<'_>,
_p_timestamps: *mut u64,
_p_max_deviation: *mut u64,
) -> Result {
panic!(concat!(
"Unable to load ",
stringify!(get_calibrated_timestamps_ext)
))
}
let cname =
CStr::from_bytes_with_nul_unchecked(b"vkGetCalibratedTimestampsEXT\0");
let val = _f(cname);
if val.is_null() {
get_calibrated_timestamps_ext
} else {
::core::mem::transmute(val)
}
},
}
}
}
}
#[doc = "VK_EXT_vertex_attribute_divisor"]
pub mod vertex_attribute_divisor {
use super::super::*;
pub use {
crate::vk::EXT_VERTEX_ATTRIBUTE_DIVISOR_NAME as NAME,
crate::vk::EXT_VERTEX_ATTRIBUTE_DIVISOR_SPEC_VERSION as SPEC_VERSION,
};
}
#[doc = "VK_EXT_pipeline_creation_feedback"]
pub mod pipeline_creation_feedback {
use super::super::*;
pub use {
crate::vk::EXT_PIPELINE_CREATION_FEEDBACK_NAME as NAME,
crate::vk::EXT_PIPELINE_CREATION_FEEDBACK_SPEC_VERSION as SPEC_VERSION,
};
}
#[doc = "VK_EXT_pci_bus_info"]
pub mod pci_bus_info {
use super::super::*;
pub use {
crate::vk::EXT_PCI_BUS_INFO_NAME as NAME,
crate::vk::EXT_PCI_BUS_INFO_SPEC_VERSION as SPEC_VERSION,
};
}
#[doc = "VK_EXT_metal_surface"]
pub mod metal_surface {
use super::super::*;
pub use {
crate::vk::EXT_METAL_SURFACE_NAME as NAME,
crate::vk::EXT_METAL_SURFACE_SPEC_VERSION as SPEC_VERSION,
};
#[doc = "VK_EXT_metal_surface instance-level functions"]
#[derive(Clone)]
pub struct Instance {
pub(crate) fp: InstanceFn,
pub(crate) handle: crate::vk::Instance,
}
impl Instance {
pub fn new(entry: &crate::Entry, instance: &crate::Instance) -> Self {
let handle = instance.handle();
let fp = InstanceFn::load(|name| unsafe {
core::mem::transmute(entry.get_instance_proc_addr(handle, name.as_ptr()))
});
Self { handle, fp }
}
#[inline]
pub fn fp(&self) -> &InstanceFn {
&self.fp
}
#[inline]
pub fn instance(&self) -> crate::vk::Instance {
self.handle
}
}
#[derive(Clone)]
#[doc = "Raw VK_EXT_metal_surface instance-level function pointers"]
pub struct InstanceFn {
pub create_metal_surface_ext: PFN_vkCreateMetalSurfaceEXT,
}
unsafe impl Send for InstanceFn {}
unsafe impl Sync for InstanceFn {}
impl InstanceFn {
pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
Self::load_erased(&mut f)
}
fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
Self {
create_metal_surface_ext: unsafe {
unsafe extern "system" fn create_metal_surface_ext(
_instance: crate::vk::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 =
CStr::from_bytes_with_nul_unchecked(b"vkCreateMetalSurfaceEXT\0");
let val = _f(cname);
if val.is_null() {
create_metal_surface_ext
} else {
::core::mem::transmute(val)
}
},
}
}
}
}
#[doc = "VK_EXT_fragment_density_map"]
pub mod fragment_density_map {
use super::super::*;
pub use {
crate::vk::EXT_FRAGMENT_DENSITY_MAP_NAME as NAME,
crate::vk::EXT_FRAGMENT_DENSITY_MAP_SPEC_VERSION as SPEC_VERSION,
};
}
#[doc = "VK_EXT_scalar_block_layout"]
pub mod scalar_block_layout {
use super::super::*;
pub use {
crate::vk::EXT_SCALAR_BLOCK_LAYOUT_NAME as NAME,
crate::vk::EXT_SCALAR_BLOCK_LAYOUT_SPEC_VERSION as SPEC_VERSION,
};
}
#[doc = "VK_EXT_subgroup_size_control"]
pub mod subgroup_size_control {
use super::super::*;
pub use {
crate::vk::EXT_SUBGROUP_SIZE_CONTROL_NAME as NAME,
crate::vk::EXT_SUBGROUP_SIZE_CONTROL_SPEC_VERSION as SPEC_VERSION,
};
}
#[doc = "VK_EXT_shader_image_atomic_int64"]
pub mod shader_image_atomic_int64 {
use super::super::*;
pub use {
crate::vk::EXT_SHADER_IMAGE_ATOMIC_INT64_NAME as NAME,
crate::vk::EXT_SHADER_IMAGE_ATOMIC_INT64_SPEC_VERSION as SPEC_VERSION,
};
}
#[doc = "VK_EXT_memory_budget"]
pub mod memory_budget {
use super::super::*;
pub use {
crate::vk::EXT_MEMORY_BUDGET_NAME as NAME,
crate::vk::EXT_MEMORY_BUDGET_SPEC_VERSION as SPEC_VERSION,
};
}
#[doc = "VK_EXT_memory_priority"]
pub mod memory_priority {
use super::super::*;
pub use {
crate::vk::EXT_MEMORY_PRIORITY_NAME as NAME,
crate::vk::EXT_MEMORY_PRIORITY_SPEC_VERSION as SPEC_VERSION,
};
}
#[doc = "VK_EXT_buffer_device_address"]
pub mod buffer_device_address {
use super::super::*;
pub use {
crate::vk::EXT_BUFFER_DEVICE_ADDRESS_NAME as NAME,
crate::vk::EXT_BUFFER_DEVICE_ADDRESS_SPEC_VERSION as SPEC_VERSION,
};
#[doc = "VK_EXT_buffer_device_address device-level functions"]
#[derive(Clone)]
pub struct Device {
pub(crate) fp: DeviceFn,
pub(crate) handle: crate::vk::Device,
}
impl Device {
pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
let handle = device.handle();
let fp = DeviceFn::load(|name| unsafe {
core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
});
Self { handle, fp }
}
#[inline]
pub fn fp(&self) -> &DeviceFn {
&self.fp
}
#[inline]
pub fn device(&self) -> crate::vk::Device {
self.handle
}
}
#[derive(Clone)]
#[doc = "Raw VK_EXT_buffer_device_address device-level function pointers"]
pub struct DeviceFn {
pub get_buffer_device_address_ext: PFN_vkGetBufferDeviceAddress,
}
unsafe impl Send for DeviceFn {}
unsafe impl Sync for DeviceFn {}
impl DeviceFn {
pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
Self::load_erased(&mut f)
}
fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
Self {
get_buffer_device_address_ext: unsafe {
unsafe extern "system" fn get_buffer_device_address_ext(
_device: crate::vk::Device,
_p_info: *const BufferDeviceAddressInfo<'_>,
) -> DeviceAddress {
panic!(concat!(
"Unable to load ",
stringify!(get_buffer_device_address_ext)
))
}
let cname =
CStr::from_bytes_with_nul_unchecked(b"vkGetBufferDeviceAddressEXT\0");
let val = _f(cname);
if val.is_null() {
get_buffer_device_address_ext
} else {
::core::mem::transmute(val)
}
},
}
}
}
}
#[doc = "VK_EXT_tooling_info"]
pub mod tooling_info {
use super::super::*;
pub use {
crate::vk::EXT_TOOLING_INFO_NAME as NAME,
crate::vk::EXT_TOOLING_INFO_SPEC_VERSION as SPEC_VERSION,
};
#[doc = "VK_EXT_tooling_info instance-level functions"]
#[derive(Clone)]
pub struct Instance {
pub(crate) fp: InstanceFn,
pub(crate) handle: crate::vk::Instance,
}
impl Instance {
pub fn new(entry: &crate::Entry, instance: &crate::Instance) -> Self {
let handle = instance.handle();
let fp = InstanceFn::load(|name| unsafe {
core::mem::transmute(entry.get_instance_proc_addr(handle, name.as_ptr()))
});
Self { handle, fp }
}
#[inline]
pub fn fp(&self) -> &InstanceFn {
&self.fp
}
#[inline]
pub fn instance(&self) -> crate::vk::Instance {
self.handle
}
}
#[derive(Clone)]
#[doc = "Raw VK_EXT_tooling_info instance-level function pointers"]
pub struct InstanceFn {
pub get_physical_device_tool_properties_ext: PFN_vkGetPhysicalDeviceToolProperties,
}
unsafe impl Send for InstanceFn {}
unsafe impl Sync for InstanceFn {}
impl InstanceFn {
pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
Self::load_erased(&mut f)
}
fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
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 = CStr::from_bytes_with_nul_unchecked(
b"vkGetPhysicalDeviceToolPropertiesEXT\0",
);
let val = _f(cname);
if val.is_null() {
get_physical_device_tool_properties_ext
} else {
::core::mem::transmute(val)
}
},
}
}
}
}
#[doc = "VK_EXT_separate_stencil_usage"]
pub mod separate_stencil_usage {
use super::super::*;
pub use {
crate::vk::EXT_SEPARATE_STENCIL_USAGE_NAME as NAME,
crate::vk::EXT_SEPARATE_STENCIL_USAGE_SPEC_VERSION as SPEC_VERSION,
};
}
#[doc = "VK_EXT_validation_features"]
pub mod validation_features {
use super::super::*;
pub use {
crate::vk::EXT_VALIDATION_FEATURES_NAME as NAME,
crate::vk::EXT_VALIDATION_FEATURES_SPEC_VERSION as SPEC_VERSION,
};
}
#[doc = "VK_EXT_fragment_shader_interlock"]
pub mod fragment_shader_interlock {
use super::super::*;
pub use {
crate::vk::EXT_FRAGMENT_SHADER_INTERLOCK_NAME as NAME,
crate::vk::EXT_FRAGMENT_SHADER_INTERLOCK_SPEC_VERSION as SPEC_VERSION,
};
}
#[doc = "VK_EXT_ycbcr_image_arrays"]
pub mod ycbcr_image_arrays {
use super::super::*;
pub use {
crate::vk::EXT_YCBCR_IMAGE_ARRAYS_NAME as NAME,
crate::vk::EXT_YCBCR_IMAGE_ARRAYS_SPEC_VERSION as SPEC_VERSION,
};
}
#[doc = "VK_EXT_provoking_vertex"]
pub mod provoking_vertex {
use super::super::*;
pub use {
crate::vk::EXT_PROVOKING_VERTEX_NAME as NAME,
crate::vk::EXT_PROVOKING_VERTEX_SPEC_VERSION as SPEC_VERSION,
};
}
#[doc = "VK_EXT_full_screen_exclusive"]
pub mod full_screen_exclusive {
use super::super::*;
pub use {
crate::vk::EXT_FULL_SCREEN_EXCLUSIVE_NAME as NAME,
crate::vk::EXT_FULL_SCREEN_EXCLUSIVE_SPEC_VERSION as SPEC_VERSION,
};
#[doc = "VK_EXT_full_screen_exclusive instance-level functions"]
#[derive(Clone)]
pub struct Instance {
pub(crate) fp: InstanceFn,
pub(crate) handle: crate::vk::Instance,
}
impl Instance {
pub fn new(entry: &crate::Entry, instance: &crate::Instance) -> Self {
let handle = instance.handle();
let fp = InstanceFn::load(|name| unsafe {
core::mem::transmute(entry.get_instance_proc_addr(handle, name.as_ptr()))
});
Self { handle, fp }
}
#[inline]
pub fn fp(&self) -> &InstanceFn {
&self.fp
}
#[inline]
pub fn instance(&self) -> crate::vk::Instance {
self.handle
}
}
#[derive(Clone)]
#[doc = "Raw VK_EXT_full_screen_exclusive instance-level function pointers"]
pub struct InstanceFn {
pub get_physical_device_surface_present_modes2_ext:
PFN_vkGetPhysicalDeviceSurfacePresentModes2EXT,
}
unsafe impl Send for InstanceFn {}
unsafe impl Sync for InstanceFn {}
impl InstanceFn {
pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
Self::load_erased(&mut f)
}
fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
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 = 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 {
::core::mem::transmute(val)
}
},
}
}
}
#[doc = "VK_EXT_full_screen_exclusive device-level functions"]
#[derive(Clone)]
pub struct Device {
pub(crate) fp: DeviceFn,
pub(crate) handle: crate::vk::Device,
}
impl Device {
pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
let handle = device.handle();
let fp = DeviceFn::load(|name| unsafe {
core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
});
Self { handle, fp }
}
#[inline]
pub fn fp(&self) -> &DeviceFn {
&self.fp
}
#[inline]
pub fn device(&self) -> crate::vk::Device {
self.handle
}
}
#[derive(Clone)]
#[doc = "Raw VK_EXT_full_screen_exclusive device-level function pointers"]
pub struct DeviceFn {
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 DeviceFn {}
unsafe impl Sync for DeviceFn {}
impl DeviceFn {
pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
Self::load_erased(&mut f)
}
fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
Self {
acquire_full_screen_exclusive_mode_ext: unsafe {
unsafe extern "system" fn acquire_full_screen_exclusive_mode_ext(
_device: crate::vk::Device,
_swapchain: SwapchainKHR,
) -> Result {
panic!(concat!(
"Unable to load ",
stringify!(acquire_full_screen_exclusive_mode_ext)
))
}
let cname = CStr::from_bytes_with_nul_unchecked(
b"vkAcquireFullScreenExclusiveModeEXT\0",
);
let val = _f(cname);
if val.is_null() {
acquire_full_screen_exclusive_mode_ext
} else {
::core::mem::transmute(val)
}
},
release_full_screen_exclusive_mode_ext: unsafe {
unsafe extern "system" fn release_full_screen_exclusive_mode_ext(
_device: crate::vk::Device,
_swapchain: SwapchainKHR,
) -> Result {
panic!(concat!(
"Unable to load ",
stringify!(release_full_screen_exclusive_mode_ext)
))
}
let cname = CStr::from_bytes_with_nul_unchecked(
b"vkReleaseFullScreenExclusiveModeEXT\0",
);
let val = _f(cname);
if val.is_null() {
release_full_screen_exclusive_mode_ext
} else {
::core::mem::transmute(val)
}
},
get_device_group_surface_present_modes2_ext: unsafe {
unsafe extern "system" fn get_device_group_surface_present_modes2_ext(
_device: crate::vk::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 = 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 {
::core::mem::transmute(val)
}
},
}
}
}
}
#[doc = "VK_EXT_headless_surface"]
pub mod headless_surface {
use super::super::*;
pub use {
crate::vk::EXT_HEADLESS_SURFACE_NAME as NAME,
crate::vk::EXT_HEADLESS_SURFACE_SPEC_VERSION as SPEC_VERSION,
};
#[doc = "VK_EXT_headless_surface instance-level functions"]
#[derive(Clone)]
pub struct Instance {
pub(crate) fp: InstanceFn,
pub(crate) handle: crate::vk::Instance,
}
impl Instance {
pub fn new(entry: &crate::Entry, instance: &crate::Instance) -> Self {
let handle = instance.handle();
let fp = InstanceFn::load(|name| unsafe {
core::mem::transmute(entry.get_instance_proc_addr(handle, name.as_ptr()))
});
Self { handle, fp }
}
#[inline]
pub fn fp(&self) -> &InstanceFn {
&self.fp
}
#[inline]
pub fn instance(&self) -> crate::vk::Instance {
self.handle
}
}
#[derive(Clone)]
#[doc = "Raw VK_EXT_headless_surface instance-level function pointers"]
pub struct InstanceFn {
pub create_headless_surface_ext: PFN_vkCreateHeadlessSurfaceEXT,
}
unsafe impl Send for InstanceFn {}
unsafe impl Sync for InstanceFn {}
impl InstanceFn {
pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
Self::load_erased(&mut f)
}
fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
Self {
create_headless_surface_ext: unsafe {
unsafe extern "system" fn create_headless_surface_ext(
_instance: crate::vk::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 =
CStr::from_bytes_with_nul_unchecked(b"vkCreateHeadlessSurfaceEXT\0");
let val = _f(cname);
if val.is_null() {
create_headless_surface_ext
} else {
::core::mem::transmute(val)
}
},
}
}
}
}
#[doc = "VK_EXT_line_rasterization"]
pub mod line_rasterization {
use super::super::*;
pub use {
crate::vk::EXT_LINE_RASTERIZATION_NAME as NAME,
crate::vk::EXT_LINE_RASTERIZATION_SPEC_VERSION as SPEC_VERSION,
};
#[doc = "VK_EXT_line_rasterization device-level functions"]
#[derive(Clone)]
pub struct Device {
pub(crate) fp: DeviceFn,
pub(crate) handle: crate::vk::Device,
}
impl Device {
pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
let handle = device.handle();
let fp = DeviceFn::load(|name| unsafe {
core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
});
Self { handle, fp }
}
#[inline]
pub fn fp(&self) -> &DeviceFn {
&self.fp
}
#[inline]
pub fn device(&self) -> crate::vk::Device {
self.handle
}
}
#[derive(Clone)]
#[doc = "Raw VK_EXT_line_rasterization device-level function pointers"]
pub struct DeviceFn {
pub cmd_set_line_stipple_ext: PFN_vkCmdSetLineStippleKHR,
}
unsafe impl Send for DeviceFn {}
unsafe impl Sync for DeviceFn {}
impl DeviceFn {
pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
Self::load_erased(&mut f)
}
fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
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 =
CStr::from_bytes_with_nul_unchecked(b"vkCmdSetLineStippleEXT\0");
let val = _f(cname);
if val.is_null() {
cmd_set_line_stipple_ext
} else {
::core::mem::transmute(val)
}
},
}
}
}
}
#[doc = "VK_EXT_shader_atomic_float"]
pub mod shader_atomic_float {
use super::super::*;
pub use {
crate::vk::EXT_SHADER_ATOMIC_FLOAT_NAME as NAME,
crate::vk::EXT_SHADER_ATOMIC_FLOAT_SPEC_VERSION as SPEC_VERSION,
};
}
#[doc = "VK_EXT_host_query_reset"]
pub mod host_query_reset {
use super::super::*;
pub use {
crate::vk::EXT_HOST_QUERY_RESET_NAME as NAME,
crate::vk::EXT_HOST_QUERY_RESET_SPEC_VERSION as SPEC_VERSION,
};
#[doc = "VK_EXT_host_query_reset device-level functions"]
#[derive(Clone)]
pub struct Device {
pub(crate) fp: DeviceFn,
pub(crate) handle: crate::vk::Device,
}
impl Device {
pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
let handle = device.handle();
let fp = DeviceFn::load(|name| unsafe {
core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
});
Self { handle, fp }
}
#[inline]
pub fn fp(&self) -> &DeviceFn {
&self.fp
}
#[inline]
pub fn device(&self) -> crate::vk::Device {
self.handle
}
}
#[derive(Clone)]
#[doc = "Raw VK_EXT_host_query_reset device-level function pointers"]
pub struct DeviceFn {
pub reset_query_pool_ext: PFN_vkResetQueryPool,
}
unsafe impl Send for DeviceFn {}
unsafe impl Sync for DeviceFn {}
impl DeviceFn {
pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
Self::load_erased(&mut f)
}
fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
Self {
reset_query_pool_ext: unsafe {
unsafe extern "system" fn reset_query_pool_ext(
_device: crate::vk::Device,
_query_pool: QueryPool,
_first_query: u32,
_query_count: u32,
) {
panic!(concat!("Unable to load ", stringify!(reset_query_pool_ext)))
}
let cname = CStr::from_bytes_with_nul_unchecked(b"vkResetQueryPoolEXT\0");
let val = _f(cname);
if val.is_null() {
reset_query_pool_ext
} else {
::core::mem::transmute(val)
}
},
}
}
}
}
#[doc = "VK_EXT_index_type_uint8"]
pub mod index_type_uint8 {
use super::super::*;
pub use {
crate::vk::EXT_INDEX_TYPE_UINT8_NAME as NAME,
crate::vk::EXT_INDEX_TYPE_UINT8_SPEC_VERSION as SPEC_VERSION,
};
}
#[doc = "VK_EXT_extended_dynamic_state"]
pub mod extended_dynamic_state {
use super::super::*;
pub use {
crate::vk::EXT_EXTENDED_DYNAMIC_STATE_NAME as NAME,
crate::vk::EXT_EXTENDED_DYNAMIC_STATE_SPEC_VERSION as SPEC_VERSION,
};
#[doc = "VK_EXT_extended_dynamic_state device-level functions"]
#[derive(Clone)]
pub struct Device {
pub(crate) fp: DeviceFn,
pub(crate) handle: crate::vk::Device,
}
impl Device {
pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
let handle = device.handle();
let fp = DeviceFn::load(|name| unsafe {
core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
});
Self { handle, fp }
}
#[inline]
pub fn fp(&self) -> &DeviceFn {
&self.fp
}
#[inline]
pub fn device(&self) -> crate::vk::Device {
self.handle
}
}
#[derive(Clone)]
#[doc = "Raw VK_EXT_extended_dynamic_state device-level function pointers"]
pub struct DeviceFn {
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 DeviceFn {}
unsafe impl Sync for DeviceFn {}
impl DeviceFn {
pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
Self::load_erased(&mut f)
}
fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
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 = CStr::from_bytes_with_nul_unchecked(b"vkCmdSetCullModeEXT\0");
let val = _f(cname);
if val.is_null() {
cmd_set_cull_mode_ext
} else {
::core::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 = CStr::from_bytes_with_nul_unchecked(b"vkCmdSetFrontFaceEXT\0");
let val = _f(cname);
if val.is_null() {
cmd_set_front_face_ext
} else {
::core::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 =
CStr::from_bytes_with_nul_unchecked(b"vkCmdSetPrimitiveTopologyEXT\0");
let val = _f(cname);
if val.is_null() {
cmd_set_primitive_topology_ext
} else {
::core::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 =
CStr::from_bytes_with_nul_unchecked(b"vkCmdSetViewportWithCountEXT\0");
let val = _f(cname);
if val.is_null() {
cmd_set_viewport_with_count_ext
} else {
::core::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 =
CStr::from_bytes_with_nul_unchecked(b"vkCmdSetScissorWithCountEXT\0");
let val = _f(cname);
if val.is_null() {
cmd_set_scissor_with_count_ext
} else {
::core::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 =
CStr::from_bytes_with_nul_unchecked(b"vkCmdBindVertexBuffers2EXT\0");
let val = _f(cname);
if val.is_null() {
cmd_bind_vertex_buffers2_ext
} else {
::core::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 =
CStr::from_bytes_with_nul_unchecked(b"vkCmdSetDepthTestEnableEXT\0");
let val = _f(cname);
if val.is_null() {
cmd_set_depth_test_enable_ext
} else {
::core::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 =
CStr::from_bytes_with_nul_unchecked(b"vkCmdSetDepthWriteEnableEXT\0");
let val = _f(cname);
if val.is_null() {
cmd_set_depth_write_enable_ext
} else {
::core::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 =
CStr::from_bytes_with_nul_unchecked(b"vkCmdSetDepthCompareOpEXT\0");
let val = _f(cname);
if val.is_null() {
cmd_set_depth_compare_op_ext
} else {
::core::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 = 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 {
::core::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 =
CStr::from_bytes_with_nul_unchecked(b"vkCmdSetStencilTestEnableEXT\0");
let val = _f(cname);
if val.is_null() {
cmd_set_stencil_test_enable_ext
} else {
::core::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 = CStr::from_bytes_with_nul_unchecked(b"vkCmdSetStencilOpEXT\0");
let val = _f(cname);
if val.is_null() {
cmd_set_stencil_op_ext
} else {
::core::mem::transmute(val)
}
},
}
}
}
}
#[doc = "VK_EXT_host_image_copy"]
pub mod host_image_copy {
use super::super::*;
pub use {
crate::vk::EXT_HOST_IMAGE_COPY_NAME as NAME,
crate::vk::EXT_HOST_IMAGE_COPY_SPEC_VERSION as SPEC_VERSION,
};
#[doc = "VK_EXT_host_image_copy device-level functions"]
#[derive(Clone)]
pub struct Device {
pub(crate) fp: DeviceFn,
pub(crate) handle: crate::vk::Device,
}
impl Device {
pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
let handle = device.handle();
let fp = DeviceFn::load(|name| unsafe {
core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
});
Self { handle, fp }
}
#[inline]
pub fn fp(&self) -> &DeviceFn {
&self.fp
}
#[inline]
pub fn device(&self) -> crate::vk::Device {
self.handle
}
}
#[derive(Clone)]
#[doc = "Raw VK_EXT_host_image_copy device-level function pointers"]
pub struct DeviceFn {
pub copy_memory_to_image_ext: PFN_vkCopyMemoryToImageEXT,
pub copy_image_to_memory_ext: PFN_vkCopyImageToMemoryEXT,
pub copy_image_to_image_ext: PFN_vkCopyImageToImageEXT,
pub transition_image_layout_ext: PFN_vkTransitionImageLayoutEXT,
pub get_image_subresource_layout2_ext: PFN_vkGetImageSubresourceLayout2KHR,
}
unsafe impl Send for DeviceFn {}
unsafe impl Sync for DeviceFn {}
impl DeviceFn {
pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
Self::load_erased(&mut f)
}
fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
Self {
copy_memory_to_image_ext: unsafe {
unsafe extern "system" fn copy_memory_to_image_ext(
_device: crate::vk::Device,
_p_copy_memory_to_image_info: *const CopyMemoryToImageInfoEXT<'_>,
) -> Result {
panic!(concat!(
"Unable to load ",
stringify!(copy_memory_to_image_ext)
))
}
let cname =
CStr::from_bytes_with_nul_unchecked(b"vkCopyMemoryToImageEXT\0");
let val = _f(cname);
if val.is_null() {
copy_memory_to_image_ext
} else {
::core::mem::transmute(val)
}
},
copy_image_to_memory_ext: unsafe {
unsafe extern "system" fn copy_image_to_memory_ext(
_device: crate::vk::Device,
_p_copy_image_to_memory_info: *const CopyImageToMemoryInfoEXT<'_>,
) -> Result {
panic!(concat!(
"Unable to load ",
stringify!(copy_image_to_memory_ext)
))
}
let cname =
CStr::from_bytes_with_nul_unchecked(b"vkCopyImageToMemoryEXT\0");
let val = _f(cname);
if val.is_null() {
copy_image_to_memory_ext
} else {
::core::mem::transmute(val)
}
},
copy_image_to_image_ext: unsafe {
unsafe extern "system" fn copy_image_to_image_ext(
_device: crate::vk::Device,
_p_copy_image_to_image_info: *const CopyImageToImageInfoEXT<'_>,
) -> Result {
panic!(concat!(
"Unable to load ",
stringify!(copy_image_to_image_ext)
))
}
let cname = CStr::from_bytes_with_nul_unchecked(b"vkCopyImageToImageEXT\0");
let val = _f(cname);
if val.is_null() {
copy_image_to_image_ext
} else {
::core::mem::transmute(val)
}
},
transition_image_layout_ext: unsafe {
unsafe extern "system" fn transition_image_layout_ext(
_device: crate::vk::Device,
_transition_count: u32,
_p_transitions: *const HostImageLayoutTransitionInfoEXT<'_>,
) -> Result {
panic!(concat!(
"Unable to load ",
stringify!(transition_image_layout_ext)
))
}
let cname =
CStr::from_bytes_with_nul_unchecked(b"vkTransitionImageLayoutEXT\0");
let val = _f(cname);
if val.is_null() {
transition_image_layout_ext
} else {
::core::mem::transmute(val)
}
},
get_image_subresource_layout2_ext: unsafe {
unsafe extern "system" fn get_image_subresource_layout2_ext(
_device: crate::vk::Device,
_image: Image,
_p_subresource: *const ImageSubresource2KHR<'_>,
_p_layout: *mut SubresourceLayout2KHR<'_>,
) {
panic!(concat!(
"Unable to load ",
stringify!(get_image_subresource_layout2_ext)
))
}
let cname = CStr::from_bytes_with_nul_unchecked(
b"vkGetImageSubresourceLayout2EXT\0",
);
let val = _f(cname);
if val.is_null() {
get_image_subresource_layout2_ext
} else {
::core::mem::transmute(val)
}
},
}
}
}
}
#[doc = "VK_EXT_map_memory_placed"]
pub mod map_memory_placed {
use super::super::*;
pub use {
crate::vk::EXT_MAP_MEMORY_PLACED_NAME as NAME,
crate::vk::EXT_MAP_MEMORY_PLACED_SPEC_VERSION as SPEC_VERSION,
};
}
#[doc = "VK_EXT_shader_atomic_float2"]
pub mod shader_atomic_float2 {
use super::super::*;
pub use {
crate::vk::EXT_SHADER_ATOMIC_FLOAT2_NAME as NAME,
crate::vk::EXT_SHADER_ATOMIC_FLOAT2_SPEC_VERSION as SPEC_VERSION,
};
}
#[doc = "VK_EXT_surface_maintenance1"]
pub mod surface_maintenance1 {
use super::super::*;
pub use {
crate::vk::EXT_SURFACE_MAINTENANCE1_NAME as NAME,
crate::vk::EXT_SURFACE_MAINTENANCE1_SPEC_VERSION as SPEC_VERSION,
};
}
#[doc = "VK_EXT_swapchain_maintenance1"]
pub mod swapchain_maintenance1 {
use super::super::*;
pub use {
crate::vk::EXT_SWAPCHAIN_MAINTENANCE1_NAME as NAME,
crate::vk::EXT_SWAPCHAIN_MAINTENANCE1_SPEC_VERSION as SPEC_VERSION,
};
#[doc = "VK_EXT_swapchain_maintenance1 device-level functions"]
#[derive(Clone)]
pub struct Device {
pub(crate) fp: DeviceFn,
pub(crate) handle: crate::vk::Device,
}
impl Device {
pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
let handle = device.handle();
let fp = DeviceFn::load(|name| unsafe {
core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
});
Self { handle, fp }
}
#[inline]
pub fn fp(&self) -> &DeviceFn {
&self.fp
}
#[inline]
pub fn device(&self) -> crate::vk::Device {
self.handle
}
}
#[derive(Clone)]
#[doc = "Raw VK_EXT_swapchain_maintenance1 device-level function pointers"]
pub struct DeviceFn {
pub release_swapchain_images_ext: PFN_vkReleaseSwapchainImagesEXT,
}
unsafe impl Send for DeviceFn {}
unsafe impl Sync for DeviceFn {}
impl DeviceFn {
pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
Self::load_erased(&mut f)
}
fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
Self {
release_swapchain_images_ext: unsafe {
unsafe extern "system" fn release_swapchain_images_ext(
_device: crate::vk::Device,
_p_release_info: *const ReleaseSwapchainImagesInfoEXT<'_>,
) -> Result {
panic!(concat!(
"Unable to load ",
stringify!(release_swapchain_images_ext)
))
}
let cname =
CStr::from_bytes_with_nul_unchecked(b"vkReleaseSwapchainImagesEXT\0");
let val = _f(cname);
if val.is_null() {
release_swapchain_images_ext
} else {
::core::mem::transmute(val)
}
},
}
}
}
}
#[doc = "VK_EXT_shader_demote_to_helper_invocation"]
pub mod shader_demote_to_helper_invocation {
use super::super::*;
pub use {
crate::vk::EXT_SHADER_DEMOTE_TO_HELPER_INVOCATION_NAME as NAME,
crate::vk::EXT_SHADER_DEMOTE_TO_HELPER_INVOCATION_SPEC_VERSION as SPEC_VERSION,
};
}
#[doc = "VK_EXT_texel_buffer_alignment"]
pub mod texel_buffer_alignment {
use super::super::*;
pub use {
crate::vk::EXT_TEXEL_BUFFER_ALIGNMENT_NAME as NAME,
crate::vk::EXT_TEXEL_BUFFER_ALIGNMENT_SPEC_VERSION as SPEC_VERSION,
};
}
#[doc = "VK_EXT_depth_bias_control"]
pub mod depth_bias_control {
use super::super::*;
pub use {
crate::vk::EXT_DEPTH_BIAS_CONTROL_NAME as NAME,
crate::vk::EXT_DEPTH_BIAS_CONTROL_SPEC_VERSION as SPEC_VERSION,
};
#[doc = "VK_EXT_depth_bias_control device-level functions"]
#[derive(Clone)]
pub struct Device {
pub(crate) fp: DeviceFn,
pub(crate) handle: crate::vk::Device,
}
impl Device {
pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
let handle = device.handle();
let fp = DeviceFn::load(|name| unsafe {
core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
});
Self { handle, fp }
}
#[inline]
pub fn fp(&self) -> &DeviceFn {
&self.fp
}
#[inline]
pub fn device(&self) -> crate::vk::Device {
self.handle
}
}
#[derive(Clone)]
#[doc = "Raw VK_EXT_depth_bias_control device-level function pointers"]
pub struct DeviceFn {
pub cmd_set_depth_bias2_ext: PFN_vkCmdSetDepthBias2EXT,
}
unsafe impl Send for DeviceFn {}
unsafe impl Sync for DeviceFn {}
impl DeviceFn {
pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
Self::load_erased(&mut f)
}
fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
Self {
cmd_set_depth_bias2_ext: unsafe {
unsafe extern "system" fn cmd_set_depth_bias2_ext(
_command_buffer: CommandBuffer,
_p_depth_bias_info: *const DepthBiasInfoEXT<'_>,
) {
panic!(concat!(
"Unable to load ",
stringify!(cmd_set_depth_bias2_ext)
))
}
let cname = CStr::from_bytes_with_nul_unchecked(b"vkCmdSetDepthBias2EXT\0");
let val = _f(cname);
if val.is_null() {
cmd_set_depth_bias2_ext
} else {
::core::mem::transmute(val)
}
},
}
}
}
}
#[doc = "VK_EXT_device_memory_report"]
pub mod device_memory_report {
use super::super::*;
pub use {
crate::vk::EXT_DEVICE_MEMORY_REPORT_NAME as NAME,
crate::vk::EXT_DEVICE_MEMORY_REPORT_SPEC_VERSION as SPEC_VERSION,
};
}
#[doc = "VK_EXT_acquire_drm_display"]
pub mod acquire_drm_display {
use super::super::*;
pub use {
crate::vk::EXT_ACQUIRE_DRM_DISPLAY_NAME as NAME,
crate::vk::EXT_ACQUIRE_DRM_DISPLAY_SPEC_VERSION as SPEC_VERSION,
};
#[doc = "VK_EXT_acquire_drm_display instance-level functions"]
#[derive(Clone)]
pub struct Instance {
pub(crate) fp: InstanceFn,
pub(crate) handle: crate::vk::Instance,
}
impl Instance {
pub fn new(entry: &crate::Entry, instance: &crate::Instance) -> Self {
let handle = instance.handle();
let fp = InstanceFn::load(|name| unsafe {
core::mem::transmute(entry.get_instance_proc_addr(handle, name.as_ptr()))
});
Self { handle, fp }
}
#[inline]
pub fn fp(&self) -> &InstanceFn {
&self.fp
}
#[inline]
pub fn instance(&self) -> crate::vk::Instance {
self.handle
}
}
#[derive(Clone)]
#[doc = "Raw VK_EXT_acquire_drm_display instance-level function pointers"]
pub struct InstanceFn {
pub acquire_drm_display_ext: PFN_vkAcquireDrmDisplayEXT,
pub get_drm_display_ext: PFN_vkGetDrmDisplayEXT,
}
unsafe impl Send for InstanceFn {}
unsafe impl Sync for InstanceFn {}
impl InstanceFn {
pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
Self::load_erased(&mut f)
}
fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
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 =
CStr::from_bytes_with_nul_unchecked(b"vkAcquireDrmDisplayEXT\0");
let val = _f(cname);
if val.is_null() {
acquire_drm_display_ext
} else {
::core::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 = CStr::from_bytes_with_nul_unchecked(b"vkGetDrmDisplayEXT\0");
let val = _f(cname);
if val.is_null() {
get_drm_display_ext
} else {
::core::mem::transmute(val)
}
},
}
}
}
}
#[doc = "VK_EXT_robustness2"]
pub mod robustness2 {
use super::super::*;
pub use {
crate::vk::EXT_ROBUSTNESS2_NAME as NAME,
crate::vk::EXT_ROBUSTNESS2_SPEC_VERSION as SPEC_VERSION,
};
}
#[doc = "VK_EXT_custom_border_color"]
pub mod custom_border_color {
use super::super::*;
pub use {
crate::vk::EXT_CUSTOM_BORDER_COLOR_NAME as NAME,
crate::vk::EXT_CUSTOM_BORDER_COLOR_SPEC_VERSION as SPEC_VERSION,
};
}
#[doc = "VK_EXT_private_data"]
pub mod private_data {
use super::super::*;
pub use {
crate::vk::EXT_PRIVATE_DATA_NAME as NAME,
crate::vk::EXT_PRIVATE_DATA_SPEC_VERSION as SPEC_VERSION,
};
#[doc = "VK_EXT_private_data device-level functions"]
#[derive(Clone)]
pub struct Device {
pub(crate) fp: DeviceFn,
pub(crate) handle: crate::vk::Device,
}
impl Device {
pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
let handle = device.handle();
let fp = DeviceFn::load(|name| unsafe {
core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
});
Self { handle, fp }
}
#[inline]
pub fn fp(&self) -> &DeviceFn {
&self.fp
}
#[inline]
pub fn device(&self) -> crate::vk::Device {
self.handle
}
}
#[derive(Clone)]
#[doc = "Raw VK_EXT_private_data device-level function pointers"]
pub struct DeviceFn {
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 DeviceFn {}
unsafe impl Sync for DeviceFn {}
impl DeviceFn {
pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
Self::load_erased(&mut f)
}
fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
Self {
create_private_data_slot_ext: unsafe {
unsafe extern "system" fn create_private_data_slot_ext(
_device: crate::vk::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 =
CStr::from_bytes_with_nul_unchecked(b"vkCreatePrivateDataSlotEXT\0");
let val = _f(cname);
if val.is_null() {
create_private_data_slot_ext
} else {
::core::mem::transmute(val)
}
},
destroy_private_data_slot_ext: unsafe {
unsafe extern "system" fn destroy_private_data_slot_ext(
_device: crate::vk::Device,
_private_data_slot: PrivateDataSlot,
_p_allocator: *const AllocationCallbacks<'_>,
) {
panic!(concat!(
"Unable to load ",
stringify!(destroy_private_data_slot_ext)
))
}
let cname =
CStr::from_bytes_with_nul_unchecked(b"vkDestroyPrivateDataSlotEXT\0");
let val = _f(cname);
if val.is_null() {
destroy_private_data_slot_ext
} else {
::core::mem::transmute(val)
}
},
set_private_data_ext: unsafe {
unsafe extern "system" fn set_private_data_ext(
_device: crate::vk::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 = CStr::from_bytes_with_nul_unchecked(b"vkSetPrivateDataEXT\0");
let val = _f(cname);
if val.is_null() {
set_private_data_ext
} else {
::core::mem::transmute(val)
}
},
get_private_data_ext: unsafe {
unsafe extern "system" fn get_private_data_ext(
_device: crate::vk::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 = CStr::from_bytes_with_nul_unchecked(b"vkGetPrivateDataEXT\0");
let val = _f(cname);
if val.is_null() {
get_private_data_ext
} else {
::core::mem::transmute(val)
}
},
}
}
}
}
#[doc = "VK_EXT_pipeline_creation_cache_control"]
pub mod pipeline_creation_cache_control {
use super::super::*;
pub use {
crate::vk::EXT_PIPELINE_CREATION_CACHE_CONTROL_NAME as NAME,
crate::vk::EXT_PIPELINE_CREATION_CACHE_CONTROL_SPEC_VERSION as SPEC_VERSION,
};
}
#[doc = "VK_EXT_metal_objects"]
pub mod metal_objects {
use super::super::*;
pub use {
crate::vk::EXT_METAL_OBJECTS_NAME as NAME,
crate::vk::EXT_METAL_OBJECTS_SPEC_VERSION as SPEC_VERSION,
};
#[doc = "VK_EXT_metal_objects device-level functions"]
#[derive(Clone)]
pub struct Device {
pub(crate) fp: DeviceFn,
pub(crate) handle: crate::vk::Device,
}
impl Device {
pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
let handle = device.handle();
let fp = DeviceFn::load(|name| unsafe {
core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
});
Self { handle, fp }
}
#[inline]
pub fn fp(&self) -> &DeviceFn {
&self.fp
}
#[inline]
pub fn device(&self) -> crate::vk::Device {
self.handle
}
}
#[derive(Clone)]
#[doc = "Raw VK_EXT_metal_objects device-level function pointers"]
pub struct DeviceFn {
pub export_metal_objects_ext: PFN_vkExportMetalObjectsEXT,
}
unsafe impl Send for DeviceFn {}
unsafe impl Sync for DeviceFn {}
impl DeviceFn {
pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
Self::load_erased(&mut f)
}
fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
Self {
export_metal_objects_ext: unsafe {
unsafe extern "system" fn export_metal_objects_ext(
_device: crate::vk::Device,
_p_metal_objects_info: *mut ExportMetalObjectsInfoEXT<'_>,
) {
panic!(concat!(
"Unable to load ",
stringify!(export_metal_objects_ext)
))
}
let cname =
CStr::from_bytes_with_nul_unchecked(b"vkExportMetalObjectsEXT\0");
let val = _f(cname);
if val.is_null() {
export_metal_objects_ext
} else {
::core::mem::transmute(val)
}
},
}
}
}
}
#[doc = "VK_EXT_descriptor_buffer"]
pub mod descriptor_buffer {
use super::super::*;
pub use {
crate::vk::EXT_DESCRIPTOR_BUFFER_NAME as NAME,
crate::vk::EXT_DESCRIPTOR_BUFFER_SPEC_VERSION as SPEC_VERSION,
};
#[doc = "VK_EXT_descriptor_buffer device-level functions"]
#[derive(Clone)]
pub struct Device {
pub(crate) fp: DeviceFn,
pub(crate) handle: crate::vk::Device,
}
impl Device {
pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
let handle = device.handle();
let fp = DeviceFn::load(|name| unsafe {
core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
});
Self { handle, fp }
}
#[inline]
pub fn fp(&self) -> &DeviceFn {
&self.fp
}
#[inline]
pub fn device(&self) -> crate::vk::Device {
self.handle
}
}
#[derive(Clone)]
#[doc = "Raw VK_EXT_descriptor_buffer device-level function pointers"]
pub struct DeviceFn {
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 DeviceFn {}
unsafe impl Sync for DeviceFn {}
impl DeviceFn {
pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
Self::load_erased(&mut f)
}
fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
Self {
get_descriptor_set_layout_size_ext: unsafe {
unsafe extern "system" fn get_descriptor_set_layout_size_ext(
_device: crate::vk::Device,
_layout: DescriptorSetLayout,
_p_layout_size_in_bytes: *mut DeviceSize,
) {
panic!(concat!(
"Unable to load ",
stringify!(get_descriptor_set_layout_size_ext)
))
}
let cname = CStr::from_bytes_with_nul_unchecked(
b"vkGetDescriptorSetLayoutSizeEXT\0",
);
let val = _f(cname);
if val.is_null() {
get_descriptor_set_layout_size_ext
} else {
::core::mem::transmute(val)
}
},
get_descriptor_set_layout_binding_offset_ext: unsafe {
unsafe extern "system" fn get_descriptor_set_layout_binding_offset_ext(
_device: crate::vk::Device,
_layout: DescriptorSetLayout,
_binding: u32,
_p_offset: *mut DeviceSize,
) {
panic!(concat!(
"Unable to load ",
stringify!(get_descriptor_set_layout_binding_offset_ext)
))
}
let cname = 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 {
::core::mem::transmute(val)
}
},
get_descriptor_ext: unsafe {
unsafe extern "system" fn get_descriptor_ext(
_device: crate::vk::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 = CStr::from_bytes_with_nul_unchecked(b"vkGetDescriptorEXT\0");
let val = _f(cname);
if val.is_null() {
get_descriptor_ext
} else {
::core::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 =
CStr::from_bytes_with_nul_unchecked(b"vkCmdBindDescriptorBuffersEXT\0");
let val = _f(cname);
if val.is_null() {
cmd_bind_descriptor_buffers_ext
} else {
::core::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 = CStr::from_bytes_with_nul_unchecked(
b"vkCmdSetDescriptorBufferOffsetsEXT\0",
);
let val = _f(cname);
if val.is_null() {
cmd_set_descriptor_buffer_offsets_ext
} else {
::core::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 = 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 {
::core::mem::transmute(val)
}
},
get_buffer_opaque_capture_descriptor_data_ext: unsafe {
unsafe extern "system" fn get_buffer_opaque_capture_descriptor_data_ext(
_device: crate::vk::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 = 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 {
::core::mem::transmute(val)
}
},
get_image_opaque_capture_descriptor_data_ext: unsafe {
unsafe extern "system" fn get_image_opaque_capture_descriptor_data_ext(
_device: crate::vk::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 = 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 {
::core::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: crate::vk::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 = 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 {
::core::mem::transmute(val)
}
},
get_sampler_opaque_capture_descriptor_data_ext: unsafe {
unsafe extern "system" fn get_sampler_opaque_capture_descriptor_data_ext(
_device: crate::vk::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 = 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 {
::core::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: crate::vk::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 = 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 {
::core::mem::transmute(val)
}
},
}
}
}
}
#[doc = "VK_EXT_graphics_pipeline_library"]
pub mod graphics_pipeline_library {
use super::super::*;
pub use {
crate::vk::EXT_GRAPHICS_PIPELINE_LIBRARY_NAME as NAME,
crate::vk::EXT_GRAPHICS_PIPELINE_LIBRARY_SPEC_VERSION as SPEC_VERSION,
};
}
#[doc = "VK_EXT_mesh_shader"]
pub mod mesh_shader {
use super::super::*;
pub use {
crate::vk::EXT_MESH_SHADER_NAME as NAME,
crate::vk::EXT_MESH_SHADER_SPEC_VERSION as SPEC_VERSION,
};
#[doc = "VK_EXT_mesh_shader device-level functions"]
#[derive(Clone)]
pub struct Device {
pub(crate) fp: DeviceFn,
pub(crate) handle: crate::vk::Device,
}
impl Device {
pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
let handle = device.handle();
let fp = DeviceFn::load(|name| unsafe {
core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
});
Self { handle, fp }
}
#[inline]
pub fn fp(&self) -> &DeviceFn {
&self.fp
}
#[inline]
pub fn device(&self) -> crate::vk::Device {
self.handle
}
}
#[derive(Clone)]
#[doc = "Raw VK_EXT_mesh_shader device-level function pointers"]
pub struct DeviceFn {
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 DeviceFn {}
unsafe impl Sync for DeviceFn {}
impl DeviceFn {
pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
Self::load_erased(&mut f)
}
fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
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 = CStr::from_bytes_with_nul_unchecked(b"vkCmdDrawMeshTasksEXT\0");
let val = _f(cname);
if val.is_null() {
cmd_draw_mesh_tasks_ext
} else {
::core::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 =
CStr::from_bytes_with_nul_unchecked(b"vkCmdDrawMeshTasksIndirectEXT\0");
let val = _f(cname);
if val.is_null() {
cmd_draw_mesh_tasks_indirect_ext
} else {
::core::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 = 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 {
::core::mem::transmute(val)
}
},
}
}
}
}
#[doc = "VK_EXT_ycbcr_2plane_444_formats"]
pub mod ycbcr_2plane_444_formats {
use super::super::*;
pub use {
crate::vk::EXT_YCBCR_2PLANE_444_FORMATS_NAME as NAME,
crate::vk::EXT_YCBCR_2PLANE_444_FORMATS_SPEC_VERSION as SPEC_VERSION,
};
}
#[doc = "VK_EXT_fragment_density_map2"]
pub mod fragment_density_map2 {
use super::super::*;
pub use {
crate::vk::EXT_FRAGMENT_DENSITY_MAP2_NAME as NAME,
crate::vk::EXT_FRAGMENT_DENSITY_MAP2_SPEC_VERSION as SPEC_VERSION,
};
}
#[doc = "VK_EXT_image_robustness"]
pub mod image_robustness {
use super::super::*;
pub use {
crate::vk::EXT_IMAGE_ROBUSTNESS_NAME as NAME,
crate::vk::EXT_IMAGE_ROBUSTNESS_SPEC_VERSION as SPEC_VERSION,
};
}
#[doc = "VK_EXT_image_compression_control"]
pub mod image_compression_control {
use super::super::*;
pub use {
crate::vk::EXT_IMAGE_COMPRESSION_CONTROL_NAME as NAME,
crate::vk::EXT_IMAGE_COMPRESSION_CONTROL_SPEC_VERSION as SPEC_VERSION,
};
#[doc = "VK_EXT_image_compression_control device-level functions"]
#[derive(Clone)]
pub struct Device {
pub(crate) fp: DeviceFn,
pub(crate) handle: crate::vk::Device,
}
impl Device {
pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
let handle = device.handle();
let fp = DeviceFn::load(|name| unsafe {
core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
});
Self { handle, fp }
}
#[inline]
pub fn fp(&self) -> &DeviceFn {
&self.fp
}
#[inline]
pub fn device(&self) -> crate::vk::Device {
self.handle
}
}
#[derive(Clone)]
#[doc = "Raw VK_EXT_image_compression_control device-level function pointers"]
pub struct DeviceFn {
pub get_image_subresource_layout2_ext: PFN_vkGetImageSubresourceLayout2KHR,
}
unsafe impl Send for DeviceFn {}
unsafe impl Sync for DeviceFn {}
impl DeviceFn {
pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
Self::load_erased(&mut f)
}
fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
Self {
get_image_subresource_layout2_ext: unsafe {
unsafe extern "system" fn get_image_subresource_layout2_ext(
_device: crate::vk::Device,
_image: Image,
_p_subresource: *const ImageSubresource2KHR<'_>,
_p_layout: *mut SubresourceLayout2KHR<'_>,
) {
panic!(concat!(
"Unable to load ",
stringify!(get_image_subresource_layout2_ext)
))
}
let cname = CStr::from_bytes_with_nul_unchecked(
b"vkGetImageSubresourceLayout2EXT\0",
);
let val = _f(cname);
if val.is_null() {
get_image_subresource_layout2_ext
} else {
::core::mem::transmute(val)
}
},
}
}
}
}
#[doc = "VK_EXT_attachment_feedback_loop_layout"]
pub mod attachment_feedback_loop_layout {
use super::super::*;
pub use {
crate::vk::EXT_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_NAME as NAME,
crate::vk::EXT_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_SPEC_VERSION as SPEC_VERSION,
};
}
#[doc = "VK_EXT_4444_formats"]
pub mod _4444_formats {
use super::super::*;
pub use {
crate::vk::EXT_4444_FORMATS_NAME as NAME,
crate::vk::EXT_4444_FORMATS_SPEC_VERSION as SPEC_VERSION,
};
}
#[doc = "VK_EXT_device_fault"]
pub mod device_fault {
use super::super::*;
pub use {
crate::vk::EXT_DEVICE_FAULT_NAME as NAME,
crate::vk::EXT_DEVICE_FAULT_SPEC_VERSION as SPEC_VERSION,
};
#[doc = "VK_EXT_device_fault device-level functions"]
#[derive(Clone)]
pub struct Device {
pub(crate) fp: DeviceFn,
pub(crate) handle: crate::vk::Device,
}
impl Device {
pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
let handle = device.handle();
let fp = DeviceFn::load(|name| unsafe {
core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
});
Self { handle, fp }
}
#[inline]
pub fn fp(&self) -> &DeviceFn {
&self.fp
}
#[inline]
pub fn device(&self) -> crate::vk::Device {
self.handle
}
}
#[derive(Clone)]
#[doc = "Raw VK_EXT_device_fault device-level function pointers"]
pub struct DeviceFn {
pub get_device_fault_info_ext: PFN_vkGetDeviceFaultInfoEXT,
}
unsafe impl Send for DeviceFn {}
unsafe impl Sync for DeviceFn {}
impl DeviceFn {
pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
Self::load_erased(&mut f)
}
fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
Self {
get_device_fault_info_ext: unsafe {
unsafe extern "system" fn get_device_fault_info_ext(
_device: crate::vk::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 =
CStr::from_bytes_with_nul_unchecked(b"vkGetDeviceFaultInfoEXT\0");
let val = _f(cname);
if val.is_null() {
get_device_fault_info_ext
} else {
::core::mem::transmute(val)
}
},
}
}
}
}
#[doc = "VK_EXT_rgba10x6_formats"]
pub mod rgba10x6_formats {
use super::super::*;
pub use {
crate::vk::EXT_RGBA10X6_FORMATS_NAME as NAME,
crate::vk::EXT_RGBA10X6_FORMATS_SPEC_VERSION as SPEC_VERSION,
};
}
#[doc = "VK_EXT_directfb_surface"]
pub mod directfb_surface {
use super::super::*;
pub use {
crate::vk::EXT_DIRECTFB_SURFACE_NAME as NAME,
crate::vk::EXT_DIRECTFB_SURFACE_SPEC_VERSION as SPEC_VERSION,
};
#[doc = "VK_EXT_directfb_surface instance-level functions"]
#[derive(Clone)]
pub struct Instance {
pub(crate) fp: InstanceFn,
pub(crate) handle: crate::vk::Instance,
}
impl Instance {
pub fn new(entry: &crate::Entry, instance: &crate::Instance) -> Self {
let handle = instance.handle();
let fp = InstanceFn::load(|name| unsafe {
core::mem::transmute(entry.get_instance_proc_addr(handle, name.as_ptr()))
});
Self { handle, fp }
}
#[inline]
pub fn fp(&self) -> &InstanceFn {
&self.fp
}
#[inline]
pub fn instance(&self) -> crate::vk::Instance {
self.handle
}
}
#[derive(Clone)]
#[doc = "Raw VK_EXT_directfb_surface instance-level function pointers"]
pub struct InstanceFn {
pub create_direct_fb_surface_ext: PFN_vkCreateDirectFBSurfaceEXT,
pub get_physical_device_direct_fb_presentation_support_ext:
PFN_vkGetPhysicalDeviceDirectFBPresentationSupportEXT,
}
unsafe impl Send for InstanceFn {}
unsafe impl Sync for InstanceFn {}
impl InstanceFn {
pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
Self::load_erased(&mut f)
}
fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
Self {
create_direct_fb_surface_ext: unsafe {
unsafe extern "system" fn create_direct_fb_surface_ext(
_instance: crate::vk::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 =
CStr::from_bytes_with_nul_unchecked(b"vkCreateDirectFBSurfaceEXT\0");
let val = _f(cname);
if val.is_null() {
create_direct_fb_surface_ext
} else {
::core::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 = 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 {
::core::mem::transmute(val)
}
},
}
}
}
}
#[doc = "VK_EXT_vertex_input_dynamic_state"]
pub mod vertex_input_dynamic_state {
use super::super::*;
pub use {
crate::vk::EXT_VERTEX_INPUT_DYNAMIC_STATE_NAME as NAME,
crate::vk::EXT_VERTEX_INPUT_DYNAMIC_STATE_SPEC_VERSION as SPEC_VERSION,
};
#[doc = "VK_EXT_vertex_input_dynamic_state device-level functions"]
#[derive(Clone)]
pub struct Device {
pub(crate) fp: DeviceFn,
pub(crate) handle: crate::vk::Device,
}
impl Device {
pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
let handle = device.handle();
let fp = DeviceFn::load(|name| unsafe {
core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
});
Self { handle, fp }
}
#[inline]
pub fn fp(&self) -> &DeviceFn {
&self.fp
}
#[inline]
pub fn device(&self) -> crate::vk::Device {
self.handle
}
}
#[derive(Clone)]
#[doc = "Raw VK_EXT_vertex_input_dynamic_state device-level function pointers"]
pub struct DeviceFn {
pub cmd_set_vertex_input_ext: PFN_vkCmdSetVertexInputEXT,
}
unsafe impl Send for DeviceFn {}
unsafe impl Sync for DeviceFn {}
impl DeviceFn {
pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
Self::load_erased(&mut f)
}
fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
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 =
CStr::from_bytes_with_nul_unchecked(b"vkCmdSetVertexInputEXT\0");
let val = _f(cname);
if val.is_null() {
cmd_set_vertex_input_ext
} else {
::core::mem::transmute(val)
}
},
}
}
}
}
#[doc = "VK_EXT_physical_device_drm"]
pub mod physical_device_drm {
use super::super::*;
pub use {
crate::vk::EXT_PHYSICAL_DEVICE_DRM_NAME as NAME,
crate::vk::EXT_PHYSICAL_DEVICE_DRM_SPEC_VERSION as SPEC_VERSION,
};
}
#[doc = "VK_EXT_device_address_binding_report"]
pub mod device_address_binding_report {
use super::super::*;
pub use {
crate::vk::EXT_DEVICE_ADDRESS_BINDING_REPORT_NAME as NAME,
crate::vk::EXT_DEVICE_ADDRESS_BINDING_REPORT_SPEC_VERSION as SPEC_VERSION,
};
}
#[doc = "VK_EXT_depth_clip_control"]
pub mod depth_clip_control {
use super::super::*;
pub use {
crate::vk::EXT_DEPTH_CLIP_CONTROL_NAME as NAME,
crate::vk::EXT_DEPTH_CLIP_CONTROL_SPEC_VERSION as SPEC_VERSION,
};
}
#[doc = "VK_EXT_primitive_topology_list_restart"]
pub mod primitive_topology_list_restart {
use super::super::*;
pub use {
crate::vk::EXT_PRIMITIVE_TOPOLOGY_LIST_RESTART_NAME as NAME,
crate::vk::EXT_PRIMITIVE_TOPOLOGY_LIST_RESTART_SPEC_VERSION as SPEC_VERSION,
};
}
#[doc = "VK_EXT_pipeline_properties"]
pub mod pipeline_properties {
use super::super::*;
pub use {
crate::vk::EXT_PIPELINE_PROPERTIES_NAME as NAME,
crate::vk::EXT_PIPELINE_PROPERTIES_SPEC_VERSION as SPEC_VERSION,
};
#[doc = "VK_EXT_pipeline_properties device-level functions"]
#[derive(Clone)]
pub struct Device {
pub(crate) fp: DeviceFn,
pub(crate) handle: crate::vk::Device,
}
impl Device {
pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
let handle = device.handle();
let fp = DeviceFn::load(|name| unsafe {
core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
});
Self { handle, fp }
}
#[inline]
pub fn fp(&self) -> &DeviceFn {
&self.fp
}
#[inline]
pub fn device(&self) -> crate::vk::Device {
self.handle
}
}
#[allow(non_camel_case_types)]
#[doc = "Implemented for all types that can be passed as argument to `pipeline_properties` in [`PFN_vkGetPipelinePropertiesEXT`]"]
pub unsafe trait GetPipelinePropertiesEXTParamPipelineProperties {}
unsafe impl GetPipelinePropertiesEXTParamPipelineProperties
for PipelinePropertiesIdentifierEXT<'_>
{
}
#[derive(Clone)]
#[doc = "Raw VK_EXT_pipeline_properties device-level function pointers"]
pub struct DeviceFn {
pub get_pipeline_properties_ext: PFN_vkGetPipelinePropertiesEXT,
}
unsafe impl Send for DeviceFn {}
unsafe impl Sync for DeviceFn {}
impl DeviceFn {
pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
Self::load_erased(&mut f)
}
fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
Self {
get_pipeline_properties_ext: unsafe {
unsafe extern "system" fn get_pipeline_properties_ext(
_device: crate::vk::Device,
_p_pipeline_info: *const PipelineInfoEXT<'_>,
_p_pipeline_properties: *mut BaseOutStructure<'_>,
) -> Result {
panic!(concat!(
"Unable to load ",
stringify!(get_pipeline_properties_ext)
))
}
let cname =
CStr::from_bytes_with_nul_unchecked(b"vkGetPipelinePropertiesEXT\0");
let val = _f(cname);
if val.is_null() {
get_pipeline_properties_ext
} else {
::core::mem::transmute(val)
}
},
}
}
}
}
#[doc = "VK_EXT_frame_boundary"]
pub mod frame_boundary {
use super::super::*;
pub use {
crate::vk::EXT_FRAME_BOUNDARY_NAME as NAME,
crate::vk::EXT_FRAME_BOUNDARY_SPEC_VERSION as SPEC_VERSION,
};
}
#[doc = "VK_EXT_multisampled_render_to_single_sampled"]
pub mod multisampled_render_to_single_sampled {
use super::super::*;
pub use {
crate::vk::EXT_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_NAME as NAME,
crate::vk::EXT_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_SPEC_VERSION as SPEC_VERSION,
};
}
#[doc = "VK_EXT_extended_dynamic_state2"]
pub mod extended_dynamic_state2 {
use super::super::*;
pub use {
crate::vk::EXT_EXTENDED_DYNAMIC_STATE2_NAME as NAME,
crate::vk::EXT_EXTENDED_DYNAMIC_STATE2_SPEC_VERSION as SPEC_VERSION,
};
#[doc = "VK_EXT_extended_dynamic_state2 device-level functions"]
#[derive(Clone)]
pub struct Device {
pub(crate) fp: DeviceFn,
pub(crate) handle: crate::vk::Device,
}
impl Device {
pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
let handle = device.handle();
let fp = DeviceFn::load(|name| unsafe {
core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
});
Self { handle, fp }
}
#[inline]
pub fn fp(&self) -> &DeviceFn {
&self.fp
}
#[inline]
pub fn device(&self) -> crate::vk::Device {
self.handle
}
}
#[derive(Clone)]
#[doc = "Raw VK_EXT_extended_dynamic_state2 device-level function pointers"]
pub struct DeviceFn {
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 DeviceFn {}
unsafe impl Sync for DeviceFn {}
impl DeviceFn {
pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
Self::load_erased(&mut f)
}
fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
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 =
CStr::from_bytes_with_nul_unchecked(b"vkCmdSetPatchControlPointsEXT\0");
let val = _f(cname);
if val.is_null() {
cmd_set_patch_control_points_ext
} else {
::core::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 = CStr::from_bytes_with_nul_unchecked(
b"vkCmdSetRasterizerDiscardEnableEXT\0",
);
let val = _f(cname);
if val.is_null() {
cmd_set_rasterizer_discard_enable_ext
} else {
::core::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 =
CStr::from_bytes_with_nul_unchecked(b"vkCmdSetDepthBiasEnableEXT\0");
let val = _f(cname);
if val.is_null() {
cmd_set_depth_bias_enable_ext
} else {
::core::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 = CStr::from_bytes_with_nul_unchecked(b"vkCmdSetLogicOpEXT\0");
let val = _f(cname);
if val.is_null() {
cmd_set_logic_op_ext
} else {
::core::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 = CStr::from_bytes_with_nul_unchecked(
b"vkCmdSetPrimitiveRestartEnableEXT\0",
);
let val = _f(cname);
if val.is_null() {
cmd_set_primitive_restart_enable_ext
} else {
::core::mem::transmute(val)
}
},
}
}
}
}
#[doc = "VK_EXT_color_write_enable"]
pub mod color_write_enable {
use super::super::*;
pub use {
crate::vk::EXT_COLOR_WRITE_ENABLE_NAME as NAME,
crate::vk::EXT_COLOR_WRITE_ENABLE_SPEC_VERSION as SPEC_VERSION,
};
#[doc = "VK_EXT_color_write_enable device-level functions"]
#[derive(Clone)]
pub struct Device {
pub(crate) fp: DeviceFn,
pub(crate) handle: crate::vk::Device,
}
impl Device {
pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
let handle = device.handle();
let fp = DeviceFn::load(|name| unsafe {
core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
});
Self { handle, fp }
}
#[inline]
pub fn fp(&self) -> &DeviceFn {
&self.fp
}
#[inline]
pub fn device(&self) -> crate::vk::Device {
self.handle
}
}
#[derive(Clone)]
#[doc = "Raw VK_EXT_color_write_enable device-level function pointers"]
pub struct DeviceFn {
pub cmd_set_color_write_enable_ext: PFN_vkCmdSetColorWriteEnableEXT,
}
unsafe impl Send for DeviceFn {}
unsafe impl Sync for DeviceFn {}
impl DeviceFn {
pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
Self::load_erased(&mut f)
}
fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
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 =
CStr::from_bytes_with_nul_unchecked(b"vkCmdSetColorWriteEnableEXT\0");
let val = _f(cname);
if val.is_null() {
cmd_set_color_write_enable_ext
} else {
::core::mem::transmute(val)
}
},
}
}
}
}
#[doc = "VK_EXT_primitives_generated_query"]
pub mod primitives_generated_query {
use super::super::*;
pub use {
crate::vk::EXT_PRIMITIVES_GENERATED_QUERY_NAME as NAME,
crate::vk::EXT_PRIMITIVES_GENERATED_QUERY_SPEC_VERSION as SPEC_VERSION,
};
}
#[doc = "VK_EXT_global_priority_query"]
pub mod global_priority_query {
use super::super::*;
pub use {
crate::vk::EXT_GLOBAL_PRIORITY_QUERY_NAME as NAME,
crate::vk::EXT_GLOBAL_PRIORITY_QUERY_SPEC_VERSION as SPEC_VERSION,
};
}
#[doc = "VK_EXT_image_view_min_lod"]
pub mod image_view_min_lod {
use super::super::*;
pub use {
crate::vk::EXT_IMAGE_VIEW_MIN_LOD_NAME as NAME,
crate::vk::EXT_IMAGE_VIEW_MIN_LOD_SPEC_VERSION as SPEC_VERSION,
};
}
#[doc = "VK_EXT_multi_draw"]
pub mod multi_draw {
use super::super::*;
pub use {
crate::vk::EXT_MULTI_DRAW_NAME as NAME,
crate::vk::EXT_MULTI_DRAW_SPEC_VERSION as SPEC_VERSION,
};
#[doc = "VK_EXT_multi_draw device-level functions"]
#[derive(Clone)]
pub struct Device {
pub(crate) fp: DeviceFn,
pub(crate) handle: crate::vk::Device,
}
impl Device {
pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
let handle = device.handle();
let fp = DeviceFn::load(|name| unsafe {
core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
});
Self { handle, fp }
}
#[inline]
pub fn fp(&self) -> &DeviceFn {
&self.fp
}
#[inline]
pub fn device(&self) -> crate::vk::Device {
self.handle
}
}
#[derive(Clone)]
#[doc = "Raw VK_EXT_multi_draw device-level function pointers"]
pub struct DeviceFn {
pub cmd_draw_multi_ext: PFN_vkCmdDrawMultiEXT,
pub cmd_draw_multi_indexed_ext: PFN_vkCmdDrawMultiIndexedEXT,
}
unsafe impl Send for DeviceFn {}
unsafe impl Sync for DeviceFn {}
impl DeviceFn {
pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
Self::load_erased(&mut f)
}
fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
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 = CStr::from_bytes_with_nul_unchecked(b"vkCmdDrawMultiEXT\0");
let val = _f(cname);
if val.is_null() {
cmd_draw_multi_ext
} else {
::core::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 =
CStr::from_bytes_with_nul_unchecked(b"vkCmdDrawMultiIndexedEXT\0");
let val = _f(cname);
if val.is_null() {
cmd_draw_multi_indexed_ext
} else {
::core::mem::transmute(val)
}
},
}
}
}
}
#[doc = "VK_EXT_image_2d_view_of_3d"]
pub mod image_2d_view_of_3d {
use super::super::*;
pub use {
crate::vk::EXT_IMAGE_2D_VIEW_OF_3D_NAME as NAME,
crate::vk::EXT_IMAGE_2D_VIEW_OF_3D_SPEC_VERSION as SPEC_VERSION,
};
}
#[doc = "VK_EXT_shader_tile_image"]
pub mod shader_tile_image {
use super::super::*;
pub use {
crate::vk::EXT_SHADER_TILE_IMAGE_NAME as NAME,
crate::vk::EXT_SHADER_TILE_IMAGE_SPEC_VERSION as SPEC_VERSION,
};
}
#[doc = "VK_EXT_opacity_micromap"]
pub mod opacity_micromap {
use super::super::*;
pub use {
crate::vk::EXT_OPACITY_MICROMAP_NAME as NAME,
crate::vk::EXT_OPACITY_MICROMAP_SPEC_VERSION as SPEC_VERSION,
};
#[doc = "VK_EXT_opacity_micromap device-level functions"]
#[derive(Clone)]
pub struct Device {
pub(crate) fp: DeviceFn,
pub(crate) handle: crate::vk::Device,
}
impl Device {
pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
let handle = device.handle();
let fp = DeviceFn::load(|name| unsafe {
core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
});
Self { handle, fp }
}
#[inline]
pub fn fp(&self) -> &DeviceFn {
&self.fp
}
#[inline]
pub fn device(&self) -> crate::vk::Device {
self.handle
}
}
#[derive(Clone)]
#[doc = "Raw VK_EXT_opacity_micromap device-level function pointers"]
pub struct DeviceFn {
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 DeviceFn {}
unsafe impl Sync for DeviceFn {}
impl DeviceFn {
pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
Self::load_erased(&mut f)
}
fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
Self {
create_micromap_ext: unsafe {
unsafe extern "system" fn create_micromap_ext(
_device: crate::vk::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 = CStr::from_bytes_with_nul_unchecked(b"vkCreateMicromapEXT\0");
let val = _f(cname);
if val.is_null() {
create_micromap_ext
} else {
::core::mem::transmute(val)
}
},
destroy_micromap_ext: unsafe {
unsafe extern "system" fn destroy_micromap_ext(
_device: crate::vk::Device,
_micromap: MicromapEXT,
_p_allocator: *const AllocationCallbacks<'_>,
) {
panic!(concat!("Unable to load ", stringify!(destroy_micromap_ext)))
}
let cname = CStr::from_bytes_with_nul_unchecked(b"vkDestroyMicromapEXT\0");
let val = _f(cname);
if val.is_null() {
destroy_micromap_ext
} else {
::core::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 =
CStr::from_bytes_with_nul_unchecked(b"vkCmdBuildMicromapsEXT\0");
let val = _f(cname);
if val.is_null() {
cmd_build_micromaps_ext
} else {
::core::mem::transmute(val)
}
},
build_micromaps_ext: unsafe {
unsafe extern "system" fn build_micromaps_ext(
_device: crate::vk::Device,
_deferred_operation: DeferredOperationKHR,
_info_count: u32,
_p_infos: *const MicromapBuildInfoEXT<'_>,
) -> Result {
panic!(concat!("Unable to load ", stringify!(build_micromaps_ext)))
}
let cname = CStr::from_bytes_with_nul_unchecked(b"vkBuildMicromapsEXT\0");
let val = _f(cname);
if val.is_null() {
build_micromaps_ext
} else {
::core::mem::transmute(val)
}
},
copy_micromap_ext: unsafe {
unsafe extern "system" fn copy_micromap_ext(
_device: crate::vk::Device,
_deferred_operation: DeferredOperationKHR,
_p_info: *const CopyMicromapInfoEXT<'_>,
) -> Result {
panic!(concat!("Unable to load ", stringify!(copy_micromap_ext)))
}
let cname = CStr::from_bytes_with_nul_unchecked(b"vkCopyMicromapEXT\0");
let val = _f(cname);
if val.is_null() {
copy_micromap_ext
} else {
::core::mem::transmute(val)
}
},
copy_micromap_to_memory_ext: unsafe {
unsafe extern "system" fn copy_micromap_to_memory_ext(
_device: crate::vk::Device,
_deferred_operation: DeferredOperationKHR,
_p_info: *const CopyMicromapToMemoryInfoEXT<'_>,
) -> Result {
panic!(concat!(
"Unable to load ",
stringify!(copy_micromap_to_memory_ext)
))
}
let cname =
CStr::from_bytes_with_nul_unchecked(b"vkCopyMicromapToMemoryEXT\0");
let val = _f(cname);
if val.is_null() {
copy_micromap_to_memory_ext
} else {
::core::mem::transmute(val)
}
},
copy_memory_to_micromap_ext: unsafe {
unsafe extern "system" fn copy_memory_to_micromap_ext(
_device: crate::vk::Device,
_deferred_operation: DeferredOperationKHR,
_p_info: *const CopyMemoryToMicromapInfoEXT<'_>,
) -> Result {
panic!(concat!(
"Unable to load ",
stringify!(copy_memory_to_micromap_ext)
))
}
let cname =
CStr::from_bytes_with_nul_unchecked(b"vkCopyMemoryToMicromapEXT\0");
let val = _f(cname);
if val.is_null() {
copy_memory_to_micromap_ext
} else {
::core::mem::transmute(val)
}
},
write_micromaps_properties_ext: unsafe {
unsafe extern "system" fn write_micromaps_properties_ext(
_device: crate::vk::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 =
CStr::from_bytes_with_nul_unchecked(b"vkWriteMicromapsPropertiesEXT\0");
let val = _f(cname);
if val.is_null() {
write_micromaps_properties_ext
} else {
::core::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 = CStr::from_bytes_with_nul_unchecked(b"vkCmdCopyMicromapEXT\0");
let val = _f(cname);
if val.is_null() {
cmd_copy_micromap_ext
} else {
::core::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 =
CStr::from_bytes_with_nul_unchecked(b"vkCmdCopyMicromapToMemoryEXT\0");
let val = _f(cname);
if val.is_null() {
cmd_copy_micromap_to_memory_ext
} else {
::core::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 =
CStr::from_bytes_with_nul_unchecked(b"vkCmdCopyMemoryToMicromapEXT\0");
let val = _f(cname);
if val.is_null() {
cmd_copy_memory_to_micromap_ext
} else {
::core::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 = CStr::from_bytes_with_nul_unchecked(
b"vkCmdWriteMicromapsPropertiesEXT\0",
);
let val = _f(cname);
if val.is_null() {
cmd_write_micromaps_properties_ext
} else {
::core::mem::transmute(val)
}
},
get_device_micromap_compatibility_ext: unsafe {
unsafe extern "system" fn get_device_micromap_compatibility_ext(
_device: crate::vk::Device,
_p_version_info: *const MicromapVersionInfoEXT<'_>,
_p_compatibility: *mut AccelerationStructureCompatibilityKHR,
) {
panic!(concat!(
"Unable to load ",
stringify!(get_device_micromap_compatibility_ext)
))
}
let cname = CStr::from_bytes_with_nul_unchecked(
b"vkGetDeviceMicromapCompatibilityEXT\0",
);
let val = _f(cname);
if val.is_null() {
get_device_micromap_compatibility_ext
} else {
::core::mem::transmute(val)
}
},
get_micromap_build_sizes_ext: unsafe {
unsafe extern "system" fn get_micromap_build_sizes_ext(
_device: crate::vk::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 =
CStr::from_bytes_with_nul_unchecked(b"vkGetMicromapBuildSizesEXT\0");
let val = _f(cname);
if val.is_null() {
get_micromap_build_sizes_ext
} else {
::core::mem::transmute(val)
}
},
}
}
}
}
#[doc = "VK_EXT_load_store_op_none"]
pub mod load_store_op_none {
use super::super::*;
pub use {
crate::vk::EXT_LOAD_STORE_OP_NONE_NAME as NAME,
crate::vk::EXT_LOAD_STORE_OP_NONE_SPEC_VERSION as SPEC_VERSION,
};
}
#[doc = "VK_EXT_border_color_swizzle"]
pub mod border_color_swizzle {
use super::super::*;
pub use {
crate::vk::EXT_BORDER_COLOR_SWIZZLE_NAME as NAME,
crate::vk::EXT_BORDER_COLOR_SWIZZLE_SPEC_VERSION as SPEC_VERSION,
};
}
#[doc = "VK_EXT_pageable_device_local_memory"]
pub mod pageable_device_local_memory {
use super::super::*;
pub use {
crate::vk::EXT_PAGEABLE_DEVICE_LOCAL_MEMORY_NAME as NAME,
crate::vk::EXT_PAGEABLE_DEVICE_LOCAL_MEMORY_SPEC_VERSION as SPEC_VERSION,
};
#[doc = "VK_EXT_pageable_device_local_memory device-level functions"]
#[derive(Clone)]
pub struct Device {
pub(crate) fp: DeviceFn,
pub(crate) handle: crate::vk::Device,
}
impl Device {
pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
let handle = device.handle();
let fp = DeviceFn::load(|name| unsafe {
core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
});
Self { handle, fp }
}
#[inline]
pub fn fp(&self) -> &DeviceFn {
&self.fp
}
#[inline]
pub fn device(&self) -> crate::vk::Device {
self.handle
}
}
#[derive(Clone)]
#[doc = "Raw VK_EXT_pageable_device_local_memory device-level function pointers"]
pub struct DeviceFn {
pub set_device_memory_priority_ext: PFN_vkSetDeviceMemoryPriorityEXT,
}
unsafe impl Send for DeviceFn {}
unsafe impl Sync for DeviceFn {}
impl DeviceFn {
pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
Self::load_erased(&mut f)
}
fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
Self {
set_device_memory_priority_ext: unsafe {
unsafe extern "system" fn set_device_memory_priority_ext(
_device: crate::vk::Device,
_memory: DeviceMemory,
_priority: f32,
) {
panic!(concat!(
"Unable to load ",
stringify!(set_device_memory_priority_ext)
))
}
let cname =
CStr::from_bytes_with_nul_unchecked(b"vkSetDeviceMemoryPriorityEXT\0");
let val = _f(cname);
if val.is_null() {
set_device_memory_priority_ext
} else {
::core::mem::transmute(val)
}
},
}
}
}
}
#[doc = "VK_EXT_image_sliced_view_of_3d"]
pub mod image_sliced_view_of_3d {
use super::super::*;
pub use {
crate::vk::EXT_IMAGE_SLICED_VIEW_OF_3D_NAME as NAME,
crate::vk::EXT_IMAGE_SLICED_VIEW_OF_3D_SPEC_VERSION as SPEC_VERSION,
};
}
#[doc = "VK_EXT_depth_clamp_zero_one"]
pub mod depth_clamp_zero_one {
use super::super::*;
pub use {
crate::vk::EXT_DEPTH_CLAMP_ZERO_ONE_NAME as NAME,
crate::vk::EXT_DEPTH_CLAMP_ZERO_ONE_SPEC_VERSION as SPEC_VERSION,
};
}
#[doc = "VK_EXT_non_seamless_cube_map"]
pub mod non_seamless_cube_map {
use super::super::*;
pub use {
crate::vk::EXT_NON_SEAMLESS_CUBE_MAP_NAME as NAME,
crate::vk::EXT_NON_SEAMLESS_CUBE_MAP_SPEC_VERSION as SPEC_VERSION,
};
}
#[doc = "VK_EXT_image_compression_control_swapchain"]
pub mod image_compression_control_swapchain {
use super::super::*;
pub use {
crate::vk::EXT_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_NAME as NAME,
crate::vk::EXT_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_SPEC_VERSION as SPEC_VERSION,
};
}
#[doc = "VK_EXT_nested_command_buffer"]
pub mod nested_command_buffer {
use super::super::*;
pub use {
crate::vk::EXT_NESTED_COMMAND_BUFFER_NAME as NAME,
crate::vk::EXT_NESTED_COMMAND_BUFFER_SPEC_VERSION as SPEC_VERSION,
};
}
#[doc = "VK_EXT_external_memory_acquire_unmodified"]
pub mod external_memory_acquire_unmodified {
use super::super::*;
pub use {
crate::vk::EXT_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_NAME as NAME,
crate::vk::EXT_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_SPEC_VERSION as SPEC_VERSION,
};
}
#[doc = "VK_EXT_extended_dynamic_state3"]
pub mod extended_dynamic_state3 {
use super::super::*;
pub use {
crate::vk::EXT_EXTENDED_DYNAMIC_STATE3_NAME as NAME,
crate::vk::EXT_EXTENDED_DYNAMIC_STATE3_SPEC_VERSION as SPEC_VERSION,
};
#[doc = "VK_EXT_extended_dynamic_state3 device-level functions"]
#[derive(Clone)]
pub struct Device {
pub(crate) fp: DeviceFn,
pub(crate) handle: crate::vk::Device,
}
impl Device {
pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
let handle = device.handle();
let fp = DeviceFn::load(|name| unsafe {
core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
});
Self { handle, fp }
}
#[inline]
pub fn fp(&self) -> &DeviceFn {
&self.fp
}
#[inline]
pub fn device(&self) -> crate::vk::Device {
self.handle
}
}
#[derive(Clone)]
#[doc = "Raw VK_EXT_extended_dynamic_state3 device-level function pointers"]
pub struct DeviceFn {
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_tessellation_domain_origin_ext: PFN_vkCmdSetTessellationDomainOriginEXT,
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 DeviceFn {}
unsafe impl Sync for DeviceFn {}
impl DeviceFn {
pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
Self::load_erased(&mut f)
}
fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
Self {
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 =
CStr::from_bytes_with_nul_unchecked(b"vkCmdSetDepthClampEnableEXT\0");
let val = _f(cname);
if val.is_null() {
cmd_set_depth_clamp_enable_ext
} else {
::core::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 =
CStr::from_bytes_with_nul_unchecked(b"vkCmdSetPolygonModeEXT\0");
let val = _f(cname);
if val.is_null() {
cmd_set_polygon_mode_ext
} else {
::core::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 = CStr::from_bytes_with_nul_unchecked(
b"vkCmdSetRasterizationSamplesEXT\0",
);
let val = _f(cname);
if val.is_null() {
cmd_set_rasterization_samples_ext
} else {
::core::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 = CStr::from_bytes_with_nul_unchecked(b"vkCmdSetSampleMaskEXT\0");
let val = _f(cname);
if val.is_null() {
cmd_set_sample_mask_ext
} else {
::core::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 = 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 {
::core::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 =
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 {
::core::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 =
CStr::from_bytes_with_nul_unchecked(b"vkCmdSetLogicOpEnableEXT\0");
let val = _f(cname);
if val.is_null() {
cmd_set_logic_op_enable_ext
} else {
::core::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 =
CStr::from_bytes_with_nul_unchecked(b"vkCmdSetColorBlendEnableEXT\0");
let val = _f(cname);
if val.is_null() {
cmd_set_color_blend_enable_ext
} else {
::core::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 =
CStr::from_bytes_with_nul_unchecked(b"vkCmdSetColorBlendEquationEXT\0");
let val = _f(cname);
if val.is_null() {
cmd_set_color_blend_equation_ext
} else {
::core::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 =
CStr::from_bytes_with_nul_unchecked(b"vkCmdSetColorWriteMaskEXT\0");
let val = _f(cname);
if val.is_null() {
cmd_set_color_write_mask_ext
} else {
::core::mem::transmute(val)
}
},
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 = CStr::from_bytes_with_nul_unchecked(
b"vkCmdSetTessellationDomainOriginEXT\0",
);
let val = _f(cname);
if val.is_null() {
cmd_set_tessellation_domain_origin_ext
} else {
::core::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 = CStr::from_bytes_with_nul_unchecked(
b"vkCmdSetRasterizationStreamEXT\0",
);
let val = _f(cname);
if val.is_null() {
cmd_set_rasterization_stream_ext
} else {
::core::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 = CStr::from_bytes_with_nul_unchecked(
b"vkCmdSetConservativeRasterizationModeEXT\0",
);
let val = _f(cname);
if val.is_null() {
cmd_set_conservative_rasterization_mode_ext
} else {
::core::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 = 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 {
::core::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 =
CStr::from_bytes_with_nul_unchecked(b"vkCmdSetDepthClipEnableEXT\0");
let val = _f(cname);
if val.is_null() {
cmd_set_depth_clip_enable_ext
} else {
::core::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 = CStr::from_bytes_with_nul_unchecked(
b"vkCmdSetSampleLocationsEnableEXT\0",
);
let val = _f(cname);
if val.is_null() {
cmd_set_sample_locations_enable_ext
} else {
::core::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 =
CStr::from_bytes_with_nul_unchecked(b"vkCmdSetColorBlendAdvancedEXT\0");
let val = _f(cname);
if val.is_null() {
cmd_set_color_blend_advanced_ext
} else {
::core::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 = CStr::from_bytes_with_nul_unchecked(
b"vkCmdSetProvokingVertexModeEXT\0",
);
let val = _f(cname);
if val.is_null() {
cmd_set_provoking_vertex_mode_ext
} else {
::core::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 = CStr::from_bytes_with_nul_unchecked(
b"vkCmdSetLineRasterizationModeEXT\0",
);
let val = _f(cname);
if val.is_null() {
cmd_set_line_rasterization_mode_ext
} else {
::core::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 =
CStr::from_bytes_with_nul_unchecked(b"vkCmdSetLineStippleEnableEXT\0");
let val = _f(cname);
if val.is_null() {
cmd_set_line_stipple_enable_ext
} else {
::core::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 = 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 {
::core::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 = 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 {
::core::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 =
CStr::from_bytes_with_nul_unchecked(b"vkCmdSetViewportSwizzleNV\0");
let val = _f(cname);
if val.is_null() {
cmd_set_viewport_swizzle_nv
} else {
::core::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 = 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 {
::core::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 = 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 {
::core::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 = CStr::from_bytes_with_nul_unchecked(
b"vkCmdSetCoverageModulationModeNV\0",
);
let val = _f(cname);
if val.is_null() {
cmd_set_coverage_modulation_mode_nv
} else {
::core::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 = 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 {
::core::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 = CStr::from_bytes_with_nul_unchecked(
b"vkCmdSetCoverageModulationTableNV\0",
);
let val = _f(cname);
if val.is_null() {
cmd_set_coverage_modulation_table_nv
} else {
::core::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 = 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 {
::core::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 = 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 {
::core::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 = CStr::from_bytes_with_nul_unchecked(
b"vkCmdSetCoverageReductionModeNV\0",
);
let val = _f(cname);
if val.is_null() {
cmd_set_coverage_reduction_mode_nv
} else {
::core::mem::transmute(val)
}
},
}
}
}
}
#[doc = "VK_EXT_subpass_merge_feedback"]
pub mod subpass_merge_feedback {
use super::super::*;
pub use {
crate::vk::EXT_SUBPASS_MERGE_FEEDBACK_NAME as NAME,
crate::vk::EXT_SUBPASS_MERGE_FEEDBACK_SPEC_VERSION as SPEC_VERSION,
};
}
#[doc = "VK_EXT_shader_module_identifier"]
pub mod shader_module_identifier {
use super::super::*;
pub use {
crate::vk::EXT_SHADER_MODULE_IDENTIFIER_NAME as NAME,
crate::vk::EXT_SHADER_MODULE_IDENTIFIER_SPEC_VERSION as SPEC_VERSION,
};
#[doc = "VK_EXT_shader_module_identifier device-level functions"]
#[derive(Clone)]
pub struct Device {
pub(crate) fp: DeviceFn,
pub(crate) handle: crate::vk::Device,
}
impl Device {
pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
let handle = device.handle();
let fp = DeviceFn::load(|name| unsafe {
core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
});
Self { handle, fp }
}
#[inline]
pub fn fp(&self) -> &DeviceFn {
&self.fp
}
#[inline]
pub fn device(&self) -> crate::vk::Device {
self.handle
}
}
#[derive(Clone)]
#[doc = "Raw VK_EXT_shader_module_identifier device-level function pointers"]
pub struct DeviceFn {
pub get_shader_module_identifier_ext: PFN_vkGetShaderModuleIdentifierEXT,
pub get_shader_module_create_info_identifier_ext:
PFN_vkGetShaderModuleCreateInfoIdentifierEXT,
}
unsafe impl Send for DeviceFn {}
unsafe impl Sync for DeviceFn {}
impl DeviceFn {
pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
Self::load_erased(&mut f)
}
fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
Self {
get_shader_module_identifier_ext: unsafe {
unsafe extern "system" fn get_shader_module_identifier_ext(
_device: crate::vk::Device,
_shader_module: ShaderModule,
_p_identifier: *mut ShaderModuleIdentifierEXT<'_>,
) {
panic!(concat!(
"Unable to load ",
stringify!(get_shader_module_identifier_ext)
))
}
let cname = CStr::from_bytes_with_nul_unchecked(
b"vkGetShaderModuleIdentifierEXT\0",
);
let val = _f(cname);
if val.is_null() {
get_shader_module_identifier_ext
} else {
::core::mem::transmute(val)
}
},
get_shader_module_create_info_identifier_ext: unsafe {
unsafe extern "system" fn get_shader_module_create_info_identifier_ext(
_device: crate::vk::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 = 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 {
::core::mem::transmute(val)
}
},
}
}
}
}
#[doc = "VK_EXT_rasterization_order_attachment_access"]
pub mod rasterization_order_attachment_access {
use super::super::*;
pub use {
crate::vk::EXT_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_NAME as NAME,
crate::vk::EXT_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_SPEC_VERSION as SPEC_VERSION,
};
}
#[doc = "VK_EXT_legacy_dithering"]
pub mod legacy_dithering {
use super::super::*;
pub use {
crate::vk::EXT_LEGACY_DITHERING_NAME as NAME,
crate::vk::EXT_LEGACY_DITHERING_SPEC_VERSION as SPEC_VERSION,
};
}
#[doc = "VK_EXT_pipeline_protected_access"]
pub mod pipeline_protected_access {
use super::super::*;
pub use {
crate::vk::EXT_PIPELINE_PROTECTED_ACCESS_NAME as NAME,
crate::vk::EXT_PIPELINE_PROTECTED_ACCESS_SPEC_VERSION as SPEC_VERSION,
};
}
#[doc = "VK_EXT_shader_object"]
pub mod shader_object {
use super::super::*;
pub use {
crate::vk::EXT_SHADER_OBJECT_NAME as NAME,
crate::vk::EXT_SHADER_OBJECT_SPEC_VERSION as SPEC_VERSION,
};
#[doc = "VK_EXT_shader_object device-level functions"]
#[derive(Clone)]
pub struct Device {
pub(crate) fp: DeviceFn,
pub(crate) handle: crate::vk::Device,
}
impl Device {
pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
let handle = device.handle();
let fp = DeviceFn::load(|name| unsafe {
core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
});
Self { handle, fp }
}
#[inline]
pub fn fp(&self) -> &DeviceFn {
&self.fp
}
#[inline]
pub fn device(&self) -> crate::vk::Device {
self.handle
}
}
#[derive(Clone)]
#[doc = "Raw VK_EXT_shader_object device-level function pointers"]
pub struct DeviceFn {
pub create_shaders_ext: PFN_vkCreateShadersEXT,
pub destroy_shader_ext: PFN_vkDestroyShaderEXT,
pub get_shader_binary_data_ext: PFN_vkGetShaderBinaryDataEXT,
pub cmd_bind_shaders_ext: PFN_vkCmdBindShadersEXT,
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,
pub cmd_set_vertex_input_ext: PFN_vkCmdSetVertexInputEXT,
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,
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 DeviceFn {}
unsafe impl Sync for DeviceFn {}
impl DeviceFn {
pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
Self::load_erased(&mut f)
}
fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
Self {
create_shaders_ext: unsafe {
unsafe extern "system" fn create_shaders_ext(
_device: crate::vk::Device,
_create_info_count: u32,
_p_create_infos: *const ShaderCreateInfoEXT<'_>,
_p_allocator: *const AllocationCallbacks<'_>,
_p_shaders: *mut ShaderEXT,
) -> Result {
panic!(concat!("Unable to load ", stringify!(create_shaders_ext)))
}
let cname = CStr::from_bytes_with_nul_unchecked(b"vkCreateShadersEXT\0");
let val = _f(cname);
if val.is_null() {
create_shaders_ext
} else {
::core::mem::transmute(val)
}
},
destroy_shader_ext: unsafe {
unsafe extern "system" fn destroy_shader_ext(
_device: crate::vk::Device,
_shader: ShaderEXT,
_p_allocator: *const AllocationCallbacks<'_>,
) {
panic!(concat!("Unable to load ", stringify!(destroy_shader_ext)))
}
let cname = CStr::from_bytes_with_nul_unchecked(b"vkDestroyShaderEXT\0");
let val = _f(cname);
if val.is_null() {
destroy_shader_ext
} else {
::core::mem::transmute(val)
}
},
get_shader_binary_data_ext: unsafe {
unsafe extern "system" fn get_shader_binary_data_ext(
_device: crate::vk::Device,
_shader: ShaderEXT,
_p_data_size: *mut usize,
_p_data: *mut c_void,
) -> Result {
panic!(concat!(
"Unable to load ",
stringify!(get_shader_binary_data_ext)
))
}
let cname =
CStr::from_bytes_with_nul_unchecked(b"vkGetShaderBinaryDataEXT\0");
let val = _f(cname);
if val.is_null() {
get_shader_binary_data_ext
} else {
::core::mem::transmute(val)
}
},
cmd_bind_shaders_ext: unsafe {
unsafe extern "system" fn cmd_bind_shaders_ext(
_command_buffer: CommandBuffer,
_stage_count: u32,
_p_stages: *const ShaderStageFlags,
_p_shaders: *const ShaderEXT,
) {
panic!(concat!("Unable to load ", stringify!(cmd_bind_shaders_ext)))
}
let cname = CStr::from_bytes_with_nul_unchecked(b"vkCmdBindShadersEXT\0");
let val = _f(cname);
if val.is_null() {
cmd_bind_shaders_ext
} else {
::core::mem::transmute(val)
}
},
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 = CStr::from_bytes_with_nul_unchecked(b"vkCmdSetCullModeEXT\0");
let val = _f(cname);
if val.is_null() {
cmd_set_cull_mode_ext
} else {
::core::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 = CStr::from_bytes_with_nul_unchecked(b"vkCmdSetFrontFaceEXT\0");
let val = _f(cname);
if val.is_null() {
cmd_set_front_face_ext
} else {
::core::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 =
CStr::from_bytes_with_nul_unchecked(b"vkCmdSetPrimitiveTopologyEXT\0");
let val = _f(cname);
if val.is_null() {
cmd_set_primitive_topology_ext
} else {
::core::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 =
CStr::from_bytes_with_nul_unchecked(b"vkCmdSetViewportWithCountEXT\0");
let val = _f(cname);
if val.is_null() {
cmd_set_viewport_with_count_ext
} else {
::core::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 =
CStr::from_bytes_with_nul_unchecked(b"vkCmdSetScissorWithCountEXT\0");
let val = _f(cname);
if val.is_null() {
cmd_set_scissor_with_count_ext
} else {
::core::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 =
CStr::from_bytes_with_nul_unchecked(b"vkCmdBindVertexBuffers2EXT\0");
let val = _f(cname);
if val.is_null() {
cmd_bind_vertex_buffers2_ext
} else {
::core::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 =
CStr::from_bytes_with_nul_unchecked(b"vkCmdSetDepthTestEnableEXT\0");
let val = _f(cname);
if val.is_null() {
cmd_set_depth_test_enable_ext
} else {
::core::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 =
CStr::from_bytes_with_nul_unchecked(b"vkCmdSetDepthWriteEnableEXT\0");
let val = _f(cname);
if val.is_null() {
cmd_set_depth_write_enable_ext
} else {
::core::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 =
CStr::from_bytes_with_nul_unchecked(b"vkCmdSetDepthCompareOpEXT\0");
let val = _f(cname);
if val.is_null() {
cmd_set_depth_compare_op_ext
} else {
::core::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 = 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 {
::core::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 =
CStr::from_bytes_with_nul_unchecked(b"vkCmdSetStencilTestEnableEXT\0");
let val = _f(cname);
if val.is_null() {
cmd_set_stencil_test_enable_ext
} else {
::core::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 = CStr::from_bytes_with_nul_unchecked(b"vkCmdSetStencilOpEXT\0");
let val = _f(cname);
if val.is_null() {
cmd_set_stencil_op_ext
} else {
::core::mem::transmute(val)
}
},
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 =
CStr::from_bytes_with_nul_unchecked(b"vkCmdSetVertexInputEXT\0");
let val = _f(cname);
if val.is_null() {
cmd_set_vertex_input_ext
} else {
::core::mem::transmute(val)
}
},
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 =
CStr::from_bytes_with_nul_unchecked(b"vkCmdSetPatchControlPointsEXT\0");
let val = _f(cname);
if val.is_null() {
cmd_set_patch_control_points_ext
} else {
::core::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 = CStr::from_bytes_with_nul_unchecked(
b"vkCmdSetRasterizerDiscardEnableEXT\0",
);
let val = _f(cname);
if val.is_null() {
cmd_set_rasterizer_discard_enable_ext
} else {
::core::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 =
CStr::from_bytes_with_nul_unchecked(b"vkCmdSetDepthBiasEnableEXT\0");
let val = _f(cname);
if val.is_null() {
cmd_set_depth_bias_enable_ext
} else {
::core::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 = CStr::from_bytes_with_nul_unchecked(b"vkCmdSetLogicOpEXT\0");
let val = _f(cname);
if val.is_null() {
cmd_set_logic_op_ext
} else {
::core::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 = CStr::from_bytes_with_nul_unchecked(
b"vkCmdSetPrimitiveRestartEnableEXT\0",
);
let val = _f(cname);
if val.is_null() {
cmd_set_primitive_restart_enable_ext
} else {
::core::mem::transmute(val)
}
},
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 = CStr::from_bytes_with_nul_unchecked(
b"vkCmdSetTessellationDomainOriginEXT\0",
);
let val = _f(cname);
if val.is_null() {
cmd_set_tessellation_domain_origin_ext
} else {
::core::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 =
CStr::from_bytes_with_nul_unchecked(b"vkCmdSetDepthClampEnableEXT\0");
let val = _f(cname);
if val.is_null() {
cmd_set_depth_clamp_enable_ext
} else {
::core::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 =
CStr::from_bytes_with_nul_unchecked(b"vkCmdSetPolygonModeEXT\0");
let val = _f(cname);
if val.is_null() {
cmd_set_polygon_mode_ext
} else {
::core::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 = CStr::from_bytes_with_nul_unchecked(
b"vkCmdSetRasterizationSamplesEXT\0",
);
let val = _f(cname);
if val.is_null() {
cmd_set_rasterization_samples_ext
} else {
::core::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 = CStr::from_bytes_with_nul_unchecked(b"vkCmdSetSampleMaskEXT\0");
let val = _f(cname);
if val.is_null() {
cmd_set_sample_mask_ext
} else {
::core::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 = 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 {
::core::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 =
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 {
::core::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 =
CStr::from_bytes_with_nul_unchecked(b"vkCmdSetLogicOpEnableEXT\0");
let val = _f(cname);
if val.is_null() {
cmd_set_logic_op_enable_ext
} else {
::core::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 =
CStr::from_bytes_with_nul_unchecked(b"vkCmdSetColorBlendEnableEXT\0");
let val = _f(cname);
if val.is_null() {
cmd_set_color_blend_enable_ext
} else {
::core::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 =
CStr::from_bytes_with_nul_unchecked(b"vkCmdSetColorBlendEquationEXT\0");
let val = _f(cname);
if val.is_null() {
cmd_set_color_blend_equation_ext
} else {
::core::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 =
CStr::from_bytes_with_nul_unchecked(b"vkCmdSetColorWriteMaskEXT\0");
let val = _f(cname);
if val.is_null() {
cmd_set_color_write_mask_ext
} else {
::core::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 = CStr::from_bytes_with_nul_unchecked(
b"vkCmdSetRasterizationStreamEXT\0",
);
let val = _f(cname);
if val.is_null() {
cmd_set_rasterization_stream_ext
} else {
::core::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 = CStr::from_bytes_with_nul_unchecked(
b"vkCmdSetConservativeRasterizationModeEXT\0",
);
let val = _f(cname);
if val.is_null() {
cmd_set_conservative_rasterization_mode_ext
} else {
::core::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 = 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 {
::core::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 =
CStr::from_bytes_with_nul_unchecked(b"vkCmdSetDepthClipEnableEXT\0");
let val = _f(cname);
if val.is_null() {
cmd_set_depth_clip_enable_ext
} else {
::core::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 = CStr::from_bytes_with_nul_unchecked(
b"vkCmdSetSampleLocationsEnableEXT\0",
);
let val = _f(cname);
if val.is_null() {
cmd_set_sample_locations_enable_ext
} else {
::core::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 =
CStr::from_bytes_with_nul_unchecked(b"vkCmdSetColorBlendAdvancedEXT\0");
let val = _f(cname);
if val.is_null() {
cmd_set_color_blend_advanced_ext
} else {
::core::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 = CStr::from_bytes_with_nul_unchecked(
b"vkCmdSetProvokingVertexModeEXT\0",
);
let val = _f(cname);
if val.is_null() {
cmd_set_provoking_vertex_mode_ext
} else {
::core::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 = CStr::from_bytes_with_nul_unchecked(
b"vkCmdSetLineRasterizationModeEXT\0",
);
let val = _f(cname);
if val.is_null() {
cmd_set_line_rasterization_mode_ext
} else {
::core::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 =
CStr::from_bytes_with_nul_unchecked(b"vkCmdSetLineStippleEnableEXT\0");
let val = _f(cname);
if val.is_null() {
cmd_set_line_stipple_enable_ext
} else {
::core::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 = 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 {
::core::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 = 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 {
::core::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 =
CStr::from_bytes_with_nul_unchecked(b"vkCmdSetViewportSwizzleNV\0");
let val = _f(cname);
if val.is_null() {
cmd_set_viewport_swizzle_nv
} else {
::core::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 = 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 {
::core::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 = 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 {
::core::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 = CStr::from_bytes_with_nul_unchecked(
b"vkCmdSetCoverageModulationModeNV\0",
);
let val = _f(cname);
if val.is_null() {
cmd_set_coverage_modulation_mode_nv
} else {
::core::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 = 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 {
::core::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 = CStr::from_bytes_with_nul_unchecked(
b"vkCmdSetCoverageModulationTableNV\0",
);
let val = _f(cname);
if val.is_null() {
cmd_set_coverage_modulation_table_nv
} else {
::core::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 = 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 {
::core::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 = 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 {
::core::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 = CStr::from_bytes_with_nul_unchecked(
b"vkCmdSetCoverageReductionModeNV\0",
);
let val = _f(cname);
if val.is_null() {
cmd_set_coverage_reduction_mode_nv
} else {
::core::mem::transmute(val)
}
},
}
}
}
}
#[doc = "VK_EXT_mutable_descriptor_type"]
pub mod mutable_descriptor_type {
use super::super::*;
pub use {
crate::vk::EXT_MUTABLE_DESCRIPTOR_TYPE_NAME as NAME,
crate::vk::EXT_MUTABLE_DESCRIPTOR_TYPE_SPEC_VERSION as SPEC_VERSION,
};
}
#[doc = "VK_EXT_layer_settings"]
pub mod layer_settings {
use super::super::*;
pub use {
crate::vk::EXT_LAYER_SETTINGS_NAME as NAME,
crate::vk::EXT_LAYER_SETTINGS_SPEC_VERSION as SPEC_VERSION,
};
}
#[doc = "VK_EXT_pipeline_library_group_handles"]
pub mod pipeline_library_group_handles {
use super::super::*;
pub use {
crate::vk::EXT_PIPELINE_LIBRARY_GROUP_HANDLES_NAME as NAME,
crate::vk::EXT_PIPELINE_LIBRARY_GROUP_HANDLES_SPEC_VERSION as SPEC_VERSION,
};
}
#[doc = "VK_EXT_dynamic_rendering_unused_attachments"]
pub mod dynamic_rendering_unused_attachments {
use super::super::*;
pub use {
crate::vk::EXT_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_NAME as NAME,
crate::vk::EXT_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_SPEC_VERSION as SPEC_VERSION,
};
}
#[doc = "VK_EXT_attachment_feedback_loop_dynamic_state"]
pub mod attachment_feedback_loop_dynamic_state {
use super::super::*;
pub use {
crate::vk::EXT_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_NAME as NAME,
crate::vk::EXT_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_SPEC_VERSION as SPEC_VERSION,
};
#[doc = "VK_EXT_attachment_feedback_loop_dynamic_state device-level functions"]
#[derive(Clone)]
pub struct Device {
pub(crate) fp: DeviceFn,
pub(crate) handle: crate::vk::Device,
}
impl Device {
pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
let handle = device.handle();
let fp = DeviceFn::load(|name| unsafe {
core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
});
Self { handle, fp }
}
#[inline]
pub fn fp(&self) -> &DeviceFn {
&self.fp
}
#[inline]
pub fn device(&self) -> crate::vk::Device {
self.handle
}
}
#[derive(Clone)]
#[doc = "Raw VK_EXT_attachment_feedback_loop_dynamic_state device-level function pointers"]
pub struct DeviceFn {
pub cmd_set_attachment_feedback_loop_enable_ext:
PFN_vkCmdSetAttachmentFeedbackLoopEnableEXT,
}
unsafe impl Send for DeviceFn {}
unsafe impl Sync for DeviceFn {}
impl DeviceFn {
pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
Self::load_erased(&mut f)
}
fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
Self {
cmd_set_attachment_feedback_loop_enable_ext: unsafe {
unsafe extern "system" fn cmd_set_attachment_feedback_loop_enable_ext(
_command_buffer: CommandBuffer,
_aspect_mask: ImageAspectFlags,
) {
panic!(concat!(
"Unable to load ",
stringify!(cmd_set_attachment_feedback_loop_enable_ext)
))
}
let cname = CStr::from_bytes_with_nul_unchecked(
b"vkCmdSetAttachmentFeedbackLoopEnableEXT\0",
);
let val = _f(cname);
if val.is_null() {
cmd_set_attachment_feedback_loop_enable_ext
} else {
::core::mem::transmute(val)
}
},
}
}
}
}
}
#[doc = "Extensions tagged FUCHSIA"]
pub mod fuchsia {
#[doc = "VK_FUCHSIA_imagepipe_surface"]
pub mod imagepipe_surface {
use super::super::*;
pub use {
crate::vk::FUCHSIA_IMAGEPIPE_SURFACE_NAME as NAME,
crate::vk::FUCHSIA_IMAGEPIPE_SURFACE_SPEC_VERSION as SPEC_VERSION,
};
#[doc = "VK_FUCHSIA_imagepipe_surface instance-level functions"]
#[derive(Clone)]
pub struct Instance {
pub(crate) fp: InstanceFn,
pub(crate) handle: crate::vk::Instance,
}
impl Instance {
pub fn new(entry: &crate::Entry, instance: &crate::Instance) -> Self {
let handle = instance.handle();
let fp = InstanceFn::load(|name| unsafe {
core::mem::transmute(entry.get_instance_proc_addr(handle, name.as_ptr()))
});
Self { handle, fp }
}
#[inline]
pub fn fp(&self) -> &InstanceFn {
&self.fp
}
#[inline]
pub fn instance(&self) -> crate::vk::Instance {
self.handle
}
}
#[derive(Clone)]
#[doc = "Raw VK_FUCHSIA_imagepipe_surface instance-level function pointers"]
pub struct InstanceFn {
pub create_image_pipe_surface_fuchsia: PFN_vkCreateImagePipeSurfaceFUCHSIA,
}
unsafe impl Send for InstanceFn {}
unsafe impl Sync for InstanceFn {}
impl InstanceFn {
pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
Self::load_erased(&mut f)
}
fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
Self {
create_image_pipe_surface_fuchsia: unsafe {
unsafe extern "system" fn create_image_pipe_surface_fuchsia(
_instance: crate::vk::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 = CStr::from_bytes_with_nul_unchecked(
b"vkCreateImagePipeSurfaceFUCHSIA\0",
);
let val = _f(cname);
if val.is_null() {
create_image_pipe_surface_fuchsia
} else {
::core::mem::transmute(val)
}
},
}
}
}
}
#[doc = "VK_FUCHSIA_external_memory"]
pub mod external_memory {
use super::super::*;
pub use {
crate::vk::FUCHSIA_EXTERNAL_MEMORY_NAME as NAME,
crate::vk::FUCHSIA_EXTERNAL_MEMORY_SPEC_VERSION as SPEC_VERSION,
};
#[doc = "VK_FUCHSIA_external_memory device-level functions"]
#[derive(Clone)]
pub struct Device {
pub(crate) fp: DeviceFn,
pub(crate) handle: crate::vk::Device,
}
impl Device {
pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
let handle = device.handle();
let fp = DeviceFn::load(|name| unsafe {
core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
});
Self { handle, fp }
}
#[inline]
pub fn fp(&self) -> &DeviceFn {
&self.fp
}
#[inline]
pub fn device(&self) -> crate::vk::Device {
self.handle
}
}
#[derive(Clone)]
#[doc = "Raw VK_FUCHSIA_external_memory device-level function pointers"]
pub struct DeviceFn {
pub get_memory_zircon_handle_fuchsia: PFN_vkGetMemoryZirconHandleFUCHSIA,
pub get_memory_zircon_handle_properties_fuchsia:
PFN_vkGetMemoryZirconHandlePropertiesFUCHSIA,
}
unsafe impl Send for DeviceFn {}
unsafe impl Sync for DeviceFn {}
impl DeviceFn {
pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
Self::load_erased(&mut f)
}
fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
Self {
get_memory_zircon_handle_fuchsia: unsafe {
unsafe extern "system" fn get_memory_zircon_handle_fuchsia(
_device: crate::vk::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 = CStr::from_bytes_with_nul_unchecked(
b"vkGetMemoryZirconHandleFUCHSIA\0",
);
let val = _f(cname);
if val.is_null() {
get_memory_zircon_handle_fuchsia
} else {
::core::mem::transmute(val)
}
},
get_memory_zircon_handle_properties_fuchsia: unsafe {
unsafe extern "system" fn get_memory_zircon_handle_properties_fuchsia(
_device: crate::vk::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 = CStr::from_bytes_with_nul_unchecked(
b"vkGetMemoryZirconHandlePropertiesFUCHSIA\0",
);
let val = _f(cname);
if val.is_null() {
get_memory_zircon_handle_properties_fuchsia
} else {
::core::mem::transmute(val)
}
},
}
}
}
}
#[doc = "VK_FUCHSIA_external_semaphore"]
pub mod external_semaphore {
use super::super::*;
pub use {
crate::vk::FUCHSIA_EXTERNAL_SEMAPHORE_NAME as NAME,
crate::vk::FUCHSIA_EXTERNAL_SEMAPHORE_SPEC_VERSION as SPEC_VERSION,
};
#[doc = "VK_FUCHSIA_external_semaphore device-level functions"]
#[derive(Clone)]
pub struct Device {
pub(crate) fp: DeviceFn,
pub(crate) handle: crate::vk::Device,
}
impl Device {
pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
let handle = device.handle();
let fp = DeviceFn::load(|name| unsafe {
core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
});
Self { handle, fp }
}
#[inline]
pub fn fp(&self) -> &DeviceFn {
&self.fp
}
#[inline]
pub fn device(&self) -> crate::vk::Device {
self.handle
}
}
#[derive(Clone)]
#[doc = "Raw VK_FUCHSIA_external_semaphore device-level function pointers"]
pub struct DeviceFn {
pub import_semaphore_zircon_handle_fuchsia: PFN_vkImportSemaphoreZirconHandleFUCHSIA,
pub get_semaphore_zircon_handle_fuchsia: PFN_vkGetSemaphoreZirconHandleFUCHSIA,
}
unsafe impl Send for DeviceFn {}
unsafe impl Sync for DeviceFn {}
impl DeviceFn {
pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
Self::load_erased(&mut f)
}
fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
Self {
import_semaphore_zircon_handle_fuchsia: unsafe {
unsafe extern "system" fn import_semaphore_zircon_handle_fuchsia(
_device: crate::vk::Device,
_p_import_semaphore_zircon_handle_info : * const ImportSemaphoreZirconHandleInfoFUCHSIA < '_ >,
) -> Result {
panic!(concat!(
"Unable to load ",
stringify!(import_semaphore_zircon_handle_fuchsia)
))
}
let cname = CStr::from_bytes_with_nul_unchecked(
b"vkImportSemaphoreZirconHandleFUCHSIA\0",
);
let val = _f(cname);
if val.is_null() {
import_semaphore_zircon_handle_fuchsia
} else {
::core::mem::transmute(val)
}
},
get_semaphore_zircon_handle_fuchsia: unsafe {
unsafe extern "system" fn get_semaphore_zircon_handle_fuchsia(
_device: crate::vk::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 = CStr::from_bytes_with_nul_unchecked(
b"vkGetSemaphoreZirconHandleFUCHSIA\0",
);
let val = _f(cname);
if val.is_null() {
get_semaphore_zircon_handle_fuchsia
} else {
::core::mem::transmute(val)
}
},
}
}
}
}
#[doc = "VK_FUCHSIA_buffer_collection"]
pub mod buffer_collection {
use super::super::*;
pub use {
crate::vk::FUCHSIA_BUFFER_COLLECTION_NAME as NAME,
crate::vk::FUCHSIA_BUFFER_COLLECTION_SPEC_VERSION as SPEC_VERSION,
};
#[doc = "VK_FUCHSIA_buffer_collection device-level functions"]
#[derive(Clone)]
pub struct Device {
pub(crate) fp: DeviceFn,
pub(crate) handle: crate::vk::Device,
}
impl Device {
pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
let handle = device.handle();
let fp = DeviceFn::load(|name| unsafe {
core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
});
Self { handle, fp }
}
#[inline]
pub fn fp(&self) -> &DeviceFn {
&self.fp
}
#[inline]
pub fn device(&self) -> crate::vk::Device {
self.handle
}
}
#[derive(Clone)]
#[doc = "Raw VK_FUCHSIA_buffer_collection device-level function pointers"]
pub struct DeviceFn {
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 DeviceFn {}
unsafe impl Sync for DeviceFn {}
impl DeviceFn {
pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
Self::load_erased(&mut f)
}
fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
Self {
create_buffer_collection_fuchsia: unsafe {
unsafe extern "system" fn create_buffer_collection_fuchsia(
_device: crate::vk::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 = CStr::from_bytes_with_nul_unchecked(
b"vkCreateBufferCollectionFUCHSIA\0",
);
let val = _f(cname);
if val.is_null() {
create_buffer_collection_fuchsia
} else {
::core::mem::transmute(val)
}
},
set_buffer_collection_image_constraints_fuchsia: unsafe {
unsafe extern "system" fn set_buffer_collection_image_constraints_fuchsia(
_device: crate::vk::Device,
_collection: BufferCollectionFUCHSIA,
_p_image_constraints_info: *const ImageConstraintsInfoFUCHSIA<'_>,
) -> Result {
panic!(concat!(
"Unable to load ",
stringify!(set_buffer_collection_image_constraints_fuchsia)
))
}
let cname = CStr::from_bytes_with_nul_unchecked(
b"vkSetBufferCollectionImageConstraintsFUCHSIA\0",
);
let val = _f(cname);
if val.is_null() {
set_buffer_collection_image_constraints_fuchsia
} else {
::core::mem::transmute(val)
}
},
set_buffer_collection_buffer_constraints_fuchsia: unsafe {
unsafe extern "system" fn set_buffer_collection_buffer_constraints_fuchsia(
_device: crate::vk::Device,
_collection: BufferCollectionFUCHSIA,
_p_buffer_constraints_info: *const BufferConstraintsInfoFUCHSIA<'_>,
) -> Result {
panic!(concat!(
"Unable to load ",
stringify!(set_buffer_collection_buffer_constraints_fuchsia)
))
}
let cname = CStr::from_bytes_with_nul_unchecked(
b"vkSetBufferCollectionBufferConstraintsFUCHSIA\0",
);
let val = _f(cname);
if val.is_null() {
set_buffer_collection_buffer_constraints_fuchsia
} else {
::core::mem::transmute(val)
}
},
destroy_buffer_collection_fuchsia: unsafe {
unsafe extern "system" fn destroy_buffer_collection_fuchsia(
_device: crate::vk::Device,
_collection: BufferCollectionFUCHSIA,
_p_allocator: *const AllocationCallbacks<'_>,
) {
panic!(concat!(
"Unable to load ",
stringify!(destroy_buffer_collection_fuchsia)
))
}
let cname = CStr::from_bytes_with_nul_unchecked(
b"vkDestroyBufferCollectionFUCHSIA\0",
);
let val = _f(cname);
if val.is_null() {
destroy_buffer_collection_fuchsia
} else {
::core::mem::transmute(val)
}
},
get_buffer_collection_properties_fuchsia: unsafe {
unsafe extern "system" fn get_buffer_collection_properties_fuchsia(
_device: crate::vk::Device,
_collection: BufferCollectionFUCHSIA,
_p_properties: *mut BufferCollectionPropertiesFUCHSIA<'_>,
) -> Result {
panic!(concat!(
"Unable to load ",
stringify!(get_buffer_collection_properties_fuchsia)
))
}
let cname = CStr::from_bytes_with_nul_unchecked(
b"vkGetBufferCollectionPropertiesFUCHSIA\0",
);
let val = _f(cname);
if val.is_null() {
get_buffer_collection_properties_fuchsia
} else {
::core::mem::transmute(val)
}
},
}
}
}
}
}
#[doc = "Extensions tagged GGP"]
pub mod ggp {
#[doc = "VK_GGP_stream_descriptor_surface"]
pub mod stream_descriptor_surface {
use super::super::*;
pub use {
crate::vk::GGP_STREAM_DESCRIPTOR_SURFACE_NAME as NAME,
crate::vk::GGP_STREAM_DESCRIPTOR_SURFACE_SPEC_VERSION as SPEC_VERSION,
};
#[doc = "VK_GGP_stream_descriptor_surface instance-level functions"]
#[derive(Clone)]
pub struct Instance {
pub(crate) fp: InstanceFn,
pub(crate) handle: crate::vk::Instance,
}
impl Instance {
pub fn new(entry: &crate::Entry, instance: &crate::Instance) -> Self {
let handle = instance.handle();
let fp = InstanceFn::load(|name| unsafe {
core::mem::transmute(entry.get_instance_proc_addr(handle, name.as_ptr()))
});
Self { handle, fp }
}
#[inline]
pub fn fp(&self) -> &InstanceFn {
&self.fp
}
#[inline]
pub fn instance(&self) -> crate::vk::Instance {
self.handle
}
}
#[derive(Clone)]
#[doc = "Raw VK_GGP_stream_descriptor_surface instance-level function pointers"]
pub struct InstanceFn {
pub create_stream_descriptor_surface_ggp: PFN_vkCreateStreamDescriptorSurfaceGGP,
}
unsafe impl Send for InstanceFn {}
unsafe impl Sync for InstanceFn {}
impl InstanceFn {
pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
Self::load_erased(&mut f)
}
fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
Self {
create_stream_descriptor_surface_ggp: unsafe {
unsafe extern "system" fn create_stream_descriptor_surface_ggp(
_instance: crate::vk::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 = CStr::from_bytes_with_nul_unchecked(
b"vkCreateStreamDescriptorSurfaceGGP\0",
);
let val = _f(cname);
if val.is_null() {
create_stream_descriptor_surface_ggp
} else {
::core::mem::transmute(val)
}
},
}
}
}
}
#[doc = "VK_GGP_frame_token"]
pub mod frame_token {
use super::super::*;
pub use {
crate::vk::GGP_FRAME_TOKEN_NAME as NAME,
crate::vk::GGP_FRAME_TOKEN_SPEC_VERSION as SPEC_VERSION,
};
}
}
#[doc = "Extensions tagged GOOGLE"]
pub mod google {
#[doc = "VK_GOOGLE_display_timing"]
pub mod display_timing {
use super::super::*;
pub use {
crate::vk::GOOGLE_DISPLAY_TIMING_NAME as NAME,
crate::vk::GOOGLE_DISPLAY_TIMING_SPEC_VERSION as SPEC_VERSION,
};
#[doc = "VK_GOOGLE_display_timing device-level functions"]
#[derive(Clone)]
pub struct Device {
pub(crate) fp: DeviceFn,
pub(crate) handle: crate::vk::Device,
}
impl Device {
pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
let handle = device.handle();
let fp = DeviceFn::load(|name| unsafe {
core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
});
Self { handle, fp }
}
#[inline]
pub fn fp(&self) -> &DeviceFn {
&self.fp
}
#[inline]
pub fn device(&self) -> crate::vk::Device {
self.handle
}
}
#[derive(Clone)]
#[doc = "Raw VK_GOOGLE_display_timing device-level function pointers"]
pub struct DeviceFn {
pub get_refresh_cycle_duration_google: PFN_vkGetRefreshCycleDurationGOOGLE,
pub get_past_presentation_timing_google: PFN_vkGetPastPresentationTimingGOOGLE,
}
unsafe impl Send for DeviceFn {}
unsafe impl Sync for DeviceFn {}
impl DeviceFn {
pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
Self::load_erased(&mut f)
}
fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
Self {
get_refresh_cycle_duration_google: unsafe {
unsafe extern "system" fn get_refresh_cycle_duration_google(
_device: crate::vk::Device,
_swapchain: SwapchainKHR,
_p_display_timing_properties: *mut RefreshCycleDurationGOOGLE,
) -> Result {
panic!(concat!(
"Unable to load ",
stringify!(get_refresh_cycle_duration_google)
))
}
let cname = CStr::from_bytes_with_nul_unchecked(
b"vkGetRefreshCycleDurationGOOGLE\0",
);
let val = _f(cname);
if val.is_null() {
get_refresh_cycle_duration_google
} else {
::core::mem::transmute(val)
}
},
get_past_presentation_timing_google: unsafe {
unsafe extern "system" fn get_past_presentation_timing_google(
_device: crate::vk::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 = CStr::from_bytes_with_nul_unchecked(
b"vkGetPastPresentationTimingGOOGLE\0",
);
let val = _f(cname);
if val.is_null() {
get_past_presentation_timing_google
} else {
::core::mem::transmute(val)
}
},
}
}
}
}
#[doc = "VK_GOOGLE_hlsl_functionality1"]
pub mod hlsl_functionality1 {
use super::super::*;
pub use {
crate::vk::GOOGLE_HLSL_FUNCTIONALITY1_NAME as NAME,
crate::vk::GOOGLE_HLSL_FUNCTIONALITY1_SPEC_VERSION as SPEC_VERSION,
};
}
#[doc = "VK_GOOGLE_decorate_string"]
pub mod decorate_string {
use super::super::*;
pub use {
crate::vk::GOOGLE_DECORATE_STRING_NAME as NAME,
crate::vk::GOOGLE_DECORATE_STRING_SPEC_VERSION as SPEC_VERSION,
};
}
#[doc = "VK_GOOGLE_user_type"]
pub mod user_type {
use super::super::*;
pub use {
crate::vk::GOOGLE_USER_TYPE_NAME as NAME,
crate::vk::GOOGLE_USER_TYPE_SPEC_VERSION as SPEC_VERSION,
};
}
#[doc = "VK_GOOGLE_surfaceless_query"]
pub mod surfaceless_query {
use super::super::*;
pub use {
crate::vk::GOOGLE_SURFACELESS_QUERY_NAME as NAME,
crate::vk::GOOGLE_SURFACELESS_QUERY_SPEC_VERSION as SPEC_VERSION,
};
}
}
#[doc = "Extensions tagged HUAWEI"]
pub mod huawei {
#[doc = "VK_HUAWEI_subpass_shading"]
pub mod subpass_shading {
use super::super::*;
pub use {
crate::vk::HUAWEI_SUBPASS_SHADING_NAME as NAME,
crate::vk::HUAWEI_SUBPASS_SHADING_SPEC_VERSION as SPEC_VERSION,
};
#[doc = "VK_HUAWEI_subpass_shading device-level functions"]
#[derive(Clone)]
pub struct Device {
pub(crate) fp: DeviceFn,
pub(crate) handle: crate::vk::Device,
}
impl Device {
pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
let handle = device.handle();
let fp = DeviceFn::load(|name| unsafe {
core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
});
Self { handle, fp }
}
#[inline]
pub fn fp(&self) -> &DeviceFn {
&self.fp
}
#[inline]
pub fn device(&self) -> crate::vk::Device {
self.handle
}
}
#[derive(Clone)]
#[doc = "Raw VK_HUAWEI_subpass_shading device-level function pointers"]
pub struct DeviceFn {
pub get_device_subpass_shading_max_workgroup_size_huawei:
PFN_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI,
pub cmd_subpass_shading_huawei: PFN_vkCmdSubpassShadingHUAWEI,
}
unsafe impl Send for DeviceFn {}
unsafe impl Sync for DeviceFn {}
impl DeviceFn {
pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
Self::load_erased(&mut f)
}
fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
Self {
get_device_subpass_shading_max_workgroup_size_huawei: unsafe {
unsafe extern "system" fn get_device_subpass_shading_max_workgroup_size_huawei(
_device: crate::vk::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 = 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 {
::core::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 =
CStr::from_bytes_with_nul_unchecked(b"vkCmdSubpassShadingHUAWEI\0");
let val = _f(cname);
if val.is_null() {
cmd_subpass_shading_huawei
} else {
::core::mem::transmute(val)
}
},
}
}
}
}
#[doc = "VK_HUAWEI_invocation_mask"]
pub mod invocation_mask {
use super::super::*;
pub use {
crate::vk::HUAWEI_INVOCATION_MASK_NAME as NAME,
crate::vk::HUAWEI_INVOCATION_MASK_SPEC_VERSION as SPEC_VERSION,
};
#[doc = "VK_HUAWEI_invocation_mask device-level functions"]
#[derive(Clone)]
pub struct Device {
pub(crate) fp: DeviceFn,
pub(crate) handle: crate::vk::Device,
}
impl Device {
pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
let handle = device.handle();
let fp = DeviceFn::load(|name| unsafe {
core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
});
Self { handle, fp }
}
#[inline]
pub fn fp(&self) -> &DeviceFn {
&self.fp
}
#[inline]
pub fn device(&self) -> crate::vk::Device {
self.handle
}
}
#[derive(Clone)]
#[doc = "Raw VK_HUAWEI_invocation_mask device-level function pointers"]
pub struct DeviceFn {
pub cmd_bind_invocation_mask_huawei: PFN_vkCmdBindInvocationMaskHUAWEI,
}
unsafe impl Send for DeviceFn {}
unsafe impl Sync for DeviceFn {}
impl DeviceFn {
pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
Self::load_erased(&mut f)
}
fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
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 =
CStr::from_bytes_with_nul_unchecked(b"vkCmdBindInvocationMaskHUAWEI\0");
let val = _f(cname);
if val.is_null() {
cmd_bind_invocation_mask_huawei
} else {
::core::mem::transmute(val)
}
},
}
}
}
}
#[doc = "VK_HUAWEI_cluster_culling_shader"]
pub mod cluster_culling_shader {
use super::super::*;
pub use {
crate::vk::HUAWEI_CLUSTER_CULLING_SHADER_NAME as NAME,
crate::vk::HUAWEI_CLUSTER_CULLING_SHADER_SPEC_VERSION as SPEC_VERSION,
};
#[doc = "VK_HUAWEI_cluster_culling_shader device-level functions"]
#[derive(Clone)]
pub struct Device {
pub(crate) fp: DeviceFn,
pub(crate) handle: crate::vk::Device,
}
impl Device {
pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
let handle = device.handle();
let fp = DeviceFn::load(|name| unsafe {
core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
});
Self { handle, fp }
}
#[inline]
pub fn fp(&self) -> &DeviceFn {
&self.fp
}
#[inline]
pub fn device(&self) -> crate::vk::Device {
self.handle
}
}
#[derive(Clone)]
#[doc = "Raw VK_HUAWEI_cluster_culling_shader device-level function pointers"]
pub struct DeviceFn {
pub cmd_draw_cluster_huawei: PFN_vkCmdDrawClusterHUAWEI,
pub cmd_draw_cluster_indirect_huawei: PFN_vkCmdDrawClusterIndirectHUAWEI,
}
unsafe impl Send for DeviceFn {}
unsafe impl Sync for DeviceFn {}
impl DeviceFn {
pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
Self::load_erased(&mut f)
}
fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
Self {
cmd_draw_cluster_huawei: unsafe {
unsafe extern "system" fn cmd_draw_cluster_huawei(
_command_buffer: CommandBuffer,
_group_count_x: u32,
_group_count_y: u32,
_group_count_z: u32,
) {
panic!(concat!(
"Unable to load ",
stringify!(cmd_draw_cluster_huawei)
))
}
let cname =
CStr::from_bytes_with_nul_unchecked(b"vkCmdDrawClusterHUAWEI\0");
let val = _f(cname);
if val.is_null() {
cmd_draw_cluster_huawei
} else {
::core::mem::transmute(val)
}
},
cmd_draw_cluster_indirect_huawei: unsafe {
unsafe extern "system" fn cmd_draw_cluster_indirect_huawei(
_command_buffer: CommandBuffer,
_buffer: Buffer,
_offset: DeviceSize,
) {
panic!(concat!(
"Unable to load ",
stringify!(cmd_draw_cluster_indirect_huawei)
))
}
let cname = CStr::from_bytes_with_nul_unchecked(
b"vkCmdDrawClusterIndirectHUAWEI\0",
);
let val = _f(cname);
if val.is_null() {
cmd_draw_cluster_indirect_huawei
} else {
::core::mem::transmute(val)
}
},
}
}
}
}
}
#[doc = "Extensions tagged IMG"]
pub mod img {
#[doc = "VK_IMG_filter_cubic"]
pub mod filter_cubic {
use super::super::*;
pub use {
crate::vk::IMG_FILTER_CUBIC_NAME as NAME,
crate::vk::IMG_FILTER_CUBIC_SPEC_VERSION as SPEC_VERSION,
};
}
#[doc = "VK_IMG_format_pvrtc"]
pub mod format_pvrtc {
use super::super::*;
pub use {
crate::vk::IMG_FORMAT_PVRTC_NAME as NAME,
crate::vk::IMG_FORMAT_PVRTC_SPEC_VERSION as SPEC_VERSION,
};
}
#[doc = "VK_IMG_relaxed_line_rasterization"]
pub mod relaxed_line_rasterization {
use super::super::*;
pub use {
crate::vk::IMG_RELAXED_LINE_RASTERIZATION_NAME as NAME,
crate::vk::IMG_RELAXED_LINE_RASTERIZATION_SPEC_VERSION as SPEC_VERSION,
};
}
}
#[doc = "Extensions tagged INTEL"]
pub mod intel {
#[doc = "VK_INTEL_shader_integer_functions2"]
pub mod shader_integer_functions2 {
use super::super::*;
pub use {
crate::vk::INTEL_SHADER_INTEGER_FUNCTIONS2_NAME as NAME,
crate::vk::INTEL_SHADER_INTEGER_FUNCTIONS2_SPEC_VERSION as SPEC_VERSION,
};
}
#[doc = "VK_INTEL_performance_query"]
pub mod performance_query {
use super::super::*;
pub use {
crate::vk::INTEL_PERFORMANCE_QUERY_NAME as NAME,
crate::vk::INTEL_PERFORMANCE_QUERY_SPEC_VERSION as SPEC_VERSION,
};
#[doc = "VK_INTEL_performance_query device-level functions"]
#[derive(Clone)]
pub struct Device {
pub(crate) fp: DeviceFn,
pub(crate) handle: crate::vk::Device,
}
impl Device {
pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
let handle = device.handle();
let fp = DeviceFn::load(|name| unsafe {
core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
});
Self { handle, fp }
}
#[inline]
pub fn fp(&self) -> &DeviceFn {
&self.fp
}
#[inline]
pub fn device(&self) -> crate::vk::Device {
self.handle
}
}
#[derive(Clone)]
#[doc = "Raw VK_INTEL_performance_query device-level function pointers"]
pub struct DeviceFn {
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 DeviceFn {}
unsafe impl Sync for DeviceFn {}
impl DeviceFn {
pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
Self::load_erased(&mut f)
}
fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
Self {
initialize_performance_api_intel: unsafe {
unsafe extern "system" fn initialize_performance_api_intel(
_device: crate::vk::Device,
_p_initialize_info: *const InitializePerformanceApiInfoINTEL<'_>,
) -> Result {
panic!(concat!(
"Unable to load ",
stringify!(initialize_performance_api_intel)
))
}
let cname = CStr::from_bytes_with_nul_unchecked(
b"vkInitializePerformanceApiINTEL\0",
);
let val = _f(cname);
if val.is_null() {
initialize_performance_api_intel
} else {
::core::mem::transmute(val)
}
},
uninitialize_performance_api_intel: unsafe {
unsafe extern "system" fn uninitialize_performance_api_intel(
_device: crate::vk::Device,
) {
panic!(concat!(
"Unable to load ",
stringify!(uninitialize_performance_api_intel)
))
}
let cname = CStr::from_bytes_with_nul_unchecked(
b"vkUninitializePerformanceApiINTEL\0",
);
let val = _f(cname);
if val.is_null() {
uninitialize_performance_api_intel
} else {
::core::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 = CStr::from_bytes_with_nul_unchecked(
b"vkCmdSetPerformanceMarkerINTEL\0",
);
let val = _f(cname);
if val.is_null() {
cmd_set_performance_marker_intel
} else {
::core::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 = CStr::from_bytes_with_nul_unchecked(
b"vkCmdSetPerformanceStreamMarkerINTEL\0",
);
let val = _f(cname);
if val.is_null() {
cmd_set_performance_stream_marker_intel
} else {
::core::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 = CStr::from_bytes_with_nul_unchecked(
b"vkCmdSetPerformanceOverrideINTEL\0",
);
let val = _f(cname);
if val.is_null() {
cmd_set_performance_override_intel
} else {
::core::mem::transmute(val)
}
},
acquire_performance_configuration_intel: unsafe {
unsafe extern "system" fn acquire_performance_configuration_intel(
_device: crate::vk::Device,
_p_acquire_info: *const PerformanceConfigurationAcquireInfoINTEL<'_>,
_p_configuration: *mut PerformanceConfigurationINTEL,
) -> Result {
panic!(concat!(
"Unable to load ",
stringify!(acquire_performance_configuration_intel)
))
}
let cname = CStr::from_bytes_with_nul_unchecked(
b"vkAcquirePerformanceConfigurationINTEL\0",
);
let val = _f(cname);
if val.is_null() {
acquire_performance_configuration_intel
} else {
::core::mem::transmute(val)
}
},
release_performance_configuration_intel: unsafe {
unsafe extern "system" fn release_performance_configuration_intel(
_device: crate::vk::Device,
_configuration: PerformanceConfigurationINTEL,
) -> Result {
panic!(concat!(
"Unable to load ",
stringify!(release_performance_configuration_intel)
))
}
let cname = CStr::from_bytes_with_nul_unchecked(
b"vkReleasePerformanceConfigurationINTEL\0",
);
let val = _f(cname);
if val.is_null() {
release_performance_configuration_intel
} else {
::core::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 = CStr::from_bytes_with_nul_unchecked(
b"vkQueueSetPerformanceConfigurationINTEL\0",
);
let val = _f(cname);
if val.is_null() {
queue_set_performance_configuration_intel
} else {
::core::mem::transmute(val)
}
},
get_performance_parameter_intel: unsafe {
unsafe extern "system" fn get_performance_parameter_intel(
_device: crate::vk::Device,
_parameter: PerformanceParameterTypeINTEL,
_p_value: *mut PerformanceValueINTEL,
) -> Result {
panic!(concat!(
"Unable to load ",
stringify!(get_performance_parameter_intel)
))
}
let cname = CStr::from_bytes_with_nul_unchecked(
b"vkGetPerformanceParameterINTEL\0",
);
let val = _f(cname);
if val.is_null() {
get_performance_parameter_intel
} else {
::core::mem::transmute(val)
}
},
}
}
}
}
}
#[doc = "Extensions tagged KHR"]
pub mod khr {
#[doc = "VK_KHR_surface"]
pub mod surface {
use super::super::*;
pub use {
crate::vk::KHR_SURFACE_NAME as NAME,
crate::vk::KHR_SURFACE_SPEC_VERSION as SPEC_VERSION,
};
#[doc = "VK_KHR_surface instance-level functions"]
#[derive(Clone)]
pub struct Instance {
pub(crate) fp: InstanceFn,
pub(crate) handle: crate::vk::Instance,
}
impl Instance {
pub fn new(entry: &crate::Entry, instance: &crate::Instance) -> Self {
let handle = instance.handle();
let fp = InstanceFn::load(|name| unsafe {
core::mem::transmute(entry.get_instance_proc_addr(handle, name.as_ptr()))
});
Self { handle, fp }
}
#[inline]
pub fn fp(&self) -> &InstanceFn {
&self.fp
}
#[inline]
pub fn instance(&self) -> crate::vk::Instance {
self.handle
}
}
#[derive(Clone)]
#[doc = "Raw VK_KHR_surface instance-level function pointers"]
pub struct InstanceFn {
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 InstanceFn {}
unsafe impl Sync for InstanceFn {}
impl InstanceFn {
pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
Self::load_erased(&mut f)
}
fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
Self {
destroy_surface_khr: unsafe {
unsafe extern "system" fn destroy_surface_khr(
_instance: crate::vk::Instance,
_surface: SurfaceKHR,
_p_allocator: *const AllocationCallbacks<'_>,
) {
panic!(concat!("Unable to load ", stringify!(destroy_surface_khr)))
}
let cname = CStr::from_bytes_with_nul_unchecked(b"vkDestroySurfaceKHR\0");
let val = _f(cname);
if val.is_null() {
destroy_surface_khr
} else {
::core::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 = CStr::from_bytes_with_nul_unchecked(
b"vkGetPhysicalDeviceSurfaceSupportKHR\0",
);
let val = _f(cname);
if val.is_null() {
get_physical_device_surface_support_khr
} else {
::core::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 = CStr::from_bytes_with_nul_unchecked(
b"vkGetPhysicalDeviceSurfaceCapabilitiesKHR\0",
);
let val = _f(cname);
if val.is_null() {
get_physical_device_surface_capabilities_khr
} else {
::core::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 = CStr::from_bytes_with_nul_unchecked(
b"vkGetPhysicalDeviceSurfaceFormatsKHR\0",
);
let val = _f(cname);
if val.is_null() {
get_physical_device_surface_formats_khr
} else {
::core::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 = 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 {
::core::mem::transmute(val)
}
},
}
}
}
}
#[doc = "VK_KHR_swapchain"]
pub mod swapchain {
use super::super::*;
pub use {
crate::vk::KHR_SWAPCHAIN_NAME as NAME,
crate::vk::KHR_SWAPCHAIN_SPEC_VERSION as SPEC_VERSION,
};
#[doc = "VK_KHR_swapchain instance-level functions"]
#[derive(Clone)]
pub struct Instance {
pub(crate) fp: InstanceFn,
pub(crate) handle: crate::vk::Instance,
}
impl Instance {
pub fn new(entry: &crate::Entry, instance: &crate::Instance) -> Self {
let handle = instance.handle();
let fp = InstanceFn::load(|name| unsafe {
core::mem::transmute(entry.get_instance_proc_addr(handle, name.as_ptr()))
});
Self { handle, fp }
}
#[inline]
pub fn fp(&self) -> &InstanceFn {
&self.fp
}
#[inline]
pub fn instance(&self) -> crate::vk::Instance {
self.handle
}
}
#[derive(Clone)]
#[doc = "Raw VK_KHR_swapchain instance-level function pointers"]
pub struct InstanceFn {
pub get_physical_device_present_rectangles_khr:
PFN_vkGetPhysicalDevicePresentRectanglesKHR,
}
unsafe impl Send for InstanceFn {}
unsafe impl Sync for InstanceFn {}
impl InstanceFn {
pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
Self::load_erased(&mut f)
}
fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
Self {
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 = CStr::from_bytes_with_nul_unchecked(
b"vkGetPhysicalDevicePresentRectanglesKHR\0",
);
let val = _f(cname);
if val.is_null() {
get_physical_device_present_rectangles_khr
} else {
::core::mem::transmute(val)
}
},
}
}
}
#[doc = "VK_KHR_swapchain device-level functions"]
#[derive(Clone)]
pub struct Device {
pub(crate) fp: DeviceFn,
pub(crate) handle: crate::vk::Device,
}
impl Device {
pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
let handle = device.handle();
let fp = DeviceFn::load(|name| unsafe {
core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
});
Self { handle, fp }
}
#[inline]
pub fn fp(&self) -> &DeviceFn {
&self.fp
}
#[inline]
pub fn device(&self) -> crate::vk::Device {
self.handle
}
}
#[derive(Clone)]
#[doc = "Raw VK_KHR_swapchain device-level function pointers"]
pub struct DeviceFn {
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 acquire_next_image2_khr: PFN_vkAcquireNextImage2KHR,
}
unsafe impl Send for DeviceFn {}
unsafe impl Sync for DeviceFn {}
impl DeviceFn {
pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
Self::load_erased(&mut f)
}
fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
Self {
create_swapchain_khr: unsafe {
unsafe extern "system" fn create_swapchain_khr(
_device: crate::vk::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 = CStr::from_bytes_with_nul_unchecked(b"vkCreateSwapchainKHR\0");
let val = _f(cname);
if val.is_null() {
create_swapchain_khr
} else {
::core::mem::transmute(val)
}
},
destroy_swapchain_khr: unsafe {
unsafe extern "system" fn destroy_swapchain_khr(
_device: crate::vk::Device,
_swapchain: SwapchainKHR,
_p_allocator: *const AllocationCallbacks<'_>,
) {
panic!(concat!(
"Unable to load ",
stringify!(destroy_swapchain_khr)
))
}
let cname = CStr::from_bytes_with_nul_unchecked(b"vkDestroySwapchainKHR\0");
let val = _f(cname);
if val.is_null() {
destroy_swapchain_khr
} else {
::core::mem::transmute(val)
}
},
get_swapchain_images_khr: unsafe {
unsafe extern "system" fn get_swapchain_images_khr(
_device: crate::vk::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 =
CStr::from_bytes_with_nul_unchecked(b"vkGetSwapchainImagesKHR\0");
let val = _f(cname);
if val.is_null() {
get_swapchain_images_khr
} else {
::core::mem::transmute(val)
}
},
acquire_next_image_khr: unsafe {
unsafe extern "system" fn acquire_next_image_khr(
_device: crate::vk::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 = CStr::from_bytes_with_nul_unchecked(b"vkAcquireNextImageKHR\0");
let val = _f(cname);
if val.is_null() {
acquire_next_image_khr
} else {
::core::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 = CStr::from_bytes_with_nul_unchecked(b"vkQueuePresentKHR\0");
let val = _f(cname);
if val.is_null() {
queue_present_khr
} else {
::core::mem::transmute(val)
}
},
get_device_group_present_capabilities_khr: unsafe {
unsafe extern "system" fn get_device_group_present_capabilities_khr(
_device: crate::vk::Device,
_p_device_group_present_capabilities : * mut DeviceGroupPresentCapabilitiesKHR < '_ >,
) -> Result {
panic!(concat!(
"Unable to load ",
stringify!(get_device_group_present_capabilities_khr)
))
}
let cname = CStr::from_bytes_with_nul_unchecked(
b"vkGetDeviceGroupPresentCapabilitiesKHR\0",
);
let val = _f(cname);
if val.is_null() {
get_device_group_present_capabilities_khr
} else {
::core::mem::transmute(val)
}
},
get_device_group_surface_present_modes_khr: unsafe {
unsafe extern "system" fn get_device_group_surface_present_modes_khr(
_device: crate::vk::Device,
_surface: SurfaceKHR,
_p_modes: *mut DeviceGroupPresentModeFlagsKHR,
) -> Result {
panic!(concat!(
"Unable to load ",
stringify!(get_device_group_surface_present_modes_khr)
))
}
let cname = 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 {
::core::mem::transmute(val)
}
},
acquire_next_image2_khr: unsafe {
unsafe extern "system" fn acquire_next_image2_khr(
_device: crate::vk::Device,
_p_acquire_info: *const AcquireNextImageInfoKHR<'_>,
_p_image_index: *mut u32,
) -> Result {
panic!(concat!(
"Unable to load ",
stringify!(acquire_next_image2_khr)
))
}
let cname =
CStr::from_bytes_with_nul_unchecked(b"vkAcquireNextImage2KHR\0");
let val = _f(cname);
if val.is_null() {
acquire_next_image2_khr
} else {
::core::mem::transmute(val)
}
},
}
}
}
}
#[doc = "VK_KHR_display"]
pub mod display {
use super::super::*;
pub use {
crate::vk::KHR_DISPLAY_NAME as NAME,
crate::vk::KHR_DISPLAY_SPEC_VERSION as SPEC_VERSION,
};
#[doc = "VK_KHR_display instance-level functions"]
#[derive(Clone)]
pub struct Instance {
pub(crate) fp: InstanceFn,
pub(crate) handle: crate::vk::Instance,
}
impl Instance {
pub fn new(entry: &crate::Entry, instance: &crate::Instance) -> Self {
let handle = instance.handle();
let fp = InstanceFn::load(|name| unsafe {
core::mem::transmute(entry.get_instance_proc_addr(handle, name.as_ptr()))
});
Self { handle, fp }
}
#[inline]
pub fn fp(&self) -> &InstanceFn {
&self.fp
}
#[inline]
pub fn instance(&self) -> crate::vk::Instance {
self.handle
}
}
#[derive(Clone)]
#[doc = "Raw VK_KHR_display instance-level function pointers"]
pub struct InstanceFn {
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 InstanceFn {}
unsafe impl Sync for InstanceFn {}
impl InstanceFn {
pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
Self::load_erased(&mut f)
}
fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
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 = CStr::from_bytes_with_nul_unchecked(
b"vkGetPhysicalDeviceDisplayPropertiesKHR\0",
);
let val = _f(cname);
if val.is_null() {
get_physical_device_display_properties_khr
} else {
::core::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 = 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 {
::core::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 = CStr::from_bytes_with_nul_unchecked(
b"vkGetDisplayPlaneSupportedDisplaysKHR\0",
);
let val = _f(cname);
if val.is_null() {
get_display_plane_supported_displays_khr
} else {
::core::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 =
CStr::from_bytes_with_nul_unchecked(b"vkGetDisplayModePropertiesKHR\0");
let val = _f(cname);
if val.is_null() {
get_display_mode_properties_khr
} else {
::core::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 =
CStr::from_bytes_with_nul_unchecked(b"vkCreateDisplayModeKHR\0");
let val = _f(cname);
if val.is_null() {
create_display_mode_khr
} else {
::core::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 = CStr::from_bytes_with_nul_unchecked(
b"vkGetDisplayPlaneCapabilitiesKHR\0",
);
let val = _f(cname);
if val.is_null() {
get_display_plane_capabilities_khr
} else {
::core::mem::transmute(val)
}
},
create_display_plane_surface_khr: unsafe {
unsafe extern "system" fn create_display_plane_surface_khr(
_instance: crate::vk::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 = CStr::from_bytes_with_nul_unchecked(
b"vkCreateDisplayPlaneSurfaceKHR\0",
);
let val = _f(cname);
if val.is_null() {
create_display_plane_surface_khr
} else {
::core::mem::transmute(val)
}
},
}
}
}
}
#[doc = "VK_KHR_display_swapchain"]
pub mod display_swapchain {
use super::super::*;
pub use {
crate::vk::KHR_DISPLAY_SWAPCHAIN_NAME as NAME,
crate::vk::KHR_DISPLAY_SWAPCHAIN_SPEC_VERSION as SPEC_VERSION,
};
#[doc = "VK_KHR_display_swapchain device-level functions"]
#[derive(Clone)]
pub struct Device {
pub(crate) fp: DeviceFn,
pub(crate) handle: crate::vk::Device,
}
impl Device {
pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
let handle = device.handle();
let fp = DeviceFn::load(|name| unsafe {
core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
});
Self { handle, fp }
}
#[inline]
pub fn fp(&self) -> &DeviceFn {
&self.fp
}
#[inline]
pub fn device(&self) -> crate::vk::Device {
self.handle
}
}
#[derive(Clone)]
#[doc = "Raw VK_KHR_display_swapchain device-level function pointers"]
pub struct DeviceFn {
pub create_shared_swapchains_khr: PFN_vkCreateSharedSwapchainsKHR,
}
unsafe impl Send for DeviceFn {}
unsafe impl Sync for DeviceFn {}
impl DeviceFn {
pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
Self::load_erased(&mut f)
}
fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
Self {
create_shared_swapchains_khr: unsafe {
unsafe extern "system" fn create_shared_swapchains_khr(
_device: crate::vk::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 =
CStr::from_bytes_with_nul_unchecked(b"vkCreateSharedSwapchainsKHR\0");
let val = _f(cname);
if val.is_null() {
create_shared_swapchains_khr
} else {
::core::mem::transmute(val)
}
},
}
}
}
}
#[doc = "VK_KHR_xlib_surface"]
pub mod xlib_surface {
use super::super::*;
pub use {
crate::vk::KHR_XLIB_SURFACE_NAME as NAME,
crate::vk::KHR_XLIB_SURFACE_SPEC_VERSION as SPEC_VERSION,
};
#[doc = "VK_KHR_xlib_surface instance-level functions"]
#[derive(Clone)]
pub struct Instance {
pub(crate) fp: InstanceFn,
pub(crate) handle: crate::vk::Instance,
}
impl Instance {
pub fn new(entry: &crate::Entry, instance: &crate::Instance) -> Self {
let handle = instance.handle();
let fp = InstanceFn::load(|name| unsafe {
core::mem::transmute(entry.get_instance_proc_addr(handle, name.as_ptr()))
});
Self { handle, fp }
}
#[inline]
pub fn fp(&self) -> &InstanceFn {
&self.fp
}
#[inline]
pub fn instance(&self) -> crate::vk::Instance {
self.handle
}
}
#[derive(Clone)]
#[doc = "Raw VK_KHR_xlib_surface instance-level function pointers"]
pub struct InstanceFn {
pub create_xlib_surface_khr: PFN_vkCreateXlibSurfaceKHR,
pub get_physical_device_xlib_presentation_support_khr:
PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR,
}
unsafe impl Send for InstanceFn {}
unsafe impl Sync for InstanceFn {}
impl InstanceFn {
pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
Self::load_erased(&mut f)
}
fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
Self {
create_xlib_surface_khr: unsafe {
unsafe extern "system" fn create_xlib_surface_khr(
_instance: crate::vk::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 =
CStr::from_bytes_with_nul_unchecked(b"vkCreateXlibSurfaceKHR\0");
let val = _f(cname);
if val.is_null() {
create_xlib_surface_khr
} else {
::core::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 = 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 {
::core::mem::transmute(val)
}
},
}
}
}
}
#[doc = "VK_KHR_xcb_surface"]
pub mod xcb_surface {
use super::super::*;
pub use {
crate::vk::KHR_XCB_SURFACE_NAME as NAME,
crate::vk::KHR_XCB_SURFACE_SPEC_VERSION as SPEC_VERSION,
};
#[doc = "VK_KHR_xcb_surface instance-level functions"]
#[derive(Clone)]
pub struct Instance {
pub(crate) fp: InstanceFn,
pub(crate) handle: crate::vk::Instance,
}
impl Instance {
pub fn new(entry: &crate::Entry, instance: &crate::Instance) -> Self {
let handle = instance.handle();
let fp = InstanceFn::load(|name| unsafe {
core::mem::transmute(entry.get_instance_proc_addr(handle, name.as_ptr()))
});
Self { handle, fp }
}
#[inline]
pub fn fp(&self) -> &InstanceFn {
&self.fp
}
#[inline]
pub fn instance(&self) -> crate::vk::Instance {
self.handle
}
}
#[derive(Clone)]
#[doc = "Raw VK_KHR_xcb_surface instance-level function pointers"]
pub struct InstanceFn {
pub create_xcb_surface_khr: PFN_vkCreateXcbSurfaceKHR,
pub get_physical_device_xcb_presentation_support_khr:
PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR,
}
unsafe impl Send for InstanceFn {}
unsafe impl Sync for InstanceFn {}
impl InstanceFn {
pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
Self::load_erased(&mut f)
}
fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
Self {
create_xcb_surface_khr: unsafe {
unsafe extern "system" fn create_xcb_surface_khr(
_instance: crate::vk::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 = CStr::from_bytes_with_nul_unchecked(b"vkCreateXcbSurfaceKHR\0");
let val = _f(cname);
if val.is_null() {
create_xcb_surface_khr
} else {
::core::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 = 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 {
::core::mem::transmute(val)
}
},
}
}
}
}
#[doc = "VK_KHR_wayland_surface"]
pub mod wayland_surface {
use super::super::*;
pub use {
crate::vk::KHR_WAYLAND_SURFACE_NAME as NAME,
crate::vk::KHR_WAYLAND_SURFACE_SPEC_VERSION as SPEC_VERSION,
};
#[doc = "VK_KHR_wayland_surface instance-level functions"]
#[derive(Clone)]
pub struct Instance {
pub(crate) fp: InstanceFn,
pub(crate) handle: crate::vk::Instance,
}
impl Instance {
pub fn new(entry: &crate::Entry, instance: &crate::Instance) -> Self {
let handle = instance.handle();
let fp = InstanceFn::load(|name| unsafe {
core::mem::transmute(entry.get_instance_proc_addr(handle, name.as_ptr()))
});
Self { handle, fp }
}
#[inline]
pub fn fp(&self) -> &InstanceFn {
&self.fp
}
#[inline]
pub fn instance(&self) -> crate::vk::Instance {
self.handle
}
}
#[derive(Clone)]
#[doc = "Raw VK_KHR_wayland_surface instance-level function pointers"]
pub struct InstanceFn {
pub create_wayland_surface_khr: PFN_vkCreateWaylandSurfaceKHR,
pub get_physical_device_wayland_presentation_support_khr:
PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR,
}
unsafe impl Send for InstanceFn {}
unsafe impl Sync for InstanceFn {}
impl InstanceFn {
pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
Self::load_erased(&mut f)
}
fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
Self {
create_wayland_surface_khr: unsafe {
unsafe extern "system" fn create_wayland_surface_khr(
_instance: crate::vk::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 =
CStr::from_bytes_with_nul_unchecked(b"vkCreateWaylandSurfaceKHR\0");
let val = _f(cname);
if val.is_null() {
create_wayland_surface_khr
} else {
::core::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 = 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 {
::core::mem::transmute(val)
}
},
}
}
}
}
#[doc = "VK_KHR_android_surface"]
pub mod android_surface {
use super::super::*;
pub use {
crate::vk::KHR_ANDROID_SURFACE_NAME as NAME,
crate::vk::KHR_ANDROID_SURFACE_SPEC_VERSION as SPEC_VERSION,
};
#[doc = "VK_KHR_android_surface instance-level functions"]
#[derive(Clone)]
pub struct Instance {
pub(crate) fp: InstanceFn,
pub(crate) handle: crate::vk::Instance,
}
impl Instance {
pub fn new(entry: &crate::Entry, instance: &crate::Instance) -> Self {
let handle = instance.handle();
let fp = InstanceFn::load(|name| unsafe {
core::mem::transmute(entry.get_instance_proc_addr(handle, name.as_ptr()))
});
Self { handle, fp }
}
#[inline]
pub fn fp(&self) -> &InstanceFn {
&self.fp
}
#[inline]
pub fn instance(&self) -> crate::vk::Instance {
self.handle
}
}
#[derive(Clone)]
#[doc = "Raw VK_KHR_android_surface instance-level function pointers"]
pub struct InstanceFn {
pub create_android_surface_khr: PFN_vkCreateAndroidSurfaceKHR,
}
unsafe impl Send for InstanceFn {}
unsafe impl Sync for InstanceFn {}
impl InstanceFn {
pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
Self::load_erased(&mut f)
}
fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
Self {
create_android_surface_khr: unsafe {
unsafe extern "system" fn create_android_surface_khr(
_instance: crate::vk::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 =
CStr::from_bytes_with_nul_unchecked(b"vkCreateAndroidSurfaceKHR\0");
let val = _f(cname);
if val.is_null() {
create_android_surface_khr
} else {
::core::mem::transmute(val)
}
},
}
}
}
}
#[doc = "VK_KHR_win32_surface"]
pub mod win32_surface {
use super::super::*;
pub use {
crate::vk::KHR_WIN32_SURFACE_NAME as NAME,
crate::vk::KHR_WIN32_SURFACE_SPEC_VERSION as SPEC_VERSION,
};
#[doc = "VK_KHR_win32_surface instance-level functions"]
#[derive(Clone)]
pub struct Instance {
pub(crate) fp: InstanceFn,
pub(crate) handle: crate::vk::Instance,
}
impl Instance {
pub fn new(entry: &crate::Entry, instance: &crate::Instance) -> Self {
let handle = instance.handle();
let fp = InstanceFn::load(|name| unsafe {
core::mem::transmute(entry.get_instance_proc_addr(handle, name.as_ptr()))
});
Self { handle, fp }
}
#[inline]
pub fn fp(&self) -> &InstanceFn {
&self.fp
}
#[inline]
pub fn instance(&self) -> crate::vk::Instance {
self.handle
}
}
#[derive(Clone)]
#[doc = "Raw VK_KHR_win32_surface instance-level function pointers"]
pub struct InstanceFn {
pub create_win32_surface_khr: PFN_vkCreateWin32SurfaceKHR,
pub get_physical_device_win32_presentation_support_khr:
PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR,
}
unsafe impl Send for InstanceFn {}
unsafe impl Sync for InstanceFn {}
impl InstanceFn {
pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
Self::load_erased(&mut f)
}
fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
Self {
create_win32_surface_khr: unsafe {
unsafe extern "system" fn create_win32_surface_khr(
_instance: crate::vk::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 =
CStr::from_bytes_with_nul_unchecked(b"vkCreateWin32SurfaceKHR\0");
let val = _f(cname);
if val.is_null() {
create_win32_surface_khr
} else {
::core::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 = 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 {
::core::mem::transmute(val)
}
},
}
}
}
}
#[doc = "VK_KHR_sampler_mirror_clamp_to_edge"]
pub mod sampler_mirror_clamp_to_edge {
use super::super::*;
pub use {
crate::vk::KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_NAME as NAME,
crate::vk::KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_SPEC_VERSION as SPEC_VERSION,
};
}
#[doc = "VK_KHR_video_queue"]
pub mod video_queue {
use super::super::*;
pub use {
crate::vk::KHR_VIDEO_QUEUE_NAME as NAME,
crate::vk::KHR_VIDEO_QUEUE_SPEC_VERSION as SPEC_VERSION,
};
#[doc = "VK_KHR_video_queue instance-level functions"]
#[derive(Clone)]
pub struct Instance {
pub(crate) fp: InstanceFn,
pub(crate) handle: crate::vk::Instance,
}
impl Instance {
pub fn new(entry: &crate::Entry, instance: &crate::Instance) -> Self {
let handle = instance.handle();
let fp = InstanceFn::load(|name| unsafe {
core::mem::transmute(entry.get_instance_proc_addr(handle, name.as_ptr()))
});
Self { handle, fp }
}
#[inline]
pub fn fp(&self) -> &InstanceFn {
&self.fp
}
#[inline]
pub fn instance(&self) -> crate::vk::Instance {
self.handle
}
}
#[derive(Clone)]
#[doc = "Raw VK_KHR_video_queue instance-level function pointers"]
pub struct InstanceFn {
pub get_physical_device_video_capabilities_khr:
PFN_vkGetPhysicalDeviceVideoCapabilitiesKHR,
pub get_physical_device_video_format_properties_khr:
PFN_vkGetPhysicalDeviceVideoFormatPropertiesKHR,
}
unsafe impl Send for InstanceFn {}
unsafe impl Sync for InstanceFn {}
impl InstanceFn {
pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
Self::load_erased(&mut f)
}
fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
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 = CStr::from_bytes_with_nul_unchecked(
b"vkGetPhysicalDeviceVideoCapabilitiesKHR\0",
);
let val = _f(cname);
if val.is_null() {
get_physical_device_video_capabilities_khr
} else {
::core::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 = 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 {
::core::mem::transmute(val)
}
},
}
}
}
#[doc = "VK_KHR_video_queue device-level functions"]
#[derive(Clone)]
pub struct Device {
pub(crate) fp: DeviceFn,
pub(crate) handle: crate::vk::Device,
}
impl Device {
pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
let handle = device.handle();
let fp = DeviceFn::load(|name| unsafe {
core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
});
Self { handle, fp }
}
#[inline]
pub fn fp(&self) -> &DeviceFn {
&self.fp
}
#[inline]
pub fn device(&self) -> crate::vk::Device {
self.handle
}
}
#[derive(Clone)]
#[doc = "Raw VK_KHR_video_queue device-level function pointers"]
pub struct DeviceFn {
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 DeviceFn {}
unsafe impl Sync for DeviceFn {}
impl DeviceFn {
pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
Self::load_erased(&mut f)
}
fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
Self {
create_video_session_khr: unsafe {
unsafe extern "system" fn create_video_session_khr(
_device: crate::vk::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 =
CStr::from_bytes_with_nul_unchecked(b"vkCreateVideoSessionKHR\0");
let val = _f(cname);
if val.is_null() {
create_video_session_khr
} else {
::core::mem::transmute(val)
}
},
destroy_video_session_khr: unsafe {
unsafe extern "system" fn destroy_video_session_khr(
_device: crate::vk::Device,
_video_session: VideoSessionKHR,
_p_allocator: *const AllocationCallbacks<'_>,
) {
panic!(concat!(
"Unable to load ",
stringify!(destroy_video_session_khr)
))
}
let cname =
CStr::from_bytes_with_nul_unchecked(b"vkDestroyVideoSessionKHR\0");
let val = _f(cname);
if val.is_null() {
destroy_video_session_khr
} else {
::core::mem::transmute(val)
}
},
get_video_session_memory_requirements_khr: unsafe {
unsafe extern "system" fn get_video_session_memory_requirements_khr(
_device: crate::vk::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 = CStr::from_bytes_with_nul_unchecked(
b"vkGetVideoSessionMemoryRequirementsKHR\0",
);
let val = _f(cname);
if val.is_null() {
get_video_session_memory_requirements_khr
} else {
::core::mem::transmute(val)
}
},
bind_video_session_memory_khr: unsafe {
unsafe extern "system" fn bind_video_session_memory_khr(
_device: crate::vk::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 =
CStr::from_bytes_with_nul_unchecked(b"vkBindVideoSessionMemoryKHR\0");
let val = _f(cname);
if val.is_null() {
bind_video_session_memory_khr
} else {
::core::mem::transmute(val)
}
},
create_video_session_parameters_khr: unsafe {
unsafe extern "system" fn create_video_session_parameters_khr(
_device: crate::vk::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 = CStr::from_bytes_with_nul_unchecked(
b"vkCreateVideoSessionParametersKHR\0",
);
let val = _f(cname);
if val.is_null() {
create_video_session_parameters_khr
} else {
::core::mem::transmute(val)
}
},
update_video_session_parameters_khr: unsafe {
unsafe extern "system" fn update_video_session_parameters_khr(
_device: crate::vk::Device,
_video_session_parameters: VideoSessionParametersKHR,
_p_update_info: *const VideoSessionParametersUpdateInfoKHR<'_>,
) -> Result {
panic!(concat!(
"Unable to load ",
stringify!(update_video_session_parameters_khr)
))
}
let cname = CStr::from_bytes_with_nul_unchecked(
b"vkUpdateVideoSessionParametersKHR\0",
);
let val = _f(cname);
if val.is_null() {
update_video_session_parameters_khr
} else {
::core::mem::transmute(val)
}
},
destroy_video_session_parameters_khr: unsafe {
unsafe extern "system" fn destroy_video_session_parameters_khr(
_device: crate::vk::Device,
_video_session_parameters: VideoSessionParametersKHR,
_p_allocator: *const AllocationCallbacks<'_>,
) {
panic!(concat!(
"Unable to load ",
stringify!(destroy_video_session_parameters_khr)
))
}
let cname = CStr::from_bytes_with_nul_unchecked(
b"vkDestroyVideoSessionParametersKHR\0",
);
let val = _f(cname);
if val.is_null() {
destroy_video_session_parameters_khr
} else {
::core::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 =
CStr::from_bytes_with_nul_unchecked(b"vkCmdBeginVideoCodingKHR\0");
let val = _f(cname);
if val.is_null() {
cmd_begin_video_coding_khr
} else {
::core::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 =
CStr::from_bytes_with_nul_unchecked(b"vkCmdEndVideoCodingKHR\0");
let val = _f(cname);
if val.is_null() {
cmd_end_video_coding_khr
} else {
::core::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 =
CStr::from_bytes_with_nul_unchecked(b"vkCmdControlVideoCodingKHR\0");
let val = _f(cname);
if val.is_null() {
cmd_control_video_coding_khr
} else {
::core::mem::transmute(val)
}
},
}
}
}
}
#[doc = "VK_KHR_video_decode_queue"]
pub mod video_decode_queue {
use super::super::*;
pub use {
crate::vk::KHR_VIDEO_DECODE_QUEUE_NAME as NAME,
crate::vk::KHR_VIDEO_DECODE_QUEUE_SPEC_VERSION as SPEC_VERSION,
};
#[doc = "VK_KHR_video_decode_queue device-level functions"]
#[derive(Clone)]
pub struct Device {
pub(crate) fp: DeviceFn,
pub(crate) handle: crate::vk::Device,
}
impl Device {
pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
let handle = device.handle();
let fp = DeviceFn::load(|name| unsafe {
core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
});
Self { handle, fp }
}
#[inline]
pub fn fp(&self) -> &DeviceFn {
&self.fp
}
#[inline]
pub fn device(&self) -> crate::vk::Device {
self.handle
}
}
#[derive(Clone)]
#[doc = "Raw VK_KHR_video_decode_queue device-level function pointers"]
pub struct DeviceFn {
pub cmd_decode_video_khr: PFN_vkCmdDecodeVideoKHR,
}
unsafe impl Send for DeviceFn {}
unsafe impl Sync for DeviceFn {}
impl DeviceFn {
pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
Self::load_erased(&mut f)
}
fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
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 = CStr::from_bytes_with_nul_unchecked(b"vkCmdDecodeVideoKHR\0");
let val = _f(cname);
if val.is_null() {
cmd_decode_video_khr
} else {
::core::mem::transmute(val)
}
},
}
}
}
}
#[doc = "VK_KHR_video_encode_h264"]
pub mod video_encode_h264 {
use super::super::*;
pub use {
crate::vk::KHR_VIDEO_ENCODE_H264_NAME as NAME,
crate::vk::KHR_VIDEO_ENCODE_H264_SPEC_VERSION as SPEC_VERSION,
};
}
#[doc = "VK_KHR_video_encode_h265"]
pub mod video_encode_h265 {
use super::super::*;
pub use {
crate::vk::KHR_VIDEO_ENCODE_H265_NAME as NAME,
crate::vk::KHR_VIDEO_ENCODE_H265_SPEC_VERSION as SPEC_VERSION,
};
}
#[doc = "VK_KHR_video_decode_h264"]
pub mod video_decode_h264 {
use super::super::*;
pub use {
crate::vk::KHR_VIDEO_DECODE_H264_NAME as NAME,
crate::vk::KHR_VIDEO_DECODE_H264_SPEC_VERSION as SPEC_VERSION,
};
}
#[doc = "VK_KHR_dynamic_rendering"]
pub mod dynamic_rendering {
use super::super::*;
pub use {
crate::vk::KHR_DYNAMIC_RENDERING_NAME as NAME,
crate::vk::KHR_DYNAMIC_RENDERING_SPEC_VERSION as SPEC_VERSION,
};
#[doc = "VK_KHR_dynamic_rendering device-level functions"]
#[derive(Clone)]
pub struct Device {
pub(crate) fp: DeviceFn,
pub(crate) handle: crate::vk::Device,
}
impl Device {
pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
let handle = device.handle();
let fp = DeviceFn::load(|name| unsafe {
core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
});
Self { handle, fp }
}
#[inline]
pub fn fp(&self) -> &DeviceFn {
&self.fp
}
#[inline]
pub fn device(&self) -> crate::vk::Device {
self.handle
}
}
#[derive(Clone)]
#[doc = "Raw VK_KHR_dynamic_rendering device-level function pointers"]
pub struct DeviceFn {
pub cmd_begin_rendering_khr: PFN_vkCmdBeginRendering,
pub cmd_end_rendering_khr: PFN_vkCmdEndRendering,
}
unsafe impl Send for DeviceFn {}
unsafe impl Sync for DeviceFn {}
impl DeviceFn {
pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
Self::load_erased(&mut f)
}
fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
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 =
CStr::from_bytes_with_nul_unchecked(b"vkCmdBeginRenderingKHR\0");
let val = _f(cname);
if val.is_null() {
cmd_begin_rendering_khr
} else {
::core::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 = CStr::from_bytes_with_nul_unchecked(b"vkCmdEndRenderingKHR\0");
let val = _f(cname);
if val.is_null() {
cmd_end_rendering_khr
} else {
::core::mem::transmute(val)
}
},
}
}
}
}
#[doc = "VK_KHR_multiview"]
pub mod multiview {
use super::super::*;
pub use {
crate::vk::KHR_MULTIVIEW_NAME as NAME,
crate::vk::KHR_MULTIVIEW_SPEC_VERSION as SPEC_VERSION,
};
}
#[doc = "VK_KHR_get_physical_device_properties2"]
pub mod get_physical_device_properties2 {
use super::super::*;
pub use {
crate::vk::KHR_GET_PHYSICAL_DEVICE_PROPERTIES2_NAME as NAME,
crate::vk::KHR_GET_PHYSICAL_DEVICE_PROPERTIES2_SPEC_VERSION as SPEC_VERSION,
};
#[doc = "VK_KHR_get_physical_device_properties2 instance-level functions"]
#[derive(Clone)]
pub struct Instance {
pub(crate) fp: InstanceFn,
pub(crate) handle: crate::vk::Instance,
}
impl Instance {
pub fn new(entry: &crate::Entry, instance: &crate::Instance) -> Self {
let handle = instance.handle();
let fp = InstanceFn::load(|name| unsafe {
core::mem::transmute(entry.get_instance_proc_addr(handle, name.as_ptr()))
});
Self { handle, fp }
}
#[inline]
pub fn fp(&self) -> &InstanceFn {
&self.fp
}
#[inline]
pub fn instance(&self) -> crate::vk::Instance {
self.handle
}
}
#[derive(Clone)]
#[doc = "Raw VK_KHR_get_physical_device_properties2 instance-level function pointers"]
pub struct InstanceFn {
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 InstanceFn {}
unsafe impl Sync for InstanceFn {}
impl InstanceFn {
pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
Self::load_erased(&mut f)
}
fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
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 = CStr::from_bytes_with_nul_unchecked(
b"vkGetPhysicalDeviceFeatures2KHR\0",
);
let val = _f(cname);
if val.is_null() {
get_physical_device_features2_khr
} else {
::core::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 = CStr::from_bytes_with_nul_unchecked(
b"vkGetPhysicalDeviceProperties2KHR\0",
);
let val = _f(cname);
if val.is_null() {
get_physical_device_properties2_khr
} else {
::core::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 = CStr::from_bytes_with_nul_unchecked(
b"vkGetPhysicalDeviceFormatProperties2KHR\0",
);
let val = _f(cname);
if val.is_null() {
get_physical_device_format_properties2_khr
} else {
::core::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 = 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 {
::core::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 = 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 {
::core::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 = CStr::from_bytes_with_nul_unchecked(
b"vkGetPhysicalDeviceMemoryProperties2KHR\0",
);
let val = _f(cname);
if val.is_null() {
get_physical_device_memory_properties2_khr
} else {
::core::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 = 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 {
::core::mem::transmute(val)
}
},
}
}
}
}
#[doc = "VK_KHR_device_group"]
pub mod device_group {
use super::super::*;
pub use {
crate::vk::KHR_DEVICE_GROUP_NAME as NAME,
crate::vk::KHR_DEVICE_GROUP_SPEC_VERSION as SPEC_VERSION,
};
#[doc = "VK_KHR_device_group instance-level functions"]
#[derive(Clone)]
pub struct Instance {
pub(crate) fp: InstanceFn,
pub(crate) handle: crate::vk::Instance,
}
impl Instance {
pub fn new(entry: &crate::Entry, instance: &crate::Instance) -> Self {
let handle = instance.handle();
let fp = InstanceFn::load(|name| unsafe {
core::mem::transmute(entry.get_instance_proc_addr(handle, name.as_ptr()))
});
Self { handle, fp }
}
#[inline]
pub fn fp(&self) -> &InstanceFn {
&self.fp
}
#[inline]
pub fn instance(&self) -> crate::vk::Instance {
self.handle
}
}
#[derive(Clone)]
#[doc = "Raw VK_KHR_device_group instance-level function pointers"]
pub struct InstanceFn {
pub get_physical_device_present_rectangles_khr:
PFN_vkGetPhysicalDevicePresentRectanglesKHR,
}
unsafe impl Send for InstanceFn {}
unsafe impl Sync for InstanceFn {}
impl InstanceFn {
pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
Self::load_erased(&mut f)
}
fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
Self {
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 = CStr::from_bytes_with_nul_unchecked(
b"vkGetPhysicalDevicePresentRectanglesKHR\0",
);
let val = _f(cname);
if val.is_null() {
get_physical_device_present_rectangles_khr
} else {
::core::mem::transmute(val)
}
},
}
}
}
#[doc = "VK_KHR_device_group device-level functions"]
#[derive(Clone)]
pub struct Device {
pub(crate) fp: DeviceFn,
pub(crate) handle: crate::vk::Device,
}
impl Device {
pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
let handle = device.handle();
let fp = DeviceFn::load(|name| unsafe {
core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
});
Self { handle, fp }
}
#[inline]
pub fn fp(&self) -> &DeviceFn {
&self.fp
}
#[inline]
pub fn device(&self) -> crate::vk::Device {
self.handle
}
}
#[derive(Clone)]
#[doc = "Raw VK_KHR_device_group device-level function pointers"]
pub struct DeviceFn {
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:
PFN_vkGetDeviceGroupPresentCapabilitiesKHR,
pub get_device_group_surface_present_modes_khr:
PFN_vkGetDeviceGroupSurfacePresentModesKHR,
pub acquire_next_image2_khr: PFN_vkAcquireNextImage2KHR,
}
unsafe impl Send for DeviceFn {}
unsafe impl Sync for DeviceFn {}
impl DeviceFn {
pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
Self::load_erased(&mut f)
}
fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
Self {
get_device_group_peer_memory_features_khr: unsafe {
unsafe extern "system" fn get_device_group_peer_memory_features_khr(
_device: crate::vk::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 = 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 {
::core::mem::transmute(val)
}
},
cmd_set_device_mask_khr: unsafe {
unsafe extern "system" fn cmd_set_device_mask_khr(
--> --------------------
--> maximum size reached
--> --------------------
[Seitenstruktur0.668Druckenetwas mehr zur Ethik2026-04-26]
|
2026-05-26
|
|
|
|
|
