alex/ash
1
0
Fork 0
Code Issues Pull requests Packages Projects Releases Wiki Activity

Update Vulkan-Headers to 1.2.185 (#456)

Browse source 
* Update Vulkan-Headers to 1.2.185

* Update Vulkan-Headers to 1.2.186
This commit is contained in:
Marijn Suijten 2021-07-28 13:07:53 +02:00 committed by GitHub
parent ed351996e5
commit c091482389
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
4 changed files with 583 additions and 48 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

28
ash/src/vk/const_debugs.rs
View file

@ -321,7 +321,10 @@ impl fmt::Debug for AccessFlags2KHR {
AccessFlags2KHR::COLOR_ATTACHMENT_READ_NONCOHERENT_EXT.0,
"COLOR_ATTACHMENT_READ_NONCOHERENT_EXT",
),
(AccessFlags2KHR::RESERVED_39_HUAWEI.0, "RESERVED_39_HUAWEI"),
(
AccessFlags2KHR::INVOCATION_MASK_READ_HUAWEI.0,
"INVOCATION_MASK_READ_HUAWEI",
),
];
debug_flags(f, KNOWN, self.0)
}
@ -2251,7 +2254,11 @@ impl fmt::Debug for ImageUsageFlags {
ImageUsageFlags::VIDEO_ENCODE_DPB_KHR.0,
"VIDEO_ENCODE_DPB_KHR",
),
(ImageUsageFlags::RESERVED_18_HUAWEI.0, "RESERVED_18_HUAWEI"),
(ImageUsageFlags::RESERVED_19_EXT.0, "RESERVED_19_EXT"),
(
ImageUsageFlags::INVOCATION_MASK_HUAWEI.0,
"INVOCATION_MASK_HUAWEI",
),
];
debug_flags(f, KNOWN, self.0)
}
@ -3134,8 +3141,8 @@ impl fmt::Debug for PipelineStageFlags2KHR {
"SUBPASS_SHADING_HUAWEI",
),
(
PipelineStageFlags2KHR::RESERVED_40_HUAWEI.0,
"RESERVED_40_HUAWEI",
PipelineStageFlags2KHR::INVOCATION_MASK_HUAWEI.0,
"INVOCATION_MASK_HUAWEI",
),
];
debug_flags(f, KNOWN, self.0)
@ -4573,6 +4580,9 @@ impl fmt::Debug for StructureType {
Some("PHYSICAL_DEVICE_TOOL_PROPERTIES_EXT")
}
Self::VALIDATION_FEATURES_EXT => Some("VALIDATION_FEATURES_EXT"),
Self::PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR => {
Some("PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR")
}
Self::PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV => {
Some("PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV")
}
@ -4642,6 +4652,9 @@ impl fmt::Debug for StructureType {
Self::PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR => {
Some("PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR")
}
Self::PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT => {
Some("PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT")
}
Self::PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT => {
Some("PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT")
}
@ -4708,6 +4721,10 @@ impl fmt::Debug for StructureType {
Some("PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT")
}
Self::PIPELINE_LIBRARY_CREATE_INFO_KHR => Some("PIPELINE_LIBRARY_CREATE_INFO_KHR"),
Self::PRESENT_ID_KHR => Some("PRESENT_ID_KHR"),
Self::PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR => {
Some("PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR")
}
Self::PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES_EXT => {
Some("PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES_EXT")
}
@ -4836,6 +4853,9 @@ impl fmt::Debug for StructureType {
Self::PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI => {
Some("PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI")
}
Self::PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI => {
Some("PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI")
}
Self::MEMORY_GET_REMOTE_ADDRESS_INFO_NV => Some("MEMORY_GET_REMOTE_ADDRESS_INFO_NV"),
Self::PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV => {
Some("PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV")

396
ash/src/vk/definitions.rs
View file

@ -53,7 +53,7 @@ pub const API_VERSION_1_0: u32 = make_api_version(0, 1, 0, 0);
pub const API_VERSION_1_1: u32 = make_api_version(0, 1, 1, 0);
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_API_VERSION_1_2.html>"]
pub const API_VERSION_1_2: u32 = make_api_version(0, 1, 2, 0);
pub const HEADER_VERSION: u32 = 184u32;
pub const HEADER_VERSION: u32 = 186u32;
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_HEADER_VERSION_COMPLETE.html>"]
pub const HEADER_VERSION_COMPLETE: u32 = make_api_version(0, 1, 2, HEADER_VERSION);
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSampleMask.html>"]
@ -18771,6 +18771,178 @@ impl<'a> XYColorEXTBuilder<'a> {
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDevicePresentIdFeaturesKHR.html>"]
pub struct PhysicalDevicePresentIdFeaturesKHR {
pub s_type: StructureType,
pub p_next: *mut c_void,
pub present_id: Bool32,
}
impl ::std::default::Default for PhysicalDevicePresentIdFeaturesKHR {
fn default() -> PhysicalDevicePresentIdFeaturesKHR {
PhysicalDevicePresentIdFeaturesKHR {
s_type: StructureType::PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR,
p_next: ::std::ptr::null_mut(),
present_id: Bool32::default(),
}
}
}
impl PhysicalDevicePresentIdFeaturesKHR {
pub fn builder<'a>() -> PhysicalDevicePresentIdFeaturesKHRBuilder<'a> {
PhysicalDevicePresentIdFeaturesKHRBuilder {
inner: PhysicalDevicePresentIdFeaturesKHR::default(),
marker: ::std::marker::PhantomData,
}
}
}
#[repr(transparent)]
pub struct PhysicalDevicePresentIdFeaturesKHRBuilder<'a> {
inner: PhysicalDevicePresentIdFeaturesKHR,
marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePresentIdFeaturesKHRBuilder<'_> {}
unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePresentIdFeaturesKHR {}
unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePresentIdFeaturesKHRBuilder<'_> {}
unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePresentIdFeaturesKHR {}
impl<'a> ::std::ops::Deref for PhysicalDevicePresentIdFeaturesKHRBuilder<'a> {
type Target = PhysicalDevicePresentIdFeaturesKHR;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> ::std::ops::DerefMut for PhysicalDevicePresentIdFeaturesKHRBuilder<'a> {
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.inner
}
}
impl<'a> PhysicalDevicePresentIdFeaturesKHRBuilder<'a> {
pub fn present_id(mut self, present_id: bool) -> Self {
self.inner.present_id = present_id.into();
self
}
#[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
#[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
#[doc = r" so references to builders can be passed directly to Vulkan functions."]
pub fn build(self) -> PhysicalDevicePresentIdFeaturesKHR {
self.inner
}
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPresentIdKHR.html>"]
pub struct PresentIdKHR {
pub s_type: StructureType,
pub p_next: *const c_void,
pub swapchain_count: u32,
pub p_present_ids: *const u64,
}
impl ::std::default::Default for PresentIdKHR {
fn default() -> PresentIdKHR {
PresentIdKHR {
s_type: StructureType::PRESENT_ID_KHR,
p_next: ::std::ptr::null(),
swapchain_count: u32::default(),
p_present_ids: ::std::ptr::null(),
}
}
}
impl PresentIdKHR {
pub fn builder<'a>() -> PresentIdKHRBuilder<'a> {
PresentIdKHRBuilder {
inner: PresentIdKHR::default(),
marker: ::std::marker::PhantomData,
}
}
}
#[repr(transparent)]
pub struct PresentIdKHRBuilder<'a> {
inner: PresentIdKHR,
marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsPresentInfoKHR for PresentIdKHRBuilder<'_> {}
unsafe impl ExtendsPresentInfoKHR for PresentIdKHR {}
impl<'a> ::std::ops::Deref for PresentIdKHRBuilder<'a> {
type Target = PresentIdKHR;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> ::std::ops::DerefMut for PresentIdKHRBuilder<'a> {
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.inner
}
}
impl<'a> PresentIdKHRBuilder<'a> {
pub fn present_ids(mut self, present_ids: &'a [u64]) -> Self {
self.inner.swapchain_count = present_ids.len() as _;
self.inner.p_present_ids = present_ids.as_ptr();
self
}
#[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
#[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
#[doc = r" so references to builders can be passed directly to Vulkan functions."]
pub fn build(self) -> PresentIdKHR {
self.inner
}
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDevicePresentWaitFeaturesKHR.html>"]
pub struct PhysicalDevicePresentWaitFeaturesKHR {
pub s_type: StructureType,
pub p_next: *mut c_void,
pub present_wait: Bool32,
}
impl ::std::default::Default for PhysicalDevicePresentWaitFeaturesKHR {
fn default() -> PhysicalDevicePresentWaitFeaturesKHR {
PhysicalDevicePresentWaitFeaturesKHR {
s_type: StructureType::PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR,
p_next: ::std::ptr::null_mut(),
present_wait: Bool32::default(),
}
}
}
impl PhysicalDevicePresentWaitFeaturesKHR {
pub fn builder<'a>() -> PhysicalDevicePresentWaitFeaturesKHRBuilder<'a> {
PhysicalDevicePresentWaitFeaturesKHRBuilder {
inner: PhysicalDevicePresentWaitFeaturesKHR::default(),
marker: ::std::marker::PhantomData,
}
}
}
#[repr(transparent)]
pub struct PhysicalDevicePresentWaitFeaturesKHRBuilder<'a> {
inner: PhysicalDevicePresentWaitFeaturesKHR,
marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePresentWaitFeaturesKHRBuilder<'_> {}
unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePresentWaitFeaturesKHR {}
unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePresentWaitFeaturesKHRBuilder<'_> {}
unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePresentWaitFeaturesKHR {}
impl<'a> ::std::ops::Deref for PhysicalDevicePresentWaitFeaturesKHRBuilder<'a> {
type Target = PhysicalDevicePresentWaitFeaturesKHR;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> ::std::ops::DerefMut for PhysicalDevicePresentWaitFeaturesKHRBuilder<'a> {
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.inner
}
}
impl<'a> PhysicalDevicePresentWaitFeaturesKHRBuilder<'a> {
pub fn present_wait(mut self, present_wait: bool) -> Self {
self.inner.present_wait = present_wait.into();
self
}
#[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
#[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
#[doc = r" so references to builders can be passed directly to Vulkan functions."]
pub fn build(self) -> PhysicalDevicePresentWaitFeaturesKHR {
self.inner
}
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkHdrMetadataEXT.html>"]
pub struct HdrMetadataEXT {
pub s_type: StructureType,
@ -28772,6 +28944,168 @@ impl<'a> PhysicalDeviceShaderAtomicFloatFeaturesEXTBuilder<'a> {
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT.html>"]
pub struct PhysicalDeviceShaderAtomicFloat2FeaturesEXT {
pub s_type: StructureType,
pub p_next: *mut c_void,
pub shader_buffer_float16_atomics: Bool32,
pub shader_buffer_float16_atomic_add: Bool32,
pub shader_buffer_float16_atomic_min_max: Bool32,
pub shader_buffer_float32_atomic_min_max: Bool32,
pub shader_buffer_float64_atomic_min_max: Bool32,
pub shader_shared_float16_atomics: Bool32,
pub shader_shared_float16_atomic_add: Bool32,
pub shader_shared_float16_atomic_min_max: Bool32,
pub shader_shared_float32_atomic_min_max: Bool32,
pub shader_shared_float64_atomic_min_max: Bool32,
pub shader_image_float32_atomic_min_max: Bool32,
pub sparse_image_float32_atomic_min_max: Bool32,
}
impl ::std::default::Default for PhysicalDeviceShaderAtomicFloat2FeaturesEXT {
fn default() -> PhysicalDeviceShaderAtomicFloat2FeaturesEXT {
PhysicalDeviceShaderAtomicFloat2FeaturesEXT {
s_type: StructureType::PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT,
p_next: ::std::ptr::null_mut(),
shader_buffer_float16_atomics: Bool32::default(),
shader_buffer_float16_atomic_add: Bool32::default(),
shader_buffer_float16_atomic_min_max: Bool32::default(),
shader_buffer_float32_atomic_min_max: Bool32::default(),
shader_buffer_float64_atomic_min_max: Bool32::default(),
shader_shared_float16_atomics: Bool32::default(),
shader_shared_float16_atomic_add: Bool32::default(),
shader_shared_float16_atomic_min_max: Bool32::default(),
shader_shared_float32_atomic_min_max: Bool32::default(),
shader_shared_float64_atomic_min_max: Bool32::default(),
shader_image_float32_atomic_min_max: Bool32::default(),
sparse_image_float32_atomic_min_max: Bool32::default(),
}
}
}
impl PhysicalDeviceShaderAtomicFloat2FeaturesEXT {
pub fn builder<'a>() -> PhysicalDeviceShaderAtomicFloat2FeaturesEXTBuilder<'a> {
PhysicalDeviceShaderAtomicFloat2FeaturesEXTBuilder {
inner: PhysicalDeviceShaderAtomicFloat2FeaturesEXT::default(),
marker: ::std::marker::PhantomData,
}
}
}
#[repr(transparent)]
pub struct PhysicalDeviceShaderAtomicFloat2FeaturesEXTBuilder<'a> {
inner: PhysicalDeviceShaderAtomicFloat2FeaturesEXT,
marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsPhysicalDeviceFeatures2
for PhysicalDeviceShaderAtomicFloat2FeaturesEXTBuilder<'_>
{
}
unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderAtomicFloat2FeaturesEXT {}
unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderAtomicFloat2FeaturesEXTBuilder<'_> {}
unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderAtomicFloat2FeaturesEXT {}
impl<'a> ::std::ops::Deref for PhysicalDeviceShaderAtomicFloat2FeaturesEXTBuilder<'a> {
type Target = PhysicalDeviceShaderAtomicFloat2FeaturesEXT;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderAtomicFloat2FeaturesEXTBuilder<'a> {
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.inner
}
}
impl<'a> PhysicalDeviceShaderAtomicFloat2FeaturesEXTBuilder<'a> {
pub fn shader_buffer_float16_atomics(mut self, shader_buffer_float16_atomics: bool) -> Self {
self.inner.shader_buffer_float16_atomics = shader_buffer_float16_atomics.into();
self
}
pub fn shader_buffer_float16_atomic_add(
mut self,
shader_buffer_float16_atomic_add: bool,
) -> Self {
self.inner.shader_buffer_float16_atomic_add = shader_buffer_float16_atomic_add.into();
self
}
pub fn shader_buffer_float16_atomic_min_max(
mut self,
shader_buffer_float16_atomic_min_max: bool,
) -> Self {
self.inner.shader_buffer_float16_atomic_min_max =
shader_buffer_float16_atomic_min_max.into();
self
}
pub fn shader_buffer_float32_atomic_min_max(
mut self,
shader_buffer_float32_atomic_min_max: bool,
) -> Self {
self.inner.shader_buffer_float32_atomic_min_max =
shader_buffer_float32_atomic_min_max.into();
self
}
pub fn shader_buffer_float64_atomic_min_max(
mut self,
shader_buffer_float64_atomic_min_max: bool,
) -> Self {
self.inner.shader_buffer_float64_atomic_min_max =
shader_buffer_float64_atomic_min_max.into();
self
}
pub fn shader_shared_float16_atomics(mut self, shader_shared_float16_atomics: bool) -> Self {
self.inner.shader_shared_float16_atomics = shader_shared_float16_atomics.into();
self
}
pub fn shader_shared_float16_atomic_add(
mut self,
shader_shared_float16_atomic_add: bool,
) -> Self {
self.inner.shader_shared_float16_atomic_add = shader_shared_float16_atomic_add.into();
self
}
pub fn shader_shared_float16_atomic_min_max(
mut self,
shader_shared_float16_atomic_min_max: bool,
) -> Self {
self.inner.shader_shared_float16_atomic_min_max =
shader_shared_float16_atomic_min_max.into();
self
}
pub fn shader_shared_float32_atomic_min_max(
mut self,
shader_shared_float32_atomic_min_max: bool,
) -> Self {
self.inner.shader_shared_float32_atomic_min_max =
shader_shared_float32_atomic_min_max.into();
self
}
pub fn shader_shared_float64_atomic_min_max(
mut self,
shader_shared_float64_atomic_min_max: bool,
) -> Self {
self.inner.shader_shared_float64_atomic_min_max =
shader_shared_float64_atomic_min_max.into();
self
}
pub fn shader_image_float32_atomic_min_max(
mut self,
shader_image_float32_atomic_min_max: bool,
) -> Self {
self.inner.shader_image_float32_atomic_min_max = shader_image_float32_atomic_min_max.into();
self
}
pub fn sparse_image_float32_atomic_min_max(
mut self,
sparse_image_float32_atomic_min_max: bool,
) -> Self {
self.inner.sparse_image_float32_atomic_min_max = sparse_image_float32_atomic_min_max.into();
self
}
#[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
#[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
#[doc = r" so references to builders can be passed directly to Vulkan functions."]
pub fn build(self) -> PhysicalDeviceShaderAtomicFloat2FeaturesEXT {
self.inner
}
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT.html>"]
pub struct PhysicalDeviceVertexAttributeDivisorFeaturesEXT {
pub s_type: StructureType,
@ -30332,6 +30666,66 @@ impl<'a> PhysicalDeviceShadingRateImagePropertiesNVBuilder<'a> {
}
}
#[repr(C)]
#[derive(Copy, Clone, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceInvocationMaskFeaturesHUAWEI.html>"]
pub struct PhysicalDeviceInvocationMaskFeaturesHUAWEI {
pub s_type: StructureType,
pub p_next: *mut c_void,
pub invocation_mask: Bool32,
}
impl ::std::default::Default for PhysicalDeviceInvocationMaskFeaturesHUAWEI {
fn default() -> PhysicalDeviceInvocationMaskFeaturesHUAWEI {
PhysicalDeviceInvocationMaskFeaturesHUAWEI {
s_type: StructureType::PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI,
p_next: ::std::ptr::null_mut(),
invocation_mask: Bool32::default(),
}
}
}
impl PhysicalDeviceInvocationMaskFeaturesHUAWEI {
pub fn builder<'a>() -> PhysicalDeviceInvocationMaskFeaturesHUAWEIBuilder<'a> {
PhysicalDeviceInvocationMaskFeaturesHUAWEIBuilder {
inner: PhysicalDeviceInvocationMaskFeaturesHUAWEI::default(),
marker: ::std::marker::PhantomData,
}
}
}
#[repr(transparent)]
pub struct PhysicalDeviceInvocationMaskFeaturesHUAWEIBuilder<'a> {
inner: PhysicalDeviceInvocationMaskFeaturesHUAWEI,
marker: ::std::marker::PhantomData<&'a ()>,
}
unsafe impl ExtendsPhysicalDeviceFeatures2
for PhysicalDeviceInvocationMaskFeaturesHUAWEIBuilder<'_>
{
}
unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceInvocationMaskFeaturesHUAWEI {}
unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceInvocationMaskFeaturesHUAWEIBuilder<'_> {}
unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceInvocationMaskFeaturesHUAWEI {}
impl<'a> ::std::ops::Deref for PhysicalDeviceInvocationMaskFeaturesHUAWEIBuilder<'a> {
type Target = PhysicalDeviceInvocationMaskFeaturesHUAWEI;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> ::std::ops::DerefMut for PhysicalDeviceInvocationMaskFeaturesHUAWEIBuilder<'a> {
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.inner
}
}
impl<'a> PhysicalDeviceInvocationMaskFeaturesHUAWEIBuilder<'a> {
pub fn invocation_mask(mut self, invocation_mask: bool) -> Self {
self.inner.invocation_mask = invocation_mask.into();
self
}
#[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
#[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
#[doc = r" so references to builders can be passed directly to Vulkan functions."]
pub fn build(self) -> PhysicalDeviceInvocationMaskFeaturesHUAWEI {
self.inner
}
}
#[repr(C)]
#[derive(Copy, Clone, Default, Debug)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkCoarseSampleLocationNV.html>"]
pub struct CoarseSampleLocationNV {

205
ash/src/vk/extensions.rs
View file

@ -17996,24 +17996,66 @@ impl ExtValidationFeaturesFn {
impl StructureType {
pub const VALIDATION_FEATURES_EXT: Self = Self(1_000_247_000);
}
impl KhrExtension249Fn {
impl KhrPresentWaitFn {
pub fn name() -> &'static ::std::ffi::CStr {
::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_extension_249\0")
::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_present_wait\0")
.expect("Wrong extension string")
}
pub const SPEC_VERSION: u32 = 0u32;
pub const SPEC_VERSION: u32 = 1u32;
}
#[allow(non_camel_case_types)]
pub type PFN_vkWaitForPresentKHR = unsafe extern "system" fn(
device: Device,
swapchain: SwapchainKHR,
present_id: u64,
timeout: u64,
) -> Result;
#[derive(Clone)]
pub struct KhrExtension249Fn {}
unsafe impl Send for KhrExtension249Fn {}
unsafe impl Sync for KhrExtension249Fn {}
impl KhrExtension249Fn {
pub struct KhrPresentWaitFn {
pub wait_for_present_khr: PFN_vkWaitForPresentKHR,
}
unsafe impl Send for KhrPresentWaitFn {}
unsafe impl Sync for KhrPresentWaitFn {}
impl KhrPresentWaitFn {
pub fn load<F>(mut _f: F) -> Self
where
F: FnMut(&::std::ffi::CStr) -> *const c_void,
{
KhrExtension249Fn {}
KhrPresentWaitFn {
wait_for_present_khr: unsafe {
unsafe extern "system" fn wait_for_present_khr(
_device: Device,
_swapchain: SwapchainKHR,
_present_id: u64,
_timeout: u64,
) -> Result {
panic!(concat!("Unable to load ", stringify!(wait_for_present_khr)))
}
let cname =
::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkWaitForPresentKHR\0");
let val = _f(cname);
if val.is_null() {
wait_for_present_khr
} else {
::std::mem::transmute(val)
}
},
}
}
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkWaitForPresentKHR.html>"]
pub unsafe fn wait_for_present_khr(
&self,
device: Device,
swapchain: SwapchainKHR,
present_id: u64,
timeout: u64,
) -> Result {
(self.wait_for_present_khr)(device, swapchain, present_id, timeout)
}
}
#[doc = "Generated from 'VK_KHR_present_wait'"]
impl StructureType {
pub const PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR: Self = Self(1_000_248_000);
}
impl NvCooperativeMatrixFn {
pub fn name() -> &'static ::std::ffi::CStr {
@ -19929,25 +19971,29 @@ impl IntelExtension273Fn {
IntelExtension273Fn {}
}
}
impl IntelExtension274Fn {
impl ExtShaderAtomicFloat2Fn {
pub fn name() -> &'static ::std::ffi::CStr {
::std::ffi::CStr::from_bytes_with_nul(b"VK_INTEL_extension_274\0")
::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_shader_atomic_float2\0")
.expect("Wrong extension string")
}
pub const SPEC_VERSION: u32 = 0u32;
pub const SPEC_VERSION: u32 = 1u32;
}
#[derive(Clone)]
pub struct IntelExtension274Fn {}
unsafe impl Send for IntelExtension274Fn {}
unsafe impl Sync for IntelExtension274Fn {}
impl IntelExtension274Fn {
pub struct ExtShaderAtomicFloat2Fn {}
unsafe impl Send for ExtShaderAtomicFloat2Fn {}
unsafe impl Sync for ExtShaderAtomicFloat2Fn {}
impl ExtShaderAtomicFloat2Fn {
pub fn load<F>(mut _f: F) -> Self
where
F: FnMut(&::std::ffi::CStr) -> *const c_void,
{
IntelExtension274Fn {}
ExtShaderAtomicFloat2Fn {}
}
}
#[doc = "Generated from 'VK_EXT_shader_atomic_float2'"]
impl StructureType {
pub const PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT: Self = Self(1_000_273_000);
}
impl KhrExtension275Fn {
pub fn name() -> &'static ::std::ffi::CStr {
::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_extension_275\0")
@ -20898,25 +20944,33 @@ impl KhrShaderNonSemanticInfoFn {
KhrShaderNonSemanticInfoFn {}
}
}
impl KhrExtension295Fn {
impl KhrPresentIdFn {
pub fn name() -> &'static ::std::ffi::CStr {
::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_extension_295\0")
::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_present_id\0")
.expect("Wrong extension string")
}
pub const SPEC_VERSION: u32 = 0u32;
pub const SPEC_VERSION: u32 = 1u32;
}
#[derive(Clone)]
pub struct KhrExtension295Fn {}
unsafe impl Send for KhrExtension295Fn {}
unsafe impl Sync for KhrExtension295Fn {}
impl KhrExtension295Fn {
pub struct KhrPresentIdFn {}
unsafe impl Send for KhrPresentIdFn {}
unsafe impl Sync for KhrPresentIdFn {}
impl KhrPresentIdFn {
pub fn load<F>(mut _f: F) -> Self
where
F: FnMut(&::std::ffi::CStr) -> *const c_void,
{
KhrExtension295Fn {}
KhrPresentIdFn {}
}
}
#[doc = "Generated from 'VK_KHR_present_id'"]
impl StructureType {
pub const PRESENT_ID_KHR: Self = Self(1_000_294_000);
}
#[doc = "Generated from 'VK_KHR_present_id'"]
impl StructureType {
pub const PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR: Self = Self(1_000_294_001);
}
impl ExtPrivateDataFn {
pub fn name() -> &'static ::std::ffi::CStr {
::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_private_data\0")
@ -22946,6 +23000,10 @@ impl ExtExtension340Fn {
ExtExtension340Fn {}
}
}
#[doc = "Generated from 'VK_EXT_extension_340'"]
impl ImageUsageFlags {
pub const RESERVED_19_EXT: Self = Self(0b1000_0000_0000_0000_0000);
}
impl Ext4444FormatsFn {
pub fn name() -> &'static ::std::ffi::CStr {
::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_4444_formats\0")
@ -24018,36 +24076,80 @@ impl PipelineStageFlags2KHR {
impl ShaderStageFlags {
pub const SUBPASS_SHADING_HUAWEI: Self = Self(0b100_0000_0000_0000);
}
impl HuaweiExtension371Fn {
impl HuaweiInvocationMaskFn {
pub fn name() -> &'static ::std::ffi::CStr {
::std::ffi::CStr::from_bytes_with_nul(b"VK_HUAWEI_extension_371\0")
::std::ffi::CStr::from_bytes_with_nul(b"VK_HUAWEI_invocation_mask\0")
.expect("Wrong extension string")
}
pub const SPEC_VERSION: u32 = 0u32;
pub const SPEC_VERSION: u32 = 1u32;
}
#[allow(non_camel_case_types)]
pub type PFN_vkCmdBindInvocationMaskHUAWEI = unsafe extern "system" fn(
command_buffer: CommandBuffer,
image_view: ImageView,
image_layout: ImageLayout,
);
#[derive(Clone)]
pub struct HuaweiExtension371Fn {}
unsafe impl Send for HuaweiExtension371Fn {}
unsafe impl Sync for HuaweiExtension371Fn {}
impl HuaweiExtension371Fn {
pub struct HuaweiInvocationMaskFn {
pub cmd_bind_invocation_mask_huawei: PFN_vkCmdBindInvocationMaskHUAWEI,
}
unsafe impl Send for HuaweiInvocationMaskFn {}
unsafe impl Sync for HuaweiInvocationMaskFn {}
impl HuaweiInvocationMaskFn {
pub fn load<F>(mut _f: F) -> Self
where
F: FnMut(&::std::ffi::CStr) -> *const c_void,
{
HuaweiExtension371Fn {}
HuaweiInvocationMaskFn {
cmd_bind_invocation_mask_huawei: unsafe {
unsafe extern "system" fn cmd_bind_invocation_mask_huawei(
_command_buffer: CommandBuffer,
_image_view: ImageView,
_image_layout: ImageLayout,
) {
panic!(concat!(
"Unable to load ",
stringify!(cmd_bind_invocation_mask_huawei)
))
}
let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
b"vkCmdBindInvocationMaskHUAWEI\0",
);
let val = _f(cname);
if val.is_null() {
cmd_bind_invocation_mask_huawei
} else {
::std::mem::transmute(val)
}
},
}
}
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdBindInvocationMaskHUAWEI.html>"]
pub unsafe fn cmd_bind_invocation_mask_huawei(
&self,
command_buffer: CommandBuffer,
image_view: ImageView,
image_layout: ImageLayout,
) {
(self.cmd_bind_invocation_mask_huawei)(command_buffer, image_view, image_layout)
}
}
#[doc = "Generated from 'VK_HUAWEI_extension_371'"]
#[doc = "Generated from 'VK_HUAWEI_invocation_mask'"]
impl StructureType {
pub const PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI: Self = Self(1_000_370_000);
}
#[doc = "Generated from 'VK_HUAWEI_invocation_mask'"]
impl AccessFlags2KHR {
pub const RESERVED_39_HUAWEI: Self = Self(0b1000_0000_0000_0000_0000_0000_0000_0000_0000_0000);
pub const INVOCATION_MASK_READ_HUAWEI: Self =
Self(0b1000_0000_0000_0000_0000_0000_0000_0000_0000_0000);
}
#[doc = "Generated from 'VK_HUAWEI_extension_371'"]
#[doc = "Generated from 'VK_HUAWEI_invocation_mask'"]
impl ImageUsageFlags {
pub const RESERVED_18_HUAWEI: Self = Self(0b100_0000_0000_0000_0000);
pub const INVOCATION_MASK_HUAWEI: Self = Self(0b100_0000_0000_0000_0000);
}
#[doc = "Generated from 'VK_HUAWEI_extension_371'"]
#[doc = "Generated from 'VK_HUAWEI_invocation_mask'"]
impl PipelineStageFlags2KHR {
pub const RESERVED_40_HUAWEI: Self =
pub const INVOCATION_MASK_HUAWEI: Self =
Self(0b1_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000);
}
impl NvExternalMemoryRdmaFn {
@ -24060,7 +24162,7 @@ impl NvExternalMemoryRdmaFn {
#[allow(non_camel_case_types)]
pub type PFN_vkGetMemoryRemoteAddressNV = unsafe extern "system" fn(
device: Device,
get_memory_remote_address_info: *const MemoryGetRemoteAddressInfoNV,
p_memory_get_remote_address_info: *const MemoryGetRemoteAddressInfoNV,
p_address: *mut RemoteAddressNV,
) -> Result;
#[derive(Clone)]
@ -24078,7 +24180,7 @@ impl NvExternalMemoryRdmaFn {
get_memory_remote_address_nv: unsafe {
unsafe extern "system" fn get_memory_remote_address_nv(
_device: Device,
_get_memory_remote_address_info: *const MemoryGetRemoteAddressInfoNV,
_p_memory_get_remote_address_info: *const MemoryGetRemoteAddressInfoNV,
_p_address: *mut RemoteAddressNV,
) -> Result {
panic!(concat!(
@ -24102,10 +24204,10 @@ impl NvExternalMemoryRdmaFn {
pub unsafe fn get_memory_remote_address_nv(
&self,
device: Device,
get_memory_remote_address_info: *const MemoryGetRemoteAddressInfoNV,
p_memory_get_remote_address_info: *const MemoryGetRemoteAddressInfoNV,
p_address: *mut RemoteAddressNV,
) -> Result {
(self.get_memory_remote_address_nv)(device, get_memory_remote_address_info, p_address)
(self.get_memory_remote_address_nv)(device, p_memory_get_remote_address_info, p_address)
}
}
#[doc = "Generated from 'VK_NV_external_memory_rdma'"]
@ -25498,3 +25600,22 @@ impl ExtExtension420Fn {
ExtExtension420Fn {}
}
}
impl KhrExtension421Fn {
pub fn name() -> &'static ::std::ffi::CStr {
::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_extension_421\0")
.expect("Wrong extension string")
}
pub const SPEC_VERSION: u32 = 0u32;
}
#[derive(Clone)]
pub struct KhrExtension421Fn {}
unsafe impl Send for KhrExtension421Fn {}
unsafe impl Sync for KhrExtension421Fn {}
impl KhrExtension421Fn {
pub fn load<F>(mut _f: F) -> Self
where
F: FnMut(&::std::ffi::CStr) -> *const c_void,
{
KhrExtension421Fn {}
}
}

2
generator/Vulkan-Headers

@ -1 +1 @@
Subproject commit 0193e158bc9f4d17e3c3a61c9311a0439ed5572d
Subproject commit b8c57b0a09f7324fec5a7c363f5e26ff4d5a3222