From 0a378b880785c019e5acbd1a658524a50a79011f Mon Sep 17 00:00:00 2001 From: Marijn Suijten Date: Sun, 24 Jan 2021 22:13:28 +0100 Subject: [PATCH] Update Vulkan-Headers to 1.2.166 (#355) * Update Vulkan-Headers to 1.2.165 * Update Vulkan-Headers to 1.2.166 * generator: Update itertools to 0.10 --- ash/src/vk/const_debugs.rs | 16 +++ ash/src/vk/definitions.rs | 184 ++++++++++++++++++++++++- ash/src/vk/enums.rs | 27 +--- ash/src/vk/extensions.rs | 272 ++++++++++++++++++++++++++++++++++--- generator/Cargo.toml | 2 +- generator/Vulkan-Headers | 2 +- 6 files changed, 455 insertions(+), 48 deletions(-) diff --git a/ash/src/vk/const_debugs.rs b/ash/src/vk/const_debugs.rs index 6c3390f..5fa0a2d 100644 --- a/ash/src/vk/const_debugs.rs +++ b/ash/src/vk/const_debugs.rs @@ -906,6 +906,10 @@ impl fmt::Debug for DescriptorPoolCreateFlags { DescriptorPoolCreateFlags::FREE_DESCRIPTOR_SET.0, "FREE_DESCRIPTOR_SET", ), + ( + DescriptorPoolCreateFlags::HOST_ONLY_VALVE.0, + "HOST_ONLY_VALVE", + ), ( DescriptorPoolCreateFlags::UPDATE_AFTER_BIND.0, "UPDATE_AFTER_BIND", @@ -927,6 +931,10 @@ impl fmt::Debug for DescriptorSetLayoutCreateFlags { DescriptorSetLayoutCreateFlags::PUSH_DESCRIPTOR_KHR.0, "PUSH_DESCRIPTOR_KHR", ), + ( + DescriptorSetLayoutCreateFlags::HOST_ONLY_POOL_VALVE.0, + "HOST_ONLY_POOL_VALVE", + ), ( DescriptorSetLayoutCreateFlags::UPDATE_AFTER_BIND_POOL.0, "UPDATE_AFTER_BIND_POOL", @@ -952,6 +960,7 @@ impl fmt::Debug for DescriptorType { Self::INLINE_UNIFORM_BLOCK_EXT => Some("INLINE_UNIFORM_BLOCK_EXT"), Self::ACCELERATION_STRUCTURE_KHR => Some("ACCELERATION_STRUCTURE_KHR"), Self::ACCELERATION_STRUCTURE_NV => Some("ACCELERATION_STRUCTURE_NV"), + Self::MUTABLE_VALVE => Some("MUTABLE_VALVE"), _ => None, }; if let Some(x) = name { @@ -4284,6 +4293,12 @@ impl fmt::Debug for StructureType { Some("PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT") } Self::DIRECTFB_SURFACE_CREATE_INFO_EXT => Some("DIRECTFB_SURFACE_CREATE_INFO_EXT"), + Self::PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_VALVE => { + Some("PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_VALVE") + } + Self::MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_VALVE => { + Some("MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_VALVE") + } Self::PHYSICAL_DEVICE_SUBGROUP_PROPERTIES => { Some("PHYSICAL_DEVICE_SUBGROUP_PROPERTIES") } @@ -4778,6 +4793,7 @@ impl fmt::Debug for VendorId { Self::KAZAN => Some("KAZAN"), Self::CODEPLAY => Some("CODEPLAY"), Self::MESA => Some("MESA"), + Self::POCL => Some("POCL"), _ => None, }; if let Some(x) = name { diff --git a/ash/src/vk/definitions.rs b/ash/src/vk/definitions.rs index 60ccf40..5796a10 100644 --- a/ash/src/vk/definitions.rs +++ b/ash/src/vk/definitions.rs @@ -9,7 +9,7 @@ use std::os::raw::*; pub const API_VERSION_1_0: u32 = crate::vk::make_version(1, 0, 0); pub const API_VERSION_1_1: u32 = crate::vk::make_version(1, 1, 0); pub const API_VERSION_1_2: u32 = crate::vk::make_version(1, 2, 0); -pub const HEADER_VERSION: u32 = 162u32; +pub const HEADER_VERSION: u32 = 166u32; pub const HEADER_VERSION_COMPLETE: u32 = crate::vk::make_version(1, 2, HEADER_VERSION); #[doc = ""] pub type SampleMask = u32; @@ -48782,3 +48782,185 @@ impl<'a> AccelerationStructureBuildSizesInfoKHRBuilder<'a> { self.inner } } +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = ""] +pub struct PhysicalDeviceMutableDescriptorTypeFeaturesVALVE { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub mutable_descriptor_type: Bool32, +} +impl ::std::default::Default for PhysicalDeviceMutableDescriptorTypeFeaturesVALVE { + fn default() -> PhysicalDeviceMutableDescriptorTypeFeaturesVALVE { + PhysicalDeviceMutableDescriptorTypeFeaturesVALVE { + s_type: StructureType::PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_VALVE, + p_next: ::std::ptr::null_mut(), + mutable_descriptor_type: Bool32::default(), + } + } +} +impl PhysicalDeviceMutableDescriptorTypeFeaturesVALVE { + pub fn builder<'a>() -> PhysicalDeviceMutableDescriptorTypeFeaturesVALVEBuilder<'a> { + PhysicalDeviceMutableDescriptorTypeFeaturesVALVEBuilder { + inner: PhysicalDeviceMutableDescriptorTypeFeaturesVALVE::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceMutableDescriptorTypeFeaturesVALVEBuilder<'a> { + inner: PhysicalDeviceMutableDescriptorTypeFeaturesVALVE, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsDeviceCreateInfo + for PhysicalDeviceMutableDescriptorTypeFeaturesVALVEBuilder<'_> +{ +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMutableDescriptorTypeFeaturesVALVE {} +impl<'a> ::std::ops::Deref for PhysicalDeviceMutableDescriptorTypeFeaturesVALVEBuilder<'a> { + type Target = PhysicalDeviceMutableDescriptorTypeFeaturesVALVE; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceMutableDescriptorTypeFeaturesVALVEBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceMutableDescriptorTypeFeaturesVALVEBuilder<'a> { + pub fn mutable_descriptor_type( + mut self, + mutable_descriptor_type: bool, + ) -> PhysicalDeviceMutableDescriptorTypeFeaturesVALVEBuilder<'a> { + self.inner.mutable_descriptor_type = mutable_descriptor_type.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceMutableDescriptorTypeFeaturesVALVE { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = ""] +pub struct MutableDescriptorTypeListVALVE { + pub descriptor_type_count: u32, + pub p_descriptor_types: *const DescriptorType, +} +impl ::std::default::Default for MutableDescriptorTypeListVALVE { + fn default() -> MutableDescriptorTypeListVALVE { + MutableDescriptorTypeListVALVE { + descriptor_type_count: u32::default(), + p_descriptor_types: ::std::ptr::null(), + } + } +} +impl MutableDescriptorTypeListVALVE { + pub fn builder<'a>() -> MutableDescriptorTypeListVALVEBuilder<'a> { + MutableDescriptorTypeListVALVEBuilder { + inner: MutableDescriptorTypeListVALVE::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct MutableDescriptorTypeListVALVEBuilder<'a> { + inner: MutableDescriptorTypeListVALVE, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for MutableDescriptorTypeListVALVEBuilder<'a> { + type Target = MutableDescriptorTypeListVALVE; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for MutableDescriptorTypeListVALVEBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> MutableDescriptorTypeListVALVEBuilder<'a> { + pub fn descriptor_types( + mut self, + descriptor_types: &'a [DescriptorType], + ) -> MutableDescriptorTypeListVALVEBuilder<'a> { + self.inner.descriptor_type_count = descriptor_types.len() as _; + self.inner.p_descriptor_types = descriptor_types.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> MutableDescriptorTypeListVALVE { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = ""] +pub struct MutableDescriptorTypeCreateInfoVALVE { + pub s_type: StructureType, + pub p_next: *const c_void, + pub mutable_descriptor_type_list_count: u32, + pub p_mutable_descriptor_type_lists: *const MutableDescriptorTypeListVALVE, +} +impl ::std::default::Default for MutableDescriptorTypeCreateInfoVALVE { + fn default() -> MutableDescriptorTypeCreateInfoVALVE { + MutableDescriptorTypeCreateInfoVALVE { + s_type: StructureType::MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_VALVE, + p_next: ::std::ptr::null(), + mutable_descriptor_type_list_count: u32::default(), + p_mutable_descriptor_type_lists: ::std::ptr::null(), + } + } +} +impl MutableDescriptorTypeCreateInfoVALVE { + pub fn builder<'a>() -> MutableDescriptorTypeCreateInfoVALVEBuilder<'a> { + MutableDescriptorTypeCreateInfoVALVEBuilder { + inner: MutableDescriptorTypeCreateInfoVALVE::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct MutableDescriptorTypeCreateInfoVALVEBuilder<'a> { + inner: MutableDescriptorTypeCreateInfoVALVE, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsDescriptorSetLayoutCreateInfo + for MutableDescriptorTypeCreateInfoVALVEBuilder<'_> +{ +} +unsafe impl ExtendsDescriptorSetLayoutCreateInfo for MutableDescriptorTypeCreateInfoVALVE {} +unsafe impl ExtendsDescriptorPoolCreateInfo for MutableDescriptorTypeCreateInfoVALVEBuilder<'_> {} +unsafe impl ExtendsDescriptorPoolCreateInfo for MutableDescriptorTypeCreateInfoVALVE {} +impl<'a> ::std::ops::Deref for MutableDescriptorTypeCreateInfoVALVEBuilder<'a> { + type Target = MutableDescriptorTypeCreateInfoVALVE; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for MutableDescriptorTypeCreateInfoVALVEBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> MutableDescriptorTypeCreateInfoVALVEBuilder<'a> { + pub fn mutable_descriptor_type_lists( + mut self, + mutable_descriptor_type_lists: &'a [MutableDescriptorTypeListVALVE], + ) -> MutableDescriptorTypeCreateInfoVALVEBuilder<'a> { + self.inner.mutable_descriptor_type_list_count = mutable_descriptor_type_lists.len() as _; + self.inner.p_mutable_descriptor_type_lists = mutable_descriptor_type_lists.as_ptr(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> MutableDescriptorTypeCreateInfoVALVE { + self.inner + } +} diff --git a/ash/src/vk/enums.rs b/ash/src/vk/enums.rs index 33205f8..b755c25 100644 --- a/ash/src/vk/enums.rs +++ b/ash/src/vk/enums.rs @@ -1054,55 +1054,30 @@ impl ObjectType { } impl ObjectType { pub const UNKNOWN: Self = Self(0); - #[doc = "VkInstance"] pub const INSTANCE: Self = Self(1); - #[doc = "VkPhysicalDevice"] pub const PHYSICAL_DEVICE: Self = Self(2); - #[doc = "VkDevice"] pub const DEVICE: Self = Self(3); - #[doc = "VkQueue"] pub const QUEUE: Self = Self(4); - #[doc = "VkSemaphore"] pub const SEMAPHORE: Self = Self(5); - #[doc = "VkCommandBuffer"] pub const COMMAND_BUFFER: Self = Self(6); - #[doc = "VkFence"] pub const FENCE: Self = Self(7); - #[doc = "VkDeviceMemory"] pub const DEVICE_MEMORY: Self = Self(8); - #[doc = "VkBuffer"] pub const BUFFER: Self = Self(9); - #[doc = "VkImage"] pub const IMAGE: Self = Self(10); - #[doc = "VkEvent"] pub const EVENT: Self = Self(11); - #[doc = "VkQueryPool"] pub const QUERY_POOL: Self = Self(12); - #[doc = "VkBufferView"] pub const BUFFER_VIEW: Self = Self(13); - #[doc = "VkImageView"] pub const IMAGE_VIEW: Self = Self(14); - #[doc = "VkShaderModule"] pub const SHADER_MODULE: Self = Self(15); - #[doc = "VkPipelineCache"] pub const PIPELINE_CACHE: Self = Self(16); - #[doc = "VkPipelineLayout"] pub const PIPELINE_LAYOUT: Self = Self(17); - #[doc = "VkRenderPass"] pub const RENDER_PASS: Self = Self(18); - #[doc = "VkPipeline"] pub const PIPELINE: Self = Self(19); - #[doc = "VkDescriptorSetLayout"] pub const DESCRIPTOR_SET_LAYOUT: Self = Self(20); - #[doc = "VkSampler"] pub const SAMPLER: Self = Self(21); - #[doc = "VkDescriptorPool"] pub const DESCRIPTOR_POOL: Self = Self(22); - #[doc = "VkDescriptorSet"] pub const DESCRIPTOR_SET: Self = Self(23); - #[doc = "VkFramebuffer"] pub const FRAMEBUFFER: Self = Self(24); - #[doc = "VkCommandPool"] pub const COMMAND_POOL: Self = Self(25); } #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] @@ -1663,6 +1638,8 @@ impl VendorId { pub const CODEPLAY: Self = Self(0x1_0004); #[doc = "Mesa vendor ID"] pub const MESA: Self = Self(0x1_0005); + #[doc = "PoCL vendor ID"] + pub const POCL: Self = Self(0x1_0006); } #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(transparent)] diff --git a/ash/src/vk/extensions.rs b/ash/src/vk/extensions.rs index f557c64..bda258d 100644 --- a/ash/src/vk/extensions.rs +++ b/ash/src/vk/extensions.rs @@ -24251,27 +24251,101 @@ impl ArmExtension345Fn { ArmExtension345Fn {} } } -impl NvExtension346Fn { +impl NvAcquireWinrtDisplayFn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_extension_346\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_acquire_winrt_display\0") .expect("Wrong extension string") } - pub const SPEC_VERSION: u32 = 0u32; + pub const SPEC_VERSION: u32 = 1u32; } -pub struct NvExtension346Fn {} -unsafe impl Send for NvExtension346Fn {} -unsafe impl Sync for NvExtension346Fn {} -impl ::std::clone::Clone for NvExtension346Fn { +#[allow(non_camel_case_types)] +pub type PFN_vkAcquireWinrtDisplayNV = + extern "system" fn(physical_device: PhysicalDevice, display: DisplayKHR) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetWinrtDisplayNV = extern "system" fn( + physical_device: PhysicalDevice, + device_relative_id: u32, + p_display: *mut DisplayKHR, +) -> Result; +pub struct NvAcquireWinrtDisplayFn { + pub acquire_winrt_display_nv: + extern "system" fn(physical_device: PhysicalDevice, display: DisplayKHR) -> Result, + pub get_winrt_display_nv: extern "system" fn( + physical_device: PhysicalDevice, + device_relative_id: u32, + p_display: *mut DisplayKHR, + ) -> Result, +} +unsafe impl Send for NvAcquireWinrtDisplayFn {} +unsafe impl Sync for NvAcquireWinrtDisplayFn {} +impl ::std::clone::Clone for NvAcquireWinrtDisplayFn { fn clone(&self) -> Self { - NvExtension346Fn {} + NvAcquireWinrtDisplayFn { + acquire_winrt_display_nv: self.acquire_winrt_display_nv, + get_winrt_display_nv: self.get_winrt_display_nv, + } } } -impl NvExtension346Fn { +impl NvAcquireWinrtDisplayFn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - NvExtension346Fn {} + NvAcquireWinrtDisplayFn { + acquire_winrt_display_nv: unsafe { + extern "system" fn acquire_winrt_display_nv( + _physical_device: PhysicalDevice, + _display: DisplayKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(acquire_winrt_display_nv) + )) + } + let raw_name = stringify!(vkAcquireWinrtDisplayNV); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + acquire_winrt_display_nv + } else { + ::std::mem::transmute(val) + } + }, + get_winrt_display_nv: unsafe { + extern "system" fn get_winrt_display_nv( + _physical_device: PhysicalDevice, + _device_relative_id: u32, + _p_display: *mut DisplayKHR, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(get_winrt_display_nv))) + } + let raw_name = stringify!(vkGetWinrtDisplayNV); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + get_winrt_display_nv + } else { + ::std::mem::transmute(val) + } + }, + } + } + #[doc = ""] + pub unsafe fn acquire_winrt_display_nv( + &self, + physical_device: PhysicalDevice, + display: DisplayKHR, + ) -> Result { + (self.acquire_winrt_display_nv)(physical_device, display) + } + #[doc = ""] + pub unsafe fn get_winrt_display_nv( + &self, + physical_device: PhysicalDevice, + device_relative_id: u32, + p_display: *mut DisplayKHR, + ) -> Result { + (self.get_winrt_display_nv)(physical_device, device_relative_id, p_display) } } impl ExtDirectfbSurfaceFn { @@ -24445,29 +24519,49 @@ impl NvExtension351Fn { NvExtension351Fn {} } } -impl ExtExtension352Fn { +impl ValveMutableDescriptorTypeFn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_extension_352\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_VALVE_mutable_descriptor_type\0") .expect("Wrong extension string") } - pub const SPEC_VERSION: u32 = 0u32; + pub const SPEC_VERSION: u32 = 1u32; } -pub struct ExtExtension352Fn {} -unsafe impl Send for ExtExtension352Fn {} -unsafe impl Sync for ExtExtension352Fn {} -impl ::std::clone::Clone for ExtExtension352Fn { +pub struct ValveMutableDescriptorTypeFn {} +unsafe impl Send for ValveMutableDescriptorTypeFn {} +unsafe impl Sync for ValveMutableDescriptorTypeFn {} +impl ::std::clone::Clone for ValveMutableDescriptorTypeFn { fn clone(&self) -> Self { - ExtExtension352Fn {} + ValveMutableDescriptorTypeFn {} } } -impl ExtExtension352Fn { +impl ValveMutableDescriptorTypeFn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - ExtExtension352Fn {} + ValveMutableDescriptorTypeFn {} } } +#[doc = "Generated from 'VK_VALVE_mutable_descriptor_type'"] +impl StructureType { + pub const PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_VALVE: Self = Self(1_000_351_000); +} +#[doc = "Generated from 'VK_VALVE_mutable_descriptor_type'"] +impl StructureType { + pub const MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_VALVE: Self = Self(1_000_351_002); +} +#[doc = "Generated from 'VK_VALVE_mutable_descriptor_type'"] +impl DescriptorType { + pub const MUTABLE_VALVE: Self = Self(1_000_351_000); +} +#[doc = "Generated from 'VK_VALVE_mutable_descriptor_type'"] +impl DescriptorPoolCreateFlags { + pub const HOST_ONLY_VALVE: Self = Self(0b100); +} +#[doc = "Generated from 'VK_VALVE_mutable_descriptor_type'"] +impl DescriptorSetLayoutCreateFlags { + pub const HOST_ONLY_POOL_VALVE: Self = Self(0b100); +} impl ExtExtension353Fn { pub fn name() -> &'static ::std::ffi::CStr { ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_extension_353\0") @@ -24936,3 +25030,141 @@ impl BufferCreateFlags { impl ImageCreateFlags { pub const RESERVED_15_NV: Self = Self(0b1000_0000_0000_0000); } +impl NvExtension373Fn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_extension_373\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 0u32; +} +pub struct NvExtension373Fn {} +unsafe impl Send for NvExtension373Fn {} +unsafe impl Sync for NvExtension373Fn {} +impl ::std::clone::Clone for NvExtension373Fn { + fn clone(&self) -> Self { + NvExtension373Fn {} + } +} +impl NvExtension373Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + NvExtension373Fn {} + } +} +impl NvExtension374Fn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_extension_374\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 0u32; +} +pub struct NvExtension374Fn {} +unsafe impl Send for NvExtension374Fn {} +unsafe impl Sync for NvExtension374Fn {} +impl ::std::clone::Clone for NvExtension374Fn { + fn clone(&self) -> Self { + NvExtension374Fn {} + } +} +impl NvExtension374Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + NvExtension374Fn {} + } +} +impl NvExtension375Fn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_extension_375\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 0u32; +} +pub struct NvExtension375Fn {} +unsafe impl Send for NvExtension375Fn {} +unsafe impl Sync for NvExtension375Fn {} +impl ::std::clone::Clone for NvExtension375Fn { + fn clone(&self) -> Self { + NvExtension375Fn {} + } +} +impl NvExtension375Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + NvExtension375Fn {} + } +} +impl ExtExtension376Fn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_extension_376\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 0u32; +} +pub struct ExtExtension376Fn {} +unsafe impl Send for ExtExtension376Fn {} +unsafe impl Sync for ExtExtension376Fn {} +impl ::std::clone::Clone for ExtExtension376Fn { + fn clone(&self) -> Self { + ExtExtension376Fn {} + } +} +impl ExtExtension376Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + ExtExtension376Fn {} + } +} +impl ExtExtension377Fn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_extension_377\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 0u32; +} +pub struct ExtExtension377Fn {} +unsafe impl Send for ExtExtension377Fn {} +unsafe impl Sync for ExtExtension377Fn {} +impl ::std::clone::Clone for ExtExtension377Fn { + fn clone(&self) -> Self { + ExtExtension377Fn {} + } +} +impl ExtExtension377Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + ExtExtension377Fn {} + } +} +impl NvExtension378Fn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_extension_378\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 0u32; +} +pub struct NvExtension378Fn {} +unsafe impl Send for NvExtension378Fn {} +unsafe impl Sync for NvExtension378Fn {} +impl ::std::clone::Clone for NvExtension378Fn { + fn clone(&self) -> Self { + NvExtension378Fn {} + } +} +impl NvExtension378Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + NvExtension378Fn {} + } +} diff --git a/generator/Cargo.toml b/generator/Cargo.toml index 5bf6d73..f19295a 100644 --- a/generator/Cargo.toml +++ b/generator/Cargo.toml @@ -10,7 +10,7 @@ vkxml = "0.3" nom = "6.0" heck = "0.3" proc-macro2 = "1.0" -itertools = "0.9" +itertools = "0.10" quote = "1.0" [dependencies.syn] diff --git a/generator/Vulkan-Headers b/generator/Vulkan-Headers index d230818..9efc4a6 160000 --- a/generator/Vulkan-Headers +++ b/generator/Vulkan-Headers @@ -1 +1 @@ -Subproject commit d2308183f2846a1453ce7ae8c77ea7b5a7424ad2 +Subproject commit 9efc4a631161eeea11082bbd16d605cca0b7a01e