From 05747b25aa04d2a8a4285cbe2a2cb1ddcfa84f60 Mon Sep 17 00:00:00 2001 From: Marijn Suijten Date: Sun, 13 Dec 2020 18:30:42 +0100 Subject: [PATCH] Update Vulkan-Headers to 1.2.162 with stable ray-tracing spec (#341) * Update Vulkan-Headers subproject to 1.2.162 (ray tracing) * Generate against vk.xml 1.2.162 * generator: Shim IDirectFB and IDirectFBSurface to c_void * generator: Edgecase for name-clash in p_geometries and pp_geometries * extensions: Migrate acceleration structure to separate extension * extensions: Migrate RT safe wrapper functions to ray_tracing_pipeline * Add high level wrapper for currently-empty RayQuery extension * vk: definition: Turn host/device AS handle into type safe union Co-authored-by: Marijn Suijten Co-authored-by: Darius Bouma --- .../extensions/khr/acceleration_structure.rs | 321 + ash/src/extensions/khr/mod.rs | 8 +- ash/src/extensions/khr/ray_query.rs | 35 + ash/src/extensions/khr/ray_tracing.rs | 343 - .../extensions/khr/ray_tracing_pipeline.rs | 183 + ash/src/vk/aliases.rs | 5 - ash/src/vk/bitflags.rs | 42 +- ash/src/vk/const_debugs.rs | 427 +- ash/src/vk/definitions.rs | 5457 ++++- ash/src/vk/enums.rs | 149 +- ash/src/vk/extensions.rs | 16734 +++++++++------- ash/src/vk/platform_types.rs | 2 + generator/Vulkan-Headers | 2 +- generator/src/lib.rs | 38 +- 14 files changed, 15557 insertions(+), 8189 deletions(-) create mode 100644 ash/src/extensions/khr/acceleration_structure.rs create mode 100644 ash/src/extensions/khr/ray_query.rs delete mode 100644 ash/src/extensions/khr/ray_tracing.rs create mode 100644 ash/src/extensions/khr/ray_tracing_pipeline.rs diff --git a/ash/src/extensions/khr/acceleration_structure.rs b/ash/src/extensions/khr/acceleration_structure.rs new file mode 100644 index 000000000..a23307949 --- /dev/null +++ b/ash/src/extensions/khr/acceleration_structure.rs @@ -0,0 +1,321 @@ +#![allow(dead_code)] +use crate::prelude::*; +use crate::version::{DeviceV1_0, InstanceV1_0, InstanceV1_1}; +use crate::vk; +use crate::RawPtr; +use std::ffi::CStr; +use std::mem; + +#[derive(Clone)] +pub struct AccelerationStructure { + handle: vk::Device, + acceleration_structure_fn: vk::KhrAccelerationStructureFn, +} + +impl AccelerationStructure { + pub fn new(instance: &I, device: &D) -> Self { + let acceleration_structure_fn = vk::KhrAccelerationStructureFn::load(|name| unsafe { + mem::transmute(instance.get_device_proc_addr(device.handle(), name.as_ptr())) + }); + Self { + handle: device.handle(), + acceleration_structure_fn, + } + } + + pub unsafe fn get_properties( + instance: &I, + pdevice: vk::PhysicalDevice, + ) -> vk::PhysicalDeviceAccelerationStructurePropertiesKHR { + let mut props_rt = vk::PhysicalDeviceAccelerationStructurePropertiesKHR::default(); + { + let mut props = vk::PhysicalDeviceProperties2::builder().push_next(&mut props_rt); + instance.get_physical_device_properties2(pdevice, &mut props); + } + props_rt + } + + #[doc = ""] + pub unsafe fn create_acceleration_structure( + &self, + create_info: &vk::AccelerationStructureCreateInfoKHR, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) -> VkResult { + let mut accel_struct = mem::zeroed(); + let err_code = self + .acceleration_structure_fn + .create_acceleration_structure_khr( + self.handle, + create_info, + allocation_callbacks.as_raw_ptr(), + &mut accel_struct, + ); + match err_code { + vk::Result::SUCCESS => Ok(accel_struct), + _ => Err(err_code), + } + } + + #[doc = ""] + pub unsafe fn destroy_acceleration_structure( + &self, + accel_struct: vk::AccelerationStructureKHR, + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) { + self.acceleration_structure_fn + .destroy_acceleration_structure_khr( + self.handle, + accel_struct, + allocation_callbacks.as_raw_ptr(), + ); + } + + #[doc = ""] + pub unsafe fn cmd_build_acceleration_structures( + &self, + command_buffer: vk::CommandBuffer, + infos: &[vk::AccelerationStructureBuildGeometryInfoKHR], + build_range_infos: &[&[vk::AccelerationStructureBuildRangeInfoKHR]], + ) { + assert_eq!(infos.len(), build_range_infos.len()); + + let build_range_infos = build_range_infos + .iter() + .map(|slice| slice.as_ptr()) + .collect::>(); + + self.acceleration_structure_fn + .cmd_build_acceleration_structures_khr( + command_buffer, + infos.len() as _, + infos.as_ptr(), + build_range_infos.as_ptr(), + ); + } + + #[doc = ""] + pub unsafe fn cmd_build_acceleration_structures_indirect( + &self, + command_buffer: vk::CommandBuffer, + infos: &[vk::AccelerationStructureBuildGeometryInfoKHR], + indirect_device_addresses: &[vk::DeviceAddress], + indirect_strides: &[u32], + max_primitive_counts: &[&u32], + ) { + assert_eq!(infos.len(), indirect_device_addresses.len()); + assert_eq!(infos.len(), indirect_strides.len()); + assert_eq!(infos.len(), max_primitive_counts.len()); + + let max_primitive_counts = max_primitive_counts + .iter() + .map(|cnt| *cnt as *const _) + .collect::>(); + + self.acceleration_structure_fn + .cmd_build_acceleration_structures_indirect_khr( + command_buffer, + infos.len() as _, + infos.as_ptr(), + indirect_device_addresses.as_ptr(), + indirect_strides.as_ptr(), + max_primitive_counts.as_ptr(), + ); + } + + #[doc = ""] + pub unsafe fn build_acceleration_structures( + &self, + device: vk::Device, + deferred_operation: vk::DeferredOperationKHR, + infos: &[vk::AccelerationStructureBuildGeometryInfoKHR], + build_range_infos: &[&[vk::AccelerationStructureBuildRangeInfoKHR]], + ) -> VkResult<()> { + assert_eq!(infos.len(), build_range_infos.len()); + + let build_range_infos = build_range_infos + .iter() + .map(|slice| slice.as_ptr()) + .collect::>(); + + self.acceleration_structure_fn + .build_acceleration_structures_khr( + device, + deferred_operation, + infos.len() as _, + infos.as_ptr(), + build_range_infos.as_ptr(), + ) + .into() + } + + #[doc = ""] + pub unsafe fn copy_acceleration_structure( + &self, + device: vk::Device, + deferred_operation: vk::DeferredOperationKHR, + info: &vk::CopyAccelerationStructureInfoKHR, + ) -> VkResult<()> { + self.acceleration_structure_fn + .copy_acceleration_structure_khr(device, deferred_operation, info as *const _) + .into() + } + + #[doc = ""] + pub unsafe fn copy_acceleration_structure_to_memory( + &self, + device: vk::Device, + deferred_operation: vk::DeferredOperationKHR, + info: &vk::CopyAccelerationStructureToMemoryInfoKHR, + ) -> VkResult<()> { + self.acceleration_structure_fn + .copy_acceleration_structure_to_memory_khr(device, deferred_operation, info as *const _) + .into() + } + + #[doc = ""] + pub unsafe fn copy_memory_to_acceleration_structure( + &self, + device: vk::Device, + deferred_operation: vk::DeferredOperationKHR, + info: &vk::CopyMemoryToAccelerationStructureInfoKHR, + ) -> VkResult<()> { + self.acceleration_structure_fn + .copy_memory_to_acceleration_structure_khr(device, deferred_operation, info as *const _) + .into() + } + + #[doc = ""] + pub unsafe fn write_acceleration_structures_properties( + &self, + device: vk::Device, + acceleration_structures: &[vk::AccelerationStructureKHR], + query_type: vk::QueryType, + data: &mut [u8], + stride: usize, + ) -> VkResult<()> { + self.acceleration_structure_fn + .write_acceleration_structures_properties_khr( + device, + acceleration_structures.len() as _, + acceleration_structures.as_ptr(), + query_type, + data.len(), + data.as_mut_ptr() as *mut std::ffi::c_void, + stride, + ) + .into() + } + + #[doc = ""] + pub unsafe fn cmd_copy_acceleration_structure( + &self, + command_buffer: vk::CommandBuffer, + info: &vk::CopyAccelerationStructureInfoKHR, + ) { + self.acceleration_structure_fn + .cmd_copy_acceleration_structure_khr(command_buffer, info); + } + + #[doc = ""] + pub unsafe fn cmd_copy_acceleration_structure_to_memory( + &self, + command_buffer: vk::CommandBuffer, + info: &vk::CopyAccelerationStructureToMemoryInfoKHR, + ) { + self.acceleration_structure_fn + .cmd_copy_acceleration_structure_to_memory_khr(command_buffer, info as *const _); + } + + #[doc = ""] + pub unsafe fn cmd_copy_memory_to_acceleration_structure( + &self, + command_buffer: vk::CommandBuffer, + info: &vk::CopyMemoryToAccelerationStructureInfoKHR, + ) { + self.acceleration_structure_fn + .cmd_copy_memory_to_acceleration_structure_khr(command_buffer, info as *const _); + } + + #[doc = ""] + pub unsafe fn get_acceleration_structure_device_address( + &self, + device: vk::Device, + info: &vk::AccelerationStructureDeviceAddressInfoKHR, + ) -> vk::DeviceAddress { + self.acceleration_structure_fn + .get_acceleration_structure_device_address_khr(device, info as *const _) + } + + #[doc = ""] + pub unsafe fn cmd_write_acceleration_structures_properties( + &self, + command_buffer: vk::CommandBuffer, + structures: &[vk::AccelerationStructureKHR], + query_type: vk::QueryType, + query_pool: vk::QueryPool, + first_query: u32, + ) { + self.acceleration_structure_fn + .cmd_write_acceleration_structures_properties_khr( + command_buffer, + structures.len() as _, + structures.as_ptr(), + query_type, + query_pool, + first_query, + ); + } + + pub unsafe fn get_device_acceleration_structure_compatibility( + &self, + device: vk::Device, + version: &vk::AccelerationStructureVersionInfoKHR, + ) -> vk::AccelerationStructureCompatibilityKHR { + let mut compatibility = vk::AccelerationStructureCompatibilityKHR::default(); + + self.acceleration_structure_fn + .get_device_acceleration_structure_compatibility_khr( + device, + version, + &mut compatibility as *mut _, + ); + + compatibility + } + + #[doc = ""] + pub unsafe fn get_acceleration_structure_build_sizes( + &self, + device: vk::Device, + build_type: vk::AccelerationStructureBuildTypeKHR, + build_info: &vk::AccelerationStructureBuildGeometryInfoKHR, + max_primitive_counts: &[u32], + ) -> vk::AccelerationStructureBuildSizesInfoKHR { + assert_eq!(max_primitive_counts.len(), build_info.geometry_count as _); + + let mut size_info = vk::AccelerationStructureBuildSizesInfoKHR::default(); + + self.acceleration_structure_fn + .get_acceleration_structure_build_sizes_khr( + device, + build_type, + build_info as *const _, + max_primitive_counts.as_ptr(), + &mut size_info as *mut _, + ); + + size_info + } + + pub fn name() -> &'static CStr { + vk::KhrAccelerationStructureFn::name() + } + + pub fn fp(&self) -> &vk::KhrAccelerationStructureFn { + &self.acceleration_structure_fn + } + + pub fn device(&self) -> vk::Device { + self.handle + } +} diff --git a/ash/src/extensions/khr/mod.rs b/ash/src/extensions/khr/mod.rs index 8334184cc..f5c54ca6b 100644 --- a/ash/src/extensions/khr/mod.rs +++ b/ash/src/extensions/khr/mod.rs @@ -1,3 +1,4 @@ +pub use self::acceleration_structure::AccelerationStructure; pub use self::android_surface::AndroidSurface; pub use self::display::Display; pub use self::display_swapchain::DisplaySwapchain; @@ -5,7 +6,8 @@ pub use self::draw_indirect_count::DrawIndirectCount; pub use self::external_memory_fd::ExternalMemoryFd; pub use self::pipeline_executable_properties::PipelineExecutableProperties; pub use self::push_descriptor::PushDescriptor; -pub use self::ray_tracing::RayTracing; +pub use self::ray_query::RayQuery; +pub use self::ray_tracing_pipeline::RayTracingPipeline; pub use self::surface::Surface; pub use self::swapchain::Swapchain; pub use self::timeline_semaphore::TimelineSemaphore; @@ -14,6 +16,7 @@ pub use self::win32_surface::Win32Surface; pub use self::xcb_surface::XcbSurface; pub use self::xlib_surface::XlibSurface; +mod acceleration_structure; mod android_surface; mod display; mod display_swapchain; @@ -21,7 +24,8 @@ mod draw_indirect_count; mod external_memory_fd; mod pipeline_executable_properties; mod push_descriptor; -mod ray_tracing; +mod ray_query; +mod ray_tracing_pipeline; mod surface; mod swapchain; mod timeline_semaphore; diff --git a/ash/src/extensions/khr/ray_query.rs b/ash/src/extensions/khr/ray_query.rs new file mode 100644 index 000000000..d7c3aef07 --- /dev/null +++ b/ash/src/extensions/khr/ray_query.rs @@ -0,0 +1,35 @@ +#![allow(dead_code)] +use crate::version::{DeviceV1_0, InstanceV1_0}; +use crate::vk; +use std::ffi::CStr; +use std::mem; + +#[derive(Clone)] +pub struct RayQuery { + handle: vk::Device, + ray_query_fn: vk::KhrRayQueryFn, +} + +impl RayQuery { + pub fn new(instance: &I, device: &D) -> Self { + let ray_query_fn = vk::KhrRayQueryFn::load(|name| unsafe { + mem::transmute(instance.get_device_proc_addr(device.handle(), name.as_ptr())) + }); + Self { + handle: device.handle(), + ray_query_fn, + } + } + + pub fn name() -> &'static CStr { + vk::KhrRayQueryFn::name() + } + + pub fn fp(&self) -> &vk::KhrRayQueryFn { + &self.ray_query_fn + } + + pub fn device(&self) -> vk::Device { + self.handle + } +} diff --git a/ash/src/extensions/khr/ray_tracing.rs b/ash/src/extensions/khr/ray_tracing.rs deleted file mode 100644 index 325747399..000000000 --- a/ash/src/extensions/khr/ray_tracing.rs +++ /dev/null @@ -1,343 +0,0 @@ -#![allow(dead_code)] -use crate::prelude::*; -use crate::version::{DeviceV1_0, InstanceV1_0, InstanceV1_1}; -use crate::vk; -use crate::RawPtr; -use std::ffi::CStr; -use std::mem; - -#[derive(Clone)] -pub struct RayTracing { - handle: vk::Device, - ray_tracing_fn: vk::KhrRayTracingFn, -} - -impl RayTracing { - pub fn new(instance: &I, device: &D) -> RayTracing { - let ray_tracing_fn = vk::KhrRayTracingFn::load(|name| unsafe { - mem::transmute(instance.get_device_proc_addr(device.handle(), name.as_ptr())) - }); - RayTracing { - handle: device.handle(), - ray_tracing_fn, - } - } - - pub unsafe fn get_properties( - instance: &I, - pdevice: vk::PhysicalDevice, - ) -> vk::PhysicalDeviceRayTracingPropertiesKHR { - let mut props_rt = vk::PhysicalDeviceRayTracingPropertiesKHR::default(); - { - let mut props = vk::PhysicalDeviceProperties2::builder().push_next(&mut props_rt); - instance.get_physical_device_properties2(pdevice, &mut props); - } - props_rt - } - - #[doc = ""] - pub unsafe fn create_acceleration_structure( - &self, - create_info: &vk::AccelerationStructureCreateInfoKHR, - allocation_callbacks: Option<&vk::AllocationCallbacks>, - ) -> VkResult { - let mut accel_struct = mem::zeroed(); - self.ray_tracing_fn - .create_acceleration_structure_khr( - self.handle, - create_info, - allocation_callbacks.as_raw_ptr(), - &mut accel_struct, - ) - .result_with_success(accel_struct) - } - - #[doc = ""] - pub unsafe fn destroy_acceleration_structure( - &self, - accel_struct: vk::AccelerationStructureKHR, - allocation_callbacks: Option<&vk::AllocationCallbacks>, - ) { - self.ray_tracing_fn.destroy_acceleration_structure_khr( - self.handle, - accel_struct, - allocation_callbacks.as_raw_ptr(), - ); - } - - #[doc = ""] - pub unsafe fn get_acceleration_structure_memory_requirements( - &self, - info: &vk::AccelerationStructureMemoryRequirementsInfoKHR, - ) -> vk::MemoryRequirements2KHR { - let mut requirements = Default::default(); - self.ray_tracing_fn - .get_acceleration_structure_memory_requirements_khr( - self.handle, - info, - &mut requirements, - ); - requirements - } - - #[doc = ""] - pub unsafe fn bind_acceleration_structure_memory( - &self, - bind_info: &[vk::BindAccelerationStructureMemoryInfoKHR], - ) -> VkResult<()> { - self.ray_tracing_fn - .bind_acceleration_structure_memory_khr( - self.handle, - bind_info.len() as u32, - bind_info.as_ptr(), - ) - .into() - } - - #[doc = ""] - pub unsafe fn cmd_build_acceleration_structure( - &self, - command_buffer: vk::CommandBuffer, - infos: &[vk::AccelerationStructureBuildGeometryInfoKHR], - offset_infos: &[&[vk::AccelerationStructureBuildOffsetInfoKHR]], - ) { - let offset_info_ptr = offset_infos - .iter() - .map(|slice| slice.as_ptr()) - .collect::>(); - - self.ray_tracing_fn.cmd_build_acceleration_structure_khr( - command_buffer, - infos.len() as u32, - infos.as_ptr(), - offset_info_ptr.as_ptr(), - ); - } - - #[doc = ""] - pub unsafe fn cmd_copy_acceleration_structure( - &self, - command_buffer: vk::CommandBuffer, - info: &vk::CopyAccelerationStructureInfoKHR, - ) { - self.ray_tracing_fn - .cmd_copy_acceleration_structure_khr(command_buffer, info); - } - - #[doc = ""] - pub unsafe fn cmd_trace_rays( - &self, - command_buffer: vk::CommandBuffer, - raygen_shader_binding_tables: &[vk::StridedBufferRegionKHR], - miss_shader_binding_tables: &[vk::StridedBufferRegionKHR], - hit_shader_binding_tables: &[vk::StridedBufferRegionKHR], - callable_shader_binding_tables: &[vk::StridedBufferRegionKHR], - width: u32, - height: u32, - depth: u32, - ) { - self.ray_tracing_fn.cmd_trace_rays_khr( - command_buffer, - raygen_shader_binding_tables.as_ptr(), - miss_shader_binding_tables.as_ptr(), - hit_shader_binding_tables.as_ptr(), - callable_shader_binding_tables.as_ptr(), - width, - height, - depth, - ); - } - - #[doc = ""] - pub unsafe fn create_ray_tracing_pipelines( - &self, - pipeline_cache: vk::PipelineCache, - create_info: &[vk::RayTracingPipelineCreateInfoKHR], - allocation_callbacks: Option<&vk::AllocationCallbacks>, - ) -> VkResult> { - let mut pipelines = vec![mem::zeroed(); create_info.len()]; - self.ray_tracing_fn - .create_ray_tracing_pipelines_khr( - self.handle, - pipeline_cache, - create_info.len() as u32, - create_info.as_ptr(), - allocation_callbacks.as_raw_ptr(), - pipelines.as_mut_ptr(), - ) - .result_with_success(pipelines) - } - - #[doc = ""] - pub unsafe fn get_ray_tracing_shader_group_handles( - &self, - pipeline: vk::Pipeline, - first_group: u32, - group_count: u32, - data_size: usize, - ) -> VkResult> { - let mut data = Vec::::with_capacity(data_size); - let err_code = self - .ray_tracing_fn - .get_ray_tracing_shader_group_handles_khr( - self.handle, - pipeline, - first_group, - group_count, - data_size, - data.as_mut_ptr() as *mut std::ffi::c_void, - ); - data.set_len(data_size); - err_code.result_with_success(data) - } - - #[doc = ""] - pub unsafe fn get_acceleration_structure_device_address( - &self, - info: &vk::AccelerationStructureDeviceAddressInfoKHR, - ) -> vk::DeviceAddress { - self.ray_tracing_fn - .get_acceleration_structure_device_address_khr(self.handle, info) - } - - #[doc = ""] - pub unsafe fn cmd_write_acceleration_structures_properties( - &self, - command_buffer: vk::CommandBuffer, - structures: &[vk::AccelerationStructureKHR], - query_type: vk::QueryType, - query_pool: vk::QueryPool, - first_query: u32, - ) { - self.ray_tracing_fn - .cmd_write_acceleration_structures_properties_khr( - command_buffer, - structures.len() as u32, - structures.as_ptr(), - query_type, - query_pool, - first_query, - ); - } - - pub unsafe fn cmd_build_acceleration_structure_indirect( - &self, - command_buffer: vk::CommandBuffer, - info: &vk::AccelerationStructureBuildGeometryInfoKHR, - indirect_buffer: vk::Buffer, - indirect_offset: vk::DeviceSize, - indirect_stride: u32, - ) { - self.ray_tracing_fn - .cmd_build_acceleration_structure_indirect_khr( - command_buffer, - info, - indirect_buffer, - indirect_offset, - indirect_stride, - ); - } - - pub unsafe fn copy_acceleration_structure_to_memory( - &self, - device: vk::Device, - info: &vk::CopyAccelerationStructureToMemoryInfoKHR, - ) -> VkResult<()> { - self.ray_tracing_fn - .copy_acceleration_structure_to_memory_khr(device, info) - .into() - } - - pub unsafe fn copy_memory_to_acceleration_structure( - &self, - device: vk::Device, - info: &vk::CopyMemoryToAccelerationStructureInfoKHR, - ) -> VkResult<()> { - self.ray_tracing_fn - .copy_memory_to_acceleration_structure_khr(device, info) - .into() - } - - pub unsafe fn cmd_copy_acceleration_structure_to_memory( - &self, - command_buffer: vk::CommandBuffer, - info: &vk::CopyAccelerationStructureToMemoryInfoKHR, - ) { - self.ray_tracing_fn - .cmd_copy_acceleration_structure_to_memory_khr(command_buffer, info); - } - - pub unsafe fn cmd_copy_memory_to_acceleration_structure( - &self, - command_buffer: vk::CommandBuffer, - info: &vk::CopyMemoryToAccelerationStructureInfoKHR, - ) { - self.ray_tracing_fn - .cmd_copy_memory_to_acceleration_structure_khr(command_buffer, info); - } - - pub unsafe fn get_ray_tracing_capture_replay_shader_group_handles( - &self, - device: vk::Device, - pipeline: vk::Pipeline, - first_group: u32, - group_count: u32, - data_size: usize, - ) -> VkResult> { - let mut data: Vec = Vec::with_capacity(data_size); - - self.ray_tracing_fn - .get_ray_tracing_capture_replay_shader_group_handles_khr( - device, - pipeline, - first_group, - group_count, - data_size, - data.as_mut_ptr() as *mut _, - ) - .result_with_success(data) - } - - pub unsafe fn cmd_trace_rays_indirect( - &self, - command_buffer: vk::CommandBuffer, - raygen_shader_binding_table: &[vk::StridedBufferRegionKHR], - miss_shader_binding_table: &[vk::StridedBufferRegionKHR], - hit_shader_binding_table: &[vk::StridedBufferRegionKHR], - callable_shader_binding_table: &[vk::StridedBufferRegionKHR], - buffer: vk::Buffer, - offset: vk::DeviceSize, - ) { - self.ray_tracing_fn.cmd_trace_rays_indirect_khr( - command_buffer, - raygen_shader_binding_table.as_ptr(), - miss_shader_binding_table.as_ptr(), - hit_shader_binding_table.as_ptr(), - callable_shader_binding_table.as_ptr(), - buffer, - offset, - ); - } - - pub unsafe fn get_device_acceleration_structure_compatibility( - &self, - device: vk::Device, - version: &vk::AccelerationStructureVersionKHR, - ) -> VkResult<()> { - self.ray_tracing_fn - .get_device_acceleration_structure_compatibility_khr(device, version) - .into() - } - - pub fn name() -> &'static CStr { - vk::KhrRayTracingFn::name() - } - - pub fn fp(&self) -> &vk::KhrRayTracingFn { - &self.ray_tracing_fn - } - - pub fn device(&self) -> vk::Device { - self.handle - } -} diff --git a/ash/src/extensions/khr/ray_tracing_pipeline.rs b/ash/src/extensions/khr/ray_tracing_pipeline.rs new file mode 100644 index 000000000..d22f08c27 --- /dev/null +++ b/ash/src/extensions/khr/ray_tracing_pipeline.rs @@ -0,0 +1,183 @@ +#![allow(dead_code)] +use crate::prelude::*; +use crate::version::{DeviceV1_0, InstanceV1_0, InstanceV1_1}; +use crate::vk; +use crate::RawPtr; +use std::ffi::CStr; +use std::mem; + +#[derive(Clone)] +pub struct RayTracingPipeline { + handle: vk::Device, + ray_tracing_fn: vk::KhrRayTracingPipelineFn, +} + +impl RayTracingPipeline { + pub fn new(instance: &I, device: &D) -> Self { + let ray_tracing_fn = vk::KhrRayTracingPipelineFn::load(|name| unsafe { + mem::transmute(instance.get_device_proc_addr(device.handle(), name.as_ptr())) + }); + Self { + handle: device.handle(), + ray_tracing_fn, + } + } + + pub unsafe fn get_properties( + instance: &I, + pdevice: vk::PhysicalDevice, + ) -> vk::PhysicalDeviceRayTracingPipelinePropertiesKHR { + let mut props_rt = vk::PhysicalDeviceRayTracingPipelinePropertiesKHR::default(); + { + let mut props = vk::PhysicalDeviceProperties2::builder().push_next(&mut props_rt); + instance.get_physical_device_properties2(pdevice, &mut props); + } + props_rt + } + + #[doc = ""] + pub unsafe fn cmd_trace_rays( + &self, + command_buffer: vk::CommandBuffer, + raygen_shader_binding_tables: &[vk::StridedDeviceAddressRegionKHR], + miss_shader_binding_tables: &[vk::StridedDeviceAddressRegionKHR], + hit_shader_binding_tables: &[vk::StridedDeviceAddressRegionKHR], + callable_shader_binding_tables: &[vk::StridedDeviceAddressRegionKHR], + width: u32, + height: u32, + depth: u32, + ) { + self.ray_tracing_fn.cmd_trace_rays_khr( + command_buffer, + raygen_shader_binding_tables.as_ptr(), + miss_shader_binding_tables.as_ptr(), + hit_shader_binding_tables.as_ptr(), + callable_shader_binding_tables.as_ptr(), + width, + height, + depth, + ); + } + + #[doc = ""] + pub unsafe fn create_ray_tracing_pipelines( + &self, + deferred_operation: vk::DeferredOperationKHR, + pipeline_cache: vk::PipelineCache, + create_info: &[vk::RayTracingPipelineCreateInfoKHR], + allocation_callbacks: Option<&vk::AllocationCallbacks>, + ) -> VkResult> { + let mut pipelines = vec![mem::zeroed(); create_info.len()]; + self.ray_tracing_fn + .create_ray_tracing_pipelines_khr( + self.handle, + deferred_operation, + pipeline_cache, + create_info.len() as u32, + create_info.as_ptr(), + allocation_callbacks.as_raw_ptr(), + pipelines.as_mut_ptr(), + ) + .result_with_success(pipelines) + } + + #[doc = ""] + pub unsafe fn get_ray_tracing_shader_group_handles( + &self, + pipeline: vk::Pipeline, + first_group: u32, + group_count: u32, + data_size: usize, + ) -> VkResult> { + let mut data = Vec::::with_capacity(data_size); + let err_code = self + .ray_tracing_fn + .get_ray_tracing_shader_group_handles_khr( + self.handle, + pipeline, + first_group, + group_count, + data_size, + data.as_mut_ptr() as *mut std::ffi::c_void, + ); + data.set_len(data_size); + err_code.result_with_success(data) + } + + #[doc = ""] + pub unsafe fn get_ray_tracing_capture_replay_shader_group_handles( + &self, + device: vk::Device, + pipeline: vk::Pipeline, + first_group: u32, + group_count: u32, + data_size: usize, + ) -> VkResult> { + let mut data: Vec = Vec::with_capacity(data_size); + + self.ray_tracing_fn + .get_ray_tracing_capture_replay_shader_group_handles_khr( + device, + pipeline, + first_group, + group_count, + data_size, + data.as_mut_ptr() as *mut _, + ) + .result_with_success(data) + } + + #[doc = ""] + pub unsafe fn cmd_trace_rays_indirect( + &self, + command_buffer: vk::CommandBuffer, + raygen_shader_binding_table: &[vk::StridedDeviceAddressRegionKHR], + miss_shader_binding_table: &[vk::StridedDeviceAddressRegionKHR], + hit_shader_binding_table: &[vk::StridedDeviceAddressRegionKHR], + callable_shader_binding_table: &[vk::StridedDeviceAddressRegionKHR], + indirect_device_address: vk::DeviceAddress, + ) { + self.ray_tracing_fn.cmd_trace_rays_indirect_khr( + command_buffer, + raygen_shader_binding_table.as_ptr(), + miss_shader_binding_table.as_ptr(), + hit_shader_binding_table.as_ptr(), + callable_shader_binding_table.as_ptr(), + indirect_device_address, + ); + } + + #[doc = ""] + pub unsafe fn get_ray_tracing_shader_group_stack_size( + &self, + device: vk::Device, + pipeline: vk::Pipeline, + group: u32, + group_shader: vk::ShaderGroupShaderKHR, + ) -> vk::DeviceSize { + self.ray_tracing_fn + .get_ray_tracing_shader_group_stack_size_khr(device, pipeline, group, group_shader) + } + + #[doc = ""] + pub unsafe fn cmd_set_ray_tracing_pipeline_stack_size( + &self, + command_buffer: vk::CommandBuffer, + pipeline_stack_size: u32, + ) { + self.ray_tracing_fn + .cmd_set_ray_tracing_pipeline_stack_size_khr(command_buffer, pipeline_stack_size); + } + + pub fn name() -> &'static CStr { + vk::KhrRayTracingPipelineFn::name() + } + + pub fn fp(&self) -> &vk::KhrRayTracingPipelineFn { + &self.ray_tracing_fn + } + + pub fn device(&self) -> vk::Device { + self.handle + } +} diff --git a/ash/src/vk/aliases.rs b/ash/src/vk/aliases.rs index b0a15e52e..be3930277 100644 --- a/ash/src/vk/aliases.rs +++ b/ash/src/vk/aliases.rs @@ -21,7 +21,6 @@ pub type DescriptorBindingFlagsEXT = DescriptorBindingFlags; pub type ResolveModeFlagsKHR = ResolveModeFlags; pub type DescriptorUpdateTemplateKHR = DescriptorUpdateTemplate; pub type SamplerYcbcrConversionKHR = SamplerYcbcrConversion; -pub type AccelerationStructureNV = AccelerationStructureKHR; pub type DescriptorUpdateTemplateTypeKHR = DescriptorUpdateTemplateType; pub type PointClippingBehaviorKHR = PointClippingBehavior; pub type SemaphoreTypeKHR = SemaphoreType; @@ -29,8 +28,6 @@ pub type CopyAccelerationStructureModeNV = CopyAccelerationStructureModeKHR; pub type AccelerationStructureTypeNV = AccelerationStructureTypeKHR; pub type GeometryTypeNV = GeometryTypeKHR; pub type RayTracingShaderGroupTypeNV = RayTracingShaderGroupTypeKHR; -pub type AccelerationStructureMemoryRequirementsTypeNV = - AccelerationStructureMemoryRequirementsTypeKHR; pub type TessellationDomainOriginKHR = TessellationDomainOrigin; pub type SamplerYcbcrModelConversionKHR = SamplerYcbcrModelConversion; pub type SamplerYcbcrRangeKHR = SamplerYcbcrRange; @@ -144,8 +141,6 @@ pub type PhysicalDeviceShaderAtomicInt64FeaturesKHR = PhysicalDeviceShaderAtomic pub type PhysicalDeviceDepthStencilResolvePropertiesKHR = PhysicalDeviceDepthStencilResolveProperties; pub type SubpassDescriptionDepthStencilResolveKHR = SubpassDescriptionDepthStencilResolve; -pub type BindAccelerationStructureMemoryInfoNV = BindAccelerationStructureMemoryInfoKHR; -pub type WriteDescriptorSetAccelerationStructureNV = WriteDescriptorSetAccelerationStructureKHR; pub type ImageStencilUsageCreateInfoEXT = ImageStencilUsageCreateInfo; pub type PhysicalDeviceScalarBlockLayoutFeaturesEXT = PhysicalDeviceScalarBlockLayoutFeatures; pub type PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR = diff --git a/ash/src/vk/bitflags.rs b/ash/src/vk/bitflags.rs index d0f7f63b2..a0a6beb27 100644 --- a/ash/src/vk/bitflags.rs +++ b/ash/src/vk/bitflags.rs @@ -7,17 +7,6 @@ vk_bitflags_wrapped!(PipelineCacheCreateFlags, 0b0, Flags); impl PipelineCacheCreateFlags {} #[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] -#[doc = ""] -pub struct CullModeFlags(pub(crate) Flags); -vk_bitflags_wrapped!(CullModeFlags, 0b11, Flags); -impl CullModeFlags { - pub const NONE: Self = Self(0); - pub const FRONT: Self = Self(0b1); - pub const BACK: Self = Self(0b10); - pub const FRONT_AND_BACK: Self = Self(0x0000_0003); -} -#[repr(transparent)] -#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[doc = ""] pub struct QueueFlags(pub(crate) Flags); vk_bitflags_wrapped!(QueueFlags, 0b1111, Flags); @@ -33,6 +22,17 @@ impl QueueFlags { } #[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct CullModeFlags(pub(crate) Flags); +vk_bitflags_wrapped!(CullModeFlags, 0b11, Flags); +impl CullModeFlags { + pub const NONE: Self = Self(0); + pub const FRONT: Self = Self(0b1); + pub const BACK: Self = Self(0b10); + pub const FRONT_AND_BACK: Self = Self(0x0000_0003); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[doc = ""] pub struct RenderPassCreateFlags(pub(crate) Flags); vk_bitflags_wrapped!(RenderPassCreateFlags, 0b0, Flags); @@ -256,12 +256,6 @@ impl FenceCreateFlags { } #[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] -#[doc = ""] -pub struct SemaphoreCreateFlags(pub(crate) Flags); -vk_bitflags_wrapped!(SemaphoreCreateFlags, 0b0, Flags); -impl SemaphoreCreateFlags {} -#[repr(transparent)] -#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[doc = ""] pub struct FormatFeatureFlags(pub(crate) Flags); vk_bitflags_wrapped!(FormatFeatureFlags, 0b1_1111_1111_1111, Flags); @@ -651,6 +645,12 @@ impl IndirectStateFlagsNV { } #[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct PrivateDataSlotCreateFlagsEXT(pub(crate) Flags); +vk_bitflags_wrapped!(PrivateDataSlotCreateFlagsEXT, 0b0, Flags); +impl PrivateDataSlotCreateFlagsEXT {} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[doc = ""] pub struct DescriptorSetLayoutCreateFlags(pub(crate) Flags); vk_bitflags_wrapped!(DescriptorSetLayoutCreateFlags, 0b0, Flags); @@ -881,6 +881,14 @@ impl BuildAccelerationStructureFlagsKHR { } #[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct AccelerationStructureCreateFlagsKHR(pub(crate) Flags); +vk_bitflags_wrapped!(AccelerationStructureCreateFlagsKHR, 0b1, Flags); +impl AccelerationStructureCreateFlagsKHR { + pub const DEVICE_ADDRESS_CAPTURE_REPLAY: Self = Self(0b1); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[doc = ""] pub struct FramebufferCreateFlags(pub(crate) Flags); vk_bitflags_wrapped!(FramebufferCreateFlags, 0b0, Flags); diff --git a/ash/src/vk/const_debugs.rs b/ash/src/vk/const_debugs.rs index 91aff3330..8f7ecfcbe 100644 --- a/ash/src/vk/const_debugs.rs +++ b/ash/src/vk/const_debugs.rs @@ -42,7 +42,30 @@ impl fmt::Debug for AccelerationStructureBuildTypeKHR { } } } -impl fmt::Debug for AccelerationStructureMemoryRequirementsTypeKHR { +impl fmt::Debug for AccelerationStructureCompatibilityKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::COMPATIBLE => Some("COMPATIBLE"), + Self::INCOMPATIBLE => Some("INCOMPATIBLE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for AccelerationStructureCreateFlagsKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[( + AccelerationStructureCreateFlagsKHR::DEVICE_ADDRESS_CAPTURE_REPLAY.0, + "DEVICE_ADDRESS_CAPTURE_REPLAY", + )]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for AccelerationStructureMemoryRequirementsTypeNV { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { Self::OBJECT => Some("OBJECT"), @@ -62,6 +85,7 @@ impl fmt::Debug for AccelerationStructureTypeKHR { let name = match *self { Self::TOP_LEVEL => Some("TOP_LEVEL"), Self::BOTTOM_LEVEL => Some("BOTTOM_LEVEL"), + Self::GENERIC => Some("GENERIC"), _ => None, }; if let Some(x) = name { @@ -113,7 +137,6 @@ impl fmt::Debug for AccessFlags { (AccessFlags::MEMORY_READ.0, "MEMORY_READ"), (AccessFlags::MEMORY_WRITE.0, "MEMORY_WRITE"), (AccessFlags::RESERVED_30_KHR.0, "RESERVED_30_KHR"), - (AccessFlags::RESERVED_31_KHR.0, "RESERVED_31_KHR"), (AccessFlags::RESERVED_28_KHR.0, "RESERVED_28_KHR"), (AccessFlags::RESERVED_29_KHR.0, "RESERVED_29_KHR"), ( @@ -202,6 +225,7 @@ impl fmt::Debug for AttachmentStoreOp { let name = match *self { Self::STORE => Some("STORE"), Self::DONT_CARE => Some("DONT_CARE"), + Self::NONE_QCOM => Some("NONE_QCOM"), _ => None, }; if let Some(x) = name { @@ -329,6 +353,8 @@ impl fmt::Debug for BorderColor { Self::INT_OPAQUE_BLACK => Some("INT_OPAQUE_BLACK"), Self::FLOAT_OPAQUE_WHITE => Some("FLOAT_OPAQUE_WHITE"), Self::INT_OPAQUE_WHITE => Some("INT_OPAQUE_WHITE"), + Self::FLOAT_CUSTOM_EXT => Some("FLOAT_CUSTOM_EXT"), + Self::INT_CUSTOM_EXT => Some("INT_CUSTOM_EXT"), _ => None, }; if let Some(x) = name { @@ -344,6 +370,7 @@ impl fmt::Debug for BufferCreateFlags { (BufferCreateFlags::SPARSE_BINDING.0, "SPARSE_BINDING"), (BufferCreateFlags::SPARSE_RESIDENCY.0, "SPARSE_RESIDENCY"), (BufferCreateFlags::SPARSE_ALIASED.0, "SPARSE_ALIASED"), + (BufferCreateFlags::RESERVED_5_NV.0, "RESERVED_5_NV"), (BufferCreateFlags::PROTECTED.0, "PROTECTED"), ( BufferCreateFlags::DEVICE_ADDRESS_CAPTURE_REPLAY.0, @@ -387,7 +414,18 @@ impl fmt::Debug for BufferUsageFlags { BufferUsageFlags::CONDITIONAL_RENDERING_EXT.0, "CONDITIONAL_RENDERING_EXT", ), - (BufferUsageFlags::RAY_TRACING_KHR.0, "RAY_TRACING_KHR"), + ( + BufferUsageFlags::ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_KHR.0, + "ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_KHR", + ), + ( + BufferUsageFlags::ACCELERATION_STRUCTURE_STORAGE_KHR.0, + "ACCELERATION_STRUCTURE_STORAGE_KHR", + ), + ( + BufferUsageFlags::SHADER_BINDING_TABLE_KHR.0, + "SHADER_BINDING_TABLE_KHR", + ), (BufferUsageFlags::RESERVED_18_QCOM.0, "RESERVED_18_QCOM"), ( BufferUsageFlags::SHADER_DEVICE_ADDRESS.0, @@ -430,6 +468,20 @@ impl fmt::Debug for BuildAccelerationStructureFlagsKHR { debug_flags(f, KNOWN, self.0) } } +impl fmt::Debug for BuildAccelerationStructureModeKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::BUILD => Some("BUILD"), + Self::UPDATE => Some("UPDATE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} impl fmt::Debug for ChromaLocation { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -773,6 +825,7 @@ impl fmt::Debug for DebugReportObjectTypeEXT { Self::SAMPLER_YCBCR_CONVERSION => Some("SAMPLER_YCBCR_CONVERSION"), Self::DESCRIPTOR_UPDATE_TEMPLATE => Some("DESCRIPTOR_UPDATE_TEMPLATE"), Self::ACCELERATION_STRUCTURE_KHR => Some("ACCELERATION_STRUCTURE_KHR"), + Self::ACCELERATION_STRUCTURE_NV => Some("ACCELERATION_STRUCTURE_NV"), _ => None, }; if let Some(x) = name { @@ -841,6 +894,7 @@ impl fmt::Debug for DescriptorBindingFlags { DescriptorBindingFlags::VARIABLE_DESCRIPTOR_COUNT.0, "VARIABLE_DESCRIPTOR_COUNT", ), + (DescriptorBindingFlags::RESERVED_4_QCOM.0, "RESERVED_4_QCOM"), ]; debug_flags(f, KNOWN, self.0) } @@ -897,6 +951,7 @@ impl fmt::Debug for DescriptorType { Self::INPUT_ATTACHMENT => Some("INPUT_ATTACHMENT"), 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"), _ => None, }; if let Some(x) = name { @@ -978,12 +1033,41 @@ impl fmt::Debug for DeviceGroupPresentModeFlagsKHR { debug_flags(f, KNOWN, self.0) } } +impl fmt::Debug for DeviceMemoryReportEventTypeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ALLOCATE => Some("ALLOCATE"), + Self::FREE => Some("FREE"), + Self::IMPORT => Some("IMPORT"), + Self::UNIMPORT => Some("UNIMPORT"), + Self::ALLOCATION_FAILED => Some("ALLOCATION_FAILED"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for DeviceMemoryReportFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[]; + debug_flags(f, KNOWN, self.0) + } +} impl fmt::Debug for DeviceQueueCreateFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[(DeviceQueueCreateFlags::PROTECTED.0, "PROTECTED")]; debug_flags(f, KNOWN, self.0) } } +impl fmt::Debug for DirectFBSurfaceCreateFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[]; + debug_flags(f, KNOWN, self.0) + } +} impl fmt::Debug for DiscardRectangleModeEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -1067,6 +1151,8 @@ impl fmt::Debug for DriverId { Self::GOOGLE_SWIFTSHADER => Some("GOOGLE_SWIFTSHADER"), Self::GGP_PROPRIETARY => Some("GGP_PROPRIETARY"), Self::BROADCOM_PROPRIETARY => Some("BROADCOM_PROPRIETARY"), + Self::MESA_LLVMPIPE => Some("MESA_LLVMPIPE"), + Self::MOLTEN => Some("MOLTEN"), _ => None, }; if let Some(x) = name { @@ -1091,10 +1177,26 @@ impl fmt::Debug for DynamicState { Self::VIEWPORT_W_SCALING_NV => Some("VIEWPORT_W_SCALING_NV"), Self::DISCARD_RECTANGLE_EXT => Some("DISCARD_RECTANGLE_EXT"), Self::SAMPLE_LOCATIONS_EXT => Some("SAMPLE_LOCATIONS_EXT"), + Self::RAY_TRACING_PIPELINE_STACK_SIZE_KHR => { + Some("RAY_TRACING_PIPELINE_STACK_SIZE_KHR") + } Self::VIEWPORT_SHADING_RATE_PALETTE_NV => Some("VIEWPORT_SHADING_RATE_PALETTE_NV"), Self::VIEWPORT_COARSE_SAMPLE_ORDER_NV => Some("VIEWPORT_COARSE_SAMPLE_ORDER_NV"), Self::EXCLUSIVE_SCISSOR_NV => Some("EXCLUSIVE_SCISSOR_NV"), + Self::FRAGMENT_SHADING_RATE_KHR => Some("FRAGMENT_SHADING_RATE_KHR"), Self::LINE_STIPPLE_EXT => Some("LINE_STIPPLE_EXT"), + Self::CULL_MODE_EXT => Some("CULL_MODE_EXT"), + Self::FRONT_FACE_EXT => Some("FRONT_FACE_EXT"), + Self::PRIMITIVE_TOPOLOGY_EXT => Some("PRIMITIVE_TOPOLOGY_EXT"), + Self::VIEWPORT_WITH_COUNT_EXT => Some("VIEWPORT_WITH_COUNT_EXT"), + Self::SCISSOR_WITH_COUNT_EXT => Some("SCISSOR_WITH_COUNT_EXT"), + Self::VERTEX_INPUT_BINDING_STRIDE_EXT => Some("VERTEX_INPUT_BINDING_STRIDE_EXT"), + Self::DEPTH_TEST_ENABLE_EXT => Some("DEPTH_TEST_ENABLE_EXT"), + Self::DEPTH_WRITE_ENABLE_EXT => Some("DEPTH_WRITE_ENABLE_EXT"), + Self::DEPTH_COMPARE_OP_EXT => Some("DEPTH_COMPARE_OP_EXT"), + Self::DEPTH_BOUNDS_TEST_ENABLE_EXT => Some("DEPTH_BOUNDS_TEST_ENABLE_EXT"), + Self::STENCIL_TEST_ENABLE_EXT => Some("STENCIL_TEST_ENABLE_EXT"), + Self::STENCIL_OP_EXT => Some("STENCIL_OP_EXT"), _ => None, }; if let Some(x) = name { @@ -1494,6 +1596,38 @@ impl fmt::Debug for Format { Self::ASTC_10X10_SFLOAT_BLOCK_EXT => Some("ASTC_10X10_SFLOAT_BLOCK_EXT"), Self::ASTC_12X10_SFLOAT_BLOCK_EXT => Some("ASTC_12X10_SFLOAT_BLOCK_EXT"), Self::ASTC_12X12_SFLOAT_BLOCK_EXT => Some("ASTC_12X12_SFLOAT_BLOCK_EXT"), + Self::ASTC_3X3X3_UNORM_BLOCK_EXT => Some("ASTC_3X3X3_UNORM_BLOCK_EXT"), + Self::ASTC_3X3X3_SRGB_BLOCK_EXT => Some("ASTC_3X3X3_SRGB_BLOCK_EXT"), + Self::ASTC_3X3X3_SFLOAT_BLOCK_EXT => Some("ASTC_3X3X3_SFLOAT_BLOCK_EXT"), + Self::ASTC_4X3X3_UNORM_BLOCK_EXT => Some("ASTC_4X3X3_UNORM_BLOCK_EXT"), + Self::ASTC_4X3X3_SRGB_BLOCK_EXT => Some("ASTC_4X3X3_SRGB_BLOCK_EXT"), + Self::ASTC_4X3X3_SFLOAT_BLOCK_EXT => Some("ASTC_4X3X3_SFLOAT_BLOCK_EXT"), + Self::ASTC_4X4X3_UNORM_BLOCK_EXT => Some("ASTC_4X4X3_UNORM_BLOCK_EXT"), + Self::ASTC_4X4X3_SRGB_BLOCK_EXT => Some("ASTC_4X4X3_SRGB_BLOCK_EXT"), + Self::ASTC_4X4X3_SFLOAT_BLOCK_EXT => Some("ASTC_4X4X3_SFLOAT_BLOCK_EXT"), + Self::ASTC_4X4X4_UNORM_BLOCK_EXT => Some("ASTC_4X4X4_UNORM_BLOCK_EXT"), + Self::ASTC_4X4X4_SRGB_BLOCK_EXT => Some("ASTC_4X4X4_SRGB_BLOCK_EXT"), + Self::ASTC_4X4X4_SFLOAT_BLOCK_EXT => Some("ASTC_4X4X4_SFLOAT_BLOCK_EXT"), + Self::ASTC_5X4X4_UNORM_BLOCK_EXT => Some("ASTC_5X4X4_UNORM_BLOCK_EXT"), + Self::ASTC_5X4X4_SRGB_BLOCK_EXT => Some("ASTC_5X4X4_SRGB_BLOCK_EXT"), + Self::ASTC_5X4X4_SFLOAT_BLOCK_EXT => Some("ASTC_5X4X4_SFLOAT_BLOCK_EXT"), + Self::ASTC_5X5X4_UNORM_BLOCK_EXT => Some("ASTC_5X5X4_UNORM_BLOCK_EXT"), + Self::ASTC_5X5X4_SRGB_BLOCK_EXT => Some("ASTC_5X5X4_SRGB_BLOCK_EXT"), + Self::ASTC_5X5X4_SFLOAT_BLOCK_EXT => Some("ASTC_5X5X4_SFLOAT_BLOCK_EXT"), + Self::ASTC_5X5X5_UNORM_BLOCK_EXT => Some("ASTC_5X5X5_UNORM_BLOCK_EXT"), + Self::ASTC_5X5X5_SRGB_BLOCK_EXT => Some("ASTC_5X5X5_SRGB_BLOCK_EXT"), + Self::ASTC_5X5X5_SFLOAT_BLOCK_EXT => Some("ASTC_5X5X5_SFLOAT_BLOCK_EXT"), + Self::ASTC_6X5X5_UNORM_BLOCK_EXT => Some("ASTC_6X5X5_UNORM_BLOCK_EXT"), + Self::ASTC_6X5X5_SRGB_BLOCK_EXT => Some("ASTC_6X5X5_SRGB_BLOCK_EXT"), + Self::ASTC_6X5X5_SFLOAT_BLOCK_EXT => Some("ASTC_6X5X5_SFLOAT_BLOCK_EXT"), + Self::ASTC_6X6X5_UNORM_BLOCK_EXT => Some("ASTC_6X6X5_UNORM_BLOCK_EXT"), + Self::ASTC_6X6X5_SRGB_BLOCK_EXT => Some("ASTC_6X6X5_SRGB_BLOCK_EXT"), + Self::ASTC_6X6X5_SFLOAT_BLOCK_EXT => Some("ASTC_6X6X5_SFLOAT_BLOCK_EXT"), + Self::ASTC_6X6X6_UNORM_BLOCK_EXT => Some("ASTC_6X6X6_UNORM_BLOCK_EXT"), + Self::ASTC_6X6X6_SRGB_BLOCK_EXT => Some("ASTC_6X6X6_SRGB_BLOCK_EXT"), + Self::ASTC_6X6X6_SFLOAT_BLOCK_EXT => Some("ASTC_6X6X6_SFLOAT_BLOCK_EXT"), + Self::A4R4G4B4_UNORM_PACK16_EXT => Some("A4R4G4B4_UNORM_PACK16_EXT"), + Self::A4B4G4R4_UNORM_PACK16_EXT => Some("A4B4G4R4_UNORM_PACK16_EXT"), Self::G8B8G8R8_422_UNORM => Some("G8B8G8R8_422_UNORM"), Self::B8G8R8G8_422_UNORM => Some("B8G8R8G8_422_UNORM"), Self::G8_B8_R8_3PLANE_420_UNORM => Some("G8_B8_R8_3PLANE_420_UNORM"), @@ -1567,10 +1701,65 @@ impl fmt::Debug for Format { } impl fmt::Debug for FormatFeatureFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN : & [ ( Flags , & str ) ] = & [ ( FormatFeatureFlags :: SAMPLED_IMAGE . 0 , "SAMPLED_IMAGE" ) , ( FormatFeatureFlags :: STORAGE_IMAGE . 0 , "STORAGE_IMAGE" ) , ( FormatFeatureFlags :: STORAGE_IMAGE_ATOMIC . 0 , "STORAGE_IMAGE_ATOMIC" ) , ( FormatFeatureFlags :: UNIFORM_TEXEL_BUFFER . 0 , "UNIFORM_TEXEL_BUFFER" ) , ( FormatFeatureFlags :: STORAGE_TEXEL_BUFFER . 0 , "STORAGE_TEXEL_BUFFER" ) , ( FormatFeatureFlags :: STORAGE_TEXEL_BUFFER_ATOMIC . 0 , "STORAGE_TEXEL_BUFFER_ATOMIC" ) , ( FormatFeatureFlags :: VERTEX_BUFFER . 0 , "VERTEX_BUFFER" ) , ( FormatFeatureFlags :: COLOR_ATTACHMENT . 0 , "COLOR_ATTACHMENT" ) , ( FormatFeatureFlags :: COLOR_ATTACHMENT_BLEND . 0 , "COLOR_ATTACHMENT_BLEND" ) , ( FormatFeatureFlags :: DEPTH_STENCIL_ATTACHMENT . 0 , "DEPTH_STENCIL_ATTACHMENT" ) , ( FormatFeatureFlags :: BLIT_SRC . 0 , "BLIT_SRC" ) , ( FormatFeatureFlags :: BLIT_DST . 0 , "BLIT_DST" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_LINEAR . 0 , "SAMPLED_IMAGE_FILTER_LINEAR" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_CUBIC_IMG . 0 , "SAMPLED_IMAGE_FILTER_CUBIC_IMG" ) , ( FormatFeatureFlags :: RESERVED_27_KHR . 0 , "RESERVED_27_KHR" ) , ( FormatFeatureFlags :: RESERVED_28_KHR . 0 , "RESERVED_28_KHR" ) , ( FormatFeatureFlags :: RESERVED_25_KHR . 0 , "RESERVED_25_KHR" ) , ( FormatFeatureFlags :: RESERVED_26_KHR . 0 , "RESERVED_26_KHR" ) , ( FormatFeatureFlags :: ACCELERATION_STRUCTURE_VERTEX_BUFFER_KHR . 0 , "ACCELERATION_STRUCTURE_VERTEX_BUFFER_KHR" ) , ( FormatFeatureFlags :: FRAGMENT_DENSITY_MAP_EXT . 0 , "FRAGMENT_DENSITY_MAP_EXT" ) , ( FormatFeatureFlags :: TRANSFER_SRC . 0 , "TRANSFER_SRC" ) , ( FormatFeatureFlags :: TRANSFER_DST . 0 , "TRANSFER_DST" ) , ( FormatFeatureFlags :: MIDPOINT_CHROMA_SAMPLES . 0 , "MIDPOINT_CHROMA_SAMPLES" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE" ) , ( FormatFeatureFlags :: DISJOINT . 0 , "DISJOINT" ) , ( FormatFeatureFlags :: COSITED_CHROMA_SAMPLES . 0 , "COSITED_CHROMA_SAMPLES" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_MINMAX . 0 , "SAMPLED_IMAGE_FILTER_MINMAX" ) ] ; + const KNOWN : & [ ( Flags , & str ) ] = & [ ( FormatFeatureFlags :: SAMPLED_IMAGE . 0 , "SAMPLED_IMAGE" ) , ( FormatFeatureFlags :: STORAGE_IMAGE . 0 , "STORAGE_IMAGE" ) , ( FormatFeatureFlags :: STORAGE_IMAGE_ATOMIC . 0 , "STORAGE_IMAGE_ATOMIC" ) , ( FormatFeatureFlags :: UNIFORM_TEXEL_BUFFER . 0 , "UNIFORM_TEXEL_BUFFER" ) , ( FormatFeatureFlags :: STORAGE_TEXEL_BUFFER . 0 , "STORAGE_TEXEL_BUFFER" ) , ( FormatFeatureFlags :: STORAGE_TEXEL_BUFFER_ATOMIC . 0 , "STORAGE_TEXEL_BUFFER_ATOMIC" ) , ( FormatFeatureFlags :: VERTEX_BUFFER . 0 , "VERTEX_BUFFER" ) , ( FormatFeatureFlags :: COLOR_ATTACHMENT . 0 , "COLOR_ATTACHMENT" ) , ( FormatFeatureFlags :: COLOR_ATTACHMENT_BLEND . 0 , "COLOR_ATTACHMENT_BLEND" ) , ( FormatFeatureFlags :: DEPTH_STENCIL_ATTACHMENT . 0 , "DEPTH_STENCIL_ATTACHMENT" ) , ( FormatFeatureFlags :: BLIT_SRC . 0 , "BLIT_SRC" ) , ( FormatFeatureFlags :: BLIT_DST . 0 , "BLIT_DST" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_LINEAR . 0 , "SAMPLED_IMAGE_FILTER_LINEAR" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_CUBIC_IMG . 0 , "SAMPLED_IMAGE_FILTER_CUBIC_IMG" ) , ( FormatFeatureFlags :: RESERVED_27_KHR . 0 , "RESERVED_27_KHR" ) , ( FormatFeatureFlags :: RESERVED_28_KHR . 0 , "RESERVED_28_KHR" ) , ( FormatFeatureFlags :: RESERVED_25_KHR . 0 , "RESERVED_25_KHR" ) , ( FormatFeatureFlags :: RESERVED_26_KHR . 0 , "RESERVED_26_KHR" ) , ( FormatFeatureFlags :: ACCELERATION_STRUCTURE_VERTEX_BUFFER_KHR . 0 , "ACCELERATION_STRUCTURE_VERTEX_BUFFER_KHR" ) , ( FormatFeatureFlags :: FRAGMENT_DENSITY_MAP_EXT . 0 , "FRAGMENT_DENSITY_MAP_EXT" ) , ( FormatFeatureFlags :: FRAGMENT_SHADING_RATE_ATTACHMENT_KHR . 0 , "FRAGMENT_SHADING_RATE_ATTACHMENT_KHR" ) , ( FormatFeatureFlags :: TRANSFER_SRC . 0 , "TRANSFER_SRC" ) , ( FormatFeatureFlags :: TRANSFER_DST . 0 , "TRANSFER_DST" ) , ( FormatFeatureFlags :: MIDPOINT_CHROMA_SAMPLES . 0 , "MIDPOINT_CHROMA_SAMPLES" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE" ) , ( FormatFeatureFlags :: DISJOINT . 0 , "DISJOINT" ) , ( FormatFeatureFlags :: COSITED_CHROMA_SAMPLES . 0 , "COSITED_CHROMA_SAMPLES" ) , ( FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_MINMAX . 0 , "SAMPLED_IMAGE_FILTER_MINMAX" ) ] ; debug_flags(f, KNOWN, self.0) } } +impl fmt::Debug for FragmentShadingRateCombinerOpKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::KEEP => Some("KEEP"), + Self::REPLACE => Some("REPLACE"), + Self::MIN => Some("MIN"), + Self::MAX => Some("MAX"), + Self::MUL => Some("MUL"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for FragmentShadingRateNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::TYPE_1_INVOCATION_PER_PIXEL => Some("TYPE_1_INVOCATION_PER_PIXEL"), + Self::TYPE_1_INVOCATION_PER_1X2_PIXELS => Some("TYPE_1_INVOCATION_PER_1X2_PIXELS"), + Self::TYPE_1_INVOCATION_PER_2X1_PIXELS => Some("TYPE_1_INVOCATION_PER_2X1_PIXELS"), + Self::TYPE_1_INVOCATION_PER_2X2_PIXELS => Some("TYPE_1_INVOCATION_PER_2X2_PIXELS"), + Self::TYPE_1_INVOCATION_PER_2X4_PIXELS => Some("TYPE_1_INVOCATION_PER_2X4_PIXELS"), + Self::TYPE_1_INVOCATION_PER_4X2_PIXELS => Some("TYPE_1_INVOCATION_PER_4X2_PIXELS"), + Self::TYPE_1_INVOCATION_PER_4X4_PIXELS => Some("TYPE_1_INVOCATION_PER_4X4_PIXELS"), + Self::TYPE_2_INVOCATIONS_PER_PIXEL => Some("TYPE_2_INVOCATIONS_PER_PIXEL"), + Self::TYPE_4_INVOCATIONS_PER_PIXEL => Some("TYPE_4_INVOCATIONS_PER_PIXEL"), + Self::TYPE_8_INVOCATIONS_PER_PIXEL => Some("TYPE_8_INVOCATIONS_PER_PIXEL"), + Self::TYPE_16_INVOCATIONS_PER_PIXEL => Some("TYPE_16_INVOCATIONS_PER_PIXEL"), + Self::NO_INVOCATIONS => Some("NO_INVOCATIONS"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for FragmentShadingRateTypeNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::FRAGMENT_SIZE => Some("FRAGMENT_SIZE"), + Self::ENUMS => Some("ENUMS"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} impl fmt::Debug for FramebufferCreateFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[(FramebufferCreateFlags::IMAGELESS.0, "IMAGELESS")]; @@ -1698,6 +1887,7 @@ impl fmt::Debug for ImageCreateFlags { "SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_EXT", ), (ImageCreateFlags::SUBSAMPLED_EXT.0, "SUBSAMPLED_EXT"), + (ImageCreateFlags::RESERVED_15_NV.0, "RESERVED_15_NV"), (ImageCreateFlags::ALIAS.0, "ALIAS"), ( ImageCreateFlags::SPLIT_INSTANCE_BIND_REGIONS.0, @@ -1828,10 +2018,16 @@ impl fmt::Debug for ImageUsageFlags { } impl fmt::Debug for ImageViewCreateFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[( - ImageViewCreateFlags::FRAGMENT_DENSITY_MAP_DYNAMIC_EXT.0, - "FRAGMENT_DENSITY_MAP_DYNAMIC_EXT", - )]; + const KNOWN: &[(Flags, &str)] = &[ + ( + ImageViewCreateFlags::FRAGMENT_DENSITY_MAP_DYNAMIC_EXT.0, + "FRAGMENT_DENSITY_MAP_DYNAMIC_EXT", + ), + ( + ImageViewCreateFlags::FRAGMENT_DENSITY_MAP_DEFERRED_EXT.0, + "FRAGMENT_DENSITY_MAP_DEFERRED_EXT", + ), + ]; debug_flags(f, KNOWN, self.0) } } @@ -2093,9 +2289,11 @@ impl fmt::Debug for ObjectType { Self::DEBUG_UTILS_MESSENGER_EXT => Some("DEBUG_UTILS_MESSENGER_EXT"), Self::ACCELERATION_STRUCTURE_KHR => Some("ACCELERATION_STRUCTURE_KHR"), Self::VALIDATION_CACHE_EXT => Some("VALIDATION_CACHE_EXT"), + Self::ACCELERATION_STRUCTURE_NV => Some("ACCELERATION_STRUCTURE_NV"), Self::PERFORMANCE_CONFIGURATION_INTEL => Some("PERFORMANCE_CONFIGURATION_INTEL"), Self::DEFERRED_OPERATION_KHR => Some("DEFERRED_OPERATION_KHR"), Self::INDIRECT_COMMANDS_LAYOUT_NV => Some("INDIRECT_COMMANDS_LAYOUT_NV"), + Self::PRIVATE_DATA_SLOT_EXT => Some("PRIVATE_DATA_SLOT_EXT"), Self::SAMPLER_YCBCR_CONVERSION => Some("SAMPLER_YCBCR_CONVERSION"), Self::DESCRIPTOR_UPDATE_TEMPLATE => Some("DESCRIPTOR_UPDATE_TEMPLATE"), _ => None, @@ -2292,10 +2490,14 @@ impl fmt::Debug for PipelineBindPoint { } impl fmt::Debug for PipelineCacheCreateFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[( - PipelineCacheCreateFlags::EXTERNALLY_SYNCHRONIZED_EXT.0, - "EXTERNALLY_SYNCHRONIZED_EXT", - )]; + const KNOWN: &[(Flags, &str)] = &[ + (PipelineCacheCreateFlags::RESERVED_1_EXT.0, "RESERVED_1_EXT"), + ( + PipelineCacheCreateFlags::EXTERNALLY_SYNCHRONIZED_EXT.0, + "EXTERNALLY_SYNCHRONIZED_EXT", + ), + (PipelineCacheCreateFlags::RESERVED_2_EXT.0, "RESERVED_2_EXT"), + ]; debug_flags(f, KNOWN, self.0) } } @@ -2378,6 +2580,10 @@ impl fmt::Debug for PipelineCreateFlags { PipelineCreateFlags::RAY_TRACING_SKIP_AABBS_KHR.0, "RAY_TRACING_SKIP_AABBS_KHR", ), + ( + PipelineCreateFlags::RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY_KHR.0, + "RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY_KHR", + ), (PipelineCreateFlags::DEFER_COMPILE_NV.0, "DEFER_COMPILE_NV"), ( PipelineCreateFlags::CAPTURE_STATISTICS_KHR.0, @@ -2569,14 +2775,14 @@ impl fmt::Debug for PipelineStageFlags { PipelineStageFlags::CONDITIONAL_RENDERING_EXT.0, "CONDITIONAL_RENDERING_EXT", ), - ( - PipelineStageFlags::RAY_TRACING_SHADER_KHR.0, - "RAY_TRACING_SHADER_KHR", - ), ( PipelineStageFlags::ACCELERATION_STRUCTURE_BUILD_KHR.0, "ACCELERATION_STRUCTURE_BUILD_KHR", ), + ( + PipelineStageFlags::RAY_TRACING_SHADER_KHR.0, + "RAY_TRACING_SHADER_KHR", + ), ( PipelineStageFlags::SHADING_RATE_IMAGE_NV.0, "SHADING_RATE_IMAGE_NV", @@ -2690,6 +2896,12 @@ impl fmt::Debug for PrimitiveTopology { } } } +impl fmt::Debug for PrivateDataSlotCreateFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[]; + debug_flags(f, KNOWN, self.0) + } +} impl fmt::Debug for QueryControlFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[(QueryControlFlags::PRECISE.0, "PRECISE")]; @@ -2795,6 +3007,9 @@ impl fmt::Debug for QueryType { Self::ACCELERATION_STRUCTURE_SERIALIZATION_SIZE_KHR => { Some("ACCELERATION_STRUCTURE_SERIALIZATION_SIZE_KHR") } + Self::ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV => { + Some("ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV") + } Self::PERFORMANCE_QUERY_INTEL => Some("PERFORMANCE_QUERY_INTEL"), _ => None, }; @@ -2914,7 +3129,6 @@ impl fmt::Debug for Result { Self::ERROR_INCOMPATIBLE_DISPLAY_KHR => Some("ERROR_INCOMPATIBLE_DISPLAY_KHR"), Self::ERROR_VALIDATION_FAILED_EXT => Some("ERROR_VALIDATION_FAILED_EXT"), Self::ERROR_INVALID_SHADER_NV => Some("ERROR_INVALID_SHADER_NV"), - Self::ERROR_INCOMPATIBLE_VERSION_KHR => Some("ERROR_INCOMPATIBLE_VERSION_KHR"), Self::ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT => { Some("ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT") } @@ -2926,9 +3140,7 @@ impl fmt::Debug for Result { Self::THREAD_DONE_KHR => Some("THREAD_DONE_KHR"), Self::OPERATION_DEFERRED_KHR => Some("OPERATION_DEFERRED_KHR"), Self::OPERATION_NOT_DEFERRED_KHR => Some("OPERATION_NOT_DEFERRED_KHR"), - Self::ERROR_PIPELINE_COMPILE_REQUIRED_EXT => { - Some("ERROR_PIPELINE_COMPILE_REQUIRED_EXT") - } + Self::PIPELINE_COMPILE_REQUIRED_EXT => Some("PIPELINE_COMPILE_REQUIRED_EXT"), Self::ERROR_OUT_OF_POOL_MEMORY => Some("ERROR_OUT_OF_POOL_MEMORY"), Self::ERROR_INVALID_EXTERNAL_HANDLE => Some("ERROR_INVALID_EXTERNAL_HANDLE"), Self::ERROR_FRAGMENTATION => Some("ERROR_FRAGMENTATION"), @@ -3116,6 +3328,22 @@ impl fmt::Debug for ShaderFloatControlsIndependence { } } } +impl fmt::Debug for ShaderGroupShaderKHR { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::GENERAL => Some("GENERAL"), + Self::CLOSEST_HIT => Some("CLOSEST_HIT"), + Self::ANY_HIT => Some("ANY_HIT"), + Self::INTERSECTION => Some("INTERSECTION"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} impl fmt::Debug for ShaderInfoTypeAMD { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -3388,6 +3616,7 @@ impl fmt::Debug for StructureType { Some("PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT") } Self::IMAGE_VIEW_HANDLE_INFO_NVX => Some("IMAGE_VIEW_HANDLE_INFO_NVX"), + Self::IMAGE_VIEW_ADDRESS_PROPERTIES_NVX => Some("IMAGE_VIEW_ADDRESS_PROPERTIES_NVX"), Self::TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD => { Some("TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD") } @@ -3581,18 +3810,12 @@ impl fmt::Debug for StructureType { Self::PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV => { Some("PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV") } - Self::BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_KHR => { - Some("BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_KHR") - } Self::WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR => { Some("WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR") } Self::ACCELERATION_STRUCTURE_BUILD_GEOMETRY_INFO_KHR => { Some("ACCELERATION_STRUCTURE_BUILD_GEOMETRY_INFO_KHR") } - Self::ACCELERATION_STRUCTURE_CREATE_GEOMETRY_TYPE_INFO_KHR => { - Some("ACCELERATION_STRUCTURE_CREATE_GEOMETRY_TYPE_INFO_KHR") - } Self::ACCELERATION_STRUCTURE_DEVICE_ADDRESS_INFO_KHR => { Some("ACCELERATION_STRUCTURE_DEVICE_ADDRESS_INFO_KHR") } @@ -3608,11 +3831,9 @@ impl fmt::Debug for StructureType { Self::ACCELERATION_STRUCTURE_GEOMETRY_KHR => { Some("ACCELERATION_STRUCTURE_GEOMETRY_KHR") } - Self::ACCELERATION_STRUCTURE_INFO_KHR => Some("ACCELERATION_STRUCTURE_INFO_KHR"), - Self::ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_KHR => { - Some("ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_KHR") + Self::ACCELERATION_STRUCTURE_VERSION_INFO_KHR => { + Some("ACCELERATION_STRUCTURE_VERSION_INFO_KHR") } - Self::ACCELERATION_STRUCTURE_VERSION_KHR => Some("ACCELERATION_STRUCTURE_VERSION_KHR"), Self::COPY_ACCELERATION_STRUCTURE_INFO_KHR => { Some("COPY_ACCELERATION_STRUCTURE_INFO_KHR") } @@ -3622,11 +3843,23 @@ impl fmt::Debug for StructureType { Self::COPY_MEMORY_TO_ACCELERATION_STRUCTURE_INFO_KHR => { Some("COPY_MEMORY_TO_ACCELERATION_STRUCTURE_INFO_KHR") } - Self::PHYSICAL_DEVICE_RAY_TRACING_FEATURES_KHR => { - Some("PHYSICAL_DEVICE_RAY_TRACING_FEATURES_KHR") + Self::PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR => { + Some("PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR") } - Self::PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_KHR => { - Some("PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_KHR") + Self::PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR => { + Some("PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR") + } + Self::ACCELERATION_STRUCTURE_CREATE_INFO_KHR => { + Some("ACCELERATION_STRUCTURE_CREATE_INFO_KHR") + } + Self::ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR => { + Some("ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR") + } + Self::PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR => { + Some("PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR") + } + Self::PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR => { + Some("PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR") } Self::RAY_TRACING_PIPELINE_CREATE_INFO_KHR => { Some("RAY_TRACING_PIPELINE_CREATE_INFO_KHR") @@ -3634,12 +3867,12 @@ impl fmt::Debug for StructureType { Self::RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR => { Some("RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR") } - Self::ACCELERATION_STRUCTURE_CREATE_INFO_KHR => { - Some("ACCELERATION_STRUCTURE_CREATE_INFO_KHR") - } Self::RAY_TRACING_PIPELINE_INTERFACE_CREATE_INFO_KHR => { Some("RAY_TRACING_PIPELINE_INTERFACE_CREATE_INFO_KHR") } + Self::PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR => { + Some("PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR") + } Self::PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV => { Some("PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV") } @@ -3652,7 +3885,6 @@ impl fmt::Debug for StructureType { Self::DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT => { Some("DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT") } - Self::DRM_FORMAT_MODIFIER_PROPERTIES_EXT => Some("DRM_FORMAT_MODIFIER_PROPERTIES_EXT"), Self::PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT => { Some("PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT") } @@ -3669,6 +3901,12 @@ impl fmt::Debug for StructureType { Self::SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT => { Some("SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT") } + Self::PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR => { + Some("PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR") + } + Self::PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR => { + Some("PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR") + } Self::PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV => { Some("PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV") } @@ -3690,6 +3928,12 @@ impl fmt::Debug for StructureType { Self::GEOMETRY_NV => Some("GEOMETRY_NV"), Self::GEOMETRY_TRIANGLES_NV => Some("GEOMETRY_TRIANGLES_NV"), Self::GEOMETRY_AABB_NV => Some("GEOMETRY_AABB_NV"), + Self::BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NV => { + Some("BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NV") + } + Self::WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV => { + Some("WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV") + } Self::ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV => { Some("ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV") } @@ -3776,7 +4020,9 @@ impl fmt::Debug for StructureType { Self::PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL => { Some("PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL") } - Self::QUERY_POOL_CREATE_INFO_INTEL => Some("QUERY_POOL_CREATE_INFO_INTEL"), + Self::QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL => { + Some("QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL") + } Self::INITIALIZE_PERFORMANCE_API_INFO_INTEL => { Some("INITIALIZE_PERFORMANCE_API_INFO_INTEL") } @@ -3800,6 +4046,9 @@ impl fmt::Debug for StructureType { Self::IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA => { Some("IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA") } + Self::PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES_KHR => { + Some("PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES_KHR") + } Self::METAL_SURFACE_CREATE_INFO_EXT => Some("METAL_SURFACE_CREATE_INFO_EXT"), Self::PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT => { Some("PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT") @@ -3819,12 +4068,30 @@ impl fmt::Debug for StructureType { Self::PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT => { Some("PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT") } + Self::FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR => { + Some("FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR") + } + Self::PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR => { + Some("PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR") + } + Self::PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR => { + Some("PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR") + } + Self::PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR => { + Some("PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR") + } + Self::PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR => { + Some("PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR") + } Self::PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD => { Some("PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD") } Self::PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD => { Some("PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD") } + Self::PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT") + } Self::PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT => { Some("PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT") } @@ -3887,10 +4154,15 @@ impl fmt::Debug for StructureType { Self::PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT => { Some("PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT") } + Self::PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT") + } Self::PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT => { Some("PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT") } - Self::DEFERRED_OPERATION_INFO_KHR => Some("DEFERRED_OPERATION_INFO_KHR"), + Self::PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT") + } Self::PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR => { Some("PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR") } @@ -3936,7 +4208,38 @@ impl fmt::Debug for StructureType { Self::RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM => { Some("RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM") } + Self::PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT") + } + Self::DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT => { + Some("DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT") + } + Self::DEVICE_MEMORY_REPORT_CALLBACK_DATA_EXT => { + Some("DEVICE_MEMORY_REPORT_CALLBACK_DATA_EXT") + } + Self::PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT") + } + Self::PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT => { + Some("PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT") + } + Self::SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT => { + Some("SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT") + } + Self::PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT => { + Some("PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT") + } + Self::PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT") + } Self::PIPELINE_LIBRARY_CREATE_INFO_KHR => Some("PIPELINE_LIBRARY_CREATE_INFO_KHR"), + Self::PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES_EXT") + } + Self::DEVICE_PRIVATE_DATA_CREATE_INFO_EXT => { + Some("DEVICE_PRIVATE_DATA_CREATE_INFO_EXT") + } + Self::PRIVATE_DATA_SLOT_CREATE_INFO_EXT => Some("PRIVATE_DATA_SLOT_CREATE_INFO_EXT"), Self::PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES_EXT => { Some("PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES_EXT") } @@ -3947,6 +4250,40 @@ impl fmt::Debug for StructureType { Some("DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV") } Self::RESERVED_QCOM => Some("RESERVED_QCOM"), + Self::PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV => { + Some("PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV") + } + Self::PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV => { + Some("PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV") + } + Self::PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV => { + Some("PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV") + } + Self::PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT") + } + Self::PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT => { + Some("PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT") + } + Self::COPY_COMMAND_TRANSFORM_INFO_QCOM => Some("COPY_COMMAND_TRANSFORM_INFO_QCOM"), + Self::PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES_EXT") + } + Self::COPY_BUFFER_INFO_2_KHR => Some("COPY_BUFFER_INFO_2_KHR"), + Self::COPY_IMAGE_INFO_2_KHR => Some("COPY_IMAGE_INFO_2_KHR"), + Self::COPY_BUFFER_TO_IMAGE_INFO_2_KHR => Some("COPY_BUFFER_TO_IMAGE_INFO_2_KHR"), + Self::COPY_IMAGE_TO_BUFFER_INFO_2_KHR => Some("COPY_IMAGE_TO_BUFFER_INFO_2_KHR"), + Self::BLIT_IMAGE_INFO_2_KHR => Some("BLIT_IMAGE_INFO_2_KHR"), + Self::RESOLVE_IMAGE_INFO_2_KHR => Some("RESOLVE_IMAGE_INFO_2_KHR"), + Self::BUFFER_COPY_2_KHR => Some("BUFFER_COPY_2_KHR"), + Self::IMAGE_COPY_2_KHR => Some("IMAGE_COPY_2_KHR"), + Self::IMAGE_BLIT_2_KHR => Some("IMAGE_BLIT_2_KHR"), + Self::BUFFER_IMAGE_COPY_2_KHR => Some("BUFFER_IMAGE_COPY_2_KHR"), + Self::IMAGE_RESOLVE_2_KHR => Some("IMAGE_RESOLVE_2_KHR"), + Self::PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT") + } + Self::DIRECTFB_SURFACE_CREATE_INFO_EXT => Some("DIRECTFB_SURFACE_CREATE_INFO_EXT"), Self::PHYSICAL_DEVICE_SUBGROUP_PROPERTIES => { Some("PHYSICAL_DEVICE_SUBGROUP_PROPERTIES") } @@ -4233,12 +4570,12 @@ impl fmt::Debug for SubpassDescriptionFlags { "PER_VIEW_POSITION_X_ONLY_NVX", ), ( - SubpassDescriptionFlags::RESERVED_2_QCOM.0, - "RESERVED_2_QCOM", + SubpassDescriptionFlags::FRAGMENT_REGION_QCOM.0, + "FRAGMENT_REGION_QCOM", ), ( - SubpassDescriptionFlags::RESERVED_3_QCOM.0, - "RESERVED_3_QCOM", + SubpassDescriptionFlags::SHADER_RESOLVE_QCOM.0, + "SHADER_RESOLVE_QCOM", ), ]; debug_flags(f, KNOWN, self.0) @@ -4423,6 +4760,7 @@ impl fmt::Debug for ValidationFeatureEnableEXT { Self::GPU_ASSISTED_RESERVE_BINDING_SLOT => Some("GPU_ASSISTED_RESERVE_BINDING_SLOT"), Self::BEST_PRACTICES => Some("BEST_PRACTICES"), Self::DEBUG_PRINTF => Some("DEBUG_PRINTF"), + Self::SYNCHRONIZATION_VALIDATION => Some("SYNCHRONIZATION_VALIDATION"), _ => None, }; if let Some(x) = name { @@ -4439,6 +4777,7 @@ impl fmt::Debug for VendorId { Self::VSI => Some("VSI"), Self::KAZAN => Some("KAZAN"), Self::CODEPLAY => Some("CODEPLAY"), + Self::MESA => Some("MESA"), _ => None, }; if let Some(x) = name { diff --git a/ash/src/vk/definitions.rs b/ash/src/vk/definitions.rs index d4b5be2e1..45802ab82 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 = 135u32; +pub const HEADER_VERSION: u32 = 162u32; pub const HEADER_VERSION_COMPLETE: u32 = crate::vk::make_version(1, 2, HEADER_VERSION); #[doc = ""] pub type SampleMask = u32; @@ -93,6 +93,11 @@ pub struct DeviceCreateFlags(pub(crate) Flags); vk_bitflags_wrapped!(DeviceCreateFlags, 0b0, Flags); #[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct SemaphoreCreateFlags(pub(crate) Flags); +vk_bitflags_wrapped!(SemaphoreCreateFlags, 0b0, Flags); +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[doc = ""] pub struct EventCreateFlags(pub(crate) Flags); vk_bitflags_wrapped!(EventCreateFlags, 0b0, Flags); @@ -153,6 +158,11 @@ pub struct XcbSurfaceCreateFlagsKHR(pub(crate) Flags); vk_bitflags_wrapped!(XcbSurfaceCreateFlagsKHR, 0b0, Flags); #[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct DirectFBSurfaceCreateFlagsEXT(pub(crate) Flags); +vk_bitflags_wrapped!(DirectFBSurfaceCreateFlagsEXT, 0b0, Flags); +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[doc = ""] pub struct IOSSurfaceCreateFlagsMVK(pub(crate) Flags); vk_bitflags_wrapped!(IOSSurfaceCreateFlagsMVK, 0b0, Flags); @@ -228,6 +238,11 @@ pub struct DebugUtilsMessengerCallbackDataFlagsEXT(pub(crate) Flags); vk_bitflags_wrapped!(DebugUtilsMessengerCallbackDataFlagsEXT, 0b0, Flags); #[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct DeviceMemoryReportFlagsEXT(pub(crate) Flags); +vk_bitflags_wrapped!(DeviceMemoryReportFlagsEXT, 0b0, Flags); +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[doc = ""] pub struct PipelineRasterizationConservativeStateCreateFlagsEXT(pub(crate) Flags); vk_bitflags_wrapped!( @@ -340,8 +355,10 @@ handle_nondispatchable ! ( DescriptorUpdateTemplate , DESCRIPTOR_UPDATE_TEMPLATE handle_nondispatchable ! ( SamplerYcbcrConversion , SAMPLER_YCBCR_CONVERSION , doc = "" ) ; handle_nondispatchable ! ( ValidationCacheEXT , VALIDATION_CACHE_EXT , doc = "" ) ; handle_nondispatchable ! ( AccelerationStructureKHR , ACCELERATION_STRUCTURE_KHR , doc = "" ) ; +handle_nondispatchable ! ( AccelerationStructureNV , ACCELERATION_STRUCTURE_NV , doc = "" ) ; handle_nondispatchable ! ( PerformanceConfigurationINTEL , PERFORMANCE_CONFIGURATION_INTEL , doc = "" ) ; handle_nondispatchable ! ( DeferredOperationKHR , DEFERRED_OPERATION_KHR , doc = "" ) ; +handle_nondispatchable ! ( PrivateDataSlotEXT , PRIVATE_DATA_SLOT_EXT , doc = "" ) ; handle_nondispatchable!( DisplayKHR, DISPLAY_KHR, @@ -430,6 +447,14 @@ pub type PFN_vkDebugUtilsMessengerCallbackEXT = Option< p_user_data: *mut c_void, ) -> Bool32, >; +#[allow(non_camel_case_types)] +#[doc = ""] +pub type PFN_vkDeviceMemoryReportCallbackEXT = Option< + unsafe extern "system" fn( + p_callback_data: *const DeviceMemoryReportCallbackDataEXT, + p_user_data: *mut c_void, + ) -> c_void, +>; #[repr(C)] #[derive(Copy, Clone, Debug)] #[doc = ""] @@ -11733,6 +11758,95 @@ impl<'a> XcbSurfaceCreateInfoKHRBuilder<'a> { } #[repr(C)] #[derive(Copy, Clone, Debug)] +#[doc = ""] +pub struct DirectFBSurfaceCreateInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: DirectFBSurfaceCreateFlagsEXT, + pub dfb: *mut IDirectFB, + pub surface: *mut IDirectFBSurface, +} +impl ::std::default::Default for DirectFBSurfaceCreateInfoEXT { + fn default() -> DirectFBSurfaceCreateInfoEXT { + DirectFBSurfaceCreateInfoEXT { + s_type: StructureType::DIRECTFB_SURFACE_CREATE_INFO_EXT, + p_next: ::std::ptr::null(), + flags: DirectFBSurfaceCreateFlagsEXT::default(), + dfb: ::std::ptr::null_mut(), + surface: ::std::ptr::null_mut(), + } + } +} +impl DirectFBSurfaceCreateInfoEXT { + pub fn builder<'a>() -> DirectFBSurfaceCreateInfoEXTBuilder<'a> { + DirectFBSurfaceCreateInfoEXTBuilder { + inner: DirectFBSurfaceCreateInfoEXT::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DirectFBSurfaceCreateInfoEXTBuilder<'a> { + inner: DirectFBSurfaceCreateInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsDirectFBSurfaceCreateInfoEXT {} +impl<'a> ::std::ops::Deref for DirectFBSurfaceCreateInfoEXTBuilder<'a> { + type Target = DirectFBSurfaceCreateInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DirectFBSurfaceCreateInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DirectFBSurfaceCreateInfoEXTBuilder<'a> { + pub fn flags( + mut self, + flags: DirectFBSurfaceCreateFlagsEXT, + ) -> DirectFBSurfaceCreateInfoEXTBuilder<'a> { + self.inner.flags = flags; + self + } + pub fn dfb(mut self, dfb: *mut IDirectFB) -> DirectFBSurfaceCreateInfoEXTBuilder<'a> { + self.inner.dfb = dfb; + self + } + pub fn surface( + mut self, + surface: *mut IDirectFBSurface, + ) -> DirectFBSurfaceCreateInfoEXTBuilder<'a> { + self.inner.surface = surface; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next( + mut self, + next: &'a mut T, + ) -> DirectFBSurfaceCreateInfoEXTBuilder<'a> { + unsafe { + let next_ptr = next as *mut T as *mut BaseOutStructure; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DirectFBSurfaceCreateInfoEXT { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] #[doc = ""] pub struct ImagePipeSurfaceCreateInfoFUCHSIA { pub s_type: StructureType, @@ -13431,10 +13545,200 @@ impl<'a> PhysicalDeviceDeviceGeneratedCommandsFeaturesNVBuilder<'a> { } #[repr(C)] #[derive(Copy, Clone, Debug)] +#[doc = ""] +pub struct DevicePrivateDataCreateInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub private_data_slot_request_count: u32, +} +impl ::std::default::Default for DevicePrivateDataCreateInfoEXT { + fn default() -> DevicePrivateDataCreateInfoEXT { + DevicePrivateDataCreateInfoEXT { + s_type: StructureType::DEVICE_PRIVATE_DATA_CREATE_INFO_EXT, + p_next: ::std::ptr::null(), + private_data_slot_request_count: u32::default(), + } + } +} +impl DevicePrivateDataCreateInfoEXT { + pub fn builder<'a>() -> DevicePrivateDataCreateInfoEXTBuilder<'a> { + DevicePrivateDataCreateInfoEXTBuilder { + inner: DevicePrivateDataCreateInfoEXT::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DevicePrivateDataCreateInfoEXTBuilder<'a> { + inner: DevicePrivateDataCreateInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsDeviceCreateInfo for DevicePrivateDataCreateInfoEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for DevicePrivateDataCreateInfoEXT {} +impl<'a> ::std::ops::Deref for DevicePrivateDataCreateInfoEXTBuilder<'a> { + type Target = DevicePrivateDataCreateInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DevicePrivateDataCreateInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DevicePrivateDataCreateInfoEXTBuilder<'a> { + pub fn private_data_slot_request_count( + mut self, + private_data_slot_request_count: u32, + ) -> DevicePrivateDataCreateInfoEXTBuilder<'a> { + self.inner.private_data_slot_request_count = private_data_slot_request_count; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DevicePrivateDataCreateInfoEXT { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = ""] +pub struct PrivateDataSlotCreateInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: PrivateDataSlotCreateFlagsEXT, +} +impl ::std::default::Default for PrivateDataSlotCreateInfoEXT { + fn default() -> PrivateDataSlotCreateInfoEXT { + PrivateDataSlotCreateInfoEXT { + s_type: StructureType::PRIVATE_DATA_SLOT_CREATE_INFO_EXT, + p_next: ::std::ptr::null(), + flags: PrivateDataSlotCreateFlagsEXT::default(), + } + } +} +impl PrivateDataSlotCreateInfoEXT { + pub fn builder<'a>() -> PrivateDataSlotCreateInfoEXTBuilder<'a> { + PrivateDataSlotCreateInfoEXTBuilder { + inner: PrivateDataSlotCreateInfoEXT::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PrivateDataSlotCreateInfoEXTBuilder<'a> { + inner: PrivateDataSlotCreateInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsPrivateDataSlotCreateInfoEXT {} +impl<'a> ::std::ops::Deref for PrivateDataSlotCreateInfoEXTBuilder<'a> { + type Target = PrivateDataSlotCreateInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PrivateDataSlotCreateInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PrivateDataSlotCreateInfoEXTBuilder<'a> { + pub fn flags( + mut self, + flags: PrivateDataSlotCreateFlagsEXT, + ) -> PrivateDataSlotCreateInfoEXTBuilder<'a> { + self.inner.flags = flags; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next( + mut self, + next: &'a mut T, + ) -> PrivateDataSlotCreateInfoEXTBuilder<'a> { + unsafe { + let next_ptr = next as *mut T as *mut BaseOutStructure; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PrivateDataSlotCreateInfoEXT { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = ""] +pub struct PhysicalDevicePrivateDataFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub private_data: Bool32, +} +impl ::std::default::Default for PhysicalDevicePrivateDataFeaturesEXT { + fn default() -> PhysicalDevicePrivateDataFeaturesEXT { + PhysicalDevicePrivateDataFeaturesEXT { + s_type: StructureType::PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES_EXT, + p_next: ::std::ptr::null_mut(), + private_data: Bool32::default(), + } + } +} +impl PhysicalDevicePrivateDataFeaturesEXT { + pub fn builder<'a>() -> PhysicalDevicePrivateDataFeaturesEXTBuilder<'a> { + PhysicalDevicePrivateDataFeaturesEXTBuilder { + inner: PhysicalDevicePrivateDataFeaturesEXT::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDevicePrivateDataFeaturesEXTBuilder<'a> { + inner: PhysicalDevicePrivateDataFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePrivateDataFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePrivateDataFeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDevicePrivateDataFeaturesEXTBuilder<'a> { + type Target = PhysicalDevicePrivateDataFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDevicePrivateDataFeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDevicePrivateDataFeaturesEXTBuilder<'a> { + pub fn private_data( + mut self, + private_data: bool, + ) -> PhysicalDevicePrivateDataFeaturesEXTBuilder<'a> { + self.inner.private_data = private_data.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDevicePrivateDataFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] #[doc = ""] pub struct PhysicalDeviceDeviceGeneratedCommandsPropertiesNV { pub s_type: StructureType, - pub p_next: *const c_void, + pub p_next: *mut c_void, pub max_graphics_shader_group_count: u32, pub max_indirect_sequence_count: u32, pub max_indirect_commands_token_count: u32, @@ -13449,7 +13753,7 @@ impl ::std::default::Default for PhysicalDeviceDeviceGeneratedCommandsProperties fn default() -> PhysicalDeviceDeviceGeneratedCommandsPropertiesNV { PhysicalDeviceDeviceGeneratedCommandsPropertiesNV { s_type: StructureType::PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV, - p_next: ::std::ptr::null(), + p_next: ::std::ptr::null_mut(), max_graphics_shader_group_count: u32::default(), max_indirect_sequence_count: u32::default(), max_indirect_commands_token_count: u32::default(), @@ -27207,6 +27511,276 @@ impl<'a> DebugUtilsMessengerCallbackDataEXTBuilder<'a> { } #[repr(C)] #[derive(Copy, Clone, Debug)] +#[doc = ""] +pub struct PhysicalDeviceDeviceMemoryReportFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub device_memory_report: Bool32, +} +impl ::std::default::Default for PhysicalDeviceDeviceMemoryReportFeaturesEXT { + fn default() -> PhysicalDeviceDeviceMemoryReportFeaturesEXT { + PhysicalDeviceDeviceMemoryReportFeaturesEXT { + s_type: StructureType::PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT, + p_next: ::std::ptr::null_mut(), + device_memory_report: Bool32::default(), + } + } +} +impl PhysicalDeviceDeviceMemoryReportFeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceDeviceMemoryReportFeaturesEXTBuilder<'a> { + PhysicalDeviceDeviceMemoryReportFeaturesEXTBuilder { + inner: PhysicalDeviceDeviceMemoryReportFeaturesEXT::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceDeviceMemoryReportFeaturesEXTBuilder<'a> { + inner: PhysicalDeviceDeviceMemoryReportFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDeviceMemoryReportFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDeviceMemoryReportFeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceDeviceMemoryReportFeaturesEXTBuilder<'a> { + type Target = PhysicalDeviceDeviceMemoryReportFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceDeviceMemoryReportFeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceDeviceMemoryReportFeaturesEXTBuilder<'a> { + pub fn device_memory_report( + mut self, + device_memory_report: bool, + ) -> PhysicalDeviceDeviceMemoryReportFeaturesEXTBuilder<'a> { + self.inner.device_memory_report = device_memory_report.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceDeviceMemoryReportFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DeviceDeviceMemoryReportCreateInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: DeviceMemoryReportFlagsEXT, + pub pfn_user_callback: PFN_vkDeviceMemoryReportCallbackEXT, + pub p_user_data: *mut c_void, +} +impl fmt::Debug for DeviceDeviceMemoryReportCreateInfoEXT { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fmt.debug_struct("DeviceDeviceMemoryReportCreateInfoEXT") + .field("s_type", &self.s_type) + .field("p_next", &self.p_next) + .field("flags", &self.flags) + .field( + "pfn_user_callback", + &(self.pfn_user_callback.map(|x| x as *const ())), + ) + .field("p_user_data", &self.p_user_data) + .finish() + } +} +impl ::std::default::Default for DeviceDeviceMemoryReportCreateInfoEXT { + fn default() -> DeviceDeviceMemoryReportCreateInfoEXT { + DeviceDeviceMemoryReportCreateInfoEXT { + s_type: StructureType::DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT, + p_next: ::std::ptr::null(), + flags: DeviceMemoryReportFlagsEXT::default(), + pfn_user_callback: PFN_vkDeviceMemoryReportCallbackEXT::default(), + p_user_data: ::std::ptr::null_mut(), + } + } +} +impl DeviceDeviceMemoryReportCreateInfoEXT { + pub fn builder<'a>() -> DeviceDeviceMemoryReportCreateInfoEXTBuilder<'a> { + DeviceDeviceMemoryReportCreateInfoEXTBuilder { + inner: DeviceDeviceMemoryReportCreateInfoEXT::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DeviceDeviceMemoryReportCreateInfoEXTBuilder<'a> { + inner: DeviceDeviceMemoryReportCreateInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsDeviceCreateInfo for DeviceDeviceMemoryReportCreateInfoEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for DeviceDeviceMemoryReportCreateInfoEXT {} +impl<'a> ::std::ops::Deref for DeviceDeviceMemoryReportCreateInfoEXTBuilder<'a> { + type Target = DeviceDeviceMemoryReportCreateInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DeviceDeviceMemoryReportCreateInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DeviceDeviceMemoryReportCreateInfoEXTBuilder<'a> { + pub fn flags( + mut self, + flags: DeviceMemoryReportFlagsEXT, + ) -> DeviceDeviceMemoryReportCreateInfoEXTBuilder<'a> { + self.inner.flags = flags; + self + } + pub fn pfn_user_callback( + mut self, + pfn_user_callback: PFN_vkDeviceMemoryReportCallbackEXT, + ) -> DeviceDeviceMemoryReportCreateInfoEXTBuilder<'a> { + self.inner.pfn_user_callback = pfn_user_callback; + self + } + pub fn user_data( + mut self, + user_data: *mut c_void, + ) -> DeviceDeviceMemoryReportCreateInfoEXTBuilder<'a> { + self.inner.p_user_data = user_data; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DeviceDeviceMemoryReportCreateInfoEXT { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = ""] +pub struct DeviceMemoryReportCallbackDataEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: DeviceMemoryReportFlagsEXT, + pub ty: DeviceMemoryReportEventTypeEXT, + pub memory_object_id: u64, + pub size: DeviceSize, + pub object_type: ObjectType, + pub object_handle: u64, + pub heap_index: u32, +} +impl ::std::default::Default for DeviceMemoryReportCallbackDataEXT { + fn default() -> DeviceMemoryReportCallbackDataEXT { + DeviceMemoryReportCallbackDataEXT { + s_type: StructureType::DEVICE_MEMORY_REPORT_CALLBACK_DATA_EXT, + p_next: ::std::ptr::null(), + flags: DeviceMemoryReportFlagsEXT::default(), + ty: DeviceMemoryReportEventTypeEXT::default(), + memory_object_id: u64::default(), + size: DeviceSize::default(), + object_type: ObjectType::default(), + object_handle: u64::default(), + heap_index: u32::default(), + } + } +} +impl DeviceMemoryReportCallbackDataEXT { + pub fn builder<'a>() -> DeviceMemoryReportCallbackDataEXTBuilder<'a> { + DeviceMemoryReportCallbackDataEXTBuilder { + inner: DeviceMemoryReportCallbackDataEXT::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct DeviceMemoryReportCallbackDataEXTBuilder<'a> { + inner: DeviceMemoryReportCallbackDataEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsDeviceMemoryReportCallbackDataEXT {} +impl<'a> ::std::ops::Deref for DeviceMemoryReportCallbackDataEXTBuilder<'a> { + type Target = DeviceMemoryReportCallbackDataEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for DeviceMemoryReportCallbackDataEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> DeviceMemoryReportCallbackDataEXTBuilder<'a> { + pub fn flags( + mut self, + flags: DeviceMemoryReportFlagsEXT, + ) -> DeviceMemoryReportCallbackDataEXTBuilder<'a> { + self.inner.flags = flags; + self + } + pub fn ty( + mut self, + ty: DeviceMemoryReportEventTypeEXT, + ) -> DeviceMemoryReportCallbackDataEXTBuilder<'a> { + self.inner.ty = ty; + self + } + pub fn memory_object_id( + mut self, + memory_object_id: u64, + ) -> DeviceMemoryReportCallbackDataEXTBuilder<'a> { + self.inner.memory_object_id = memory_object_id; + self + } + pub fn size(mut self, size: DeviceSize) -> DeviceMemoryReportCallbackDataEXTBuilder<'a> { + self.inner.size = size; + self + } + pub fn object_type( + mut self, + object_type: ObjectType, + ) -> DeviceMemoryReportCallbackDataEXTBuilder<'a> { + self.inner.object_type = object_type; + self + } + pub fn object_handle( + mut self, + object_handle: u64, + ) -> DeviceMemoryReportCallbackDataEXTBuilder<'a> { + self.inner.object_handle = object_handle; + self + } + pub fn heap_index(mut self, heap_index: u32) -> DeviceMemoryReportCallbackDataEXTBuilder<'a> { + self.inner.heap_index = heap_index; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next( + mut self, + next: &'a mut T, + ) -> DeviceMemoryReportCallbackDataEXTBuilder<'a> { + unsafe { + let next_ptr = next as *mut T as *mut BaseOutStructure; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> DeviceMemoryReportCallbackDataEXT { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] #[doc = ""] pub struct ImportMemoryHostPointerInfoEXT { pub s_type: StructureType, @@ -30924,6 +31498,163 @@ impl<'a> PhysicalDeviceShaderAtomicInt64FeaturesBuilder<'a> { } #[repr(C)] #[derive(Copy, Clone, Debug)] +#[doc = ""] +pub struct PhysicalDeviceShaderAtomicFloatFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub shader_buffer_float32_atomics: Bool32, + pub shader_buffer_float32_atomic_add: Bool32, + pub shader_buffer_float64_atomics: Bool32, + pub shader_buffer_float64_atomic_add: Bool32, + pub shader_shared_float32_atomics: Bool32, + pub shader_shared_float32_atomic_add: Bool32, + pub shader_shared_float64_atomics: Bool32, + pub shader_shared_float64_atomic_add: Bool32, + pub shader_image_float32_atomics: Bool32, + pub shader_image_float32_atomic_add: Bool32, + pub sparse_image_float32_atomics: Bool32, + pub sparse_image_float32_atomic_add: Bool32, +} +impl ::std::default::Default for PhysicalDeviceShaderAtomicFloatFeaturesEXT { + fn default() -> PhysicalDeviceShaderAtomicFloatFeaturesEXT { + PhysicalDeviceShaderAtomicFloatFeaturesEXT { + s_type: StructureType::PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT, + p_next: ::std::ptr::null_mut(), + shader_buffer_float32_atomics: Bool32::default(), + shader_buffer_float32_atomic_add: Bool32::default(), + shader_buffer_float64_atomics: Bool32::default(), + shader_buffer_float64_atomic_add: Bool32::default(), + shader_shared_float32_atomics: Bool32::default(), + shader_shared_float32_atomic_add: Bool32::default(), + shader_shared_float64_atomics: Bool32::default(), + shader_shared_float64_atomic_add: Bool32::default(), + shader_image_float32_atomics: Bool32::default(), + shader_image_float32_atomic_add: Bool32::default(), + sparse_image_float32_atomics: Bool32::default(), + sparse_image_float32_atomic_add: Bool32::default(), + } + } +} +impl PhysicalDeviceShaderAtomicFloatFeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceShaderAtomicFloatFeaturesEXTBuilder<'a> { + PhysicalDeviceShaderAtomicFloatFeaturesEXTBuilder { + inner: PhysicalDeviceShaderAtomicFloatFeaturesEXT::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceShaderAtomicFloatFeaturesEXTBuilder<'a> { + inner: PhysicalDeviceShaderAtomicFloatFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderAtomicFloatFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderAtomicFloatFeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceShaderAtomicFloatFeaturesEXTBuilder<'a> { + type Target = PhysicalDeviceShaderAtomicFloatFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderAtomicFloatFeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceShaderAtomicFloatFeaturesEXTBuilder<'a> { + pub fn shader_buffer_float32_atomics( + mut self, + shader_buffer_float32_atomics: bool, + ) -> PhysicalDeviceShaderAtomicFloatFeaturesEXTBuilder<'a> { + self.inner.shader_buffer_float32_atomics = shader_buffer_float32_atomics.into(); + self + } + pub fn shader_buffer_float32_atomic_add( + mut self, + shader_buffer_float32_atomic_add: bool, + ) -> PhysicalDeviceShaderAtomicFloatFeaturesEXTBuilder<'a> { + self.inner.shader_buffer_float32_atomic_add = shader_buffer_float32_atomic_add.into(); + self + } + pub fn shader_buffer_float64_atomics( + mut self, + shader_buffer_float64_atomics: bool, + ) -> PhysicalDeviceShaderAtomicFloatFeaturesEXTBuilder<'a> { + self.inner.shader_buffer_float64_atomics = shader_buffer_float64_atomics.into(); + self + } + pub fn shader_buffer_float64_atomic_add( + mut self, + shader_buffer_float64_atomic_add: bool, + ) -> PhysicalDeviceShaderAtomicFloatFeaturesEXTBuilder<'a> { + self.inner.shader_buffer_float64_atomic_add = shader_buffer_float64_atomic_add.into(); + self + } + pub fn shader_shared_float32_atomics( + mut self, + shader_shared_float32_atomics: bool, + ) -> PhysicalDeviceShaderAtomicFloatFeaturesEXTBuilder<'a> { + self.inner.shader_shared_float32_atomics = shader_shared_float32_atomics.into(); + self + } + pub fn shader_shared_float32_atomic_add( + mut self, + shader_shared_float32_atomic_add: bool, + ) -> PhysicalDeviceShaderAtomicFloatFeaturesEXTBuilder<'a> { + self.inner.shader_shared_float32_atomic_add = shader_shared_float32_atomic_add.into(); + self + } + pub fn shader_shared_float64_atomics( + mut self, + shader_shared_float64_atomics: bool, + ) -> PhysicalDeviceShaderAtomicFloatFeaturesEXTBuilder<'a> { + self.inner.shader_shared_float64_atomics = shader_shared_float64_atomics.into(); + self + } + pub fn shader_shared_float64_atomic_add( + mut self, + shader_shared_float64_atomic_add: bool, + ) -> PhysicalDeviceShaderAtomicFloatFeaturesEXTBuilder<'a> { + self.inner.shader_shared_float64_atomic_add = shader_shared_float64_atomic_add.into(); + self + } + pub fn shader_image_float32_atomics( + mut self, + shader_image_float32_atomics: bool, + ) -> PhysicalDeviceShaderAtomicFloatFeaturesEXTBuilder<'a> { + self.inner.shader_image_float32_atomics = shader_image_float32_atomics.into(); + self + } + pub fn shader_image_float32_atomic_add( + mut self, + shader_image_float32_atomic_add: bool, + ) -> PhysicalDeviceShaderAtomicFloatFeaturesEXTBuilder<'a> { + self.inner.shader_image_float32_atomic_add = shader_image_float32_atomic_add.into(); + self + } + pub fn sparse_image_float32_atomics( + mut self, + sparse_image_float32_atomics: bool, + ) -> PhysicalDeviceShaderAtomicFloatFeaturesEXTBuilder<'a> { + self.inner.sparse_image_float32_atomics = sparse_image_float32_atomics.into(); + self + } + pub fn sparse_image_float32_atomic_add( + mut self, + sparse_image_float32_atomic_add: bool, + ) -> PhysicalDeviceShaderAtomicFloatFeaturesEXTBuilder<'a> { + self.inner.sparse_image_float32_atomic_add = sparse_image_float32_atomic_add.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceShaderAtomicFloatFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] #[doc = ""] pub struct PhysicalDeviceVertexAttributeDivisorFeaturesEXT { pub s_type: StructureType, @@ -33379,9 +34110,10 @@ pub struct RayTracingPipelineCreateInfoKHR { pub p_stages: *const PipelineShaderStageCreateInfo, pub group_count: u32, pub p_groups: *const RayTracingShaderGroupCreateInfoKHR, - pub max_recursion_depth: u32, - pub libraries: PipelineLibraryCreateInfoKHR, + pub max_pipeline_ray_recursion_depth: u32, + pub p_library_info: *const PipelineLibraryCreateInfoKHR, pub p_library_interface: *const RayTracingPipelineInterfaceCreateInfoKHR, + pub p_dynamic_state: *const PipelineDynamicStateCreateInfo, pub layout: PipelineLayout, pub base_pipeline_handle: Pipeline, pub base_pipeline_index: i32, @@ -33396,9 +34128,10 @@ impl ::std::default::Default for RayTracingPipelineCreateInfoKHR { p_stages: ::std::ptr::null(), group_count: u32::default(), p_groups: ::std::ptr::null(), - max_recursion_depth: u32::default(), - libraries: PipelineLibraryCreateInfoKHR::default(), + max_pipeline_ray_recursion_depth: u32::default(), + p_library_info: ::std::ptr::null(), p_library_interface: ::std::ptr::null(), + p_dynamic_state: ::std::ptr::null(), layout: PipelineLayout::default(), base_pipeline_handle: Pipeline::default(), base_pipeline_index: i32::default(), @@ -33454,18 +34187,18 @@ impl<'a> RayTracingPipelineCreateInfoKHRBuilder<'a> { self.inner.p_groups = groups.as_ptr(); self } - pub fn max_recursion_depth( + pub fn max_pipeline_ray_recursion_depth( mut self, - max_recursion_depth: u32, + max_pipeline_ray_recursion_depth: u32, ) -> RayTracingPipelineCreateInfoKHRBuilder<'a> { - self.inner.max_recursion_depth = max_recursion_depth; + self.inner.max_pipeline_ray_recursion_depth = max_pipeline_ray_recursion_depth; self } - pub fn libraries( + pub fn library_info( mut self, - libraries: PipelineLibraryCreateInfoKHR, + library_info: &'a PipelineLibraryCreateInfoKHR, ) -> RayTracingPipelineCreateInfoKHRBuilder<'a> { - self.inner.libraries = libraries; + self.inner.p_library_info = library_info; self } pub fn library_interface( @@ -33475,6 +34208,13 @@ impl<'a> RayTracingPipelineCreateInfoKHRBuilder<'a> { self.inner.p_library_interface = library_interface; self } + pub fn dynamic_state( + mut self, + dynamic_state: &'a PipelineDynamicStateCreateInfo, + ) -> RayTracingPipelineCreateInfoKHRBuilder<'a> { + self.inner.p_dynamic_state = dynamic_state; + self + } pub fn layout(mut self, layout: PipelineLayout) -> RayTracingPipelineCreateInfoKHRBuilder<'a> { self.inner.layout = layout; self @@ -34050,22 +34790,22 @@ impl<'a> AccelerationStructureCreateInfoNVBuilder<'a> { } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = ""] -pub struct BindAccelerationStructureMemoryInfoKHR { +#[doc = ""] +pub struct BindAccelerationStructureMemoryInfoNV { pub s_type: StructureType, pub p_next: *const c_void, - pub acceleration_structure: AccelerationStructureKHR, + pub acceleration_structure: AccelerationStructureNV, pub memory: DeviceMemory, pub memory_offset: DeviceSize, pub device_index_count: u32, pub p_device_indices: *const u32, } -impl ::std::default::Default for BindAccelerationStructureMemoryInfoKHR { - fn default() -> BindAccelerationStructureMemoryInfoKHR { - BindAccelerationStructureMemoryInfoKHR { - s_type: StructureType::BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_KHR, +impl ::std::default::Default for BindAccelerationStructureMemoryInfoNV { + fn default() -> BindAccelerationStructureMemoryInfoNV { + BindAccelerationStructureMemoryInfoNV { + s_type: StructureType::BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NV, p_next: ::std::ptr::null(), - acceleration_structure: AccelerationStructureKHR::default(), + acceleration_structure: AccelerationStructureNV::default(), memory: DeviceMemory::default(), memory_offset: DeviceSize::default(), device_index_count: u32::default(), @@ -34073,57 +34813,57 @@ impl ::std::default::Default for BindAccelerationStructureMemoryInfoKHR { } } } -impl BindAccelerationStructureMemoryInfoKHR { - pub fn builder<'a>() -> BindAccelerationStructureMemoryInfoKHRBuilder<'a> { - BindAccelerationStructureMemoryInfoKHRBuilder { - inner: BindAccelerationStructureMemoryInfoKHR::default(), +impl BindAccelerationStructureMemoryInfoNV { + pub fn builder<'a>() -> BindAccelerationStructureMemoryInfoNVBuilder<'a> { + BindAccelerationStructureMemoryInfoNVBuilder { + inner: BindAccelerationStructureMemoryInfoNV::default(), marker: ::std::marker::PhantomData, } } } #[repr(transparent)] -pub struct BindAccelerationStructureMemoryInfoKHRBuilder<'a> { - inner: BindAccelerationStructureMemoryInfoKHR, +pub struct BindAccelerationStructureMemoryInfoNVBuilder<'a> { + inner: BindAccelerationStructureMemoryInfoNV, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsBindAccelerationStructureMemoryInfoKHR {} -impl<'a> ::std::ops::Deref for BindAccelerationStructureMemoryInfoKHRBuilder<'a> { - type Target = BindAccelerationStructureMemoryInfoKHR; +pub unsafe trait ExtendsBindAccelerationStructureMemoryInfoNV {} +impl<'a> ::std::ops::Deref for BindAccelerationStructureMemoryInfoNVBuilder<'a> { + type Target = BindAccelerationStructureMemoryInfoNV; fn deref(&self) -> &Self::Target { &self.inner } } -impl<'a> ::std::ops::DerefMut for BindAccelerationStructureMemoryInfoKHRBuilder<'a> { +impl<'a> ::std::ops::DerefMut for BindAccelerationStructureMemoryInfoNVBuilder<'a> { fn deref_mut(&mut self) -> &mut Self::Target { &mut self.inner } } -impl<'a> BindAccelerationStructureMemoryInfoKHRBuilder<'a> { +impl<'a> BindAccelerationStructureMemoryInfoNVBuilder<'a> { pub fn acceleration_structure( mut self, - acceleration_structure: AccelerationStructureKHR, - ) -> BindAccelerationStructureMemoryInfoKHRBuilder<'a> { + acceleration_structure: AccelerationStructureNV, + ) -> BindAccelerationStructureMemoryInfoNVBuilder<'a> { self.inner.acceleration_structure = acceleration_structure; self } pub fn memory( mut self, memory: DeviceMemory, - ) -> BindAccelerationStructureMemoryInfoKHRBuilder<'a> { + ) -> BindAccelerationStructureMemoryInfoNVBuilder<'a> { self.inner.memory = memory; self } pub fn memory_offset( mut self, memory_offset: DeviceSize, - ) -> BindAccelerationStructureMemoryInfoKHRBuilder<'a> { + ) -> BindAccelerationStructureMemoryInfoNVBuilder<'a> { self.inner.memory_offset = memory_offset; self } pub fn device_indices( mut self, device_indices: &'a [u32], - ) -> BindAccelerationStructureMemoryInfoKHRBuilder<'a> { + ) -> BindAccelerationStructureMemoryInfoNVBuilder<'a> { self.inner.device_index_count = device_indices.len() as _; self.inner.p_device_indices = device_indices.as_ptr(); self @@ -34133,10 +34873,10 @@ impl<'a> BindAccelerationStructureMemoryInfoKHRBuilder<'a> { #[doc = r" valid extension structs can be pushed into the chain."] #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next( + pub fn push_next( mut self, next: &'a mut T, - ) -> BindAccelerationStructureMemoryInfoKHRBuilder<'a> { + ) -> BindAccelerationStructureMemoryInfoNVBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; let last_next = ptr_chain_iter(next).last().unwrap(); @@ -34148,7 +34888,7 @@ impl<'a> BindAccelerationStructureMemoryInfoKHRBuilder<'a> { #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> BindAccelerationStructureMemoryInfoKHR { + pub fn build(self) -> BindAccelerationStructureMemoryInfoNV { self.inner } } @@ -34215,93 +34955,62 @@ impl<'a> WriteDescriptorSetAccelerationStructureKHRBuilder<'a> { } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = ""] -pub struct AccelerationStructureMemoryRequirementsInfoKHR { +#[doc = ""] +pub struct WriteDescriptorSetAccelerationStructureNV { pub s_type: StructureType, pub p_next: *const c_void, - pub ty: AccelerationStructureMemoryRequirementsTypeKHR, - pub build_type: AccelerationStructureBuildTypeKHR, - pub acceleration_structure: AccelerationStructureKHR, + pub acceleration_structure_count: u32, + pub p_acceleration_structures: *const AccelerationStructureNV, } -impl ::std::default::Default for AccelerationStructureMemoryRequirementsInfoKHR { - fn default() -> AccelerationStructureMemoryRequirementsInfoKHR { - AccelerationStructureMemoryRequirementsInfoKHR { - s_type: StructureType::ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_KHR, +impl ::std::default::Default for WriteDescriptorSetAccelerationStructureNV { + fn default() -> WriteDescriptorSetAccelerationStructureNV { + WriteDescriptorSetAccelerationStructureNV { + s_type: StructureType::WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV, p_next: ::std::ptr::null(), - ty: AccelerationStructureMemoryRequirementsTypeKHR::default(), - build_type: AccelerationStructureBuildTypeKHR::default(), - acceleration_structure: AccelerationStructureKHR::default(), + acceleration_structure_count: u32::default(), + p_acceleration_structures: ::std::ptr::null(), } } } -impl AccelerationStructureMemoryRequirementsInfoKHR { - pub fn builder<'a>() -> AccelerationStructureMemoryRequirementsInfoKHRBuilder<'a> { - AccelerationStructureMemoryRequirementsInfoKHRBuilder { - inner: AccelerationStructureMemoryRequirementsInfoKHR::default(), +impl WriteDescriptorSetAccelerationStructureNV { + pub fn builder<'a>() -> WriteDescriptorSetAccelerationStructureNVBuilder<'a> { + WriteDescriptorSetAccelerationStructureNVBuilder { + inner: WriteDescriptorSetAccelerationStructureNV::default(), marker: ::std::marker::PhantomData, } } } #[repr(transparent)] -pub struct AccelerationStructureMemoryRequirementsInfoKHRBuilder<'a> { - inner: AccelerationStructureMemoryRequirementsInfoKHR, +pub struct WriteDescriptorSetAccelerationStructureNVBuilder<'a> { + inner: WriteDescriptorSetAccelerationStructureNV, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsAccelerationStructureMemoryRequirementsInfoKHR {} -impl<'a> ::std::ops::Deref for AccelerationStructureMemoryRequirementsInfoKHRBuilder<'a> { - type Target = AccelerationStructureMemoryRequirementsInfoKHR; +unsafe impl ExtendsWriteDescriptorSet for WriteDescriptorSetAccelerationStructureNVBuilder<'_> {} +unsafe impl ExtendsWriteDescriptorSet for WriteDescriptorSetAccelerationStructureNV {} +impl<'a> ::std::ops::Deref for WriteDescriptorSetAccelerationStructureNVBuilder<'a> { + type Target = WriteDescriptorSetAccelerationStructureNV; fn deref(&self) -> &Self::Target { &self.inner } } -impl<'a> ::std::ops::DerefMut for AccelerationStructureMemoryRequirementsInfoKHRBuilder<'a> { +impl<'a> ::std::ops::DerefMut for WriteDescriptorSetAccelerationStructureNVBuilder<'a> { fn deref_mut(&mut self) -> &mut Self::Target { &mut self.inner } } -impl<'a> AccelerationStructureMemoryRequirementsInfoKHRBuilder<'a> { - pub fn ty( - mut self, - ty: AccelerationStructureMemoryRequirementsTypeKHR, - ) -> AccelerationStructureMemoryRequirementsInfoKHRBuilder<'a> { - self.inner.ty = ty; - self - } - pub fn build_type( - mut self, - build_type: AccelerationStructureBuildTypeKHR, - ) -> AccelerationStructureMemoryRequirementsInfoKHRBuilder<'a> { - self.inner.build_type = build_type; - self - } - pub fn acceleration_structure( - mut self, - acceleration_structure: AccelerationStructureKHR, - ) -> AccelerationStructureMemoryRequirementsInfoKHRBuilder<'a> { - self.inner.acceleration_structure = acceleration_structure; - self - } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next( +impl<'a> WriteDescriptorSetAccelerationStructureNVBuilder<'a> { + pub fn acceleration_structures( mut self, - next: &'a mut T, - ) -> AccelerationStructureMemoryRequirementsInfoKHRBuilder<'a> { - unsafe { - let next_ptr = next as *mut T as *mut BaseOutStructure; - let last_next = ptr_chain_iter(next).last().unwrap(); - (*last_next).p_next = self.inner.p_next as _; - self.inner.p_next = next_ptr as _; - } + acceleration_structures: &'a [AccelerationStructureNV], + ) -> WriteDescriptorSetAccelerationStructureNVBuilder<'a> { + self.inner.acceleration_structure_count = acceleration_structures.len() as _; + self.inner.p_acceleration_structures = acceleration_structures.as_ptr(); self } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> AccelerationStructureMemoryRequirementsInfoKHR { + pub fn build(self) -> WriteDescriptorSetAccelerationStructureNV { self.inner } } @@ -34390,266 +35099,511 @@ impl<'a> AccelerationStructureMemoryRequirementsInfoNVBuilder<'a> { } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = ""] -pub struct PhysicalDeviceRayTracingFeaturesKHR { +#[doc = ""] +pub struct PhysicalDeviceAccelerationStructureFeaturesKHR { pub s_type: StructureType, pub p_next: *mut c_void, - pub ray_tracing: Bool32, - pub ray_tracing_shader_group_handle_capture_replay: Bool32, - pub ray_tracing_shader_group_handle_capture_replay_mixed: Bool32, - pub ray_tracing_acceleration_structure_capture_replay: Bool32, - pub ray_tracing_indirect_trace_rays: Bool32, - pub ray_tracing_indirect_acceleration_structure_build: Bool32, - pub ray_tracing_host_acceleration_structure_commands: Bool32, - pub ray_query: Bool32, - pub ray_tracing_primitive_culling: Bool32, -} -impl ::std::default::Default for PhysicalDeviceRayTracingFeaturesKHR { - fn default() -> PhysicalDeviceRayTracingFeaturesKHR { - PhysicalDeviceRayTracingFeaturesKHR { - s_type: StructureType::PHYSICAL_DEVICE_RAY_TRACING_FEATURES_KHR, + pub acceleration_structure: Bool32, + pub acceleration_structure_capture_replay: Bool32, + pub acceleration_structure_indirect_build: Bool32, + pub acceleration_structure_host_commands: Bool32, + pub descriptor_binding_acceleration_structure_update_after_bind: Bool32, +} +impl ::std::default::Default for PhysicalDeviceAccelerationStructureFeaturesKHR { + fn default() -> PhysicalDeviceAccelerationStructureFeaturesKHR { + PhysicalDeviceAccelerationStructureFeaturesKHR { + s_type: StructureType::PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR, p_next: ::std::ptr::null_mut(), - ray_tracing: Bool32::default(), - ray_tracing_shader_group_handle_capture_replay: Bool32::default(), - ray_tracing_shader_group_handle_capture_replay_mixed: Bool32::default(), - ray_tracing_acceleration_structure_capture_replay: Bool32::default(), - ray_tracing_indirect_trace_rays: Bool32::default(), - ray_tracing_indirect_acceleration_structure_build: Bool32::default(), - ray_tracing_host_acceleration_structure_commands: Bool32::default(), - ray_query: Bool32::default(), - ray_tracing_primitive_culling: Bool32::default(), + acceleration_structure: Bool32::default(), + acceleration_structure_capture_replay: Bool32::default(), + acceleration_structure_indirect_build: Bool32::default(), + acceleration_structure_host_commands: Bool32::default(), + descriptor_binding_acceleration_structure_update_after_bind: Bool32::default(), } } } -impl PhysicalDeviceRayTracingFeaturesKHR { - pub fn builder<'a>() -> PhysicalDeviceRayTracingFeaturesKHRBuilder<'a> { - PhysicalDeviceRayTracingFeaturesKHRBuilder { - inner: PhysicalDeviceRayTracingFeaturesKHR::default(), +impl PhysicalDeviceAccelerationStructureFeaturesKHR { + pub fn builder<'a>() -> PhysicalDeviceAccelerationStructureFeaturesKHRBuilder<'a> { + PhysicalDeviceAccelerationStructureFeaturesKHRBuilder { + inner: PhysicalDeviceAccelerationStructureFeaturesKHR::default(), marker: ::std::marker::PhantomData, } } } #[repr(transparent)] -pub struct PhysicalDeviceRayTracingFeaturesKHRBuilder<'a> { - inner: PhysicalDeviceRayTracingFeaturesKHR, +pub struct PhysicalDeviceAccelerationStructureFeaturesKHRBuilder<'a> { + inner: PhysicalDeviceAccelerationStructureFeaturesKHR, marker: ::std::marker::PhantomData<&'a ()>, } -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceRayTracingFeaturesKHRBuilder<'_> {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceRayTracingFeaturesKHR {} -impl<'a> ::std::ops::Deref for PhysicalDeviceRayTracingFeaturesKHRBuilder<'a> { - type Target = PhysicalDeviceRayTracingFeaturesKHR; +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceAccelerationStructureFeaturesKHRBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceAccelerationStructureFeaturesKHR {} +impl<'a> ::std::ops::Deref for PhysicalDeviceAccelerationStructureFeaturesKHRBuilder<'a> { + type Target = PhysicalDeviceAccelerationStructureFeaturesKHR; fn deref(&self) -> &Self::Target { &self.inner } } -impl<'a> ::std::ops::DerefMut for PhysicalDeviceRayTracingFeaturesKHRBuilder<'a> { +impl<'a> ::std::ops::DerefMut for PhysicalDeviceAccelerationStructureFeaturesKHRBuilder<'a> { fn deref_mut(&mut self) -> &mut Self::Target { &mut self.inner } } -impl<'a> PhysicalDeviceRayTracingFeaturesKHRBuilder<'a> { - pub fn ray_tracing( +impl<'a> PhysicalDeviceAccelerationStructureFeaturesKHRBuilder<'a> { + pub fn acceleration_structure( mut self, - ray_tracing: bool, - ) -> PhysicalDeviceRayTracingFeaturesKHRBuilder<'a> { - self.inner.ray_tracing = ray_tracing.into(); + acceleration_structure: bool, + ) -> PhysicalDeviceAccelerationStructureFeaturesKHRBuilder<'a> { + self.inner.acceleration_structure = acceleration_structure.into(); self } - pub fn ray_tracing_shader_group_handle_capture_replay( + pub fn acceleration_structure_capture_replay( mut self, - ray_tracing_shader_group_handle_capture_replay: bool, - ) -> PhysicalDeviceRayTracingFeaturesKHRBuilder<'a> { - self.inner.ray_tracing_shader_group_handle_capture_replay = - ray_tracing_shader_group_handle_capture_replay.into(); + acceleration_structure_capture_replay: bool, + ) -> PhysicalDeviceAccelerationStructureFeaturesKHRBuilder<'a> { + self.inner.acceleration_structure_capture_replay = + acceleration_structure_capture_replay.into(); self } - pub fn ray_tracing_shader_group_handle_capture_replay_mixed( + pub fn acceleration_structure_indirect_build( mut self, - ray_tracing_shader_group_handle_capture_replay_mixed: bool, - ) -> PhysicalDeviceRayTracingFeaturesKHRBuilder<'a> { - self.inner - .ray_tracing_shader_group_handle_capture_replay_mixed = - ray_tracing_shader_group_handle_capture_replay_mixed.into(); + acceleration_structure_indirect_build: bool, + ) -> PhysicalDeviceAccelerationStructureFeaturesKHRBuilder<'a> { + self.inner.acceleration_structure_indirect_build = + acceleration_structure_indirect_build.into(); self } - pub fn ray_tracing_acceleration_structure_capture_replay( + pub fn acceleration_structure_host_commands( mut self, - ray_tracing_acceleration_structure_capture_replay: bool, - ) -> PhysicalDeviceRayTracingFeaturesKHRBuilder<'a> { - self.inner.ray_tracing_acceleration_structure_capture_replay = - ray_tracing_acceleration_structure_capture_replay.into(); + acceleration_structure_host_commands: bool, + ) -> PhysicalDeviceAccelerationStructureFeaturesKHRBuilder<'a> { + self.inner.acceleration_structure_host_commands = + acceleration_structure_host_commands.into(); self } - pub fn ray_tracing_indirect_trace_rays( + pub fn descriptor_binding_acceleration_structure_update_after_bind( mut self, - ray_tracing_indirect_trace_rays: bool, - ) -> PhysicalDeviceRayTracingFeaturesKHRBuilder<'a> { - self.inner.ray_tracing_indirect_trace_rays = ray_tracing_indirect_trace_rays.into(); + descriptor_binding_acceleration_structure_update_after_bind: bool, + ) -> PhysicalDeviceAccelerationStructureFeaturesKHRBuilder<'a> { + self.inner + .descriptor_binding_acceleration_structure_update_after_bind = + descriptor_binding_acceleration_structure_update_after_bind.into(); self } - pub fn ray_tracing_indirect_acceleration_structure_build( + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceAccelerationStructureFeaturesKHR { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = ""] +pub struct PhysicalDeviceRayTracingPipelineFeaturesKHR { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub ray_tracing_pipeline: Bool32, + pub ray_tracing_pipeline_shader_group_handle_capture_replay: Bool32, + pub ray_tracing_pipeline_shader_group_handle_capture_replay_mixed: Bool32, + pub ray_tracing_pipeline_trace_rays_indirect: Bool32, + pub ray_traversal_primitive_culling: Bool32, +} +impl ::std::default::Default for PhysicalDeviceRayTracingPipelineFeaturesKHR { + fn default() -> PhysicalDeviceRayTracingPipelineFeaturesKHR { + PhysicalDeviceRayTracingPipelineFeaturesKHR { + s_type: StructureType::PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR, + p_next: ::std::ptr::null_mut(), + ray_tracing_pipeline: Bool32::default(), + ray_tracing_pipeline_shader_group_handle_capture_replay: Bool32::default(), + ray_tracing_pipeline_shader_group_handle_capture_replay_mixed: Bool32::default(), + ray_tracing_pipeline_trace_rays_indirect: Bool32::default(), + ray_traversal_primitive_culling: Bool32::default(), + } + } +} +impl PhysicalDeviceRayTracingPipelineFeaturesKHR { + pub fn builder<'a>() -> PhysicalDeviceRayTracingPipelineFeaturesKHRBuilder<'a> { + PhysicalDeviceRayTracingPipelineFeaturesKHRBuilder { + inner: PhysicalDeviceRayTracingPipelineFeaturesKHR::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceRayTracingPipelineFeaturesKHRBuilder<'a> { + inner: PhysicalDeviceRayTracingPipelineFeaturesKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceRayTracingPipelineFeaturesKHRBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceRayTracingPipelineFeaturesKHR {} +impl<'a> ::std::ops::Deref for PhysicalDeviceRayTracingPipelineFeaturesKHRBuilder<'a> { + type Target = PhysicalDeviceRayTracingPipelineFeaturesKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceRayTracingPipelineFeaturesKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceRayTracingPipelineFeaturesKHRBuilder<'a> { + pub fn ray_tracing_pipeline( mut self, - ray_tracing_indirect_acceleration_structure_build: bool, - ) -> PhysicalDeviceRayTracingFeaturesKHRBuilder<'a> { - self.inner.ray_tracing_indirect_acceleration_structure_build = - ray_tracing_indirect_acceleration_structure_build.into(); + ray_tracing_pipeline: bool, + ) -> PhysicalDeviceRayTracingPipelineFeaturesKHRBuilder<'a> { + self.inner.ray_tracing_pipeline = ray_tracing_pipeline.into(); self } - pub fn ray_tracing_host_acceleration_structure_commands( + pub fn ray_tracing_pipeline_shader_group_handle_capture_replay( mut self, - ray_tracing_host_acceleration_structure_commands: bool, - ) -> PhysicalDeviceRayTracingFeaturesKHRBuilder<'a> { - self.inner.ray_tracing_host_acceleration_structure_commands = - ray_tracing_host_acceleration_structure_commands.into(); + ray_tracing_pipeline_shader_group_handle_capture_replay: bool, + ) -> PhysicalDeviceRayTracingPipelineFeaturesKHRBuilder<'a> { + self.inner + .ray_tracing_pipeline_shader_group_handle_capture_replay = + ray_tracing_pipeline_shader_group_handle_capture_replay.into(); self } - pub fn ray_query(mut self, ray_query: bool) -> PhysicalDeviceRayTracingFeaturesKHRBuilder<'a> { - self.inner.ray_query = ray_query.into(); + pub fn ray_tracing_pipeline_shader_group_handle_capture_replay_mixed( + mut self, + ray_tracing_pipeline_shader_group_handle_capture_replay_mixed: bool, + ) -> PhysicalDeviceRayTracingPipelineFeaturesKHRBuilder<'a> { + self.inner + .ray_tracing_pipeline_shader_group_handle_capture_replay_mixed = + ray_tracing_pipeline_shader_group_handle_capture_replay_mixed.into(); self } - pub fn ray_tracing_primitive_culling( + pub fn ray_tracing_pipeline_trace_rays_indirect( mut self, - ray_tracing_primitive_culling: bool, - ) -> PhysicalDeviceRayTracingFeaturesKHRBuilder<'a> { - self.inner.ray_tracing_primitive_culling = ray_tracing_primitive_culling.into(); + ray_tracing_pipeline_trace_rays_indirect: bool, + ) -> PhysicalDeviceRayTracingPipelineFeaturesKHRBuilder<'a> { + self.inner.ray_tracing_pipeline_trace_rays_indirect = + ray_tracing_pipeline_trace_rays_indirect.into(); + self + } + pub fn ray_traversal_primitive_culling( + mut self, + ray_traversal_primitive_culling: bool, + ) -> PhysicalDeviceRayTracingPipelineFeaturesKHRBuilder<'a> { + self.inner.ray_traversal_primitive_culling = ray_traversal_primitive_culling.into(); self } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceRayTracingFeaturesKHR { + pub fn build(self) -> PhysicalDeviceRayTracingPipelineFeaturesKHR { self.inner } } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = ""] -pub struct PhysicalDeviceRayTracingPropertiesKHR { +#[doc = ""] +pub struct PhysicalDeviceRayQueryFeaturesKHR { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub ray_query: Bool32, +} +impl ::std::default::Default for PhysicalDeviceRayQueryFeaturesKHR { + fn default() -> PhysicalDeviceRayQueryFeaturesKHR { + PhysicalDeviceRayQueryFeaturesKHR { + s_type: StructureType::PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR, + p_next: ::std::ptr::null_mut(), + ray_query: Bool32::default(), + } + } +} +impl PhysicalDeviceRayQueryFeaturesKHR { + pub fn builder<'a>() -> PhysicalDeviceRayQueryFeaturesKHRBuilder<'a> { + PhysicalDeviceRayQueryFeaturesKHRBuilder { + inner: PhysicalDeviceRayQueryFeaturesKHR::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceRayQueryFeaturesKHRBuilder<'a> { + inner: PhysicalDeviceRayQueryFeaturesKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceRayQueryFeaturesKHRBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceRayQueryFeaturesKHR {} +impl<'a> ::std::ops::Deref for PhysicalDeviceRayQueryFeaturesKHRBuilder<'a> { + type Target = PhysicalDeviceRayQueryFeaturesKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceRayQueryFeaturesKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceRayQueryFeaturesKHRBuilder<'a> { + pub fn ray_query(mut self, ray_query: bool) -> PhysicalDeviceRayQueryFeaturesKHRBuilder<'a> { + self.inner.ray_query = ray_query.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceRayQueryFeaturesKHR { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = ""] +pub struct PhysicalDeviceAccelerationStructurePropertiesKHR { pub s_type: StructureType, pub p_next: *mut c_void, - pub shader_group_handle_size: u32, - pub max_recursion_depth: u32, - pub max_shader_group_stride: u32, - pub shader_group_base_alignment: u32, pub max_geometry_count: u64, pub max_instance_count: u64, pub max_primitive_count: u64, + pub max_per_stage_descriptor_acceleration_structures: u32, + pub max_per_stage_descriptor_update_after_bind_acceleration_structures: u32, pub max_descriptor_set_acceleration_structures: u32, - pub shader_group_handle_capture_replay_size: u32, + pub max_descriptor_set_update_after_bind_acceleration_structures: u32, + pub min_acceleration_structure_scratch_offset_alignment: u32, } -impl ::std::default::Default for PhysicalDeviceRayTracingPropertiesKHR { - fn default() -> PhysicalDeviceRayTracingPropertiesKHR { - PhysicalDeviceRayTracingPropertiesKHR { - s_type: StructureType::PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_KHR, +impl ::std::default::Default for PhysicalDeviceAccelerationStructurePropertiesKHR { + fn default() -> PhysicalDeviceAccelerationStructurePropertiesKHR { + PhysicalDeviceAccelerationStructurePropertiesKHR { + s_type: StructureType::PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR, p_next: ::std::ptr::null_mut(), - shader_group_handle_size: u32::default(), - max_recursion_depth: u32::default(), - max_shader_group_stride: u32::default(), - shader_group_base_alignment: u32::default(), max_geometry_count: u64::default(), max_instance_count: u64::default(), max_primitive_count: u64::default(), + max_per_stage_descriptor_acceleration_structures: u32::default(), + max_per_stage_descriptor_update_after_bind_acceleration_structures: u32::default(), max_descriptor_set_acceleration_structures: u32::default(), + max_descriptor_set_update_after_bind_acceleration_structures: u32::default(), + min_acceleration_structure_scratch_offset_alignment: u32::default(), + } + } +} +impl PhysicalDeviceAccelerationStructurePropertiesKHR { + pub fn builder<'a>() -> PhysicalDeviceAccelerationStructurePropertiesKHRBuilder<'a> { + PhysicalDeviceAccelerationStructurePropertiesKHRBuilder { + inner: PhysicalDeviceAccelerationStructurePropertiesKHR::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceAccelerationStructurePropertiesKHRBuilder<'a> { + inner: PhysicalDeviceAccelerationStructurePropertiesKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceAccelerationStructurePropertiesKHRBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceAccelerationStructurePropertiesKHR {} +impl<'a> ::std::ops::Deref for PhysicalDeviceAccelerationStructurePropertiesKHRBuilder<'a> { + type Target = PhysicalDeviceAccelerationStructurePropertiesKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceAccelerationStructurePropertiesKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceAccelerationStructurePropertiesKHRBuilder<'a> { + pub fn max_geometry_count( + mut self, + max_geometry_count: u64, + ) -> PhysicalDeviceAccelerationStructurePropertiesKHRBuilder<'a> { + self.inner.max_geometry_count = max_geometry_count; + self + } + pub fn max_instance_count( + mut self, + max_instance_count: u64, + ) -> PhysicalDeviceAccelerationStructurePropertiesKHRBuilder<'a> { + self.inner.max_instance_count = max_instance_count; + self + } + pub fn max_primitive_count( + mut self, + max_primitive_count: u64, + ) -> PhysicalDeviceAccelerationStructurePropertiesKHRBuilder<'a> { + self.inner.max_primitive_count = max_primitive_count; + self + } + pub fn max_per_stage_descriptor_acceleration_structures( + mut self, + max_per_stage_descriptor_acceleration_structures: u32, + ) -> PhysicalDeviceAccelerationStructurePropertiesKHRBuilder<'a> { + self.inner.max_per_stage_descriptor_acceleration_structures = + max_per_stage_descriptor_acceleration_structures; + self + } + pub fn max_per_stage_descriptor_update_after_bind_acceleration_structures( + mut self, + max_per_stage_descriptor_update_after_bind_acceleration_structures: u32, + ) -> PhysicalDeviceAccelerationStructurePropertiesKHRBuilder<'a> { + self.inner + .max_per_stage_descriptor_update_after_bind_acceleration_structures = + max_per_stage_descriptor_update_after_bind_acceleration_structures; + self + } + pub fn max_descriptor_set_acceleration_structures( + mut self, + max_descriptor_set_acceleration_structures: u32, + ) -> PhysicalDeviceAccelerationStructurePropertiesKHRBuilder<'a> { + self.inner.max_descriptor_set_acceleration_structures = + max_descriptor_set_acceleration_structures; + self + } + pub fn max_descriptor_set_update_after_bind_acceleration_structures( + mut self, + max_descriptor_set_update_after_bind_acceleration_structures: u32, + ) -> PhysicalDeviceAccelerationStructurePropertiesKHRBuilder<'a> { + self.inner + .max_descriptor_set_update_after_bind_acceleration_structures = + max_descriptor_set_update_after_bind_acceleration_structures; + self + } + pub fn min_acceleration_structure_scratch_offset_alignment( + mut self, + min_acceleration_structure_scratch_offset_alignment: u32, + ) -> PhysicalDeviceAccelerationStructurePropertiesKHRBuilder<'a> { + self.inner + .min_acceleration_structure_scratch_offset_alignment = + min_acceleration_structure_scratch_offset_alignment; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceAccelerationStructurePropertiesKHR { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = ""] +pub struct PhysicalDeviceRayTracingPipelinePropertiesKHR { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub shader_group_handle_size: u32, + pub max_ray_recursion_depth: u32, + pub max_shader_group_stride: u32, + pub shader_group_base_alignment: u32, + pub shader_group_handle_capture_replay_size: u32, + pub max_ray_dispatch_invocation_count: u32, + pub shader_group_handle_alignment: u32, + pub max_ray_hit_attribute_size: u32, +} +impl ::std::default::Default for PhysicalDeviceRayTracingPipelinePropertiesKHR { + fn default() -> PhysicalDeviceRayTracingPipelinePropertiesKHR { + PhysicalDeviceRayTracingPipelinePropertiesKHR { + s_type: StructureType::PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR, + p_next: ::std::ptr::null_mut(), + shader_group_handle_size: u32::default(), + max_ray_recursion_depth: u32::default(), + max_shader_group_stride: u32::default(), + shader_group_base_alignment: u32::default(), shader_group_handle_capture_replay_size: u32::default(), + max_ray_dispatch_invocation_count: u32::default(), + shader_group_handle_alignment: u32::default(), + max_ray_hit_attribute_size: u32::default(), } } } -impl PhysicalDeviceRayTracingPropertiesKHR { - pub fn builder<'a>() -> PhysicalDeviceRayTracingPropertiesKHRBuilder<'a> { - PhysicalDeviceRayTracingPropertiesKHRBuilder { - inner: PhysicalDeviceRayTracingPropertiesKHR::default(), +impl PhysicalDeviceRayTracingPipelinePropertiesKHR { + pub fn builder<'a>() -> PhysicalDeviceRayTracingPipelinePropertiesKHRBuilder<'a> { + PhysicalDeviceRayTracingPipelinePropertiesKHRBuilder { + inner: PhysicalDeviceRayTracingPipelinePropertiesKHR::default(), marker: ::std::marker::PhantomData, } } } #[repr(transparent)] -pub struct PhysicalDeviceRayTracingPropertiesKHRBuilder<'a> { - inner: PhysicalDeviceRayTracingPropertiesKHR, +pub struct PhysicalDeviceRayTracingPipelinePropertiesKHRBuilder<'a> { + inner: PhysicalDeviceRayTracingPipelinePropertiesKHR, marker: ::std::marker::PhantomData<&'a ()>, } -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceRayTracingPropertiesKHRBuilder<'_> {} -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceRayTracingPropertiesKHR {} -impl<'a> ::std::ops::Deref for PhysicalDeviceRayTracingPropertiesKHRBuilder<'a> { - type Target = PhysicalDeviceRayTracingPropertiesKHR; +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceRayTracingPipelinePropertiesKHRBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceRayTracingPipelinePropertiesKHR {} +impl<'a> ::std::ops::Deref for PhysicalDeviceRayTracingPipelinePropertiesKHRBuilder<'a> { + type Target = PhysicalDeviceRayTracingPipelinePropertiesKHR; fn deref(&self) -> &Self::Target { &self.inner } } -impl<'a> ::std::ops::DerefMut for PhysicalDeviceRayTracingPropertiesKHRBuilder<'a> { +impl<'a> ::std::ops::DerefMut for PhysicalDeviceRayTracingPipelinePropertiesKHRBuilder<'a> { fn deref_mut(&mut self) -> &mut Self::Target { &mut self.inner } } -impl<'a> PhysicalDeviceRayTracingPropertiesKHRBuilder<'a> { +impl<'a> PhysicalDeviceRayTracingPipelinePropertiesKHRBuilder<'a> { pub fn shader_group_handle_size( mut self, shader_group_handle_size: u32, - ) -> PhysicalDeviceRayTracingPropertiesKHRBuilder<'a> { + ) -> PhysicalDeviceRayTracingPipelinePropertiesKHRBuilder<'a> { self.inner.shader_group_handle_size = shader_group_handle_size; self } - pub fn max_recursion_depth( + pub fn max_ray_recursion_depth( mut self, - max_recursion_depth: u32, - ) -> PhysicalDeviceRayTracingPropertiesKHRBuilder<'a> { - self.inner.max_recursion_depth = max_recursion_depth; + max_ray_recursion_depth: u32, + ) -> PhysicalDeviceRayTracingPipelinePropertiesKHRBuilder<'a> { + self.inner.max_ray_recursion_depth = max_ray_recursion_depth; self } pub fn max_shader_group_stride( mut self, max_shader_group_stride: u32, - ) -> PhysicalDeviceRayTracingPropertiesKHRBuilder<'a> { + ) -> PhysicalDeviceRayTracingPipelinePropertiesKHRBuilder<'a> { self.inner.max_shader_group_stride = max_shader_group_stride; self } pub fn shader_group_base_alignment( mut self, shader_group_base_alignment: u32, - ) -> PhysicalDeviceRayTracingPropertiesKHRBuilder<'a> { + ) -> PhysicalDeviceRayTracingPipelinePropertiesKHRBuilder<'a> { self.inner.shader_group_base_alignment = shader_group_base_alignment; self } - pub fn max_geometry_count( - mut self, - max_geometry_count: u64, - ) -> PhysicalDeviceRayTracingPropertiesKHRBuilder<'a> { - self.inner.max_geometry_count = max_geometry_count; - self - } - pub fn max_instance_count( + pub fn shader_group_handle_capture_replay_size( mut self, - max_instance_count: u64, - ) -> PhysicalDeviceRayTracingPropertiesKHRBuilder<'a> { - self.inner.max_instance_count = max_instance_count; + shader_group_handle_capture_replay_size: u32, + ) -> PhysicalDeviceRayTracingPipelinePropertiesKHRBuilder<'a> { + self.inner.shader_group_handle_capture_replay_size = + shader_group_handle_capture_replay_size; self } - pub fn max_primitive_count( + pub fn max_ray_dispatch_invocation_count( mut self, - max_primitive_count: u64, - ) -> PhysicalDeviceRayTracingPropertiesKHRBuilder<'a> { - self.inner.max_primitive_count = max_primitive_count; + max_ray_dispatch_invocation_count: u32, + ) -> PhysicalDeviceRayTracingPipelinePropertiesKHRBuilder<'a> { + self.inner.max_ray_dispatch_invocation_count = max_ray_dispatch_invocation_count; self } - pub fn max_descriptor_set_acceleration_structures( + pub fn shader_group_handle_alignment( mut self, - max_descriptor_set_acceleration_structures: u32, - ) -> PhysicalDeviceRayTracingPropertiesKHRBuilder<'a> { - self.inner.max_descriptor_set_acceleration_structures = - max_descriptor_set_acceleration_structures; + shader_group_handle_alignment: u32, + ) -> PhysicalDeviceRayTracingPipelinePropertiesKHRBuilder<'a> { + self.inner.shader_group_handle_alignment = shader_group_handle_alignment; self } - pub fn shader_group_handle_capture_replay_size( + pub fn max_ray_hit_attribute_size( mut self, - shader_group_handle_capture_replay_size: u32, - ) -> PhysicalDeviceRayTracingPropertiesKHRBuilder<'a> { - self.inner.shader_group_handle_capture_replay_size = - shader_group_handle_capture_replay_size; + max_ray_hit_attribute_size: u32, + ) -> PhysicalDeviceRayTracingPipelinePropertiesKHRBuilder<'a> { + self.inner.max_ray_hit_attribute_size = max_ray_hit_attribute_size; self } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> PhysicalDeviceRayTracingPropertiesKHR { + pub fn build(self) -> PhysicalDeviceRayTracingPipelinePropertiesKHR { self.inner } } @@ -34777,58 +35731,56 @@ impl<'a> PhysicalDeviceRayTracingPropertiesNVBuilder<'a> { } #[repr(C)] #[derive(Copy, Clone, Default, Debug)] -#[doc = ""] -pub struct StridedBufferRegionKHR { - pub buffer: Buffer, - pub offset: DeviceSize, +#[doc = ""] +pub struct StridedDeviceAddressRegionKHR { + pub device_address: DeviceAddress, pub stride: DeviceSize, pub size: DeviceSize, } -impl StridedBufferRegionKHR { - pub fn builder<'a>() -> StridedBufferRegionKHRBuilder<'a> { - StridedBufferRegionKHRBuilder { - inner: StridedBufferRegionKHR::default(), +impl StridedDeviceAddressRegionKHR { + pub fn builder<'a>() -> StridedDeviceAddressRegionKHRBuilder<'a> { + StridedDeviceAddressRegionKHRBuilder { + inner: StridedDeviceAddressRegionKHR::default(), marker: ::std::marker::PhantomData, } } } #[repr(transparent)] -pub struct StridedBufferRegionKHRBuilder<'a> { - inner: StridedBufferRegionKHR, +pub struct StridedDeviceAddressRegionKHRBuilder<'a> { + inner: StridedDeviceAddressRegionKHR, marker: ::std::marker::PhantomData<&'a ()>, } -impl<'a> ::std::ops::Deref for StridedBufferRegionKHRBuilder<'a> { - type Target = StridedBufferRegionKHR; +impl<'a> ::std::ops::Deref for StridedDeviceAddressRegionKHRBuilder<'a> { + type Target = StridedDeviceAddressRegionKHR; fn deref(&self) -> &Self::Target { &self.inner } } -impl<'a> ::std::ops::DerefMut for StridedBufferRegionKHRBuilder<'a> { +impl<'a> ::std::ops::DerefMut for StridedDeviceAddressRegionKHRBuilder<'a> { fn deref_mut(&mut self) -> &mut Self::Target { &mut self.inner } } -impl<'a> StridedBufferRegionKHRBuilder<'a> { - pub fn buffer(mut self, buffer: Buffer) -> StridedBufferRegionKHRBuilder<'a> { - self.inner.buffer = buffer; - self - } - pub fn offset(mut self, offset: DeviceSize) -> StridedBufferRegionKHRBuilder<'a> { - self.inner.offset = offset; +impl<'a> StridedDeviceAddressRegionKHRBuilder<'a> { + pub fn device_address( + mut self, + device_address: DeviceAddress, + ) -> StridedDeviceAddressRegionKHRBuilder<'a> { + self.inner.device_address = device_address; self } - pub fn stride(mut self, stride: DeviceSize) -> StridedBufferRegionKHRBuilder<'a> { + pub fn stride(mut self, stride: DeviceSize) -> StridedDeviceAddressRegionKHRBuilder<'a> { self.inner.stride = stride; self } - pub fn size(mut self, size: DeviceSize) -> StridedBufferRegionKHRBuilder<'a> { + pub fn size(mut self, size: DeviceSize) -> StridedDeviceAddressRegionKHRBuilder<'a> { self.inner.size = size; self } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> StridedBufferRegionKHR { + pub fn build(self) -> StridedDeviceAddressRegionKHR { self.inner } } @@ -35490,6 +36442,64 @@ impl<'a> PhysicalDeviceFragmentDensityMapFeaturesEXTBuilder<'a> { } #[repr(C)] #[derive(Copy, Clone, Debug)] +#[doc = ""] +pub struct PhysicalDeviceFragmentDensityMap2FeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub fragment_density_map_deferred: Bool32, +} +impl ::std::default::Default for PhysicalDeviceFragmentDensityMap2FeaturesEXT { + fn default() -> PhysicalDeviceFragmentDensityMap2FeaturesEXT { + PhysicalDeviceFragmentDensityMap2FeaturesEXT { + s_type: StructureType::PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT, + p_next: ::std::ptr::null_mut(), + fragment_density_map_deferred: Bool32::default(), + } + } +} +impl PhysicalDeviceFragmentDensityMap2FeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceFragmentDensityMap2FeaturesEXTBuilder<'a> { + PhysicalDeviceFragmentDensityMap2FeaturesEXTBuilder { + inner: PhysicalDeviceFragmentDensityMap2FeaturesEXT::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceFragmentDensityMap2FeaturesEXTBuilder<'a> { + inner: PhysicalDeviceFragmentDensityMap2FeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFragmentDensityMap2FeaturesEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFragmentDensityMap2FeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceFragmentDensityMap2FeaturesEXTBuilder<'a> { + type Target = PhysicalDeviceFragmentDensityMap2FeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceFragmentDensityMap2FeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceFragmentDensityMap2FeaturesEXTBuilder<'a> { + pub fn fragment_density_map_deferred( + mut self, + fragment_density_map_deferred: bool, + ) -> PhysicalDeviceFragmentDensityMap2FeaturesEXTBuilder<'a> { + self.inner.fragment_density_map_deferred = fragment_density_map_deferred.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceFragmentDensityMap2FeaturesEXT { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] #[doc = ""] pub struct PhysicalDeviceFragmentDensityMapPropertiesEXT { pub s_type: StructureType, @@ -35569,6 +36579,95 @@ impl<'a> PhysicalDeviceFragmentDensityMapPropertiesEXTBuilder<'a> { } #[repr(C)] #[derive(Copy, Clone, Debug)] +#[doc = ""] +pub struct PhysicalDeviceFragmentDensityMap2PropertiesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub subsampled_loads: Bool32, + pub subsampled_coarse_reconstruction_early_access: Bool32, + pub max_subsampled_array_layers: u32, + pub max_descriptor_set_subsampled_samplers: u32, +} +impl ::std::default::Default for PhysicalDeviceFragmentDensityMap2PropertiesEXT { + fn default() -> PhysicalDeviceFragmentDensityMap2PropertiesEXT { + PhysicalDeviceFragmentDensityMap2PropertiesEXT { + s_type: StructureType::PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT, + p_next: ::std::ptr::null_mut(), + subsampled_loads: Bool32::default(), + subsampled_coarse_reconstruction_early_access: Bool32::default(), + max_subsampled_array_layers: u32::default(), + max_descriptor_set_subsampled_samplers: u32::default(), + } + } +} +impl PhysicalDeviceFragmentDensityMap2PropertiesEXT { + pub fn builder<'a>() -> PhysicalDeviceFragmentDensityMap2PropertiesEXTBuilder<'a> { + PhysicalDeviceFragmentDensityMap2PropertiesEXTBuilder { + inner: PhysicalDeviceFragmentDensityMap2PropertiesEXT::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceFragmentDensityMap2PropertiesEXTBuilder<'a> { + inner: PhysicalDeviceFragmentDensityMap2PropertiesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceFragmentDensityMap2PropertiesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceFragmentDensityMap2PropertiesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceFragmentDensityMap2PropertiesEXTBuilder<'a> { + type Target = PhysicalDeviceFragmentDensityMap2PropertiesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceFragmentDensityMap2PropertiesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceFragmentDensityMap2PropertiesEXTBuilder<'a> { + pub fn subsampled_loads( + mut self, + subsampled_loads: bool, + ) -> PhysicalDeviceFragmentDensityMap2PropertiesEXTBuilder<'a> { + self.inner.subsampled_loads = subsampled_loads.into(); + self + } + pub fn subsampled_coarse_reconstruction_early_access( + mut self, + subsampled_coarse_reconstruction_early_access: bool, + ) -> PhysicalDeviceFragmentDensityMap2PropertiesEXTBuilder<'a> { + self.inner.subsampled_coarse_reconstruction_early_access = + subsampled_coarse_reconstruction_early_access.into(); + self + } + pub fn max_subsampled_array_layers( + mut self, + max_subsampled_array_layers: u32, + ) -> PhysicalDeviceFragmentDensityMap2PropertiesEXTBuilder<'a> { + self.inner.max_subsampled_array_layers = max_subsampled_array_layers; + self + } + pub fn max_descriptor_set_subsampled_samplers( + mut self, + max_descriptor_set_subsampled_samplers: u32, + ) -> PhysicalDeviceFragmentDensityMap2PropertiesEXTBuilder<'a> { + self.inner.max_descriptor_set_subsampled_samplers = max_descriptor_set_subsampled_samplers; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceFragmentDensityMap2PropertiesEXT { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] #[doc = ""] pub struct RenderPassFragmentDensityMapCreateInfoEXT { pub s_type: StructureType, @@ -37326,6 +38425,86 @@ impl<'a> ImageViewHandleInfoNVXBuilder<'a> { } #[repr(C)] #[derive(Copy, Clone, Debug)] +#[doc = ""] +pub struct ImageViewAddressPropertiesNVX { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub device_address: DeviceAddress, + pub size: DeviceSize, +} +impl ::std::default::Default for ImageViewAddressPropertiesNVX { + fn default() -> ImageViewAddressPropertiesNVX { + ImageViewAddressPropertiesNVX { + s_type: StructureType::IMAGE_VIEW_ADDRESS_PROPERTIES_NVX, + p_next: ::std::ptr::null_mut(), + device_address: DeviceAddress::default(), + size: DeviceSize::default(), + } + } +} +impl ImageViewAddressPropertiesNVX { + pub fn builder<'a>() -> ImageViewAddressPropertiesNVXBuilder<'a> { + ImageViewAddressPropertiesNVXBuilder { + inner: ImageViewAddressPropertiesNVX::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ImageViewAddressPropertiesNVXBuilder<'a> { + inner: ImageViewAddressPropertiesNVX, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsImageViewAddressPropertiesNVX {} +impl<'a> ::std::ops::Deref for ImageViewAddressPropertiesNVXBuilder<'a> { + type Target = ImageViewAddressPropertiesNVX; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ImageViewAddressPropertiesNVXBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ImageViewAddressPropertiesNVXBuilder<'a> { + pub fn device_address( + mut self, + device_address: DeviceAddress, + ) -> ImageViewAddressPropertiesNVXBuilder<'a> { + self.inner.device_address = device_address; + self + } + pub fn size(mut self, size: DeviceSize) -> ImageViewAddressPropertiesNVXBuilder<'a> { + self.inner.size = size; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next( + mut self, + next: &'a mut T, + ) -> ImageViewAddressPropertiesNVXBuilder<'a> { + unsafe { + let next_ptr = next as *mut T as *mut BaseOutStructure; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ImageViewAddressPropertiesNVX { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] #[doc = ""] pub struct PresentFrameTokenGGP { pub s_type: StructureType, @@ -38783,7 +39962,7 @@ pub struct QueryPoolPerformanceQueryCreateInfoINTEL { impl ::std::default::Default for QueryPoolPerformanceQueryCreateInfoINTEL { fn default() -> QueryPoolPerformanceQueryCreateInfoINTEL { QueryPoolPerformanceQueryCreateInfoINTEL { - s_type: StructureType::QUERY_POOL_CREATE_INFO_INTEL, + s_type: StructureType::QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL, p_next: ::std::ptr::null(), performance_counters_sampling: QueryPoolSamplingModeINTEL::default(), } @@ -42970,6 +44149,208 @@ impl<'a> PhysicalDeviceToolPropertiesEXTBuilder<'a> { } #[repr(C)] #[derive(Copy, Clone)] +#[doc = ""] +pub struct SamplerCustomBorderColorCreateInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub custom_border_color: ClearColorValue, + pub format: Format, +} +impl fmt::Debug for SamplerCustomBorderColorCreateInfoEXT { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fmt.debug_struct("SamplerCustomBorderColorCreateInfoEXT") + .field("s_type", &self.s_type) + .field("p_next", &self.p_next) + .field("custom_border_color", &"union") + .field("format", &self.format) + .finish() + } +} +impl ::std::default::Default for SamplerCustomBorderColorCreateInfoEXT { + fn default() -> SamplerCustomBorderColorCreateInfoEXT { + SamplerCustomBorderColorCreateInfoEXT { + s_type: StructureType::SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT, + p_next: ::std::ptr::null(), + custom_border_color: ClearColorValue::default(), + format: Format::default(), + } + } +} +impl SamplerCustomBorderColorCreateInfoEXT { + pub fn builder<'a>() -> SamplerCustomBorderColorCreateInfoEXTBuilder<'a> { + SamplerCustomBorderColorCreateInfoEXTBuilder { + inner: SamplerCustomBorderColorCreateInfoEXT::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct SamplerCustomBorderColorCreateInfoEXTBuilder<'a> { + inner: SamplerCustomBorderColorCreateInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsSamplerCreateInfo for SamplerCustomBorderColorCreateInfoEXTBuilder<'_> {} +unsafe impl ExtendsSamplerCreateInfo for SamplerCustomBorderColorCreateInfoEXT {} +impl<'a> ::std::ops::Deref for SamplerCustomBorderColorCreateInfoEXTBuilder<'a> { + type Target = SamplerCustomBorderColorCreateInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for SamplerCustomBorderColorCreateInfoEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> SamplerCustomBorderColorCreateInfoEXTBuilder<'a> { + pub fn custom_border_color( + mut self, + custom_border_color: ClearColorValue, + ) -> SamplerCustomBorderColorCreateInfoEXTBuilder<'a> { + self.inner.custom_border_color = custom_border_color; + self + } + pub fn format(mut self, format: Format) -> SamplerCustomBorderColorCreateInfoEXTBuilder<'a> { + self.inner.format = format; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> SamplerCustomBorderColorCreateInfoEXT { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = ""] +pub struct PhysicalDeviceCustomBorderColorPropertiesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub max_custom_border_color_samplers: u32, +} +impl ::std::default::Default for PhysicalDeviceCustomBorderColorPropertiesEXT { + fn default() -> PhysicalDeviceCustomBorderColorPropertiesEXT { + PhysicalDeviceCustomBorderColorPropertiesEXT { + s_type: StructureType::PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT, + p_next: ::std::ptr::null_mut(), + max_custom_border_color_samplers: u32::default(), + } + } +} +impl PhysicalDeviceCustomBorderColorPropertiesEXT { + pub fn builder<'a>() -> PhysicalDeviceCustomBorderColorPropertiesEXTBuilder<'a> { + PhysicalDeviceCustomBorderColorPropertiesEXTBuilder { + inner: PhysicalDeviceCustomBorderColorPropertiesEXT::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceCustomBorderColorPropertiesEXTBuilder<'a> { + inner: PhysicalDeviceCustomBorderColorPropertiesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceCustomBorderColorPropertiesEXTBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceCustomBorderColorPropertiesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceCustomBorderColorPropertiesEXTBuilder<'a> { + type Target = PhysicalDeviceCustomBorderColorPropertiesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceCustomBorderColorPropertiesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceCustomBorderColorPropertiesEXTBuilder<'a> { + pub fn max_custom_border_color_samplers( + mut self, + max_custom_border_color_samplers: u32, + ) -> PhysicalDeviceCustomBorderColorPropertiesEXTBuilder<'a> { + self.inner.max_custom_border_color_samplers = max_custom_border_color_samplers; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceCustomBorderColorPropertiesEXT { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = ""] +pub struct PhysicalDeviceCustomBorderColorFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub custom_border_colors: Bool32, + pub custom_border_color_without_format: Bool32, +} +impl ::std::default::Default for PhysicalDeviceCustomBorderColorFeaturesEXT { + fn default() -> PhysicalDeviceCustomBorderColorFeaturesEXT { + PhysicalDeviceCustomBorderColorFeaturesEXT { + s_type: StructureType::PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT, + p_next: ::std::ptr::null_mut(), + custom_border_colors: Bool32::default(), + custom_border_color_without_format: Bool32::default(), + } + } +} +impl PhysicalDeviceCustomBorderColorFeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceCustomBorderColorFeaturesEXTBuilder<'a> { + PhysicalDeviceCustomBorderColorFeaturesEXTBuilder { + inner: PhysicalDeviceCustomBorderColorFeaturesEXT::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceCustomBorderColorFeaturesEXTBuilder<'a> { + inner: PhysicalDeviceCustomBorderColorFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceCustomBorderColorFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceCustomBorderColorFeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceCustomBorderColorFeaturesEXTBuilder<'a> { + type Target = PhysicalDeviceCustomBorderColorFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceCustomBorderColorFeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceCustomBorderColorFeaturesEXTBuilder<'a> { + pub fn custom_border_colors( + mut self, + custom_border_colors: bool, + ) -> PhysicalDeviceCustomBorderColorFeaturesEXTBuilder<'a> { + self.inner.custom_border_colors = custom_border_colors.into(); + self + } + pub fn custom_border_color_without_format( + mut self, + custom_border_color_without_format: bool, + ) -> PhysicalDeviceCustomBorderColorFeaturesEXTBuilder<'a> { + self.inner.custom_border_color_without_format = custom_border_color_without_format.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceCustomBorderColorFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone)] #[doc = ""] pub union DeviceOrHostAddressKHR { pub device_address: DeviceAddress, @@ -43001,6 +44382,7 @@ pub struct AccelerationStructureGeometryTrianglesDataKHR { pub vertex_format: Format, pub vertex_data: DeviceOrHostAddressConstKHR, pub vertex_stride: DeviceSize, + pub max_vertex: u32, pub index_type: IndexType, pub index_data: DeviceOrHostAddressConstKHR, pub transform_data: DeviceOrHostAddressConstKHR, @@ -43013,6 +44395,7 @@ impl fmt::Debug for AccelerationStructureGeometryTrianglesDataKHR { .field("vertex_format", &self.vertex_format) .field("vertex_data", &"union") .field("vertex_stride", &self.vertex_stride) + .field("max_vertex", &self.max_vertex) .field("index_type", &self.index_type) .field("index_data", &"union") .field("transform_data", &"union") @@ -43027,6 +44410,7 @@ impl ::std::default::Default for AccelerationStructureGeometryTrianglesDataKHR { vertex_format: Format::default(), vertex_data: DeviceOrHostAddressConstKHR::default(), vertex_stride: DeviceSize::default(), + max_vertex: u32::default(), index_type: IndexType::default(), index_data: DeviceOrHostAddressConstKHR::default(), transform_data: DeviceOrHostAddressConstKHR::default(), @@ -43080,6 +44464,13 @@ impl<'a> AccelerationStructureGeometryTrianglesDataKHRBuilder<'a> { self.inner.vertex_stride = vertex_stride; self } + pub fn max_vertex( + mut self, + max_vertex: u32, + ) -> AccelerationStructureGeometryTrianglesDataKHRBuilder<'a> { + self.inner.max_vertex = max_vertex; + self + } pub fn index_type( mut self, index_type: IndexType, @@ -43432,11 +44823,11 @@ pub struct AccelerationStructureBuildGeometryInfoKHR { pub p_next: *const c_void, pub ty: AccelerationStructureTypeKHR, pub flags: BuildAccelerationStructureFlagsKHR, - pub update: Bool32, + pub mode: BuildAccelerationStructureModeKHR, pub src_acceleration_structure: AccelerationStructureKHR, pub dst_acceleration_structure: AccelerationStructureKHR, - pub geometry_array_of_pointers: Bool32, pub geometry_count: u32, + pub p_geometries: *const AccelerationStructureGeometryKHR, pub pp_geometries: *const *const AccelerationStructureGeometryKHR, pub scratch_data: DeviceOrHostAddressKHR, } @@ -43447,7 +44838,7 @@ impl fmt::Debug for AccelerationStructureBuildGeometryInfoKHR { .field("p_next", &self.p_next) .field("ty", &self.ty) .field("flags", &self.flags) - .field("update", &self.update) + .field("mode", &self.mode) .field( "src_acceleration_structure", &self.src_acceleration_structure, @@ -43456,11 +44847,8 @@ impl fmt::Debug for AccelerationStructureBuildGeometryInfoKHR { "dst_acceleration_structure", &self.dst_acceleration_structure, ) - .field( - "geometry_array_of_pointers", - &self.geometry_array_of_pointers, - ) .field("geometry_count", &self.geometry_count) + .field("p_geometries", &self.p_geometries) .field("pp_geometries", &self.pp_geometries) .field("scratch_data", &"union") .finish() @@ -43473,11 +44861,11 @@ impl ::std::default::Default for AccelerationStructureBuildGeometryInfoKHR { p_next: ::std::ptr::null(), ty: AccelerationStructureTypeKHR::default(), flags: BuildAccelerationStructureFlagsKHR::default(), - update: Bool32::default(), + mode: BuildAccelerationStructureModeKHR::default(), src_acceleration_structure: AccelerationStructureKHR::default(), dst_acceleration_structure: AccelerationStructureKHR::default(), - geometry_array_of_pointers: Bool32::default(), geometry_count: u32::default(), + p_geometries: ::std::ptr::null(), pp_geometries: ::std::ptr::null(), scratch_data: DeviceOrHostAddressKHR::default(), } @@ -43523,8 +44911,11 @@ impl<'a> AccelerationStructureBuildGeometryInfoKHRBuilder<'a> { self.inner.flags = flags; self } - pub fn update(mut self, update: bool) -> AccelerationStructureBuildGeometryInfoKHRBuilder<'a> { - self.inner.update = update.into(); + pub fn mode( + mut self, + mode: BuildAccelerationStructureModeKHR, + ) -> AccelerationStructureBuildGeometryInfoKHRBuilder<'a> { + self.inner.mode = mode; self } pub fn src_acceleration_structure( @@ -43541,25 +44932,20 @@ impl<'a> AccelerationStructureBuildGeometryInfoKHRBuilder<'a> { self.inner.dst_acceleration_structure = dst_acceleration_structure; self } - pub fn geometry_array_of_pointers( - mut self, - geometry_array_of_pointers: bool, - ) -> AccelerationStructureBuildGeometryInfoKHRBuilder<'a> { - self.inner.geometry_array_of_pointers = geometry_array_of_pointers.into(); - self - } - pub fn geometry_count( + pub fn geometries( mut self, - geometry_count: u32, + geometries: &'a [AccelerationStructureGeometryKHR], ) -> AccelerationStructureBuildGeometryInfoKHRBuilder<'a> { - self.inner.geometry_count = geometry_count; + self.inner.geometry_count = geometries.len() as _; + self.inner.p_geometries = geometries.as_ptr(); self } - pub fn geometries( + pub fn geometries_ptrs( mut self, - geometries: &'a *const AccelerationStructureGeometryKHR, + geometries: &'a [*const AccelerationStructureGeometryKHR], ) -> AccelerationStructureBuildGeometryInfoKHRBuilder<'a> { - self.inner.pp_geometries = geometries; + self.inner.geometry_count = geometries.len() as _; + self.inner.pp_geometries = geometries.as_ptr(); self } pub fn scratch_data( @@ -43595,166 +44981,391 @@ impl<'a> AccelerationStructureBuildGeometryInfoKHRBuilder<'a> { } #[repr(C)] #[derive(Copy, Clone, Default, Debug)] -#[doc = ""] -pub struct AccelerationStructureBuildOffsetInfoKHR { +#[doc = ""] +pub struct AccelerationStructureBuildRangeInfoKHR { pub primitive_count: u32, pub primitive_offset: u32, pub first_vertex: u32, pub transform_offset: u32, } -impl AccelerationStructureBuildOffsetInfoKHR { - pub fn builder<'a>() -> AccelerationStructureBuildOffsetInfoKHRBuilder<'a> { - AccelerationStructureBuildOffsetInfoKHRBuilder { - inner: AccelerationStructureBuildOffsetInfoKHR::default(), +impl AccelerationStructureBuildRangeInfoKHR { + pub fn builder<'a>() -> AccelerationStructureBuildRangeInfoKHRBuilder<'a> { + AccelerationStructureBuildRangeInfoKHRBuilder { + inner: AccelerationStructureBuildRangeInfoKHR::default(), marker: ::std::marker::PhantomData, } } } #[repr(transparent)] -pub struct AccelerationStructureBuildOffsetInfoKHRBuilder<'a> { - inner: AccelerationStructureBuildOffsetInfoKHR, +pub struct AccelerationStructureBuildRangeInfoKHRBuilder<'a> { + inner: AccelerationStructureBuildRangeInfoKHR, marker: ::std::marker::PhantomData<&'a ()>, } -impl<'a> ::std::ops::Deref for AccelerationStructureBuildOffsetInfoKHRBuilder<'a> { - type Target = AccelerationStructureBuildOffsetInfoKHR; +impl<'a> ::std::ops::Deref for AccelerationStructureBuildRangeInfoKHRBuilder<'a> { + type Target = AccelerationStructureBuildRangeInfoKHR; fn deref(&self) -> &Self::Target { &self.inner } } -impl<'a> ::std::ops::DerefMut for AccelerationStructureBuildOffsetInfoKHRBuilder<'a> { +impl<'a> ::std::ops::DerefMut for AccelerationStructureBuildRangeInfoKHRBuilder<'a> { fn deref_mut(&mut self) -> &mut Self::Target { &mut self.inner } } -impl<'a> AccelerationStructureBuildOffsetInfoKHRBuilder<'a> { +impl<'a> AccelerationStructureBuildRangeInfoKHRBuilder<'a> { pub fn primitive_count( mut self, primitive_count: u32, - ) -> AccelerationStructureBuildOffsetInfoKHRBuilder<'a> { + ) -> AccelerationStructureBuildRangeInfoKHRBuilder<'a> { self.inner.primitive_count = primitive_count; self } pub fn primitive_offset( mut self, primitive_offset: u32, - ) -> AccelerationStructureBuildOffsetInfoKHRBuilder<'a> { + ) -> AccelerationStructureBuildRangeInfoKHRBuilder<'a> { self.inner.primitive_offset = primitive_offset; self } pub fn first_vertex( mut self, first_vertex: u32, - ) -> AccelerationStructureBuildOffsetInfoKHRBuilder<'a> { + ) -> AccelerationStructureBuildRangeInfoKHRBuilder<'a> { self.inner.first_vertex = first_vertex; self } pub fn transform_offset( mut self, transform_offset: u32, - ) -> AccelerationStructureBuildOffsetInfoKHRBuilder<'a> { + ) -> AccelerationStructureBuildRangeInfoKHRBuilder<'a> { self.inner.transform_offset = transform_offset; self } #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> AccelerationStructureBuildOffsetInfoKHR { + pub fn build(self) -> AccelerationStructureBuildRangeInfoKHR { self.inner } } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = ""] -pub struct AccelerationStructureCreateGeometryTypeInfoKHR { +#[doc = ""] +pub struct AccelerationStructureCreateInfoKHR { pub s_type: StructureType, pub p_next: *const c_void, - pub geometry_type: GeometryTypeKHR, - pub max_primitive_count: u32, - pub index_type: IndexType, - pub max_vertex_count: u32, - pub vertex_format: Format, - pub allows_transforms: Bool32, + pub create_flags: AccelerationStructureCreateFlagsKHR, + pub buffer: Buffer, + pub offset: DeviceSize, + pub size: DeviceSize, + pub ty: AccelerationStructureTypeKHR, + pub device_address: DeviceAddress, } -impl ::std::default::Default for AccelerationStructureCreateGeometryTypeInfoKHR { - fn default() -> AccelerationStructureCreateGeometryTypeInfoKHR { - AccelerationStructureCreateGeometryTypeInfoKHR { - s_type: StructureType::ACCELERATION_STRUCTURE_CREATE_GEOMETRY_TYPE_INFO_KHR, +impl ::std::default::Default for AccelerationStructureCreateInfoKHR { + fn default() -> AccelerationStructureCreateInfoKHR { + AccelerationStructureCreateInfoKHR { + s_type: StructureType::ACCELERATION_STRUCTURE_CREATE_INFO_KHR, p_next: ::std::ptr::null(), - geometry_type: GeometryTypeKHR::default(), - max_primitive_count: u32::default(), - index_type: IndexType::default(), - max_vertex_count: u32::default(), - vertex_format: Format::default(), - allows_transforms: Bool32::default(), + create_flags: AccelerationStructureCreateFlagsKHR::default(), + buffer: Buffer::default(), + offset: DeviceSize::default(), + size: DeviceSize::default(), + ty: AccelerationStructureTypeKHR::default(), + device_address: DeviceAddress::default(), } } } -impl AccelerationStructureCreateGeometryTypeInfoKHR { - pub fn builder<'a>() -> AccelerationStructureCreateGeometryTypeInfoKHRBuilder<'a> { - AccelerationStructureCreateGeometryTypeInfoKHRBuilder { - inner: AccelerationStructureCreateGeometryTypeInfoKHR::default(), +impl AccelerationStructureCreateInfoKHR { + pub fn builder<'a>() -> AccelerationStructureCreateInfoKHRBuilder<'a> { + AccelerationStructureCreateInfoKHRBuilder { + inner: AccelerationStructureCreateInfoKHR::default(), marker: ::std::marker::PhantomData, } } } #[repr(transparent)] -pub struct AccelerationStructureCreateGeometryTypeInfoKHRBuilder<'a> { - inner: AccelerationStructureCreateGeometryTypeInfoKHR, +pub struct AccelerationStructureCreateInfoKHRBuilder<'a> { + inner: AccelerationStructureCreateInfoKHR, marker: ::std::marker::PhantomData<&'a ()>, } -pub unsafe trait ExtendsAccelerationStructureCreateGeometryTypeInfoKHR {} -impl<'a> ::std::ops::Deref for AccelerationStructureCreateGeometryTypeInfoKHRBuilder<'a> { - type Target = AccelerationStructureCreateGeometryTypeInfoKHR; +pub unsafe trait ExtendsAccelerationStructureCreateInfoKHR {} +impl<'a> ::std::ops::Deref for AccelerationStructureCreateInfoKHRBuilder<'a> { + type Target = AccelerationStructureCreateInfoKHR; fn deref(&self) -> &Self::Target { &self.inner } } -impl<'a> ::std::ops::DerefMut for AccelerationStructureCreateGeometryTypeInfoKHRBuilder<'a> { +impl<'a> ::std::ops::DerefMut for AccelerationStructureCreateInfoKHRBuilder<'a> { fn deref_mut(&mut self) -> &mut Self::Target { &mut self.inner } } -impl<'a> AccelerationStructureCreateGeometryTypeInfoKHRBuilder<'a> { - pub fn geometry_type( +impl<'a> AccelerationStructureCreateInfoKHRBuilder<'a> { + pub fn create_flags( mut self, - geometry_type: GeometryTypeKHR, - ) -> AccelerationStructureCreateGeometryTypeInfoKHRBuilder<'a> { - self.inner.geometry_type = geometry_type; + create_flags: AccelerationStructureCreateFlagsKHR, + ) -> AccelerationStructureCreateInfoKHRBuilder<'a> { + self.inner.create_flags = create_flags; self } - pub fn max_primitive_count( + pub fn buffer(mut self, buffer: Buffer) -> AccelerationStructureCreateInfoKHRBuilder<'a> { + self.inner.buffer = buffer; + self + } + pub fn offset(mut self, offset: DeviceSize) -> AccelerationStructureCreateInfoKHRBuilder<'a> { + self.inner.offset = offset; + self + } + pub fn size(mut self, size: DeviceSize) -> AccelerationStructureCreateInfoKHRBuilder<'a> { + self.inner.size = size; + self + } + pub fn ty( mut self, - max_primitive_count: u32, - ) -> AccelerationStructureCreateGeometryTypeInfoKHRBuilder<'a> { - self.inner.max_primitive_count = max_primitive_count; + ty: AccelerationStructureTypeKHR, + ) -> AccelerationStructureCreateInfoKHRBuilder<'a> { + self.inner.ty = ty; self } - pub fn index_type( + pub fn device_address( mut self, - index_type: IndexType, - ) -> AccelerationStructureCreateGeometryTypeInfoKHRBuilder<'a> { - self.inner.index_type = index_type; + device_address: DeviceAddress, + ) -> AccelerationStructureCreateInfoKHRBuilder<'a> { + self.inner.device_address = device_address; self } - pub fn max_vertex_count( + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next( mut self, - max_vertex_count: u32, - ) -> AccelerationStructureCreateGeometryTypeInfoKHRBuilder<'a> { - self.inner.max_vertex_count = max_vertex_count; + next: &'a mut T, + ) -> AccelerationStructureCreateInfoKHRBuilder<'a> { + unsafe { + let next_ptr = next as *mut T as *mut BaseOutStructure; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } - pub fn vertex_format( + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> AccelerationStructureCreateInfoKHR { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone, Default, Debug)] +#[doc = ""] +pub struct AabbPositionsKHR { + pub min_x: f32, + pub min_y: f32, + pub min_z: f32, + pub max_x: f32, + pub max_y: f32, + pub max_z: f32, +} +impl AabbPositionsKHR { + pub fn builder<'a>() -> AabbPositionsKHRBuilder<'a> { + AabbPositionsKHRBuilder { + inner: AabbPositionsKHR::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct AabbPositionsKHRBuilder<'a> { + inner: AabbPositionsKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +impl<'a> ::std::ops::Deref for AabbPositionsKHRBuilder<'a> { + type Target = AabbPositionsKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for AabbPositionsKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> AabbPositionsKHRBuilder<'a> { + pub fn min_x(mut self, min_x: f32) -> AabbPositionsKHRBuilder<'a> { + self.inner.min_x = min_x; + self + } + pub fn min_y(mut self, min_y: f32) -> AabbPositionsKHRBuilder<'a> { + self.inner.min_y = min_y; + self + } + pub fn min_z(mut self, min_z: f32) -> AabbPositionsKHRBuilder<'a> { + self.inner.min_z = min_z; + self + } + pub fn max_x(mut self, max_x: f32) -> AabbPositionsKHRBuilder<'a> { + self.inner.max_x = max_x; + self + } + pub fn max_y(mut self, max_y: f32) -> AabbPositionsKHRBuilder<'a> { + self.inner.max_y = max_y; + self + } + pub fn max_z(mut self, max_z: f32) -> AabbPositionsKHRBuilder<'a> { + self.inner.max_z = max_z; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> AabbPositionsKHR { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct TransformMatrixKHR { + pub matrix: [f32; 12], +} +#[repr(C)] +#[derive(Copy, Clone)] +pub union AccelerationStructureReferenceKHR { + pub device_handle: DeviceAddress, + pub host_handle: AccelerationStructureKHR, +} +#[repr(C)] +#[derive(Copy, Clone)] +pub struct AccelerationStructureInstanceKHR { + pub transform: TransformMatrixKHR, + pub instance_custom_index_and_mask: u32, + pub instance_shader_binding_table_record_offset_and_flags: u32, + pub acceleration_structure_reference: AccelerationStructureReferenceKHR, +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = ""] +pub struct AccelerationStructureDeviceAddressInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub acceleration_structure: AccelerationStructureKHR, +} +impl ::std::default::Default for AccelerationStructureDeviceAddressInfoKHR { + fn default() -> AccelerationStructureDeviceAddressInfoKHR { + AccelerationStructureDeviceAddressInfoKHR { + s_type: StructureType::ACCELERATION_STRUCTURE_DEVICE_ADDRESS_INFO_KHR, + p_next: ::std::ptr::null(), + acceleration_structure: AccelerationStructureKHR::default(), + } + } +} +impl AccelerationStructureDeviceAddressInfoKHR { + pub fn builder<'a>() -> AccelerationStructureDeviceAddressInfoKHRBuilder<'a> { + AccelerationStructureDeviceAddressInfoKHRBuilder { + inner: AccelerationStructureDeviceAddressInfoKHR::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct AccelerationStructureDeviceAddressInfoKHRBuilder<'a> { + inner: AccelerationStructureDeviceAddressInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsAccelerationStructureDeviceAddressInfoKHR {} +impl<'a> ::std::ops::Deref for AccelerationStructureDeviceAddressInfoKHRBuilder<'a> { + type Target = AccelerationStructureDeviceAddressInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for AccelerationStructureDeviceAddressInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> AccelerationStructureDeviceAddressInfoKHRBuilder<'a> { + pub fn acceleration_structure( mut self, - vertex_format: Format, - ) -> AccelerationStructureCreateGeometryTypeInfoKHRBuilder<'a> { - self.inner.vertex_format = vertex_format; + acceleration_structure: AccelerationStructureKHR, + ) -> AccelerationStructureDeviceAddressInfoKHRBuilder<'a> { + self.inner.acceleration_structure = acceleration_structure; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next( + mut self, + next: &'a mut T, + ) -> AccelerationStructureDeviceAddressInfoKHRBuilder<'a> { + unsafe { + let next_ptr = next as *mut T as *mut BaseOutStructure; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } self } - pub fn allows_transforms( + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> AccelerationStructureDeviceAddressInfoKHR { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = ""] +pub struct AccelerationStructureVersionInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub p_version_data: *const u8, +} +impl ::std::default::Default for AccelerationStructureVersionInfoKHR { + fn default() -> AccelerationStructureVersionInfoKHR { + AccelerationStructureVersionInfoKHR { + s_type: StructureType::ACCELERATION_STRUCTURE_VERSION_INFO_KHR, + p_next: ::std::ptr::null(), + p_version_data: ::std::ptr::null(), + } + } +} +impl AccelerationStructureVersionInfoKHR { + pub fn builder<'a>() -> AccelerationStructureVersionInfoKHRBuilder<'a> { + AccelerationStructureVersionInfoKHRBuilder { + inner: AccelerationStructureVersionInfoKHR::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct AccelerationStructureVersionInfoKHRBuilder<'a> { + inner: AccelerationStructureVersionInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsAccelerationStructureVersionInfoKHR {} +impl<'a> ::std::ops::Deref for AccelerationStructureVersionInfoKHRBuilder<'a> { + type Target = AccelerationStructureVersionInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for AccelerationStructureVersionInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> AccelerationStructureVersionInfoKHRBuilder<'a> { + pub fn version_data( mut self, - allows_transforms: bool, - ) -> AccelerationStructureCreateGeometryTypeInfoKHRBuilder<'a> { - self.inner.allows_transforms = allows_transforms.into(); + version_data: &'a [u8; 2 * UUID_SIZE], + ) -> AccelerationStructureVersionInfoKHRBuilder<'a> { + self.inner.p_version_data = version_data.as_ptr(); self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] @@ -43762,10 +45373,10 @@ impl<'a> AccelerationStructureCreateGeometryTypeInfoKHRBuilder<'a> { #[doc = r" valid extension structs can be pushed into the chain."] #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next( + pub fn push_next( mut self, next: &'a mut T, - ) -> AccelerationStructureCreateGeometryTypeInfoKHRBuilder<'a> { + ) -> AccelerationStructureVersionInfoKHRBuilder<'a> { unsafe { let next_ptr = next as *mut T as *mut BaseOutStructure; let last_next = ptr_chain_iter(next).last().unwrap(); @@ -43777,348 +45388,7 @@ impl<'a> AccelerationStructureCreateGeometryTypeInfoKHRBuilder<'a> { #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> AccelerationStructureCreateGeometryTypeInfoKHR { - self.inner - } -} -#[repr(C)] -#[derive(Copy, Clone, Debug)] -#[doc = ""] -pub struct AccelerationStructureCreateInfoKHR { - pub s_type: StructureType, - pub p_next: *const c_void, - pub compacted_size: DeviceSize, - pub ty: AccelerationStructureTypeKHR, - pub flags: BuildAccelerationStructureFlagsKHR, - pub max_geometry_count: u32, - pub p_geometry_infos: *const AccelerationStructureCreateGeometryTypeInfoKHR, - pub device_address: DeviceAddress, -} -impl ::std::default::Default for AccelerationStructureCreateInfoKHR { - fn default() -> AccelerationStructureCreateInfoKHR { - AccelerationStructureCreateInfoKHR { - s_type: StructureType::ACCELERATION_STRUCTURE_CREATE_INFO_KHR, - p_next: ::std::ptr::null(), - compacted_size: DeviceSize::default(), - ty: AccelerationStructureTypeKHR::default(), - flags: BuildAccelerationStructureFlagsKHR::default(), - max_geometry_count: u32::default(), - p_geometry_infos: ::std::ptr::null(), - device_address: DeviceAddress::default(), - } - } -} -impl AccelerationStructureCreateInfoKHR { - pub fn builder<'a>() -> AccelerationStructureCreateInfoKHRBuilder<'a> { - AccelerationStructureCreateInfoKHRBuilder { - inner: AccelerationStructureCreateInfoKHR::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct AccelerationStructureCreateInfoKHRBuilder<'a> { - inner: AccelerationStructureCreateInfoKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} -pub unsafe trait ExtendsAccelerationStructureCreateInfoKHR {} -impl<'a> ::std::ops::Deref for AccelerationStructureCreateInfoKHRBuilder<'a> { - type Target = AccelerationStructureCreateInfoKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for AccelerationStructureCreateInfoKHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> AccelerationStructureCreateInfoKHRBuilder<'a> { - pub fn compacted_size( - mut self, - compacted_size: DeviceSize, - ) -> AccelerationStructureCreateInfoKHRBuilder<'a> { - self.inner.compacted_size = compacted_size; - self - } - pub fn ty( - mut self, - ty: AccelerationStructureTypeKHR, - ) -> AccelerationStructureCreateInfoKHRBuilder<'a> { - self.inner.ty = ty; - self - } - pub fn flags( - mut self, - flags: BuildAccelerationStructureFlagsKHR, - ) -> AccelerationStructureCreateInfoKHRBuilder<'a> { - self.inner.flags = flags; - self - } - pub fn geometry_infos( - mut self, - geometry_infos: &'a [AccelerationStructureCreateGeometryTypeInfoKHR], - ) -> AccelerationStructureCreateInfoKHRBuilder<'a> { - self.inner.max_geometry_count = geometry_infos.len() as _; - self.inner.p_geometry_infos = geometry_infos.as_ptr(); - self - } - pub fn device_address( - mut self, - device_address: DeviceAddress, - ) -> AccelerationStructureCreateInfoKHRBuilder<'a> { - self.inner.device_address = device_address; - self - } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next( - mut self, - next: &'a mut T, - ) -> AccelerationStructureCreateInfoKHRBuilder<'a> { - unsafe { - let next_ptr = next as *mut T as *mut BaseOutStructure; - let last_next = ptr_chain_iter(next).last().unwrap(); - (*last_next).p_next = self.inner.p_next as _; - self.inner.p_next = next_ptr as _; - } - self - } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> AccelerationStructureCreateInfoKHR { - self.inner - } -} -#[repr(C)] -#[derive(Copy, Clone, Default, Debug)] -#[doc = ""] -pub struct AabbPositionsKHR { - pub min_x: f32, - pub min_y: f32, - pub min_z: f32, - pub max_x: f32, - pub max_y: f32, - pub max_z: f32, -} -impl AabbPositionsKHR { - pub fn builder<'a>() -> AabbPositionsKHRBuilder<'a> { - AabbPositionsKHRBuilder { - inner: AabbPositionsKHR::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct AabbPositionsKHRBuilder<'a> { - inner: AabbPositionsKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} -impl<'a> ::std::ops::Deref for AabbPositionsKHRBuilder<'a> { - type Target = AabbPositionsKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for AabbPositionsKHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> AabbPositionsKHRBuilder<'a> { - pub fn min_x(mut self, min_x: f32) -> AabbPositionsKHRBuilder<'a> { - self.inner.min_x = min_x; - self - } - pub fn min_y(mut self, min_y: f32) -> AabbPositionsKHRBuilder<'a> { - self.inner.min_y = min_y; - self - } - pub fn min_z(mut self, min_z: f32) -> AabbPositionsKHRBuilder<'a> { - self.inner.min_z = min_z; - self - } - pub fn max_x(mut self, max_x: f32) -> AabbPositionsKHRBuilder<'a> { - self.inner.max_x = max_x; - self - } - pub fn max_y(mut self, max_y: f32) -> AabbPositionsKHRBuilder<'a> { - self.inner.max_y = max_y; - self - } - pub fn max_z(mut self, max_z: f32) -> AabbPositionsKHRBuilder<'a> { - self.inner.max_z = max_z; - self - } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> AabbPositionsKHR { - self.inner - } -} -#[repr(C)] -#[derive(Copy, Clone)] -pub struct TransformMatrixKHR { - pub matrix: [f32; 12], -} -#[repr(C)] -#[derive(Copy, Clone)] -pub struct AccelerationStructureInstanceKHR { - pub transform: TransformMatrixKHR, - pub instance_custom_index_and_mask: u32, - pub instance_shader_binding_table_record_offset_and_flags: u32, - pub acceleration_structure_reference: u64, -} -#[repr(C)] -#[derive(Copy, Clone, Debug)] -#[doc = ""] -pub struct AccelerationStructureDeviceAddressInfoKHR { - pub s_type: StructureType, - pub p_next: *const c_void, - pub acceleration_structure: AccelerationStructureKHR, -} -impl ::std::default::Default for AccelerationStructureDeviceAddressInfoKHR { - fn default() -> AccelerationStructureDeviceAddressInfoKHR { - AccelerationStructureDeviceAddressInfoKHR { - s_type: StructureType::ACCELERATION_STRUCTURE_DEVICE_ADDRESS_INFO_KHR, - p_next: ::std::ptr::null(), - acceleration_structure: AccelerationStructureKHR::default(), - } - } -} -impl AccelerationStructureDeviceAddressInfoKHR { - pub fn builder<'a>() -> AccelerationStructureDeviceAddressInfoKHRBuilder<'a> { - AccelerationStructureDeviceAddressInfoKHRBuilder { - inner: AccelerationStructureDeviceAddressInfoKHR::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct AccelerationStructureDeviceAddressInfoKHRBuilder<'a> { - inner: AccelerationStructureDeviceAddressInfoKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} -pub unsafe trait ExtendsAccelerationStructureDeviceAddressInfoKHR {} -impl<'a> ::std::ops::Deref for AccelerationStructureDeviceAddressInfoKHRBuilder<'a> { - type Target = AccelerationStructureDeviceAddressInfoKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for AccelerationStructureDeviceAddressInfoKHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> AccelerationStructureDeviceAddressInfoKHRBuilder<'a> { - pub fn acceleration_structure( - mut self, - acceleration_structure: AccelerationStructureKHR, - ) -> AccelerationStructureDeviceAddressInfoKHRBuilder<'a> { - self.inner.acceleration_structure = acceleration_structure; - self - } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next( - mut self, - next: &'a mut T, - ) -> AccelerationStructureDeviceAddressInfoKHRBuilder<'a> { - unsafe { - let next_ptr = next as *mut T as *mut BaseOutStructure; - let last_next = ptr_chain_iter(next).last().unwrap(); - (*last_next).p_next = self.inner.p_next as _; - self.inner.p_next = next_ptr as _; - } - self - } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> AccelerationStructureDeviceAddressInfoKHR { - self.inner - } -} -#[repr(C)] -#[derive(Copy, Clone, Debug)] -#[doc = ""] -pub struct AccelerationStructureVersionKHR { - pub s_type: StructureType, - pub p_next: *const c_void, - pub version_data: *const u8, -} -impl ::std::default::Default for AccelerationStructureVersionKHR { - fn default() -> AccelerationStructureVersionKHR { - AccelerationStructureVersionKHR { - s_type: StructureType::ACCELERATION_STRUCTURE_VERSION_KHR, - p_next: ::std::ptr::null(), - version_data: ::std::ptr::null(), - } - } -} -impl AccelerationStructureVersionKHR { - pub fn builder<'a>() -> AccelerationStructureVersionKHRBuilder<'a> { - AccelerationStructureVersionKHRBuilder { - inner: AccelerationStructureVersionKHR::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct AccelerationStructureVersionKHRBuilder<'a> { - inner: AccelerationStructureVersionKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} -pub unsafe trait ExtendsAccelerationStructureVersionKHR {} -impl<'a> ::std::ops::Deref for AccelerationStructureVersionKHRBuilder<'a> { - type Target = AccelerationStructureVersionKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for AccelerationStructureVersionKHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> AccelerationStructureVersionKHRBuilder<'a> { - pub fn version_data( - mut self, - version_data: &'a [u8; 2 * UUID_SIZE], - ) -> AccelerationStructureVersionKHRBuilder<'a> { - self.inner.version_data = version_data.as_ptr(); - self - } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] - #[doc = r" chain will look like `A -> D -> B -> C`."] - pub fn push_next( - mut self, - next: &'a mut T, - ) -> AccelerationStructureVersionKHRBuilder<'a> { - unsafe { - let next_ptr = next as *mut T as *mut BaseOutStructure; - let last_next = ptr_chain_iter(next).last().unwrap(); - (*last_next).p_next = self.inner.p_next as _; - self.inner.p_next = next_ptr as _; - } - self - } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> AccelerationStructureVersionKHR { + pub fn build(self) -> AccelerationStructureVersionInfoKHR { self.inner } } @@ -44426,18 +45696,16 @@ impl<'a> CopyMemoryToAccelerationStructureInfoKHRBuilder<'a> { pub struct RayTracingPipelineInterfaceCreateInfoKHR { pub s_type: StructureType, pub p_next: *const c_void, - pub max_payload_size: u32, - pub max_attribute_size: u32, - pub max_callable_size: u32, + pub max_pipeline_ray_payload_size: u32, + pub max_pipeline_ray_hit_attribute_size: u32, } impl ::std::default::Default for RayTracingPipelineInterfaceCreateInfoKHR { fn default() -> RayTracingPipelineInterfaceCreateInfoKHR { RayTracingPipelineInterfaceCreateInfoKHR { s_type: StructureType::RAY_TRACING_PIPELINE_INTERFACE_CREATE_INFO_KHR, p_next: ::std::ptr::null(), - max_payload_size: u32::default(), - max_attribute_size: u32::default(), - max_callable_size: u32::default(), + max_pipeline_ray_payload_size: u32::default(), + max_pipeline_ray_hit_attribute_size: u32::default(), } } } @@ -44467,25 +45735,18 @@ impl<'a> ::std::ops::DerefMut for RayTracingPipelineInterfaceCreateInfoKHRBuilde } } impl<'a> RayTracingPipelineInterfaceCreateInfoKHRBuilder<'a> { - pub fn max_payload_size( - mut self, - max_payload_size: u32, - ) -> RayTracingPipelineInterfaceCreateInfoKHRBuilder<'a> { - self.inner.max_payload_size = max_payload_size; - self - } - pub fn max_attribute_size( + pub fn max_pipeline_ray_payload_size( mut self, - max_attribute_size: u32, + max_pipeline_ray_payload_size: u32, ) -> RayTracingPipelineInterfaceCreateInfoKHRBuilder<'a> { - self.inner.max_attribute_size = max_attribute_size; + self.inner.max_pipeline_ray_payload_size = max_pipeline_ray_payload_size; self } - pub fn max_callable_size( + pub fn max_pipeline_ray_hit_attribute_size( mut self, - max_callable_size: u32, + max_pipeline_ray_hit_attribute_size: u32, ) -> RayTracingPipelineInterfaceCreateInfoKHRBuilder<'a> { - self.inner.max_callable_size = max_callable_size; + self.inner.max_pipeline_ray_hit_attribute_size = max_pipeline_ray_hit_attribute_size; self } #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] @@ -44514,81 +45775,6 @@ impl<'a> RayTracingPipelineInterfaceCreateInfoKHRBuilder<'a> { } #[repr(C)] #[derive(Copy, Clone, Debug)] -#[doc = ""] -pub struct DeferredOperationInfoKHR { - pub s_type: StructureType, - pub p_next: *const c_void, - pub operation_handle: DeferredOperationKHR, -} -impl ::std::default::Default for DeferredOperationInfoKHR { - fn default() -> DeferredOperationInfoKHR { - DeferredOperationInfoKHR { - s_type: StructureType::DEFERRED_OPERATION_INFO_KHR, - p_next: ::std::ptr::null(), - operation_handle: DeferredOperationKHR::default(), - } - } -} -impl DeferredOperationInfoKHR { - pub fn builder<'a>() -> DeferredOperationInfoKHRBuilder<'a> { - DeferredOperationInfoKHRBuilder { - inner: DeferredOperationInfoKHR::default(), - marker: ::std::marker::PhantomData, - } - } -} -#[repr(transparent)] -pub struct DeferredOperationInfoKHRBuilder<'a> { - inner: DeferredOperationInfoKHR, - marker: ::std::marker::PhantomData<&'a ()>, -} -unsafe impl ExtendsRayTracingPipelineCreateInfoKHR for DeferredOperationInfoKHRBuilder<'_> {} -unsafe impl ExtendsRayTracingPipelineCreateInfoKHR for DeferredOperationInfoKHR {} -unsafe impl ExtendsAccelerationStructureBuildGeometryInfoKHR - for DeferredOperationInfoKHRBuilder<'_> -{ -} -unsafe impl ExtendsAccelerationStructureBuildGeometryInfoKHR for DeferredOperationInfoKHR {} -unsafe impl ExtendsCopyAccelerationStructureInfoKHR for DeferredOperationInfoKHRBuilder<'_> {} -unsafe impl ExtendsCopyAccelerationStructureInfoKHR for DeferredOperationInfoKHR {} -unsafe impl ExtendsCopyMemoryToAccelerationStructureInfoKHR - for DeferredOperationInfoKHRBuilder<'_> -{ -} -unsafe impl ExtendsCopyMemoryToAccelerationStructureInfoKHR for DeferredOperationInfoKHR {} -unsafe impl ExtendsCopyAccelerationStructureToMemoryInfoKHR - for DeferredOperationInfoKHRBuilder<'_> -{ -} -unsafe impl ExtendsCopyAccelerationStructureToMemoryInfoKHR for DeferredOperationInfoKHR {} -impl<'a> ::std::ops::Deref for DeferredOperationInfoKHRBuilder<'a> { - type Target = DeferredOperationInfoKHR; - fn deref(&self) -> &Self::Target { - &self.inner - } -} -impl<'a> ::std::ops::DerefMut for DeferredOperationInfoKHRBuilder<'a> { - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.inner - } -} -impl<'a> DeferredOperationInfoKHRBuilder<'a> { - pub fn operation_handle( - mut self, - operation_handle: DeferredOperationKHR, - ) -> DeferredOperationInfoKHRBuilder<'a> { - self.inner.operation_handle = operation_handle; - self - } - #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] - #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] - #[doc = r" so references to builders can be passed directly to Vulkan functions."] - pub fn build(self) -> DeferredOperationInfoKHR { - self.inner - } -} -#[repr(C)] -#[derive(Copy, Clone, Debug)] #[doc = ""] pub struct PipelineLibraryCreateInfoKHR { pub s_type: StructureType, @@ -44666,6 +45852,64 @@ impl<'a> PipelineLibraryCreateInfoKHRBuilder<'a> { } #[repr(C)] #[derive(Copy, Clone, Debug)] +#[doc = ""] +pub struct PhysicalDeviceExtendedDynamicStateFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub extended_dynamic_state: Bool32, +} +impl ::std::default::Default for PhysicalDeviceExtendedDynamicStateFeaturesEXT { + fn default() -> PhysicalDeviceExtendedDynamicStateFeaturesEXT { + PhysicalDeviceExtendedDynamicStateFeaturesEXT { + s_type: StructureType::PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT, + p_next: ::std::ptr::null_mut(), + extended_dynamic_state: Bool32::default(), + } + } +} +impl PhysicalDeviceExtendedDynamicStateFeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceExtendedDynamicStateFeaturesEXTBuilder<'a> { + PhysicalDeviceExtendedDynamicStateFeaturesEXTBuilder { + inner: PhysicalDeviceExtendedDynamicStateFeaturesEXT::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceExtendedDynamicStateFeaturesEXTBuilder<'a> { + inner: PhysicalDeviceExtendedDynamicStateFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceExtendedDynamicStateFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceExtendedDynamicStateFeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceExtendedDynamicStateFeaturesEXTBuilder<'a> { + type Target = PhysicalDeviceExtendedDynamicStateFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceExtendedDynamicStateFeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceExtendedDynamicStateFeaturesEXTBuilder<'a> { + pub fn extended_dynamic_state( + mut self, + extended_dynamic_state: bool, + ) -> PhysicalDeviceExtendedDynamicStateFeaturesEXTBuilder<'a> { + self.inner.extended_dynamic_state = extended_dynamic_state.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceExtendedDynamicStateFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] #[doc = ""] pub struct RenderPassTransformBeginInfoQCOM { pub s_type: StructureType, @@ -44724,6 +45968,66 @@ impl<'a> RenderPassTransformBeginInfoQCOMBuilder<'a> { } #[repr(C)] #[derive(Copy, Clone, Debug)] +#[doc = ""] +pub struct CopyCommandTransformInfoQCOM { + pub s_type: StructureType, + pub p_next: *const c_void, + pub transform: SurfaceTransformFlagsKHR, +} +impl ::std::default::Default for CopyCommandTransformInfoQCOM { + fn default() -> CopyCommandTransformInfoQCOM { + CopyCommandTransformInfoQCOM { + s_type: StructureType::COPY_COMMAND_TRANSFORM_INFO_QCOM, + p_next: ::std::ptr::null(), + transform: SurfaceTransformFlagsKHR::default(), + } + } +} +impl CopyCommandTransformInfoQCOM { + pub fn builder<'a>() -> CopyCommandTransformInfoQCOMBuilder<'a> { + CopyCommandTransformInfoQCOMBuilder { + inner: CopyCommandTransformInfoQCOM::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct CopyCommandTransformInfoQCOMBuilder<'a> { + inner: CopyCommandTransformInfoQCOM, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsBufferImageCopy2KHR for CopyCommandTransformInfoQCOMBuilder<'_> {} +unsafe impl ExtendsBufferImageCopy2KHR for CopyCommandTransformInfoQCOM {} +unsafe impl ExtendsImageBlit2KHR for CopyCommandTransformInfoQCOMBuilder<'_> {} +unsafe impl ExtendsImageBlit2KHR for CopyCommandTransformInfoQCOM {} +impl<'a> ::std::ops::Deref for CopyCommandTransformInfoQCOMBuilder<'a> { + type Target = CopyCommandTransformInfoQCOM; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for CopyCommandTransformInfoQCOMBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> CopyCommandTransformInfoQCOMBuilder<'a> { + pub fn transform( + mut self, + transform: SurfaceTransformFlagsKHR, + ) -> CopyCommandTransformInfoQCOMBuilder<'a> { + self.inner.transform = transform; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> CopyCommandTransformInfoQCOM { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] #[doc = ""] pub struct CommandBufferInheritanceRenderPassTransformInfoQCOM { pub s_type: StructureType, @@ -44911,3 +46215,2570 @@ impl<'a> DeviceDiagnosticsConfigCreateInfoNVBuilder<'a> { self.inner } } +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = ""] +pub struct PhysicalDeviceRobustness2FeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub robust_buffer_access2: Bool32, + pub robust_image_access2: Bool32, + pub null_descriptor: Bool32, +} +impl ::std::default::Default for PhysicalDeviceRobustness2FeaturesEXT { + fn default() -> PhysicalDeviceRobustness2FeaturesEXT { + PhysicalDeviceRobustness2FeaturesEXT { + s_type: StructureType::PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT, + p_next: ::std::ptr::null_mut(), + robust_buffer_access2: Bool32::default(), + robust_image_access2: Bool32::default(), + null_descriptor: Bool32::default(), + } + } +} +impl PhysicalDeviceRobustness2FeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceRobustness2FeaturesEXTBuilder<'a> { + PhysicalDeviceRobustness2FeaturesEXTBuilder { + inner: PhysicalDeviceRobustness2FeaturesEXT::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceRobustness2FeaturesEXTBuilder<'a> { + inner: PhysicalDeviceRobustness2FeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceRobustness2FeaturesEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceRobustness2FeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceRobustness2FeaturesEXTBuilder<'a> { + type Target = PhysicalDeviceRobustness2FeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceRobustness2FeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceRobustness2FeaturesEXTBuilder<'a> { + pub fn robust_buffer_access2( + mut self, + robust_buffer_access2: bool, + ) -> PhysicalDeviceRobustness2FeaturesEXTBuilder<'a> { + self.inner.robust_buffer_access2 = robust_buffer_access2.into(); + self + } + pub fn robust_image_access2( + mut self, + robust_image_access2: bool, + ) -> PhysicalDeviceRobustness2FeaturesEXTBuilder<'a> { + self.inner.robust_image_access2 = robust_image_access2.into(); + self + } + pub fn null_descriptor( + mut self, + null_descriptor: bool, + ) -> PhysicalDeviceRobustness2FeaturesEXTBuilder<'a> { + self.inner.null_descriptor = null_descriptor.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceRobustness2FeaturesEXT { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = ""] +pub struct PhysicalDeviceRobustness2PropertiesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub robust_storage_buffer_access_size_alignment: DeviceSize, + pub robust_uniform_buffer_access_size_alignment: DeviceSize, +} +impl ::std::default::Default for PhysicalDeviceRobustness2PropertiesEXT { + fn default() -> PhysicalDeviceRobustness2PropertiesEXT { + PhysicalDeviceRobustness2PropertiesEXT { + s_type: StructureType::PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT, + p_next: ::std::ptr::null_mut(), + robust_storage_buffer_access_size_alignment: DeviceSize::default(), + robust_uniform_buffer_access_size_alignment: DeviceSize::default(), + } + } +} +impl PhysicalDeviceRobustness2PropertiesEXT { + pub fn builder<'a>() -> PhysicalDeviceRobustness2PropertiesEXTBuilder<'a> { + PhysicalDeviceRobustness2PropertiesEXTBuilder { + inner: PhysicalDeviceRobustness2PropertiesEXT::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceRobustness2PropertiesEXTBuilder<'a> { + inner: PhysicalDeviceRobustness2PropertiesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceRobustness2PropertiesEXTBuilder<'_> {} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceRobustness2PropertiesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceRobustness2PropertiesEXTBuilder<'a> { + type Target = PhysicalDeviceRobustness2PropertiesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceRobustness2PropertiesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceRobustness2PropertiesEXTBuilder<'a> { + pub fn robust_storage_buffer_access_size_alignment( + mut self, + robust_storage_buffer_access_size_alignment: DeviceSize, + ) -> PhysicalDeviceRobustness2PropertiesEXTBuilder<'a> { + self.inner.robust_storage_buffer_access_size_alignment = + robust_storage_buffer_access_size_alignment; + self + } + pub fn robust_uniform_buffer_access_size_alignment( + mut self, + robust_uniform_buffer_access_size_alignment: DeviceSize, + ) -> PhysicalDeviceRobustness2PropertiesEXTBuilder<'a> { + self.inner.robust_uniform_buffer_access_size_alignment = + robust_uniform_buffer_access_size_alignment; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceRobustness2PropertiesEXT { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = ""] +pub struct PhysicalDeviceImageRobustnessFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub robust_image_access: Bool32, +} +impl ::std::default::Default for PhysicalDeviceImageRobustnessFeaturesEXT { + fn default() -> PhysicalDeviceImageRobustnessFeaturesEXT { + PhysicalDeviceImageRobustnessFeaturesEXT { + s_type: StructureType::PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES_EXT, + p_next: ::std::ptr::null_mut(), + robust_image_access: Bool32::default(), + } + } +} +impl PhysicalDeviceImageRobustnessFeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceImageRobustnessFeaturesEXTBuilder<'a> { + PhysicalDeviceImageRobustnessFeaturesEXTBuilder { + inner: PhysicalDeviceImageRobustnessFeaturesEXT::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceImageRobustnessFeaturesEXTBuilder<'a> { + inner: PhysicalDeviceImageRobustnessFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceImageRobustnessFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceImageRobustnessFeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceImageRobustnessFeaturesEXTBuilder<'a> { + type Target = PhysicalDeviceImageRobustnessFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceImageRobustnessFeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceImageRobustnessFeaturesEXTBuilder<'a> { + pub fn robust_image_access( + mut self, + robust_image_access: bool, + ) -> PhysicalDeviceImageRobustnessFeaturesEXTBuilder<'a> { + self.inner.robust_image_access = robust_image_access.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceImageRobustnessFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = ""] +pub struct PhysicalDevicePortabilitySubsetFeaturesKHR { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub constant_alpha_color_blend_factors: Bool32, + pub events: Bool32, + pub image_view_format_reinterpretation: Bool32, + pub image_view_format_swizzle: Bool32, + pub image_view2_d_on3_d_image: Bool32, + pub multisample_array_image: Bool32, + pub mutable_comparison_samplers: Bool32, + pub point_polygons: Bool32, + pub sampler_mip_lod_bias: Bool32, + pub separate_stencil_mask_ref: Bool32, + pub shader_sample_rate_interpolation_functions: Bool32, + pub tessellation_isolines: Bool32, + pub tessellation_point_mode: Bool32, + pub triangle_fans: Bool32, + pub vertex_attribute_access_beyond_stride: Bool32, +} +impl ::std::default::Default for PhysicalDevicePortabilitySubsetFeaturesKHR { + fn default() -> PhysicalDevicePortabilitySubsetFeaturesKHR { + PhysicalDevicePortabilitySubsetFeaturesKHR { + s_type: StructureType::PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR, + p_next: ::std::ptr::null_mut(), + constant_alpha_color_blend_factors: Bool32::default(), + events: Bool32::default(), + image_view_format_reinterpretation: Bool32::default(), + image_view_format_swizzle: Bool32::default(), + image_view2_d_on3_d_image: Bool32::default(), + multisample_array_image: Bool32::default(), + mutable_comparison_samplers: Bool32::default(), + point_polygons: Bool32::default(), + sampler_mip_lod_bias: Bool32::default(), + separate_stencil_mask_ref: Bool32::default(), + shader_sample_rate_interpolation_functions: Bool32::default(), + tessellation_isolines: Bool32::default(), + tessellation_point_mode: Bool32::default(), + triangle_fans: Bool32::default(), + vertex_attribute_access_beyond_stride: Bool32::default(), + } + } +} +impl PhysicalDevicePortabilitySubsetFeaturesKHR { + pub fn builder<'a>() -> PhysicalDevicePortabilitySubsetFeaturesKHRBuilder<'a> { + PhysicalDevicePortabilitySubsetFeaturesKHRBuilder { + inner: PhysicalDevicePortabilitySubsetFeaturesKHR::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDevicePortabilitySubsetFeaturesKHRBuilder<'a> { + inner: PhysicalDevicePortabilitySubsetFeaturesKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePortabilitySubsetFeaturesKHRBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePortabilitySubsetFeaturesKHR {} +impl<'a> ::std::ops::Deref for PhysicalDevicePortabilitySubsetFeaturesKHRBuilder<'a> { + type Target = PhysicalDevicePortabilitySubsetFeaturesKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDevicePortabilitySubsetFeaturesKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDevicePortabilitySubsetFeaturesKHRBuilder<'a> { + pub fn constant_alpha_color_blend_factors( + mut self, + constant_alpha_color_blend_factors: bool, + ) -> PhysicalDevicePortabilitySubsetFeaturesKHRBuilder<'a> { + self.inner.constant_alpha_color_blend_factors = constant_alpha_color_blend_factors.into(); + self + } + pub fn events(mut self, events: bool) -> PhysicalDevicePortabilitySubsetFeaturesKHRBuilder<'a> { + self.inner.events = events.into(); + self + } + pub fn image_view_format_reinterpretation( + mut self, + image_view_format_reinterpretation: bool, + ) -> PhysicalDevicePortabilitySubsetFeaturesKHRBuilder<'a> { + self.inner.image_view_format_reinterpretation = image_view_format_reinterpretation.into(); + self + } + pub fn image_view_format_swizzle( + mut self, + image_view_format_swizzle: bool, + ) -> PhysicalDevicePortabilitySubsetFeaturesKHRBuilder<'a> { + self.inner.image_view_format_swizzle = image_view_format_swizzle.into(); + self + } + pub fn image_view2_d_on3_d_image( + mut self, + image_view2_d_on3_d_image: bool, + ) -> PhysicalDevicePortabilitySubsetFeaturesKHRBuilder<'a> { + self.inner.image_view2_d_on3_d_image = image_view2_d_on3_d_image.into(); + self + } + pub fn multisample_array_image( + mut self, + multisample_array_image: bool, + ) -> PhysicalDevicePortabilitySubsetFeaturesKHRBuilder<'a> { + self.inner.multisample_array_image = multisample_array_image.into(); + self + } + pub fn mutable_comparison_samplers( + mut self, + mutable_comparison_samplers: bool, + ) -> PhysicalDevicePortabilitySubsetFeaturesKHRBuilder<'a> { + self.inner.mutable_comparison_samplers = mutable_comparison_samplers.into(); + self + } + pub fn point_polygons( + mut self, + point_polygons: bool, + ) -> PhysicalDevicePortabilitySubsetFeaturesKHRBuilder<'a> { + self.inner.point_polygons = point_polygons.into(); + self + } + pub fn sampler_mip_lod_bias( + mut self, + sampler_mip_lod_bias: bool, + ) -> PhysicalDevicePortabilitySubsetFeaturesKHRBuilder<'a> { + self.inner.sampler_mip_lod_bias = sampler_mip_lod_bias.into(); + self + } + pub fn separate_stencil_mask_ref( + mut self, + separate_stencil_mask_ref: bool, + ) -> PhysicalDevicePortabilitySubsetFeaturesKHRBuilder<'a> { + self.inner.separate_stencil_mask_ref = separate_stencil_mask_ref.into(); + self + } + pub fn shader_sample_rate_interpolation_functions( + mut self, + shader_sample_rate_interpolation_functions: bool, + ) -> PhysicalDevicePortabilitySubsetFeaturesKHRBuilder<'a> { + self.inner.shader_sample_rate_interpolation_functions = + shader_sample_rate_interpolation_functions.into(); + self + } + pub fn tessellation_isolines( + mut self, + tessellation_isolines: bool, + ) -> PhysicalDevicePortabilitySubsetFeaturesKHRBuilder<'a> { + self.inner.tessellation_isolines = tessellation_isolines.into(); + self + } + pub fn tessellation_point_mode( + mut self, + tessellation_point_mode: bool, + ) -> PhysicalDevicePortabilitySubsetFeaturesKHRBuilder<'a> { + self.inner.tessellation_point_mode = tessellation_point_mode.into(); + self + } + pub fn triangle_fans( + mut self, + triangle_fans: bool, + ) -> PhysicalDevicePortabilitySubsetFeaturesKHRBuilder<'a> { + self.inner.triangle_fans = triangle_fans.into(); + self + } + pub fn vertex_attribute_access_beyond_stride( + mut self, + vertex_attribute_access_beyond_stride: bool, + ) -> PhysicalDevicePortabilitySubsetFeaturesKHRBuilder<'a> { + self.inner.vertex_attribute_access_beyond_stride = + vertex_attribute_access_beyond_stride.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDevicePortabilitySubsetFeaturesKHR { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = ""] +pub struct PhysicalDevicePortabilitySubsetPropertiesKHR { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub min_vertex_input_binding_stride_alignment: u32, +} +impl ::std::default::Default for PhysicalDevicePortabilitySubsetPropertiesKHR { + fn default() -> PhysicalDevicePortabilitySubsetPropertiesKHR { + PhysicalDevicePortabilitySubsetPropertiesKHR { + s_type: StructureType::PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR, + p_next: ::std::ptr::null_mut(), + min_vertex_input_binding_stride_alignment: u32::default(), + } + } +} +impl PhysicalDevicePortabilitySubsetPropertiesKHR { + pub fn builder<'a>() -> PhysicalDevicePortabilitySubsetPropertiesKHRBuilder<'a> { + PhysicalDevicePortabilitySubsetPropertiesKHRBuilder { + inner: PhysicalDevicePortabilitySubsetPropertiesKHR::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDevicePortabilitySubsetPropertiesKHRBuilder<'a> { + inner: PhysicalDevicePortabilitySubsetPropertiesKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDevicePortabilitySubsetPropertiesKHRBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDevicePortabilitySubsetPropertiesKHR {} +impl<'a> ::std::ops::Deref for PhysicalDevicePortabilitySubsetPropertiesKHRBuilder<'a> { + type Target = PhysicalDevicePortabilitySubsetPropertiesKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDevicePortabilitySubsetPropertiesKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDevicePortabilitySubsetPropertiesKHRBuilder<'a> { + pub fn min_vertex_input_binding_stride_alignment( + mut self, + min_vertex_input_binding_stride_alignment: u32, + ) -> PhysicalDevicePortabilitySubsetPropertiesKHRBuilder<'a> { + self.inner.min_vertex_input_binding_stride_alignment = + min_vertex_input_binding_stride_alignment; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDevicePortabilitySubsetPropertiesKHR { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = ""] +pub struct PhysicalDevice4444FormatsFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub format_a4r4g4b4: Bool32, + pub format_a4b4g4r4: Bool32, +} +impl ::std::default::Default for PhysicalDevice4444FormatsFeaturesEXT { + fn default() -> PhysicalDevice4444FormatsFeaturesEXT { + PhysicalDevice4444FormatsFeaturesEXT { + s_type: StructureType::PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT, + p_next: ::std::ptr::null_mut(), + format_a4r4g4b4: Bool32::default(), + format_a4b4g4r4: Bool32::default(), + } + } +} +impl PhysicalDevice4444FormatsFeaturesEXT { + pub fn builder<'a>() -> PhysicalDevice4444FormatsFeaturesEXTBuilder<'a> { + PhysicalDevice4444FormatsFeaturesEXTBuilder { + inner: PhysicalDevice4444FormatsFeaturesEXT::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDevice4444FormatsFeaturesEXTBuilder<'a> { + inner: PhysicalDevice4444FormatsFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDevice4444FormatsFeaturesEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDevice4444FormatsFeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDevice4444FormatsFeaturesEXTBuilder<'a> { + type Target = PhysicalDevice4444FormatsFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDevice4444FormatsFeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDevice4444FormatsFeaturesEXTBuilder<'a> { + pub fn format_a4r4g4b4( + mut self, + format_a4r4g4b4: bool, + ) -> PhysicalDevice4444FormatsFeaturesEXTBuilder<'a> { + self.inner.format_a4r4g4b4 = format_a4r4g4b4.into(); + self + } + pub fn format_a4b4g4r4( + mut self, + format_a4b4g4r4: bool, + ) -> PhysicalDevice4444FormatsFeaturesEXTBuilder<'a> { + self.inner.format_a4b4g4r4 = format_a4b4g4r4.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDevice4444FormatsFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = ""] +pub struct BufferCopy2KHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub src_offset: DeviceSize, + pub dst_offset: DeviceSize, + pub size: DeviceSize, +} +impl ::std::default::Default for BufferCopy2KHR { + fn default() -> BufferCopy2KHR { + BufferCopy2KHR { + s_type: StructureType::BUFFER_COPY_2_KHR, + p_next: ::std::ptr::null(), + src_offset: DeviceSize::default(), + dst_offset: DeviceSize::default(), + size: DeviceSize::default(), + } + } +} +impl BufferCopy2KHR { + pub fn builder<'a>() -> BufferCopy2KHRBuilder<'a> { + BufferCopy2KHRBuilder { + inner: BufferCopy2KHR::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct BufferCopy2KHRBuilder<'a> { + inner: BufferCopy2KHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsBufferCopy2KHR {} +impl<'a> ::std::ops::Deref for BufferCopy2KHRBuilder<'a> { + type Target = BufferCopy2KHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for BufferCopy2KHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> BufferCopy2KHRBuilder<'a> { + pub fn src_offset(mut self, src_offset: DeviceSize) -> BufferCopy2KHRBuilder<'a> { + self.inner.src_offset = src_offset; + self + } + pub fn dst_offset(mut self, dst_offset: DeviceSize) -> BufferCopy2KHRBuilder<'a> { + self.inner.dst_offset = dst_offset; + self + } + pub fn size(mut self, size: DeviceSize) -> BufferCopy2KHRBuilder<'a> { + self.inner.size = size; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next( + mut self, + next: &'a mut T, + ) -> BufferCopy2KHRBuilder<'a> { + unsafe { + let next_ptr = next as *mut T as *mut BaseOutStructure; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> BufferCopy2KHR { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = ""] +pub struct ImageCopy2KHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub src_subresource: ImageSubresourceLayers, + pub src_offset: Offset3D, + pub dst_subresource: ImageSubresourceLayers, + pub dst_offset: Offset3D, + pub extent: Extent3D, +} +impl ::std::default::Default for ImageCopy2KHR { + fn default() -> ImageCopy2KHR { + ImageCopy2KHR { + s_type: StructureType::IMAGE_COPY_2_KHR, + p_next: ::std::ptr::null(), + src_subresource: ImageSubresourceLayers::default(), + src_offset: Offset3D::default(), + dst_subresource: ImageSubresourceLayers::default(), + dst_offset: Offset3D::default(), + extent: Extent3D::default(), + } + } +} +impl ImageCopy2KHR { + pub fn builder<'a>() -> ImageCopy2KHRBuilder<'a> { + ImageCopy2KHRBuilder { + inner: ImageCopy2KHR::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ImageCopy2KHRBuilder<'a> { + inner: ImageCopy2KHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsImageCopy2KHR {} +impl<'a> ::std::ops::Deref for ImageCopy2KHRBuilder<'a> { + type Target = ImageCopy2KHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ImageCopy2KHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ImageCopy2KHRBuilder<'a> { + pub fn src_subresource( + mut self, + src_subresource: ImageSubresourceLayers, + ) -> ImageCopy2KHRBuilder<'a> { + self.inner.src_subresource = src_subresource; + self + } + pub fn src_offset(mut self, src_offset: Offset3D) -> ImageCopy2KHRBuilder<'a> { + self.inner.src_offset = src_offset; + self + } + pub fn dst_subresource( + mut self, + dst_subresource: ImageSubresourceLayers, + ) -> ImageCopy2KHRBuilder<'a> { + self.inner.dst_subresource = dst_subresource; + self + } + pub fn dst_offset(mut self, dst_offset: Offset3D) -> ImageCopy2KHRBuilder<'a> { + self.inner.dst_offset = dst_offset; + self + } + pub fn extent(mut self, extent: Extent3D) -> ImageCopy2KHRBuilder<'a> { + self.inner.extent = extent; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next( + mut self, + next: &'a mut T, + ) -> ImageCopy2KHRBuilder<'a> { + unsafe { + let next_ptr = next as *mut T as *mut BaseOutStructure; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ImageCopy2KHR { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = ""] +pub struct ImageBlit2KHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub src_subresource: ImageSubresourceLayers, + pub src_offsets: [Offset3D; 2], + pub dst_subresource: ImageSubresourceLayers, + pub dst_offsets: [Offset3D; 2], +} +impl ::std::default::Default for ImageBlit2KHR { + fn default() -> ImageBlit2KHR { + ImageBlit2KHR { + s_type: StructureType::IMAGE_BLIT_2_KHR, + p_next: ::std::ptr::null(), + src_subresource: ImageSubresourceLayers::default(), + src_offsets: unsafe { ::std::mem::zeroed() }, + dst_subresource: ImageSubresourceLayers::default(), + dst_offsets: unsafe { ::std::mem::zeroed() }, + } + } +} +impl ImageBlit2KHR { + pub fn builder<'a>() -> ImageBlit2KHRBuilder<'a> { + ImageBlit2KHRBuilder { + inner: ImageBlit2KHR::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ImageBlit2KHRBuilder<'a> { + inner: ImageBlit2KHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsImageBlit2KHR {} +impl<'a> ::std::ops::Deref for ImageBlit2KHRBuilder<'a> { + type Target = ImageBlit2KHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ImageBlit2KHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ImageBlit2KHRBuilder<'a> { + pub fn src_subresource( + mut self, + src_subresource: ImageSubresourceLayers, + ) -> ImageBlit2KHRBuilder<'a> { + self.inner.src_subresource = src_subresource; + self + } + pub fn src_offsets(mut self, src_offsets: [Offset3D; 2]) -> ImageBlit2KHRBuilder<'a> { + self.inner.src_offsets = src_offsets; + self + } + pub fn dst_subresource( + mut self, + dst_subresource: ImageSubresourceLayers, + ) -> ImageBlit2KHRBuilder<'a> { + self.inner.dst_subresource = dst_subresource; + self + } + pub fn dst_offsets(mut self, dst_offsets: [Offset3D; 2]) -> ImageBlit2KHRBuilder<'a> { + self.inner.dst_offsets = dst_offsets; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next( + mut self, + next: &'a mut T, + ) -> ImageBlit2KHRBuilder<'a> { + unsafe { + let next_ptr = next as *mut T as *mut BaseOutStructure; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ImageBlit2KHR { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = ""] +pub struct BufferImageCopy2KHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub buffer_offset: DeviceSize, + pub buffer_row_length: u32, + pub buffer_image_height: u32, + pub image_subresource: ImageSubresourceLayers, + pub image_offset: Offset3D, + pub image_extent: Extent3D, +} +impl ::std::default::Default for BufferImageCopy2KHR { + fn default() -> BufferImageCopy2KHR { + BufferImageCopy2KHR { + s_type: StructureType::BUFFER_IMAGE_COPY_2_KHR, + p_next: ::std::ptr::null(), + buffer_offset: DeviceSize::default(), + buffer_row_length: u32::default(), + buffer_image_height: u32::default(), + image_subresource: ImageSubresourceLayers::default(), + image_offset: Offset3D::default(), + image_extent: Extent3D::default(), + } + } +} +impl BufferImageCopy2KHR { + pub fn builder<'a>() -> BufferImageCopy2KHRBuilder<'a> { + BufferImageCopy2KHRBuilder { + inner: BufferImageCopy2KHR::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct BufferImageCopy2KHRBuilder<'a> { + inner: BufferImageCopy2KHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsBufferImageCopy2KHR {} +impl<'a> ::std::ops::Deref for BufferImageCopy2KHRBuilder<'a> { + type Target = BufferImageCopy2KHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for BufferImageCopy2KHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> BufferImageCopy2KHRBuilder<'a> { + pub fn buffer_offset(mut self, buffer_offset: DeviceSize) -> BufferImageCopy2KHRBuilder<'a> { + self.inner.buffer_offset = buffer_offset; + self + } + pub fn buffer_row_length(mut self, buffer_row_length: u32) -> BufferImageCopy2KHRBuilder<'a> { + self.inner.buffer_row_length = buffer_row_length; + self + } + pub fn buffer_image_height( + mut self, + buffer_image_height: u32, + ) -> BufferImageCopy2KHRBuilder<'a> { + self.inner.buffer_image_height = buffer_image_height; + self + } + pub fn image_subresource( + mut self, + image_subresource: ImageSubresourceLayers, + ) -> BufferImageCopy2KHRBuilder<'a> { + self.inner.image_subresource = image_subresource; + self + } + pub fn image_offset(mut self, image_offset: Offset3D) -> BufferImageCopy2KHRBuilder<'a> { + self.inner.image_offset = image_offset; + self + } + pub fn image_extent(mut self, image_extent: Extent3D) -> BufferImageCopy2KHRBuilder<'a> { + self.inner.image_extent = image_extent; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next( + mut self, + next: &'a mut T, + ) -> BufferImageCopy2KHRBuilder<'a> { + unsafe { + let next_ptr = next as *mut T as *mut BaseOutStructure; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> BufferImageCopy2KHR { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = ""] +pub struct ImageResolve2KHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub src_subresource: ImageSubresourceLayers, + pub src_offset: Offset3D, + pub dst_subresource: ImageSubresourceLayers, + pub dst_offset: Offset3D, + pub extent: Extent3D, +} +impl ::std::default::Default for ImageResolve2KHR { + fn default() -> ImageResolve2KHR { + ImageResolve2KHR { + s_type: StructureType::IMAGE_RESOLVE_2_KHR, + p_next: ::std::ptr::null(), + src_subresource: ImageSubresourceLayers::default(), + src_offset: Offset3D::default(), + dst_subresource: ImageSubresourceLayers::default(), + dst_offset: Offset3D::default(), + extent: Extent3D::default(), + } + } +} +impl ImageResolve2KHR { + pub fn builder<'a>() -> ImageResolve2KHRBuilder<'a> { + ImageResolve2KHRBuilder { + inner: ImageResolve2KHR::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ImageResolve2KHRBuilder<'a> { + inner: ImageResolve2KHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsImageResolve2KHR {} +impl<'a> ::std::ops::Deref for ImageResolve2KHRBuilder<'a> { + type Target = ImageResolve2KHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ImageResolve2KHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ImageResolve2KHRBuilder<'a> { + pub fn src_subresource( + mut self, + src_subresource: ImageSubresourceLayers, + ) -> ImageResolve2KHRBuilder<'a> { + self.inner.src_subresource = src_subresource; + self + } + pub fn src_offset(mut self, src_offset: Offset3D) -> ImageResolve2KHRBuilder<'a> { + self.inner.src_offset = src_offset; + self + } + pub fn dst_subresource( + mut self, + dst_subresource: ImageSubresourceLayers, + ) -> ImageResolve2KHRBuilder<'a> { + self.inner.dst_subresource = dst_subresource; + self + } + pub fn dst_offset(mut self, dst_offset: Offset3D) -> ImageResolve2KHRBuilder<'a> { + self.inner.dst_offset = dst_offset; + self + } + pub fn extent(mut self, extent: Extent3D) -> ImageResolve2KHRBuilder<'a> { + self.inner.extent = extent; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next( + mut self, + next: &'a mut T, + ) -> ImageResolve2KHRBuilder<'a> { + unsafe { + let next_ptr = next as *mut T as *mut BaseOutStructure; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ImageResolve2KHR { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = ""] +pub struct CopyBufferInfo2KHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub src_buffer: Buffer, + pub dst_buffer: Buffer, + pub region_count: u32, + pub p_regions: *const BufferCopy2KHR, +} +impl ::std::default::Default for CopyBufferInfo2KHR { + fn default() -> CopyBufferInfo2KHR { + CopyBufferInfo2KHR { + s_type: StructureType::COPY_BUFFER_INFO_2_KHR, + p_next: ::std::ptr::null(), + src_buffer: Buffer::default(), + dst_buffer: Buffer::default(), + region_count: u32::default(), + p_regions: ::std::ptr::null(), + } + } +} +impl CopyBufferInfo2KHR { + pub fn builder<'a>() -> CopyBufferInfo2KHRBuilder<'a> { + CopyBufferInfo2KHRBuilder { + inner: CopyBufferInfo2KHR::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct CopyBufferInfo2KHRBuilder<'a> { + inner: CopyBufferInfo2KHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsCopyBufferInfo2KHR {} +impl<'a> ::std::ops::Deref for CopyBufferInfo2KHRBuilder<'a> { + type Target = CopyBufferInfo2KHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for CopyBufferInfo2KHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> CopyBufferInfo2KHRBuilder<'a> { + pub fn src_buffer(mut self, src_buffer: Buffer) -> CopyBufferInfo2KHRBuilder<'a> { + self.inner.src_buffer = src_buffer; + self + } + pub fn dst_buffer(mut self, dst_buffer: Buffer) -> CopyBufferInfo2KHRBuilder<'a> { + self.inner.dst_buffer = dst_buffer; + self + } + pub fn regions(mut self, regions: &'a [BufferCopy2KHR]) -> CopyBufferInfo2KHRBuilder<'a> { + self.inner.region_count = regions.len() as _; + self.inner.p_regions = regions.as_ptr(); + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next( + mut self, + next: &'a mut T, + ) -> CopyBufferInfo2KHRBuilder<'a> { + unsafe { + let next_ptr = next as *mut T as *mut BaseOutStructure; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> CopyBufferInfo2KHR { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = ""] +pub struct CopyImageInfo2KHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub src_image: Image, + pub src_image_layout: ImageLayout, + pub dst_image: Image, + pub dst_image_layout: ImageLayout, + pub region_count: u32, + pub p_regions: *const ImageCopy2KHR, +} +impl ::std::default::Default for CopyImageInfo2KHR { + fn default() -> CopyImageInfo2KHR { + CopyImageInfo2KHR { + s_type: StructureType::COPY_IMAGE_INFO_2_KHR, + p_next: ::std::ptr::null(), + src_image: Image::default(), + src_image_layout: ImageLayout::default(), + dst_image: Image::default(), + dst_image_layout: ImageLayout::default(), + region_count: u32::default(), + p_regions: ::std::ptr::null(), + } + } +} +impl CopyImageInfo2KHR { + pub fn builder<'a>() -> CopyImageInfo2KHRBuilder<'a> { + CopyImageInfo2KHRBuilder { + inner: CopyImageInfo2KHR::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct CopyImageInfo2KHRBuilder<'a> { + inner: CopyImageInfo2KHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsCopyImageInfo2KHR {} +impl<'a> ::std::ops::Deref for CopyImageInfo2KHRBuilder<'a> { + type Target = CopyImageInfo2KHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for CopyImageInfo2KHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> CopyImageInfo2KHRBuilder<'a> { + pub fn src_image(mut self, src_image: Image) -> CopyImageInfo2KHRBuilder<'a> { + self.inner.src_image = src_image; + self + } + pub fn src_image_layout( + mut self, + src_image_layout: ImageLayout, + ) -> CopyImageInfo2KHRBuilder<'a> { + self.inner.src_image_layout = src_image_layout; + self + } + pub fn dst_image(mut self, dst_image: Image) -> CopyImageInfo2KHRBuilder<'a> { + self.inner.dst_image = dst_image; + self + } + pub fn dst_image_layout( + mut self, + dst_image_layout: ImageLayout, + ) -> CopyImageInfo2KHRBuilder<'a> { + self.inner.dst_image_layout = dst_image_layout; + self + } + pub fn regions(mut self, regions: &'a [ImageCopy2KHR]) -> CopyImageInfo2KHRBuilder<'a> { + self.inner.region_count = regions.len() as _; + self.inner.p_regions = regions.as_ptr(); + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next( + mut self, + next: &'a mut T, + ) -> CopyImageInfo2KHRBuilder<'a> { + unsafe { + let next_ptr = next as *mut T as *mut BaseOutStructure; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> CopyImageInfo2KHR { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = ""] +pub struct BlitImageInfo2KHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub src_image: Image, + pub src_image_layout: ImageLayout, + pub dst_image: Image, + pub dst_image_layout: ImageLayout, + pub region_count: u32, + pub p_regions: *const ImageBlit2KHR, + pub filter: Filter, +} +impl ::std::default::Default for BlitImageInfo2KHR { + fn default() -> BlitImageInfo2KHR { + BlitImageInfo2KHR { + s_type: StructureType::BLIT_IMAGE_INFO_2_KHR, + p_next: ::std::ptr::null(), + src_image: Image::default(), + src_image_layout: ImageLayout::default(), + dst_image: Image::default(), + dst_image_layout: ImageLayout::default(), + region_count: u32::default(), + p_regions: ::std::ptr::null(), + filter: Filter::default(), + } + } +} +impl BlitImageInfo2KHR { + pub fn builder<'a>() -> BlitImageInfo2KHRBuilder<'a> { + BlitImageInfo2KHRBuilder { + inner: BlitImageInfo2KHR::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct BlitImageInfo2KHRBuilder<'a> { + inner: BlitImageInfo2KHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsBlitImageInfo2KHR {} +impl<'a> ::std::ops::Deref for BlitImageInfo2KHRBuilder<'a> { + type Target = BlitImageInfo2KHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for BlitImageInfo2KHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> BlitImageInfo2KHRBuilder<'a> { + pub fn src_image(mut self, src_image: Image) -> BlitImageInfo2KHRBuilder<'a> { + self.inner.src_image = src_image; + self + } + pub fn src_image_layout( + mut self, + src_image_layout: ImageLayout, + ) -> BlitImageInfo2KHRBuilder<'a> { + self.inner.src_image_layout = src_image_layout; + self + } + pub fn dst_image(mut self, dst_image: Image) -> BlitImageInfo2KHRBuilder<'a> { + self.inner.dst_image = dst_image; + self + } + pub fn dst_image_layout( + mut self, + dst_image_layout: ImageLayout, + ) -> BlitImageInfo2KHRBuilder<'a> { + self.inner.dst_image_layout = dst_image_layout; + self + } + pub fn regions(mut self, regions: &'a [ImageBlit2KHR]) -> BlitImageInfo2KHRBuilder<'a> { + self.inner.region_count = regions.len() as _; + self.inner.p_regions = regions.as_ptr(); + self + } + pub fn filter(mut self, filter: Filter) -> BlitImageInfo2KHRBuilder<'a> { + self.inner.filter = filter; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next( + mut self, + next: &'a mut T, + ) -> BlitImageInfo2KHRBuilder<'a> { + unsafe { + let next_ptr = next as *mut T as *mut BaseOutStructure; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> BlitImageInfo2KHR { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = ""] +pub struct CopyBufferToImageInfo2KHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub src_buffer: Buffer, + pub dst_image: Image, + pub dst_image_layout: ImageLayout, + pub region_count: u32, + pub p_regions: *const BufferImageCopy2KHR, +} +impl ::std::default::Default for CopyBufferToImageInfo2KHR { + fn default() -> CopyBufferToImageInfo2KHR { + CopyBufferToImageInfo2KHR { + s_type: StructureType::COPY_BUFFER_TO_IMAGE_INFO_2_KHR, + p_next: ::std::ptr::null(), + src_buffer: Buffer::default(), + dst_image: Image::default(), + dst_image_layout: ImageLayout::default(), + region_count: u32::default(), + p_regions: ::std::ptr::null(), + } + } +} +impl CopyBufferToImageInfo2KHR { + pub fn builder<'a>() -> CopyBufferToImageInfo2KHRBuilder<'a> { + CopyBufferToImageInfo2KHRBuilder { + inner: CopyBufferToImageInfo2KHR::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct CopyBufferToImageInfo2KHRBuilder<'a> { + inner: CopyBufferToImageInfo2KHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsCopyBufferToImageInfo2KHR {} +impl<'a> ::std::ops::Deref for CopyBufferToImageInfo2KHRBuilder<'a> { + type Target = CopyBufferToImageInfo2KHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for CopyBufferToImageInfo2KHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> CopyBufferToImageInfo2KHRBuilder<'a> { + pub fn src_buffer(mut self, src_buffer: Buffer) -> CopyBufferToImageInfo2KHRBuilder<'a> { + self.inner.src_buffer = src_buffer; + self + } + pub fn dst_image(mut self, dst_image: Image) -> CopyBufferToImageInfo2KHRBuilder<'a> { + self.inner.dst_image = dst_image; + self + } + pub fn dst_image_layout( + mut self, + dst_image_layout: ImageLayout, + ) -> CopyBufferToImageInfo2KHRBuilder<'a> { + self.inner.dst_image_layout = dst_image_layout; + self + } + pub fn regions( + mut self, + regions: &'a [BufferImageCopy2KHR], + ) -> CopyBufferToImageInfo2KHRBuilder<'a> { + self.inner.region_count = regions.len() as _; + self.inner.p_regions = regions.as_ptr(); + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next( + mut self, + next: &'a mut T, + ) -> CopyBufferToImageInfo2KHRBuilder<'a> { + unsafe { + let next_ptr = next as *mut T as *mut BaseOutStructure; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> CopyBufferToImageInfo2KHR { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = ""] +pub struct CopyImageToBufferInfo2KHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub src_image: Image, + pub src_image_layout: ImageLayout, + pub dst_buffer: Buffer, + pub region_count: u32, + pub p_regions: *const BufferImageCopy2KHR, +} +impl ::std::default::Default for CopyImageToBufferInfo2KHR { + fn default() -> CopyImageToBufferInfo2KHR { + CopyImageToBufferInfo2KHR { + s_type: StructureType::COPY_IMAGE_TO_BUFFER_INFO_2_KHR, + p_next: ::std::ptr::null(), + src_image: Image::default(), + src_image_layout: ImageLayout::default(), + dst_buffer: Buffer::default(), + region_count: u32::default(), + p_regions: ::std::ptr::null(), + } + } +} +impl CopyImageToBufferInfo2KHR { + pub fn builder<'a>() -> CopyImageToBufferInfo2KHRBuilder<'a> { + CopyImageToBufferInfo2KHRBuilder { + inner: CopyImageToBufferInfo2KHR::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct CopyImageToBufferInfo2KHRBuilder<'a> { + inner: CopyImageToBufferInfo2KHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsCopyImageToBufferInfo2KHR {} +impl<'a> ::std::ops::Deref for CopyImageToBufferInfo2KHRBuilder<'a> { + type Target = CopyImageToBufferInfo2KHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for CopyImageToBufferInfo2KHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> CopyImageToBufferInfo2KHRBuilder<'a> { + pub fn src_image(mut self, src_image: Image) -> CopyImageToBufferInfo2KHRBuilder<'a> { + self.inner.src_image = src_image; + self + } + pub fn src_image_layout( + mut self, + src_image_layout: ImageLayout, + ) -> CopyImageToBufferInfo2KHRBuilder<'a> { + self.inner.src_image_layout = src_image_layout; + self + } + pub fn dst_buffer(mut self, dst_buffer: Buffer) -> CopyImageToBufferInfo2KHRBuilder<'a> { + self.inner.dst_buffer = dst_buffer; + self + } + pub fn regions( + mut self, + regions: &'a [BufferImageCopy2KHR], + ) -> CopyImageToBufferInfo2KHRBuilder<'a> { + self.inner.region_count = regions.len() as _; + self.inner.p_regions = regions.as_ptr(); + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next( + mut self, + next: &'a mut T, + ) -> CopyImageToBufferInfo2KHRBuilder<'a> { + unsafe { + let next_ptr = next as *mut T as *mut BaseOutStructure; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> CopyImageToBufferInfo2KHR { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = ""] +pub struct ResolveImageInfo2KHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub src_image: Image, + pub src_image_layout: ImageLayout, + pub dst_image: Image, + pub dst_image_layout: ImageLayout, + pub region_count: u32, + pub p_regions: *const ImageResolve2KHR, +} +impl ::std::default::Default for ResolveImageInfo2KHR { + fn default() -> ResolveImageInfo2KHR { + ResolveImageInfo2KHR { + s_type: StructureType::RESOLVE_IMAGE_INFO_2_KHR, + p_next: ::std::ptr::null(), + src_image: Image::default(), + src_image_layout: ImageLayout::default(), + dst_image: Image::default(), + dst_image_layout: ImageLayout::default(), + region_count: u32::default(), + p_regions: ::std::ptr::null(), + } + } +} +impl ResolveImageInfo2KHR { + pub fn builder<'a>() -> ResolveImageInfo2KHRBuilder<'a> { + ResolveImageInfo2KHRBuilder { + inner: ResolveImageInfo2KHR::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct ResolveImageInfo2KHRBuilder<'a> { + inner: ResolveImageInfo2KHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsResolveImageInfo2KHR {} +impl<'a> ::std::ops::Deref for ResolveImageInfo2KHRBuilder<'a> { + type Target = ResolveImageInfo2KHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for ResolveImageInfo2KHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> ResolveImageInfo2KHRBuilder<'a> { + pub fn src_image(mut self, src_image: Image) -> ResolveImageInfo2KHRBuilder<'a> { + self.inner.src_image = src_image; + self + } + pub fn src_image_layout( + mut self, + src_image_layout: ImageLayout, + ) -> ResolveImageInfo2KHRBuilder<'a> { + self.inner.src_image_layout = src_image_layout; + self + } + pub fn dst_image(mut self, dst_image: Image) -> ResolveImageInfo2KHRBuilder<'a> { + self.inner.dst_image = dst_image; + self + } + pub fn dst_image_layout( + mut self, + dst_image_layout: ImageLayout, + ) -> ResolveImageInfo2KHRBuilder<'a> { + self.inner.dst_image_layout = dst_image_layout; + self + } + pub fn regions(mut self, regions: &'a [ImageResolve2KHR]) -> ResolveImageInfo2KHRBuilder<'a> { + self.inner.region_count = regions.len() as _; + self.inner.p_regions = regions.as_ptr(); + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next( + mut self, + next: &'a mut T, + ) -> ResolveImageInfo2KHRBuilder<'a> { + unsafe { + let next_ptr = next as *mut T as *mut BaseOutStructure; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> ResolveImageInfo2KHR { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = ""] +pub struct PhysicalDeviceShaderImageAtomicInt64FeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub shader_image_int64_atomics: Bool32, + pub sparse_image_int64_atomics: Bool32, +} +impl ::std::default::Default for PhysicalDeviceShaderImageAtomicInt64FeaturesEXT { + fn default() -> PhysicalDeviceShaderImageAtomicInt64FeaturesEXT { + PhysicalDeviceShaderImageAtomicInt64FeaturesEXT { + s_type: StructureType::PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT, + p_next: ::std::ptr::null_mut(), + shader_image_int64_atomics: Bool32::default(), + sparse_image_int64_atomics: Bool32::default(), + } + } +} +impl PhysicalDeviceShaderImageAtomicInt64FeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceShaderImageAtomicInt64FeaturesEXTBuilder<'a> { + PhysicalDeviceShaderImageAtomicInt64FeaturesEXTBuilder { + inner: PhysicalDeviceShaderImageAtomicInt64FeaturesEXT::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceShaderImageAtomicInt64FeaturesEXTBuilder<'a> { + inner: PhysicalDeviceShaderImageAtomicInt64FeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderImageAtomicInt64FeaturesEXTBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderImageAtomicInt64FeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceShaderImageAtomicInt64FeaturesEXTBuilder<'a> { + type Target = PhysicalDeviceShaderImageAtomicInt64FeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderImageAtomicInt64FeaturesEXTBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceShaderImageAtomicInt64FeaturesEXTBuilder<'a> { + pub fn shader_image_int64_atomics( + mut self, + shader_image_int64_atomics: bool, + ) -> PhysicalDeviceShaderImageAtomicInt64FeaturesEXTBuilder<'a> { + self.inner.shader_image_int64_atomics = shader_image_int64_atomics.into(); + self + } + pub fn sparse_image_int64_atomics( + mut self, + sparse_image_int64_atomics: bool, + ) -> PhysicalDeviceShaderImageAtomicInt64FeaturesEXTBuilder<'a> { + self.inner.sparse_image_int64_atomics = sparse_image_int64_atomics.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceShaderImageAtomicInt64FeaturesEXT { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = ""] +pub struct FragmentShadingRateAttachmentInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub p_fragment_shading_rate_attachment: *const AttachmentReference2, + pub shading_rate_attachment_texel_size: Extent2D, +} +impl ::std::default::Default for FragmentShadingRateAttachmentInfoKHR { + fn default() -> FragmentShadingRateAttachmentInfoKHR { + FragmentShadingRateAttachmentInfoKHR { + s_type: StructureType::FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR, + p_next: ::std::ptr::null(), + p_fragment_shading_rate_attachment: ::std::ptr::null(), + shading_rate_attachment_texel_size: Extent2D::default(), + } + } +} +impl FragmentShadingRateAttachmentInfoKHR { + pub fn builder<'a>() -> FragmentShadingRateAttachmentInfoKHRBuilder<'a> { + FragmentShadingRateAttachmentInfoKHRBuilder { + inner: FragmentShadingRateAttachmentInfoKHR::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct FragmentShadingRateAttachmentInfoKHRBuilder<'a> { + inner: FragmentShadingRateAttachmentInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsSubpassDescription2 for FragmentShadingRateAttachmentInfoKHRBuilder<'_> {} +unsafe impl ExtendsSubpassDescription2 for FragmentShadingRateAttachmentInfoKHR {} +impl<'a> ::std::ops::Deref for FragmentShadingRateAttachmentInfoKHRBuilder<'a> { + type Target = FragmentShadingRateAttachmentInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for FragmentShadingRateAttachmentInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> FragmentShadingRateAttachmentInfoKHRBuilder<'a> { + pub fn fragment_shading_rate_attachment( + mut self, + fragment_shading_rate_attachment: &'a AttachmentReference2, + ) -> FragmentShadingRateAttachmentInfoKHRBuilder<'a> { + self.inner.p_fragment_shading_rate_attachment = fragment_shading_rate_attachment; + self + } + pub fn shading_rate_attachment_texel_size( + mut self, + shading_rate_attachment_texel_size: Extent2D, + ) -> FragmentShadingRateAttachmentInfoKHRBuilder<'a> { + self.inner.shading_rate_attachment_texel_size = shading_rate_attachment_texel_size; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> FragmentShadingRateAttachmentInfoKHR { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = ""] +pub struct PipelineFragmentShadingRateStateCreateInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub fragment_size: Extent2D, + pub combiner_ops: [FragmentShadingRateCombinerOpKHR; 2], +} +impl ::std::default::Default for PipelineFragmentShadingRateStateCreateInfoKHR { + fn default() -> PipelineFragmentShadingRateStateCreateInfoKHR { + PipelineFragmentShadingRateStateCreateInfoKHR { + s_type: StructureType::PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR, + p_next: ::std::ptr::null(), + fragment_size: Extent2D::default(), + combiner_ops: unsafe { ::std::mem::zeroed() }, + } + } +} +impl PipelineFragmentShadingRateStateCreateInfoKHR { + pub fn builder<'a>() -> PipelineFragmentShadingRateStateCreateInfoKHRBuilder<'a> { + PipelineFragmentShadingRateStateCreateInfoKHRBuilder { + inner: PipelineFragmentShadingRateStateCreateInfoKHR::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PipelineFragmentShadingRateStateCreateInfoKHRBuilder<'a> { + inner: PipelineFragmentShadingRateStateCreateInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsGraphicsPipelineCreateInfo + for PipelineFragmentShadingRateStateCreateInfoKHRBuilder<'_> +{ +} +unsafe impl ExtendsGraphicsPipelineCreateInfo for PipelineFragmentShadingRateStateCreateInfoKHR {} +impl<'a> ::std::ops::Deref for PipelineFragmentShadingRateStateCreateInfoKHRBuilder<'a> { + type Target = PipelineFragmentShadingRateStateCreateInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PipelineFragmentShadingRateStateCreateInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PipelineFragmentShadingRateStateCreateInfoKHRBuilder<'a> { + pub fn fragment_size( + mut self, + fragment_size: Extent2D, + ) -> PipelineFragmentShadingRateStateCreateInfoKHRBuilder<'a> { + self.inner.fragment_size = fragment_size; + self + } + pub fn combiner_ops( + mut self, + combiner_ops: [FragmentShadingRateCombinerOpKHR; 2], + ) -> PipelineFragmentShadingRateStateCreateInfoKHRBuilder<'a> { + self.inner.combiner_ops = combiner_ops; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PipelineFragmentShadingRateStateCreateInfoKHR { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = ""] +pub struct PhysicalDeviceFragmentShadingRateFeaturesKHR { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub pipeline_fragment_shading_rate: Bool32, + pub primitive_fragment_shading_rate: Bool32, + pub attachment_fragment_shading_rate: Bool32, +} +impl ::std::default::Default for PhysicalDeviceFragmentShadingRateFeaturesKHR { + fn default() -> PhysicalDeviceFragmentShadingRateFeaturesKHR { + PhysicalDeviceFragmentShadingRateFeaturesKHR { + s_type: StructureType::PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR, + p_next: ::std::ptr::null_mut(), + pipeline_fragment_shading_rate: Bool32::default(), + primitive_fragment_shading_rate: Bool32::default(), + attachment_fragment_shading_rate: Bool32::default(), + } + } +} +impl PhysicalDeviceFragmentShadingRateFeaturesKHR { + pub fn builder<'a>() -> PhysicalDeviceFragmentShadingRateFeaturesKHRBuilder<'a> { + PhysicalDeviceFragmentShadingRateFeaturesKHRBuilder { + inner: PhysicalDeviceFragmentShadingRateFeaturesKHR::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceFragmentShadingRateFeaturesKHRBuilder<'a> { + inner: PhysicalDeviceFragmentShadingRateFeaturesKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFragmentShadingRateFeaturesKHRBuilder<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFragmentShadingRateFeaturesKHR {} +impl<'a> ::std::ops::Deref for PhysicalDeviceFragmentShadingRateFeaturesKHRBuilder<'a> { + type Target = PhysicalDeviceFragmentShadingRateFeaturesKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceFragmentShadingRateFeaturesKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceFragmentShadingRateFeaturesKHRBuilder<'a> { + pub fn pipeline_fragment_shading_rate( + mut self, + pipeline_fragment_shading_rate: bool, + ) -> PhysicalDeviceFragmentShadingRateFeaturesKHRBuilder<'a> { + self.inner.pipeline_fragment_shading_rate = pipeline_fragment_shading_rate.into(); + self + } + pub fn primitive_fragment_shading_rate( + mut self, + primitive_fragment_shading_rate: bool, + ) -> PhysicalDeviceFragmentShadingRateFeaturesKHRBuilder<'a> { + self.inner.primitive_fragment_shading_rate = primitive_fragment_shading_rate.into(); + self + } + pub fn attachment_fragment_shading_rate( + mut self, + attachment_fragment_shading_rate: bool, + ) -> PhysicalDeviceFragmentShadingRateFeaturesKHRBuilder<'a> { + self.inner.attachment_fragment_shading_rate = attachment_fragment_shading_rate.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceFragmentShadingRateFeaturesKHR { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = ""] +pub struct PhysicalDeviceFragmentShadingRatePropertiesKHR { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub min_fragment_shading_rate_attachment_texel_size: Extent2D, + pub max_fragment_shading_rate_attachment_texel_size: Extent2D, + pub max_fragment_shading_rate_attachment_texel_size_aspect_ratio: u32, + pub primitive_fragment_shading_rate_with_multiple_viewports: Bool32, + pub layered_shading_rate_attachments: Bool32, + pub fragment_shading_rate_non_trivial_combiner_ops: Bool32, + pub max_fragment_size: Extent2D, + pub max_fragment_size_aspect_ratio: u32, + pub max_fragment_shading_rate_coverage_samples: u32, + pub max_fragment_shading_rate_rasterization_samples: SampleCountFlags, + pub fragment_shading_rate_with_shader_depth_stencil_writes: Bool32, + pub fragment_shading_rate_with_sample_mask: Bool32, + pub fragment_shading_rate_with_shader_sample_mask: Bool32, + pub fragment_shading_rate_with_conservative_rasterization: Bool32, + pub fragment_shading_rate_with_fragment_shader_interlock: Bool32, + pub fragment_shading_rate_with_custom_sample_locations: Bool32, + pub fragment_shading_rate_strict_multiply_combiner: Bool32, +} +impl ::std::default::Default for PhysicalDeviceFragmentShadingRatePropertiesKHR { + fn default() -> PhysicalDeviceFragmentShadingRatePropertiesKHR { + PhysicalDeviceFragmentShadingRatePropertiesKHR { + s_type: StructureType::PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR, + p_next: ::std::ptr::null_mut(), + min_fragment_shading_rate_attachment_texel_size: Extent2D::default(), + max_fragment_shading_rate_attachment_texel_size: Extent2D::default(), + max_fragment_shading_rate_attachment_texel_size_aspect_ratio: u32::default(), + primitive_fragment_shading_rate_with_multiple_viewports: Bool32::default(), + layered_shading_rate_attachments: Bool32::default(), + fragment_shading_rate_non_trivial_combiner_ops: Bool32::default(), + max_fragment_size: Extent2D::default(), + max_fragment_size_aspect_ratio: u32::default(), + max_fragment_shading_rate_coverage_samples: u32::default(), + max_fragment_shading_rate_rasterization_samples: SampleCountFlags::default(), + fragment_shading_rate_with_shader_depth_stencil_writes: Bool32::default(), + fragment_shading_rate_with_sample_mask: Bool32::default(), + fragment_shading_rate_with_shader_sample_mask: Bool32::default(), + fragment_shading_rate_with_conservative_rasterization: Bool32::default(), + fragment_shading_rate_with_fragment_shader_interlock: Bool32::default(), + fragment_shading_rate_with_custom_sample_locations: Bool32::default(), + fragment_shading_rate_strict_multiply_combiner: Bool32::default(), + } + } +} +impl PhysicalDeviceFragmentShadingRatePropertiesKHR { + pub fn builder<'a>() -> PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder<'a> { + PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder { + inner: PhysicalDeviceFragmentShadingRatePropertiesKHR::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder<'a> { + inner: PhysicalDeviceFragmentShadingRatePropertiesKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceFragmentShadingRatePropertiesKHR {} +impl<'a> ::std::ops::Deref for PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder<'a> { + type Target = PhysicalDeviceFragmentShadingRatePropertiesKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder<'a> { + pub fn min_fragment_shading_rate_attachment_texel_size( + mut self, + min_fragment_shading_rate_attachment_texel_size: Extent2D, + ) -> PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder<'a> { + self.inner.min_fragment_shading_rate_attachment_texel_size = + min_fragment_shading_rate_attachment_texel_size; + self + } + pub fn max_fragment_shading_rate_attachment_texel_size( + mut self, + max_fragment_shading_rate_attachment_texel_size: Extent2D, + ) -> PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder<'a> { + self.inner.max_fragment_shading_rate_attachment_texel_size = + max_fragment_shading_rate_attachment_texel_size; + self + } + pub fn max_fragment_shading_rate_attachment_texel_size_aspect_ratio( + mut self, + max_fragment_shading_rate_attachment_texel_size_aspect_ratio: u32, + ) -> PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder<'a> { + self.inner + .max_fragment_shading_rate_attachment_texel_size_aspect_ratio = + max_fragment_shading_rate_attachment_texel_size_aspect_ratio; + self + } + pub fn primitive_fragment_shading_rate_with_multiple_viewports( + mut self, + primitive_fragment_shading_rate_with_multiple_viewports: bool, + ) -> PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder<'a> { + self.inner + .primitive_fragment_shading_rate_with_multiple_viewports = + primitive_fragment_shading_rate_with_multiple_viewports.into(); + self + } + pub fn layered_shading_rate_attachments( + mut self, + layered_shading_rate_attachments: bool, + ) -> PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder<'a> { + self.inner.layered_shading_rate_attachments = layered_shading_rate_attachments.into(); + self + } + pub fn fragment_shading_rate_non_trivial_combiner_ops( + mut self, + fragment_shading_rate_non_trivial_combiner_ops: bool, + ) -> PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder<'a> { + self.inner.fragment_shading_rate_non_trivial_combiner_ops = + fragment_shading_rate_non_trivial_combiner_ops.into(); + self + } + pub fn max_fragment_size( + mut self, + max_fragment_size: Extent2D, + ) -> PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder<'a> { + self.inner.max_fragment_size = max_fragment_size; + self + } + pub fn max_fragment_size_aspect_ratio( + mut self, + max_fragment_size_aspect_ratio: u32, + ) -> PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder<'a> { + self.inner.max_fragment_size_aspect_ratio = max_fragment_size_aspect_ratio; + self + } + pub fn max_fragment_shading_rate_coverage_samples( + mut self, + max_fragment_shading_rate_coverage_samples: u32, + ) -> PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder<'a> { + self.inner.max_fragment_shading_rate_coverage_samples = + max_fragment_shading_rate_coverage_samples; + self + } + pub fn max_fragment_shading_rate_rasterization_samples( + mut self, + max_fragment_shading_rate_rasterization_samples: SampleCountFlags, + ) -> PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder<'a> { + self.inner.max_fragment_shading_rate_rasterization_samples = + max_fragment_shading_rate_rasterization_samples; + self + } + pub fn fragment_shading_rate_with_shader_depth_stencil_writes( + mut self, + fragment_shading_rate_with_shader_depth_stencil_writes: bool, + ) -> PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder<'a> { + self.inner + .fragment_shading_rate_with_shader_depth_stencil_writes = + fragment_shading_rate_with_shader_depth_stencil_writes.into(); + self + } + pub fn fragment_shading_rate_with_sample_mask( + mut self, + fragment_shading_rate_with_sample_mask: bool, + ) -> PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder<'a> { + self.inner.fragment_shading_rate_with_sample_mask = + fragment_shading_rate_with_sample_mask.into(); + self + } + pub fn fragment_shading_rate_with_shader_sample_mask( + mut self, + fragment_shading_rate_with_shader_sample_mask: bool, + ) -> PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder<'a> { + self.inner.fragment_shading_rate_with_shader_sample_mask = + fragment_shading_rate_with_shader_sample_mask.into(); + self + } + pub fn fragment_shading_rate_with_conservative_rasterization( + mut self, + fragment_shading_rate_with_conservative_rasterization: bool, + ) -> PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder<'a> { + self.inner + .fragment_shading_rate_with_conservative_rasterization = + fragment_shading_rate_with_conservative_rasterization.into(); + self + } + pub fn fragment_shading_rate_with_fragment_shader_interlock( + mut self, + fragment_shading_rate_with_fragment_shader_interlock: bool, + ) -> PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder<'a> { + self.inner + .fragment_shading_rate_with_fragment_shader_interlock = + fragment_shading_rate_with_fragment_shader_interlock.into(); + self + } + pub fn fragment_shading_rate_with_custom_sample_locations( + mut self, + fragment_shading_rate_with_custom_sample_locations: bool, + ) -> PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder<'a> { + self.inner + .fragment_shading_rate_with_custom_sample_locations = + fragment_shading_rate_with_custom_sample_locations.into(); + self + } + pub fn fragment_shading_rate_strict_multiply_combiner( + mut self, + fragment_shading_rate_strict_multiply_combiner: bool, + ) -> PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder<'a> { + self.inner.fragment_shading_rate_strict_multiply_combiner = + fragment_shading_rate_strict_multiply_combiner.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceFragmentShadingRatePropertiesKHR { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = ""] +pub struct PhysicalDeviceFragmentShadingRateKHR { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub sample_counts: SampleCountFlags, + pub fragment_size: Extent2D, +} +impl ::std::default::Default for PhysicalDeviceFragmentShadingRateKHR { + fn default() -> PhysicalDeviceFragmentShadingRateKHR { + PhysicalDeviceFragmentShadingRateKHR { + s_type: StructureType::PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR, + p_next: ::std::ptr::null_mut(), + sample_counts: SampleCountFlags::default(), + fragment_size: Extent2D::default(), + } + } +} +impl PhysicalDeviceFragmentShadingRateKHR { + pub fn builder<'a>() -> PhysicalDeviceFragmentShadingRateKHRBuilder<'a> { + PhysicalDeviceFragmentShadingRateKHRBuilder { + inner: PhysicalDeviceFragmentShadingRateKHR::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceFragmentShadingRateKHRBuilder<'a> { + inner: PhysicalDeviceFragmentShadingRateKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsPhysicalDeviceFragmentShadingRateKHR {} +impl<'a> ::std::ops::Deref for PhysicalDeviceFragmentShadingRateKHRBuilder<'a> { + type Target = PhysicalDeviceFragmentShadingRateKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceFragmentShadingRateKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceFragmentShadingRateKHRBuilder<'a> { + pub fn sample_counts( + mut self, + sample_counts: SampleCountFlags, + ) -> PhysicalDeviceFragmentShadingRateKHRBuilder<'a> { + self.inner.sample_counts = sample_counts; + self + } + pub fn fragment_size( + mut self, + fragment_size: Extent2D, + ) -> PhysicalDeviceFragmentShadingRateKHRBuilder<'a> { + self.inner.fragment_size = fragment_size; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next( + mut self, + next: &'a mut T, + ) -> PhysicalDeviceFragmentShadingRateKHRBuilder<'a> { + unsafe { + let next_ptr = next as *mut T as *mut BaseOutStructure; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceFragmentShadingRateKHR { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = ""] +pub struct PhysicalDeviceShaderTerminateInvocationFeaturesKHR { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub shader_terminate_invocation: Bool32, +} +impl ::std::default::Default for PhysicalDeviceShaderTerminateInvocationFeaturesKHR { + fn default() -> PhysicalDeviceShaderTerminateInvocationFeaturesKHR { + PhysicalDeviceShaderTerminateInvocationFeaturesKHR { + s_type: StructureType::PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES_KHR, + p_next: ::std::ptr::null_mut(), + shader_terminate_invocation: Bool32::default(), + } + } +} +impl PhysicalDeviceShaderTerminateInvocationFeaturesKHR { + pub fn builder<'a>() -> PhysicalDeviceShaderTerminateInvocationFeaturesKHRBuilder<'a> { + PhysicalDeviceShaderTerminateInvocationFeaturesKHRBuilder { + inner: PhysicalDeviceShaderTerminateInvocationFeaturesKHR::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceShaderTerminateInvocationFeaturesKHRBuilder<'a> { + inner: PhysicalDeviceShaderTerminateInvocationFeaturesKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsDeviceCreateInfo + for PhysicalDeviceShaderTerminateInvocationFeaturesKHRBuilder<'_> +{ +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderTerminateInvocationFeaturesKHR {} +impl<'a> ::std::ops::Deref for PhysicalDeviceShaderTerminateInvocationFeaturesKHRBuilder<'a> { + type Target = PhysicalDeviceShaderTerminateInvocationFeaturesKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderTerminateInvocationFeaturesKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceShaderTerminateInvocationFeaturesKHRBuilder<'a> { + pub fn shader_terminate_invocation( + mut self, + shader_terminate_invocation: bool, + ) -> PhysicalDeviceShaderTerminateInvocationFeaturesKHRBuilder<'a> { + self.inner.shader_terminate_invocation = shader_terminate_invocation.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceShaderTerminateInvocationFeaturesKHR { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = ""] +pub struct PhysicalDeviceFragmentShadingRateEnumsFeaturesNV { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub fragment_shading_rate_enums: Bool32, + pub supersample_fragment_shading_rates: Bool32, + pub no_invocation_fragment_shading_rates: Bool32, +} +impl ::std::default::Default for PhysicalDeviceFragmentShadingRateEnumsFeaturesNV { + fn default() -> PhysicalDeviceFragmentShadingRateEnumsFeaturesNV { + PhysicalDeviceFragmentShadingRateEnumsFeaturesNV { + s_type: StructureType::PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV, + p_next: ::std::ptr::null_mut(), + fragment_shading_rate_enums: Bool32::default(), + supersample_fragment_shading_rates: Bool32::default(), + no_invocation_fragment_shading_rates: Bool32::default(), + } + } +} +impl PhysicalDeviceFragmentShadingRateEnumsFeaturesNV { + pub fn builder<'a>() -> PhysicalDeviceFragmentShadingRateEnumsFeaturesNVBuilder<'a> { + PhysicalDeviceFragmentShadingRateEnumsFeaturesNVBuilder { + inner: PhysicalDeviceFragmentShadingRateEnumsFeaturesNV::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceFragmentShadingRateEnumsFeaturesNVBuilder<'a> { + inner: PhysicalDeviceFragmentShadingRateEnumsFeaturesNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsDeviceCreateInfo + for PhysicalDeviceFragmentShadingRateEnumsFeaturesNVBuilder<'_> +{ +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFragmentShadingRateEnumsFeaturesNV {} +impl<'a> ::std::ops::Deref for PhysicalDeviceFragmentShadingRateEnumsFeaturesNVBuilder<'a> { + type Target = PhysicalDeviceFragmentShadingRateEnumsFeaturesNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceFragmentShadingRateEnumsFeaturesNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceFragmentShadingRateEnumsFeaturesNVBuilder<'a> { + pub fn fragment_shading_rate_enums( + mut self, + fragment_shading_rate_enums: bool, + ) -> PhysicalDeviceFragmentShadingRateEnumsFeaturesNVBuilder<'a> { + self.inner.fragment_shading_rate_enums = fragment_shading_rate_enums.into(); + self + } + pub fn supersample_fragment_shading_rates( + mut self, + supersample_fragment_shading_rates: bool, + ) -> PhysicalDeviceFragmentShadingRateEnumsFeaturesNVBuilder<'a> { + self.inner.supersample_fragment_shading_rates = supersample_fragment_shading_rates.into(); + self + } + pub fn no_invocation_fragment_shading_rates( + mut self, + no_invocation_fragment_shading_rates: bool, + ) -> PhysicalDeviceFragmentShadingRateEnumsFeaturesNVBuilder<'a> { + self.inner.no_invocation_fragment_shading_rates = + no_invocation_fragment_shading_rates.into(); + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceFragmentShadingRateEnumsFeaturesNV { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = ""] +pub struct PhysicalDeviceFragmentShadingRateEnumsPropertiesNV { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub max_fragment_shading_rate_invocation_count: SampleCountFlags, +} +impl ::std::default::Default for PhysicalDeviceFragmentShadingRateEnumsPropertiesNV { + fn default() -> PhysicalDeviceFragmentShadingRateEnumsPropertiesNV { + PhysicalDeviceFragmentShadingRateEnumsPropertiesNV { + s_type: StructureType::PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV, + p_next: ::std::ptr::null_mut(), + max_fragment_shading_rate_invocation_count: SampleCountFlags::default(), + } + } +} +impl PhysicalDeviceFragmentShadingRateEnumsPropertiesNV { + pub fn builder<'a>() -> PhysicalDeviceFragmentShadingRateEnumsPropertiesNVBuilder<'a> { + PhysicalDeviceFragmentShadingRateEnumsPropertiesNVBuilder { + inner: PhysicalDeviceFragmentShadingRateEnumsPropertiesNV::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PhysicalDeviceFragmentShadingRateEnumsPropertiesNVBuilder<'a> { + inner: PhysicalDeviceFragmentShadingRateEnumsPropertiesNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceFragmentShadingRateEnumsPropertiesNVBuilder<'_> +{ +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceFragmentShadingRateEnumsPropertiesNV +{ +} +impl<'a> ::std::ops::Deref for PhysicalDeviceFragmentShadingRateEnumsPropertiesNVBuilder<'a> { + type Target = PhysicalDeviceFragmentShadingRateEnumsPropertiesNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PhysicalDeviceFragmentShadingRateEnumsPropertiesNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PhysicalDeviceFragmentShadingRateEnumsPropertiesNVBuilder<'a> { + pub fn max_fragment_shading_rate_invocation_count( + mut self, + max_fragment_shading_rate_invocation_count: SampleCountFlags, + ) -> PhysicalDeviceFragmentShadingRateEnumsPropertiesNVBuilder<'a> { + self.inner.max_fragment_shading_rate_invocation_count = + max_fragment_shading_rate_invocation_count; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PhysicalDeviceFragmentShadingRateEnumsPropertiesNV { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = ""] +pub struct PipelineFragmentShadingRateEnumStateCreateInfoNV { + pub s_type: StructureType, + pub p_next: *const c_void, + pub shading_rate_type: FragmentShadingRateTypeNV, + pub shading_rate: FragmentShadingRateNV, + pub combiner_ops: [FragmentShadingRateCombinerOpKHR; 2], +} +impl ::std::default::Default for PipelineFragmentShadingRateEnumStateCreateInfoNV { + fn default() -> PipelineFragmentShadingRateEnumStateCreateInfoNV { + PipelineFragmentShadingRateEnumStateCreateInfoNV { + s_type: StructureType::PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV, + p_next: ::std::ptr::null(), + shading_rate_type: FragmentShadingRateTypeNV::default(), + shading_rate: FragmentShadingRateNV::default(), + combiner_ops: unsafe { ::std::mem::zeroed() }, + } + } +} +impl PipelineFragmentShadingRateEnumStateCreateInfoNV { + pub fn builder<'a>() -> PipelineFragmentShadingRateEnumStateCreateInfoNVBuilder<'a> { + PipelineFragmentShadingRateEnumStateCreateInfoNVBuilder { + inner: PipelineFragmentShadingRateEnumStateCreateInfoNV::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct PipelineFragmentShadingRateEnumStateCreateInfoNVBuilder<'a> { + inner: PipelineFragmentShadingRateEnumStateCreateInfoNV, + marker: ::std::marker::PhantomData<&'a ()>, +} +unsafe impl ExtendsGraphicsPipelineCreateInfo + for PipelineFragmentShadingRateEnumStateCreateInfoNVBuilder<'_> +{ +} +unsafe impl ExtendsGraphicsPipelineCreateInfo for PipelineFragmentShadingRateEnumStateCreateInfoNV {} +impl<'a> ::std::ops::Deref for PipelineFragmentShadingRateEnumStateCreateInfoNVBuilder<'a> { + type Target = PipelineFragmentShadingRateEnumStateCreateInfoNV; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for PipelineFragmentShadingRateEnumStateCreateInfoNVBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> PipelineFragmentShadingRateEnumStateCreateInfoNVBuilder<'a> { + pub fn shading_rate_type( + mut self, + shading_rate_type: FragmentShadingRateTypeNV, + ) -> PipelineFragmentShadingRateEnumStateCreateInfoNVBuilder<'a> { + self.inner.shading_rate_type = shading_rate_type; + self + } + pub fn shading_rate( + mut self, + shading_rate: FragmentShadingRateNV, + ) -> PipelineFragmentShadingRateEnumStateCreateInfoNVBuilder<'a> { + self.inner.shading_rate = shading_rate; + self + } + pub fn combiner_ops( + mut self, + combiner_ops: [FragmentShadingRateCombinerOpKHR; 2], + ) -> PipelineFragmentShadingRateEnumStateCreateInfoNVBuilder<'a> { + self.inner.combiner_ops = combiner_ops; + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> PipelineFragmentShadingRateEnumStateCreateInfoNV { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +#[doc = ""] +pub struct AccelerationStructureBuildSizesInfoKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub acceleration_structure_size: DeviceSize, + pub update_scratch_size: DeviceSize, + pub build_scratch_size: DeviceSize, +} +impl ::std::default::Default for AccelerationStructureBuildSizesInfoKHR { + fn default() -> AccelerationStructureBuildSizesInfoKHR { + AccelerationStructureBuildSizesInfoKHR { + s_type: StructureType::ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR, + p_next: ::std::ptr::null(), + acceleration_structure_size: DeviceSize::default(), + update_scratch_size: DeviceSize::default(), + build_scratch_size: DeviceSize::default(), + } + } +} +impl AccelerationStructureBuildSizesInfoKHR { + pub fn builder<'a>() -> AccelerationStructureBuildSizesInfoKHRBuilder<'a> { + AccelerationStructureBuildSizesInfoKHRBuilder { + inner: AccelerationStructureBuildSizesInfoKHR::default(), + marker: ::std::marker::PhantomData, + } + } +} +#[repr(transparent)] +pub struct AccelerationStructureBuildSizesInfoKHRBuilder<'a> { + inner: AccelerationStructureBuildSizesInfoKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsAccelerationStructureBuildSizesInfoKHR {} +impl<'a> ::std::ops::Deref for AccelerationStructureBuildSizesInfoKHRBuilder<'a> { + type Target = AccelerationStructureBuildSizesInfoKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> ::std::ops::DerefMut for AccelerationStructureBuildSizesInfoKHRBuilder<'a> { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} +impl<'a> AccelerationStructureBuildSizesInfoKHRBuilder<'a> { + pub fn acceleration_structure_size( + mut self, + acceleration_structure_size: DeviceSize, + ) -> AccelerationStructureBuildSizesInfoKHRBuilder<'a> { + self.inner.acceleration_structure_size = acceleration_structure_size; + self + } + pub fn update_scratch_size( + mut self, + update_scratch_size: DeviceSize, + ) -> AccelerationStructureBuildSizesInfoKHRBuilder<'a> { + self.inner.update_scratch_size = update_scratch_size; + self + } + pub fn build_scratch_size( + mut self, + build_scratch_size: DeviceSize, + ) -> AccelerationStructureBuildSizesInfoKHRBuilder<'a> { + self.inner.build_scratch_size = build_scratch_size; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"] + #[doc = r" chain will look like `A -> D -> B -> C`."] + pub fn push_next( + mut self, + next: &'a mut T, + ) -> AccelerationStructureBuildSizesInfoKHRBuilder<'a> { + unsafe { + let next_ptr = next as *mut T as *mut BaseOutStructure; + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.inner.p_next as _; + self.inner.p_next = next_ptr as _; + } + self + } + #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"] + #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"] + #[doc = r" so references to builders can be passed directly to Vulkan functions."] + pub fn build(self) -> AccelerationStructureBuildSizesInfoKHR { + self.inner + } +} diff --git a/ash/src/vk/enums.rs b/ash/src/vk/enums.rs index f473274f6..3cdd63016 100644 --- a/ash/src/vk/enums.rs +++ b/ash/src/vk/enums.rs @@ -1220,6 +1220,25 @@ impl DebugReportObjectTypeEXT { } #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(transparent)] +#[doc = ""] +pub struct DeviceMemoryReportEventTypeEXT(pub(crate) i32); +impl DeviceMemoryReportEventTypeEXT { + pub const fn from_raw(x: i32) -> Self { + DeviceMemoryReportEventTypeEXT(x) + } + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl DeviceMemoryReportEventTypeEXT { + pub const ALLOCATE: Self = Self(0); + pub const FREE: Self = Self(1); + pub const IMPORT: Self = Self(2); + pub const UNIMPORT: Self = Self(3); + pub const ALLOCATION_FAILED: Self = Self(4); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] #[doc = ""] pub struct RasterizationOrderAMD(pub(crate) i32); impl RasterizationOrderAMD { @@ -1267,6 +1286,7 @@ impl ValidationFeatureEnableEXT { pub const GPU_ASSISTED_RESERVE_BINDING_SLOT: Self = Self(1); pub const BEST_PRACTICES: Self = Self(2); pub const DEBUG_PRINTF: Self = Self(3); + pub const SYNCHRONIZATION_VALIDATION: Self = Self(4); } #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(transparent)] @@ -1641,6 +1661,8 @@ impl VendorId { pub const KAZAN: Self = Self(0x1_0003); #[doc = "Codeplay Software Ltd. vendor ID"] pub const CODEPLAY: Self = Self(0x1_0004); + #[doc = "Mesa vendor ID"] + pub const MESA: Self = Self(0x1_0005); } #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(transparent)] @@ -1679,6 +1701,10 @@ impl DriverId { pub const GGP_PROPRIETARY: Self = Self(11); #[doc = "Broadcom Inc."] pub const BROADCOM_PROPRIETARY: Self = Self(12); + #[doc = "Mesa"] + pub const MESA_LLVMPIPE: Self = Self(13); + #[doc = "MoltenVK"] + pub const MOLTEN: Self = Self(14); } #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(transparent)] @@ -1744,6 +1770,22 @@ impl CopyAccelerationStructureModeKHR { } #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(transparent)] +#[doc = ""] +pub struct BuildAccelerationStructureModeKHR(pub(crate) i32); +impl BuildAccelerationStructureModeKHR { + pub const fn from_raw(x: i32) -> Self { + BuildAccelerationStructureModeKHR(x) + } + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl BuildAccelerationStructureModeKHR { + pub const BUILD: Self = Self(0); + pub const UPDATE: Self = Self(1); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] #[doc = ""] pub struct AccelerationStructureTypeKHR(pub(crate) i32); impl AccelerationStructureTypeKHR { @@ -1757,6 +1799,7 @@ impl AccelerationStructureTypeKHR { impl AccelerationStructureTypeKHR { pub const TOP_LEVEL: Self = Self(0); pub const BOTTOM_LEVEL: Self = Self(1); + pub const GENERIC: Self = Self(2); } #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(transparent)] @@ -1773,20 +1816,21 @@ impl GeometryTypeKHR { impl GeometryTypeKHR { pub const TRIANGLES: Self = Self(0); pub const AABBS: Self = Self(1); + pub const INSTANCES: Self = Self(2); } #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(transparent)] -#[doc = ""] -pub struct AccelerationStructureMemoryRequirementsTypeKHR(pub(crate) i32); -impl AccelerationStructureMemoryRequirementsTypeKHR { +#[doc = ""] +pub struct AccelerationStructureMemoryRequirementsTypeNV(pub(crate) i32); +impl AccelerationStructureMemoryRequirementsTypeNV { pub const fn from_raw(x: i32) -> Self { - AccelerationStructureMemoryRequirementsTypeKHR(x) + AccelerationStructureMemoryRequirementsTypeNV(x) } pub const fn as_raw(self) -> i32 { self.0 } } -impl AccelerationStructureMemoryRequirementsTypeKHR { +impl AccelerationStructureMemoryRequirementsTypeNV { pub const OBJECT: Self = Self(0); pub const BUILD_SCRATCH: Self = Self(1); pub const UPDATE_SCRATCH: Self = Self(2); @@ -1827,6 +1871,40 @@ impl RayTracingShaderGroupTypeKHR { } #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(transparent)] +#[doc = ""] +pub struct AccelerationStructureCompatibilityKHR(pub(crate) i32); +impl AccelerationStructureCompatibilityKHR { + pub const fn from_raw(x: i32) -> Self { + AccelerationStructureCompatibilityKHR(x) + } + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl AccelerationStructureCompatibilityKHR { + pub const COMPATIBLE: Self = Self(0); + pub const INCOMPATIBLE: Self = Self(1); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct ShaderGroupShaderKHR(pub(crate) i32); +impl ShaderGroupShaderKHR { + pub const fn from_raw(x: i32) -> Self { + ShaderGroupShaderKHR(x) + } + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl ShaderGroupShaderKHR { + pub const GENERAL: Self = Self(0); + pub const CLOSEST_HIT: Self = Self(1); + pub const ANY_HIT: Self = Self(2); + pub const INTERSECTION: Self = Self(3); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] #[doc = ""] pub struct MemoryOverallocationBehaviorAMD(pub(crate) i32); impl MemoryOverallocationBehaviorAMD { @@ -2100,3 +2178,64 @@ impl LineRasterizationModeEXT { pub const BRESENHAM: Self = Self(2); pub const RECTANGULAR_SMOOTH: Self = Self(3); } +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct FragmentShadingRateCombinerOpKHR(pub(crate) i32); +impl FragmentShadingRateCombinerOpKHR { + pub const fn from_raw(x: i32) -> Self { + FragmentShadingRateCombinerOpKHR(x) + } + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl FragmentShadingRateCombinerOpKHR { + pub const KEEP: Self = Self(0); + pub const REPLACE: Self = Self(1); + pub const MIN: Self = Self(2); + pub const MAX: Self = Self(3); + pub const MUL: Self = Self(4); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct FragmentShadingRateNV(pub(crate) i32); +impl FragmentShadingRateNV { + pub const fn from_raw(x: i32) -> Self { + FragmentShadingRateNV(x) + } + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl FragmentShadingRateNV { + pub const TYPE_1_INVOCATION_PER_PIXEL: Self = Self(0); + pub const TYPE_1_INVOCATION_PER_1X2_PIXELS: Self = Self(1); + pub const TYPE_1_INVOCATION_PER_2X1_PIXELS: Self = Self(4); + pub const TYPE_1_INVOCATION_PER_2X2_PIXELS: Self = Self(5); + pub const TYPE_1_INVOCATION_PER_2X4_PIXELS: Self = Self(6); + pub const TYPE_1_INVOCATION_PER_4X2_PIXELS: Self = Self(9); + pub const TYPE_1_INVOCATION_PER_4X4_PIXELS: Self = Self(10); + pub const TYPE_2_INVOCATIONS_PER_PIXEL: Self = Self(11); + pub const TYPE_4_INVOCATIONS_PER_PIXEL: Self = Self(12); + pub const TYPE_8_INVOCATIONS_PER_PIXEL: Self = Self(13); + pub const TYPE_16_INVOCATIONS_PER_PIXEL: Self = Self(14); + pub const NO_INVOCATIONS: Self = Self(15); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct FragmentShadingRateTypeNV(pub(crate) i32); +impl FragmentShadingRateTypeNV { + pub const fn from_raw(x: i32) -> Self { + FragmentShadingRateTypeNV(x) + } + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl FragmentShadingRateTypeNV { + pub const FRAGMENT_SIZE: Self = Self(0); + pub const ENUMS: Self = Self(1); +} diff --git a/ash/src/vk/extensions.rs b/ash/src/vk/extensions.rs index 5fe3b5365..28467dc5f 100644 --- a/ash/src/vk/extensions.rs +++ b/ash/src/vk/extensions.rs @@ -2750,10 +2750,6 @@ impl AccessFlags { pub const RESERVED_30_KHR: Self = Self(0b100_0000_0000_0000_0000_0000_0000_0000); } #[doc = "Generated from \'VK_AMD_extension_24\'"] -impl AccessFlags { - pub const RESERVED_31_KHR: Self = Self(0b1000_0000_0000_0000_0000_0000_0000_0000); -} -#[doc = "Generated from \'VK_AMD_extension_24\'"] impl BufferUsageFlags { pub const RESERVED_15_KHR: Self = Self(0b1000_0000_0000_0000); } @@ -3361,14 +3357,25 @@ impl NvxImageViewHandleFn { ::std::ffi::CStr::from_bytes_with_nul(b"VK_NVX_image_view_handle\0") .expect("Wrong extension string") } - pub const SPEC_VERSION: u32 = 1u32; + pub const SPEC_VERSION: u32 = 2u32; } #[allow(non_camel_case_types)] pub type PFN_vkGetImageViewHandleNVX = extern "system" fn(device: Device, p_info: *const ImageViewHandleInfoNVX) -> u32; +#[allow(non_camel_case_types)] +pub type PFN_vkGetImageViewAddressNVX = extern "system" fn( + device: Device, + image_view: ImageView, + p_properties: *mut ImageViewAddressPropertiesNVX, +) -> Result; pub struct NvxImageViewHandleFn { pub get_image_view_handle_nvx: extern "system" fn(device: Device, p_info: *const ImageViewHandleInfoNVX) -> u32, + pub get_image_view_address_nvx: extern "system" fn( + device: Device, + image_view: ImageView, + p_properties: *mut ImageViewAddressPropertiesNVX, + ) -> Result, } unsafe impl Send for NvxImageViewHandleFn {} unsafe impl Sync for NvxImageViewHandleFn {} @@ -3376,6 +3383,7 @@ impl ::std::clone::Clone for NvxImageViewHandleFn { fn clone(&self) -> Self { NvxImageViewHandleFn { get_image_view_handle_nvx: self.get_image_view_handle_nvx, + get_image_view_address_nvx: self.get_image_view_address_nvx, } } } @@ -3404,6 +3412,26 @@ impl NvxImageViewHandleFn { ::std::mem::transmute(val) } }, + get_image_view_address_nvx: unsafe { + extern "system" fn get_image_view_address_nvx( + _device: Device, + _image_view: ImageView, + _p_properties: *mut ImageViewAddressPropertiesNVX, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_image_view_address_nvx) + )) + } + let raw_name = stringify!(vkGetImageViewAddressNVX); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + get_image_view_address_nvx + } else { + ::std::mem::transmute(val) + } + }, } } #[doc = ""] @@ -3414,11 +3442,24 @@ impl NvxImageViewHandleFn { ) -> u32 { (self.get_image_view_handle_nvx)(device, p_info) } + #[doc = ""] + pub unsafe fn get_image_view_address_nvx( + &self, + device: Device, + image_view: ImageView, + p_properties: *mut ImageViewAddressPropertiesNVX, + ) -> Result { + (self.get_image_view_address_nvx)(device, image_view, p_properties) + } } #[doc = "Generated from \'VK_NVX_image_view_handle\'"] impl StructureType { pub const IMAGE_VIEW_HANDLE_INFO_NVX: Self = Self(1_000_030_000); } +#[doc = "Generated from \'VK_NVX_image_view_handle\'"] +impl StructureType { + pub const IMAGE_VIEW_ADDRESS_PROPERTIES_NVX: Self = Self(1_000_030_001); +} impl AmdExtension32Fn { pub fn name() -> &'static ::std::ffi::CStr { ::std::ffi::CStr::from_bytes_with_nul(b"VK_AMD_extension_32\0") @@ -9642,13 +9683,13 @@ impl KhrVariablePointersFn { } #[doc = "Generated from \'VK_KHR_variable_pointers\'"] impl StructureType { - pub const PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES_KHR: Self = - StructureType::PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES; + pub const PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES_KHR: Self = + StructureType::PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES; } #[doc = "Generated from \'VK_KHR_variable_pointers\'"] impl StructureType { - pub const PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES_KHR: Self = - StructureType::PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES; + pub const PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES_KHR: Self = + StructureType::PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES_KHR; } impl KhrGetDisplayProperties2Fn { pub fn name() -> &'static ::std::ffi::CStr { @@ -9888,7 +9929,7 @@ impl MvkIosSurfaceFn { ::std::ffi::CStr::from_bytes_with_nul(b"VK_MVK_ios_surface\0") .expect("Wrong extension string") } - pub const SPEC_VERSION: u32 = 2u32; + pub const SPEC_VERSION: u32 = 3u32; } #[allow(non_camel_case_types)] pub type PFN_vkCreateIOSSurfaceMVK = extern "system" fn( @@ -9963,7 +10004,7 @@ impl MvkMacosSurfaceFn { ::std::ffi::CStr::from_bytes_with_nul(b"VK_MVK_macos_surface\0") .expect("Wrong extension string") } - pub const SPEC_VERSION: u32 = 2u32; + pub const SPEC_VERSION: u32 = 3u32; } #[allow(non_camel_case_types)] pub type PFN_vkCreateMacOSSurfaceMVK = extern "system" fn( @@ -10143,7 +10184,7 @@ impl ExtDebugUtilsFn { ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_debug_utils\0") .expect("Wrong extension string") } - pub const SPEC_VERSION: u32 = 1u32; + pub const SPEC_VERSION: u32 = 2u32; } #[allow(non_camel_case_types)] pub type PFN_vkSetDebugUtilsObjectNameEXT = @@ -11691,12 +11732,12 @@ impl NvFragmentCoverageToColorFn { impl StructureType { pub const PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV: Self = Self(1_000_149_000); } -impl KhrRayTracingFn { +impl KhrAccelerationStructureFn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_ray_tracing\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_acceleration_structure\0") .expect("Wrong extension string") } - pub const SPEC_VERSION: u32 = 8u32; + pub const SPEC_VERSION: u32 = 11u32; } #[allow(non_camel_case_types)] pub type PFN_vkCreateAccelerationStructureKHR = extern "system" fn( @@ -11712,50 +11753,45 @@ pub type PFN_vkDestroyAccelerationStructureKHR = extern "system" fn( p_allocator: *const AllocationCallbacks, ) -> c_void; #[allow(non_camel_case_types)] -pub type PFN_vkGetAccelerationStructureMemoryRequirementsKHR = extern "system" fn( - device: Device, - p_info: *const AccelerationStructureMemoryRequirementsInfoKHR, - p_memory_requirements: *mut MemoryRequirements2, -) -> c_void; -#[allow(non_camel_case_types)] -pub type PFN_vkBindAccelerationStructureMemoryKHR = extern "system" fn( - device: Device, - bind_info_count: u32, - p_bind_infos: *const BindAccelerationStructureMemoryInfoKHR, -) -> Result; -#[allow(non_camel_case_types)] -pub type PFN_vkCmdBuildAccelerationStructureKHR = extern "system" fn( +pub type PFN_vkCmdBuildAccelerationStructuresKHR = extern "system" fn( command_buffer: CommandBuffer, info_count: u32, p_infos: *const AccelerationStructureBuildGeometryInfoKHR, - pp_offset_infos: *const *const AccelerationStructureBuildOffsetInfoKHR, + pp_build_range_infos: *const *const AccelerationStructureBuildRangeInfoKHR, ) -> c_void; #[allow(non_camel_case_types)] -pub type PFN_vkCmdBuildAccelerationStructureIndirectKHR = extern "system" fn( +pub type PFN_vkCmdBuildAccelerationStructuresIndirectKHR = extern "system" fn( command_buffer: CommandBuffer, - p_info: *const AccelerationStructureBuildGeometryInfoKHR, - indirect_buffer: Buffer, - indirect_offset: DeviceSize, - indirect_stride: u32, + info_count: u32, + p_infos: *const AccelerationStructureBuildGeometryInfoKHR, + p_indirect_device_addresses: *const DeviceAddress, + p_indirect_strides: *const u32, + pp_max_primitive_counts: *const *const u32, ) -> c_void; #[allow(non_camel_case_types)] -pub type PFN_vkBuildAccelerationStructureKHR = extern "system" fn( +pub type PFN_vkBuildAccelerationStructuresKHR = extern "system" fn( device: Device, + deferred_operation: DeferredOperationKHR, info_count: u32, p_infos: *const AccelerationStructureBuildGeometryInfoKHR, - pp_offset_infos: *const *const AccelerationStructureBuildOffsetInfoKHR, + pp_build_range_infos: *const *const AccelerationStructureBuildRangeInfoKHR, ) -> Result; #[allow(non_camel_case_types)] -pub type PFN_vkCopyAccelerationStructureKHR = - extern "system" fn(device: Device, p_info: *const CopyAccelerationStructureInfoKHR) -> Result; +pub type PFN_vkCopyAccelerationStructureKHR = extern "system" fn( + device: Device, + deferred_operation: DeferredOperationKHR, + p_info: *const CopyAccelerationStructureInfoKHR, +) -> Result; #[allow(non_camel_case_types)] pub type PFN_vkCopyAccelerationStructureToMemoryKHR = extern "system" fn( device: Device, + deferred_operation: DeferredOperationKHR, p_info: *const CopyAccelerationStructureToMemoryInfoKHR, ) -> Result; #[allow(non_camel_case_types)] pub type PFN_vkCopyMemoryToAccelerationStructureKHR = extern "system" fn( device: Device, + deferred_operation: DeferredOperationKHR, p_info: *const CopyMemoryToAccelerationStructureInfoKHR, ) -> Result; #[allow(non_camel_case_types)] @@ -11784,49 +11820,11 @@ pub type PFN_vkCmdCopyMemoryToAccelerationStructureKHR = extern "system" fn( p_info: *const CopyMemoryToAccelerationStructureInfoKHR, ) -> c_void; #[allow(non_camel_case_types)] -pub type PFN_vkCmdTraceRaysKHR = extern "system" fn( - command_buffer: CommandBuffer, - p_raygen_shader_binding_table: *const StridedBufferRegionKHR, - p_miss_shader_binding_table: *const StridedBufferRegionKHR, - p_hit_shader_binding_table: *const StridedBufferRegionKHR, - p_callable_shader_binding_table: *const StridedBufferRegionKHR, - width: u32, - height: u32, - depth: u32, -) -> c_void; -#[allow(non_camel_case_types)] -pub type PFN_vkCreateRayTracingPipelinesKHR = extern "system" fn( - device: Device, - pipeline_cache: PipelineCache, - create_info_count: u32, - p_create_infos: *const RayTracingPipelineCreateInfoKHR, - p_allocator: *const AllocationCallbacks, - p_pipelines: *mut Pipeline, -) -> Result; -#[allow(non_camel_case_types)] -pub type PFN_vkGetRayTracingShaderGroupHandlesKHR = extern "system" fn( - device: Device, - pipeline: Pipeline, - first_group: u32, - group_count: u32, - data_size: usize, - p_data: *mut c_void, -) -> Result; -#[allow(non_camel_case_types)] pub type PFN_vkGetAccelerationStructureDeviceAddressKHR = extern "system" fn( device: Device, p_info: *const AccelerationStructureDeviceAddressInfoKHR, ) -> DeviceAddress; #[allow(non_camel_case_types)] -pub type PFN_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR = extern "system" fn( - device: Device, - pipeline: Pipeline, - first_group: u32, - group_count: u32, - data_size: usize, - p_data: *mut c_void, -) -> Result; -#[allow(non_camel_case_types)] pub type PFN_vkCmdWriteAccelerationStructuresPropertiesKHR = extern "system" fn( command_buffer: CommandBuffer, acceleration_structure_count: u32, @@ -11836,19 +11834,20 @@ pub type PFN_vkCmdWriteAccelerationStructuresPropertiesKHR = extern "system" fn( first_query: u32, ) -> c_void; #[allow(non_camel_case_types)] -pub type PFN_vkCmdTraceRaysIndirectKHR = extern "system" fn( - command_buffer: CommandBuffer, - p_raygen_shader_binding_table: *const StridedBufferRegionKHR, - p_miss_shader_binding_table: *const StridedBufferRegionKHR, - p_hit_shader_binding_table: *const StridedBufferRegionKHR, - p_callable_shader_binding_table: *const StridedBufferRegionKHR, - buffer: Buffer, - offset: DeviceSize, +pub type PFN_vkGetDeviceAccelerationStructureCompatibilityKHR = extern "system" fn( + device: Device, + p_version_info: *const AccelerationStructureVersionInfoKHR, + p_compatibility: *mut AccelerationStructureCompatibilityKHR, ) -> c_void; #[allow(non_camel_case_types)] -pub type PFN_vkGetDeviceAccelerationStructureCompatibilityKHR = - extern "system" fn(device: Device, version: *const AccelerationStructureVersionKHR) -> Result; -pub struct KhrRayTracingFn { +pub type PFN_vkGetAccelerationStructureBuildSizesKHR = extern "system" fn( + device: Device, + build_type: AccelerationStructureBuildTypeKHR, + p_build_info: *const AccelerationStructureBuildGeometryInfoKHR, + p_max_primitive_counts: *const u32, + p_size_info: *mut AccelerationStructureBuildSizesInfoKHR, +) -> c_void; +pub struct KhrAccelerationStructureFn { pub create_acceleration_structure_khr: extern "system" fn( device: Device, p_create_info: *const AccelerationStructureCreateInfoKHR, @@ -11860,45 +11859,40 @@ pub struct KhrRayTracingFn { acceleration_structure: AccelerationStructureKHR, p_allocator: *const AllocationCallbacks, ) -> c_void, - pub get_acceleration_structure_memory_requirements_khr: extern "system" fn( - device: Device, - p_info: *const AccelerationStructureMemoryRequirementsInfoKHR, - p_memory_requirements: *mut MemoryRequirements2, - ) -> c_void, - pub bind_acceleration_structure_memory_khr: extern "system" fn( - device: Device, - bind_info_count: u32, - p_bind_infos: *const BindAccelerationStructureMemoryInfoKHR, - ) -> Result, - pub cmd_build_acceleration_structure_khr: extern "system" fn( + pub cmd_build_acceleration_structures_khr: extern "system" fn( command_buffer: CommandBuffer, info_count: u32, p_infos: *const AccelerationStructureBuildGeometryInfoKHR, - pp_offset_infos: *const *const AccelerationStructureBuildOffsetInfoKHR, + pp_build_range_infos: *const *const AccelerationStructureBuildRangeInfoKHR, ) -> c_void, - pub cmd_build_acceleration_structure_indirect_khr: extern "system" fn( + pub cmd_build_acceleration_structures_indirect_khr: extern "system" fn( command_buffer: CommandBuffer, - p_info: *const AccelerationStructureBuildGeometryInfoKHR, - indirect_buffer: Buffer, - indirect_offset: DeviceSize, - indirect_stride: u32, + info_count: u32, + p_infos: *const AccelerationStructureBuildGeometryInfoKHR, + p_indirect_device_addresses: *const DeviceAddress, + p_indirect_strides: *const u32, + pp_max_primitive_counts: *const *const u32, ) -> c_void, - pub build_acceleration_structure_khr: extern "system" fn( + pub build_acceleration_structures_khr: extern "system" fn( device: Device, + deferred_operation: DeferredOperationKHR, info_count: u32, p_infos: *const AccelerationStructureBuildGeometryInfoKHR, - pp_offset_infos: *const *const AccelerationStructureBuildOffsetInfoKHR, + pp_build_range_infos: *const *const AccelerationStructureBuildRangeInfoKHR, ) -> Result, pub copy_acceleration_structure_khr: extern "system" fn( device: Device, + deferred_operation: DeferredOperationKHR, p_info: *const CopyAccelerationStructureInfoKHR, ) -> Result, pub copy_acceleration_structure_to_memory_khr: extern "system" fn( device: Device, + deferred_operation: DeferredOperationKHR, p_info: *const CopyAccelerationStructureToMemoryInfoKHR, ) -> Result, pub copy_memory_to_acceleration_structure_khr: extern "system" fn( device: Device, + deferred_operation: DeferredOperationKHR, p_info: *const CopyMemoryToAccelerationStructureInfoKHR, ) -> Result, pub write_acceleration_structures_properties_khr: extern "system" fn( @@ -11922,44 +11916,10 @@ pub struct KhrRayTracingFn { command_buffer: CommandBuffer, p_info: *const CopyMemoryToAccelerationStructureInfoKHR, ) -> c_void, - pub cmd_trace_rays_khr: extern "system" fn( - command_buffer: CommandBuffer, - p_raygen_shader_binding_table: *const StridedBufferRegionKHR, - p_miss_shader_binding_table: *const StridedBufferRegionKHR, - p_hit_shader_binding_table: *const StridedBufferRegionKHR, - p_callable_shader_binding_table: *const StridedBufferRegionKHR, - width: u32, - height: u32, - depth: u32, - ) -> c_void, - pub create_ray_tracing_pipelines_khr: extern "system" fn( - device: Device, - pipeline_cache: PipelineCache, - create_info_count: u32, - p_create_infos: *const RayTracingPipelineCreateInfoKHR, - p_allocator: *const AllocationCallbacks, - p_pipelines: *mut Pipeline, - ) -> Result, - pub get_ray_tracing_shader_group_handles_khr: extern "system" fn( - device: Device, - pipeline: Pipeline, - first_group: u32, - group_count: u32, - data_size: usize, - p_data: *mut c_void, - ) -> Result, pub get_acceleration_structure_device_address_khr: extern "system" fn( device: Device, p_info: *const AccelerationStructureDeviceAddressInfoKHR, ) -> DeviceAddress, - pub get_ray_tracing_capture_replay_shader_group_handles_khr: extern "system" fn( - device: Device, - pipeline: Pipeline, - first_group: u32, - group_count: u32, - data_size: usize, - p_data: *mut c_void, - ) -> Result, pub cmd_write_acceleration_structures_properties_khr: extern "system" fn( command_buffer: CommandBuffer, acceleration_structure_count: u32, @@ -11968,34 +11928,30 @@ pub struct KhrRayTracingFn { query_pool: QueryPool, first_query: u32, ) -> c_void, - pub cmd_trace_rays_indirect_khr: extern "system" fn( - command_buffer: CommandBuffer, - p_raygen_shader_binding_table: *const StridedBufferRegionKHR, - p_miss_shader_binding_table: *const StridedBufferRegionKHR, - p_hit_shader_binding_table: *const StridedBufferRegionKHR, - p_callable_shader_binding_table: *const StridedBufferRegionKHR, - buffer: Buffer, - offset: DeviceSize, - ) -> c_void, pub get_device_acceleration_structure_compatibility_khr: extern "system" fn( device: Device, - version: *const AccelerationStructureVersionKHR, - ) -> Result, + p_version_info: *const AccelerationStructureVersionInfoKHR, + p_compatibility: *mut AccelerationStructureCompatibilityKHR, + ) -> c_void, + pub get_acceleration_structure_build_sizes_khr: extern "system" fn( + device: Device, + build_type: AccelerationStructureBuildTypeKHR, + p_build_info: *const AccelerationStructureBuildGeometryInfoKHR, + p_max_primitive_counts: *const u32, + p_size_info: *mut AccelerationStructureBuildSizesInfoKHR, + ) -> c_void, } -unsafe impl Send for KhrRayTracingFn {} -unsafe impl Sync for KhrRayTracingFn {} -impl ::std::clone::Clone for KhrRayTracingFn { +unsafe impl Send for KhrAccelerationStructureFn {} +unsafe impl Sync for KhrAccelerationStructureFn {} +impl ::std::clone::Clone for KhrAccelerationStructureFn { fn clone(&self) -> Self { - KhrRayTracingFn { + KhrAccelerationStructureFn { create_acceleration_structure_khr: self.create_acceleration_structure_khr, destroy_acceleration_structure_khr: self.destroy_acceleration_structure_khr, - get_acceleration_structure_memory_requirements_khr: self - .get_acceleration_structure_memory_requirements_khr, - bind_acceleration_structure_memory_khr: self.bind_acceleration_structure_memory_khr, - cmd_build_acceleration_structure_khr: self.cmd_build_acceleration_structure_khr, - cmd_build_acceleration_structure_indirect_khr: self - .cmd_build_acceleration_structure_indirect_khr, - build_acceleration_structure_khr: self.build_acceleration_structure_khr, + cmd_build_acceleration_structures_khr: self.cmd_build_acceleration_structures_khr, + cmd_build_acceleration_structures_indirect_khr: self + .cmd_build_acceleration_structures_indirect_khr, + build_acceleration_structures_khr: self.build_acceleration_structures_khr, copy_acceleration_structure_khr: self.copy_acceleration_structure_khr, copy_acceleration_structure_to_memory_khr: self .copy_acceleration_structure_to_memory_khr, @@ -12008,27 +11964,23 @@ impl ::std::clone::Clone for KhrRayTracingFn { .cmd_copy_acceleration_structure_to_memory_khr, cmd_copy_memory_to_acceleration_structure_khr: self .cmd_copy_memory_to_acceleration_structure_khr, - cmd_trace_rays_khr: self.cmd_trace_rays_khr, - create_ray_tracing_pipelines_khr: self.create_ray_tracing_pipelines_khr, - get_ray_tracing_shader_group_handles_khr: self.get_ray_tracing_shader_group_handles_khr, get_acceleration_structure_device_address_khr: self .get_acceleration_structure_device_address_khr, - get_ray_tracing_capture_replay_shader_group_handles_khr: self - .get_ray_tracing_capture_replay_shader_group_handles_khr, cmd_write_acceleration_structures_properties_khr: self .cmd_write_acceleration_structures_properties_khr, - cmd_trace_rays_indirect_khr: self.cmd_trace_rays_indirect_khr, get_device_acceleration_structure_compatibility_khr: self .get_device_acceleration_structure_compatibility_khr, + get_acceleration_structure_build_sizes_khr: self + .get_acceleration_structure_build_sizes_khr, } } } -impl KhrRayTracingFn { +impl KhrAccelerationStructureFn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - KhrRayTracingFn { + KhrAccelerationStructureFn { create_acceleration_structure_khr: unsafe { extern "system" fn create_acceleration_structure_khr( _device: Device, @@ -12070,106 +12022,68 @@ impl KhrRayTracingFn { ::std::mem::transmute(val) } }, - get_acceleration_structure_memory_requirements_khr: unsafe { - extern "system" fn get_acceleration_structure_memory_requirements_khr( - _device: Device, - _p_info: *const AccelerationStructureMemoryRequirementsInfoKHR, - _p_memory_requirements: *mut MemoryRequirements2, - ) -> c_void { - panic!(concat!( - "Unable to load ", - stringify!(get_acceleration_structure_memory_requirements_khr) - )) - } - let raw_name = stringify!(vkGetAccelerationStructureMemoryRequirementsKHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - get_acceleration_structure_memory_requirements_khr - } else { - ::std::mem::transmute(val) - } - }, - bind_acceleration_structure_memory_khr: unsafe { - extern "system" fn bind_acceleration_structure_memory_khr( - _device: Device, - _bind_info_count: u32, - _p_bind_infos: *const BindAccelerationStructureMemoryInfoKHR, - ) -> Result { - panic!(concat!( - "Unable to load ", - stringify!(bind_acceleration_structure_memory_khr) - )) - } - let raw_name = stringify!(vkBindAccelerationStructureMemoryKHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - bind_acceleration_structure_memory_khr - } else { - ::std::mem::transmute(val) - } - }, - cmd_build_acceleration_structure_khr: unsafe { - extern "system" fn cmd_build_acceleration_structure_khr( + cmd_build_acceleration_structures_khr: unsafe { + extern "system" fn cmd_build_acceleration_structures_khr( _command_buffer: CommandBuffer, _info_count: u32, _p_infos: *const AccelerationStructureBuildGeometryInfoKHR, - _pp_offset_infos: *const *const AccelerationStructureBuildOffsetInfoKHR, + _pp_build_range_infos: *const *const AccelerationStructureBuildRangeInfoKHR, ) -> c_void { panic!(concat!( "Unable to load ", - stringify!(cmd_build_acceleration_structure_khr) + stringify!(cmd_build_acceleration_structures_khr) )) } - let raw_name = stringify!(vkCmdBuildAccelerationStructureKHR); + let raw_name = stringify!(vkCmdBuildAccelerationStructuresKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - cmd_build_acceleration_structure_khr + cmd_build_acceleration_structures_khr } else { ::std::mem::transmute(val) } }, - cmd_build_acceleration_structure_indirect_khr: unsafe { - extern "system" fn cmd_build_acceleration_structure_indirect_khr( + cmd_build_acceleration_structures_indirect_khr: unsafe { + extern "system" fn cmd_build_acceleration_structures_indirect_khr( _command_buffer: CommandBuffer, - _p_info: *const AccelerationStructureBuildGeometryInfoKHR, - _indirect_buffer: Buffer, - _indirect_offset: DeviceSize, - _indirect_stride: u32, + _info_count: u32, + _p_infos: *const AccelerationStructureBuildGeometryInfoKHR, + _p_indirect_device_addresses: *const DeviceAddress, + _p_indirect_strides: *const u32, + _pp_max_primitive_counts: *const *const u32, ) -> c_void { panic!(concat!( "Unable to load ", - stringify!(cmd_build_acceleration_structure_indirect_khr) + stringify!(cmd_build_acceleration_structures_indirect_khr) )) } - let raw_name = stringify!(vkCmdBuildAccelerationStructureIndirectKHR); + let raw_name = stringify!(vkCmdBuildAccelerationStructuresIndirectKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - cmd_build_acceleration_structure_indirect_khr + cmd_build_acceleration_structures_indirect_khr } else { ::std::mem::transmute(val) } }, - build_acceleration_structure_khr: unsafe { - extern "system" fn build_acceleration_structure_khr( + build_acceleration_structures_khr: unsafe { + extern "system" fn build_acceleration_structures_khr( _device: Device, + _deferred_operation: DeferredOperationKHR, _info_count: u32, _p_infos: *const AccelerationStructureBuildGeometryInfoKHR, - _pp_offset_infos: *const *const AccelerationStructureBuildOffsetInfoKHR, + _pp_build_range_infos: *const *const AccelerationStructureBuildRangeInfoKHR, ) -> Result { panic!(concat!( "Unable to load ", - stringify!(build_acceleration_structure_khr) + stringify!(build_acceleration_structures_khr) )) } - let raw_name = stringify!(vkBuildAccelerationStructureKHR); + let raw_name = stringify!(vkBuildAccelerationStructuresKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - build_acceleration_structure_khr + build_acceleration_structures_khr } else { ::std::mem::transmute(val) } @@ -12177,6 +12091,7 @@ impl KhrRayTracingFn { copy_acceleration_structure_khr: unsafe { extern "system" fn copy_acceleration_structure_khr( _device: Device, + _deferred_operation: DeferredOperationKHR, _p_info: *const CopyAccelerationStructureInfoKHR, ) -> Result { panic!(concat!( @@ -12196,6 +12111,7 @@ impl KhrRayTracingFn { copy_acceleration_structure_to_memory_khr: unsafe { extern "system" fn copy_acceleration_structure_to_memory_khr( _device: Device, + _deferred_operation: DeferredOperationKHR, _p_info: *const CopyAccelerationStructureToMemoryInfoKHR, ) -> Result { panic!(concat!( @@ -12215,6 +12131,7 @@ impl KhrRayTracingFn { copy_memory_to_acceleration_structure_khr: unsafe { extern "system" fn copy_memory_to_acceleration_structure_khr( _device: Device, + _deferred_operation: DeferredOperationKHR, _p_info: *const CopyMemoryToAccelerationStructureInfoKHR, ) -> Result { panic!(concat!( @@ -12312,178 +12229,86 @@ impl KhrRayTracingFn { ::std::mem::transmute(val) } }, - cmd_trace_rays_khr: unsafe { - extern "system" fn cmd_trace_rays_khr( - _command_buffer: CommandBuffer, - _p_raygen_shader_binding_table: *const StridedBufferRegionKHR, - _p_miss_shader_binding_table: *const StridedBufferRegionKHR, - _p_hit_shader_binding_table: *const StridedBufferRegionKHR, - _p_callable_shader_binding_table: *const StridedBufferRegionKHR, - _width: u32, - _height: u32, - _depth: u32, - ) -> c_void { - panic!(concat!("Unable to load ", stringify!(cmd_trace_rays_khr))) + get_acceleration_structure_device_address_khr: unsafe { + extern "system" fn get_acceleration_structure_device_address_khr( + _device: Device, + _p_info: *const AccelerationStructureDeviceAddressInfoKHR, + ) -> DeviceAddress { + panic!(concat!( + "Unable to load ", + stringify!(get_acceleration_structure_device_address_khr) + )) } - let raw_name = stringify!(vkCmdTraceRaysKHR); + let raw_name = stringify!(vkGetAccelerationStructureDeviceAddressKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - cmd_trace_rays_khr + get_acceleration_structure_device_address_khr } else { ::std::mem::transmute(val) } }, - create_ray_tracing_pipelines_khr: unsafe { - extern "system" fn create_ray_tracing_pipelines_khr( - _device: Device, - _pipeline_cache: PipelineCache, - _create_info_count: u32, - _p_create_infos: *const RayTracingPipelineCreateInfoKHR, - _p_allocator: *const AllocationCallbacks, - _p_pipelines: *mut Pipeline, - ) -> Result { + cmd_write_acceleration_structures_properties_khr: unsafe { + extern "system" fn cmd_write_acceleration_structures_properties_khr( + _command_buffer: CommandBuffer, + _acceleration_structure_count: u32, + _p_acceleration_structures: *const AccelerationStructureKHR, + _query_type: QueryType, + _query_pool: QueryPool, + _first_query: u32, + ) -> c_void { panic!(concat!( "Unable to load ", - stringify!(create_ray_tracing_pipelines_khr) + stringify!(cmd_write_acceleration_structures_properties_khr) )) } - let raw_name = stringify!(vkCreateRayTracingPipelinesKHR); + let raw_name = stringify!(vkCmdWriteAccelerationStructuresPropertiesKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - create_ray_tracing_pipelines_khr + cmd_write_acceleration_structures_properties_khr } else { ::std::mem::transmute(val) } }, - get_ray_tracing_shader_group_handles_khr: unsafe { - extern "system" fn get_ray_tracing_shader_group_handles_khr( + get_device_acceleration_structure_compatibility_khr: unsafe { + extern "system" fn get_device_acceleration_structure_compatibility_khr( _device: Device, - _pipeline: Pipeline, - _first_group: u32, - _group_count: u32, - _data_size: usize, - _p_data: *mut c_void, - ) -> Result { + _p_version_info: *const AccelerationStructureVersionInfoKHR, + _p_compatibility: *mut AccelerationStructureCompatibilityKHR, + ) -> c_void { panic!(concat!( "Unable to load ", - stringify!(get_ray_tracing_shader_group_handles_khr) + stringify!(get_device_acceleration_structure_compatibility_khr) )) } - let raw_name = stringify!(vkGetRayTracingShaderGroupHandlesKHR); + let raw_name = stringify!(vkGetDeviceAccelerationStructureCompatibilityKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - get_ray_tracing_shader_group_handles_khr + get_device_acceleration_structure_compatibility_khr } else { ::std::mem::transmute(val) } }, - get_acceleration_structure_device_address_khr: unsafe { - extern "system" fn get_acceleration_structure_device_address_khr( + get_acceleration_structure_build_sizes_khr: unsafe { + extern "system" fn get_acceleration_structure_build_sizes_khr( _device: Device, - _p_info: *const AccelerationStructureDeviceAddressInfoKHR, - ) -> DeviceAddress { + _build_type: AccelerationStructureBuildTypeKHR, + _p_build_info: *const AccelerationStructureBuildGeometryInfoKHR, + _p_max_primitive_counts: *const u32, + _p_size_info: *mut AccelerationStructureBuildSizesInfoKHR, + ) -> c_void { panic!(concat!( "Unable to load ", - stringify!(get_acceleration_structure_device_address_khr) + stringify!(get_acceleration_structure_build_sizes_khr) )) } - let raw_name = stringify!(vkGetAccelerationStructureDeviceAddressKHR); + let raw_name = stringify!(vkGetAccelerationStructureBuildSizesKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - get_acceleration_structure_device_address_khr - } else { - ::std::mem::transmute(val) - } - }, - get_ray_tracing_capture_replay_shader_group_handles_khr: unsafe { - extern "system" fn get_ray_tracing_capture_replay_shader_group_handles_khr( - _device: Device, - _pipeline: Pipeline, - _first_group: u32, - _group_count: u32, - _data_size: usize, - _p_data: *mut c_void, - ) -> Result { - panic!(concat!( - "Unable to load ", - stringify!(get_ray_tracing_capture_replay_shader_group_handles_khr) - )) - } - let raw_name = stringify!(vkGetRayTracingCaptureReplayShaderGroupHandlesKHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - get_ray_tracing_capture_replay_shader_group_handles_khr - } else { - ::std::mem::transmute(val) - } - }, - cmd_write_acceleration_structures_properties_khr: unsafe { - extern "system" fn cmd_write_acceleration_structures_properties_khr( - _command_buffer: CommandBuffer, - _acceleration_structure_count: u32, - _p_acceleration_structures: *const AccelerationStructureKHR, - _query_type: QueryType, - _query_pool: QueryPool, - _first_query: u32, - ) -> c_void { - panic!(concat!( - "Unable to load ", - stringify!(cmd_write_acceleration_structures_properties_khr) - )) - } - let raw_name = stringify!(vkCmdWriteAccelerationStructuresPropertiesKHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - cmd_write_acceleration_structures_properties_khr - } else { - ::std::mem::transmute(val) - } - }, - cmd_trace_rays_indirect_khr: unsafe { - extern "system" fn cmd_trace_rays_indirect_khr( - _command_buffer: CommandBuffer, - _p_raygen_shader_binding_table: *const StridedBufferRegionKHR, - _p_miss_shader_binding_table: *const StridedBufferRegionKHR, - _p_hit_shader_binding_table: *const StridedBufferRegionKHR, - _p_callable_shader_binding_table: *const StridedBufferRegionKHR, - _buffer: Buffer, - _offset: DeviceSize, - ) -> c_void { - panic!(concat!( - "Unable to load ", - stringify!(cmd_trace_rays_indirect_khr) - )) - } - let raw_name = stringify!(vkCmdTraceRaysIndirectKHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - cmd_trace_rays_indirect_khr - } else { - ::std::mem::transmute(val) - } - }, - get_device_acceleration_structure_compatibility_khr: unsafe { - extern "system" fn get_device_acceleration_structure_compatibility_khr( - _device: Device, - _version: *const AccelerationStructureVersionKHR, - ) -> Result { - panic!(concat!( - "Unable to load ", - stringify!(get_device_acceleration_structure_compatibility_khr) - )) - } - let raw_name = stringify!(vkGetDeviceAccelerationStructureCompatibilityKHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - get_device_acceleration_structure_compatibility_khr + get_acceleration_structure_build_sizes_khr } else { ::std::mem::transmute(val) } @@ -12514,93 +12339,83 @@ impl KhrRayTracingFn { ) -> c_void { (self.destroy_acceleration_structure_khr)(device, acceleration_structure, p_allocator) } - #[doc = ""] - pub unsafe fn get_acceleration_structure_memory_requirements_khr( - &self, - device: Device, - p_info: *const AccelerationStructureMemoryRequirementsInfoKHR, - p_memory_requirements: *mut MemoryRequirements2, - ) -> c_void { - (self.get_acceleration_structure_memory_requirements_khr)( - device, - p_info, - p_memory_requirements, - ) - } - #[doc = ""] - pub unsafe fn bind_acceleration_structure_memory_khr( - &self, - device: Device, - bind_info_count: u32, - p_bind_infos: *const BindAccelerationStructureMemoryInfoKHR, - ) -> Result { - (self.bind_acceleration_structure_memory_khr)(device, bind_info_count, p_bind_infos) - } - #[doc = ""] - pub unsafe fn cmd_build_acceleration_structure_khr( + #[doc = ""] + pub unsafe fn cmd_build_acceleration_structures_khr( &self, command_buffer: CommandBuffer, info_count: u32, p_infos: *const AccelerationStructureBuildGeometryInfoKHR, - pp_offset_infos: *const *const AccelerationStructureBuildOffsetInfoKHR, + pp_build_range_infos: *const *const AccelerationStructureBuildRangeInfoKHR, ) -> c_void { - (self.cmd_build_acceleration_structure_khr)( + (self.cmd_build_acceleration_structures_khr)( command_buffer, info_count, p_infos, - pp_offset_infos, + pp_build_range_infos, ) } - #[doc = ""] - pub unsafe fn cmd_build_acceleration_structure_indirect_khr( + #[doc = ""] + pub unsafe fn cmd_build_acceleration_structures_indirect_khr( &self, command_buffer: CommandBuffer, - p_info: *const AccelerationStructureBuildGeometryInfoKHR, - indirect_buffer: Buffer, - indirect_offset: DeviceSize, - indirect_stride: u32, + info_count: u32, + p_infos: *const AccelerationStructureBuildGeometryInfoKHR, + p_indirect_device_addresses: *const DeviceAddress, + p_indirect_strides: *const u32, + pp_max_primitive_counts: *const *const u32, ) -> c_void { - (self.cmd_build_acceleration_structure_indirect_khr)( + (self.cmd_build_acceleration_structures_indirect_khr)( command_buffer, - p_info, - indirect_buffer, - indirect_offset, - indirect_stride, + info_count, + p_infos, + p_indirect_device_addresses, + p_indirect_strides, + pp_max_primitive_counts, ) } - #[doc = ""] - pub unsafe fn build_acceleration_structure_khr( + #[doc = ""] + pub unsafe fn build_acceleration_structures_khr( &self, device: Device, + deferred_operation: DeferredOperationKHR, info_count: u32, p_infos: *const AccelerationStructureBuildGeometryInfoKHR, - pp_offset_infos: *const *const AccelerationStructureBuildOffsetInfoKHR, + pp_build_range_infos: *const *const AccelerationStructureBuildRangeInfoKHR, ) -> Result { - (self.build_acceleration_structure_khr)(device, info_count, p_infos, pp_offset_infos) + (self.build_acceleration_structures_khr)( + device, + deferred_operation, + info_count, + p_infos, + pp_build_range_infos, + ) } #[doc = ""] pub unsafe fn copy_acceleration_structure_khr( &self, device: Device, + deferred_operation: DeferredOperationKHR, p_info: *const CopyAccelerationStructureInfoKHR, ) -> Result { - (self.copy_acceleration_structure_khr)(device, p_info) + (self.copy_acceleration_structure_khr)(device, deferred_operation, p_info) } #[doc = ""] pub unsafe fn copy_acceleration_structure_to_memory_khr( &self, device: Device, + deferred_operation: DeferredOperationKHR, p_info: *const CopyAccelerationStructureToMemoryInfoKHR, ) -> Result { - (self.copy_acceleration_structure_to_memory_khr)(device, p_info) + (self.copy_acceleration_structure_to_memory_khr)(device, deferred_operation, p_info) } #[doc = ""] pub unsafe fn copy_memory_to_acceleration_structure_khr( &self, device: Device, + deferred_operation: DeferredOperationKHR, p_info: *const CopyMemoryToAccelerationStructureInfoKHR, ) -> Result { - (self.copy_memory_to_acceleration_structure_khr)(device, p_info) + (self.copy_memory_to_acceleration_structure_khr)(device, deferred_operation, p_info) } #[doc = ""] pub unsafe fn write_acceleration_structures_properties_khr( @@ -12647,67 +12462,6 @@ impl KhrRayTracingFn { ) -> c_void { (self.cmd_copy_memory_to_acceleration_structure_khr)(command_buffer, p_info) } - #[doc = ""] - pub unsafe fn cmd_trace_rays_khr( - &self, - command_buffer: CommandBuffer, - p_raygen_shader_binding_table: *const StridedBufferRegionKHR, - p_miss_shader_binding_table: *const StridedBufferRegionKHR, - p_hit_shader_binding_table: *const StridedBufferRegionKHR, - p_callable_shader_binding_table: *const StridedBufferRegionKHR, - width: u32, - height: u32, - depth: u32, - ) -> c_void { - (self.cmd_trace_rays_khr)( - command_buffer, - p_raygen_shader_binding_table, - p_miss_shader_binding_table, - p_hit_shader_binding_table, - p_callable_shader_binding_table, - width, - height, - depth, - ) - } - #[doc = ""] - pub unsafe fn create_ray_tracing_pipelines_khr( - &self, - device: Device, - pipeline_cache: PipelineCache, - create_info_count: u32, - p_create_infos: *const RayTracingPipelineCreateInfoKHR, - p_allocator: *const AllocationCallbacks, - p_pipelines: *mut Pipeline, - ) -> Result { - (self.create_ray_tracing_pipelines_khr)( - device, - pipeline_cache, - create_info_count, - p_create_infos, - p_allocator, - p_pipelines, - ) - } - #[doc = ""] - pub unsafe fn get_ray_tracing_shader_group_handles_khr( - &self, - device: Device, - pipeline: Pipeline, - first_group: u32, - group_count: u32, - data_size: usize, - p_data: *mut c_void, - ) -> Result { - (self.get_ray_tracing_shader_group_handles_khr)( - device, - pipeline, - first_group, - group_count, - data_size, - p_data, - ) - } #[doc = ""] pub unsafe fn get_acceleration_structure_device_address_khr( &self, @@ -12716,25 +12470,6 @@ impl KhrRayTracingFn { ) -> DeviceAddress { (self.get_acceleration_structure_device_address_khr)(device, p_info) } - #[doc = ""] - pub unsafe fn get_ray_tracing_capture_replay_shader_group_handles_khr( - &self, - device: Device, - pipeline: Pipeline, - first_group: u32, - group_count: u32, - data_size: usize, - p_data: *mut c_void, - ) -> Result { - (self.get_ray_tracing_capture_replay_shader_group_handles_khr)( - device, - pipeline, - first_group, - group_count, - data_size, - p_data, - ) - } #[doc = ""] pub unsafe fn cmd_write_acceleration_structures_properties_khr( &self, @@ -12754,2102 +12489,2157 @@ impl KhrRayTracingFn { first_query, ) } - #[doc = ""] - pub unsafe fn cmd_trace_rays_indirect_khr( + #[doc = ""] + pub unsafe fn get_device_acceleration_structure_compatibility_khr( &self, - command_buffer: CommandBuffer, - p_raygen_shader_binding_table: *const StridedBufferRegionKHR, - p_miss_shader_binding_table: *const StridedBufferRegionKHR, - p_hit_shader_binding_table: *const StridedBufferRegionKHR, - p_callable_shader_binding_table: *const StridedBufferRegionKHR, - buffer: Buffer, - offset: DeviceSize, + device: Device, + p_version_info: *const AccelerationStructureVersionInfoKHR, + p_compatibility: *mut AccelerationStructureCompatibilityKHR, ) -> c_void { - (self.cmd_trace_rays_indirect_khr)( - command_buffer, - p_raygen_shader_binding_table, - p_miss_shader_binding_table, - p_hit_shader_binding_table, - p_callable_shader_binding_table, - buffer, - offset, + (self.get_device_acceleration_structure_compatibility_khr)( + device, + p_version_info, + p_compatibility, ) } - #[doc = ""] - pub unsafe fn get_device_acceleration_structure_compatibility_khr( + #[doc = ""] + pub unsafe fn get_acceleration_structure_build_sizes_khr( &self, device: Device, - version: *const AccelerationStructureVersionKHR, - ) -> Result { - (self.get_device_acceleration_structure_compatibility_khr)(device, version) + build_type: AccelerationStructureBuildTypeKHR, + p_build_info: *const AccelerationStructureBuildGeometryInfoKHR, + p_max_primitive_counts: *const u32, + p_size_info: *mut AccelerationStructureBuildSizesInfoKHR, + ) -> c_void { + (self.get_acceleration_structure_build_sizes_khr)( + device, + build_type, + p_build_info, + p_max_primitive_counts, + p_size_info, + ) } } -#[doc = "Generated from \'VK_KHR_ray_tracing\'"] -impl StructureType { - pub const BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_KHR: Self = Self(1_000_165_006); -} -#[doc = "Generated from \'VK_KHR_ray_tracing\'"] +#[doc = "Generated from \'VK_KHR_acceleration_structure\'"] impl StructureType { - pub const WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR: Self = Self(1_000_165_007); + pub const WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR: Self = Self(1_000_150_007); } -#[doc = "Generated from \'VK_KHR_ray_tracing\'"] +#[doc = "Generated from \'VK_KHR_acceleration_structure\'"] impl StructureType { pub const ACCELERATION_STRUCTURE_BUILD_GEOMETRY_INFO_KHR: Self = Self(1_000_150_000); } -#[doc = "Generated from \'VK_KHR_ray_tracing\'"] -impl StructureType { - pub const ACCELERATION_STRUCTURE_CREATE_GEOMETRY_TYPE_INFO_KHR: Self = Self(1_000_150_001); -} -#[doc = "Generated from \'VK_KHR_ray_tracing\'"] +#[doc = "Generated from \'VK_KHR_acceleration_structure\'"] impl StructureType { pub const ACCELERATION_STRUCTURE_DEVICE_ADDRESS_INFO_KHR: Self = Self(1_000_150_002); } -#[doc = "Generated from \'VK_KHR_ray_tracing\'"] +#[doc = "Generated from \'VK_KHR_acceleration_structure\'"] impl StructureType { pub const ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA_KHR: Self = Self(1_000_150_003); } -#[doc = "Generated from \'VK_KHR_ray_tracing\'"] +#[doc = "Generated from \'VK_KHR_acceleration_structure\'"] impl StructureType { pub const ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR: Self = Self(1_000_150_004); } -#[doc = "Generated from \'VK_KHR_ray_tracing\'"] +#[doc = "Generated from \'VK_KHR_acceleration_structure\'"] impl StructureType { pub const ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR: Self = Self(1_000_150_005); } -#[doc = "Generated from \'VK_KHR_ray_tracing\'"] +#[doc = "Generated from \'VK_KHR_acceleration_structure\'"] impl StructureType { pub const ACCELERATION_STRUCTURE_GEOMETRY_KHR: Self = Self(1_000_150_006); } -#[doc = "Generated from \'VK_KHR_ray_tracing\'"] -impl StructureType { - pub const ACCELERATION_STRUCTURE_INFO_KHR: Self = Self(1_000_150_007); -} -#[doc = "Generated from \'VK_KHR_ray_tracing\'"] +#[doc = "Generated from \'VK_KHR_acceleration_structure\'"] impl StructureType { - pub const ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_KHR: Self = Self(1_000_150_008); + pub const ACCELERATION_STRUCTURE_VERSION_INFO_KHR: Self = Self(1_000_150_009); } -#[doc = "Generated from \'VK_KHR_ray_tracing\'"] -impl StructureType { - pub const ACCELERATION_STRUCTURE_VERSION_KHR: Self = Self(1_000_150_009); -} -#[doc = "Generated from \'VK_KHR_ray_tracing\'"] +#[doc = "Generated from \'VK_KHR_acceleration_structure\'"] impl StructureType { pub const COPY_ACCELERATION_STRUCTURE_INFO_KHR: Self = Self(1_000_150_010); } -#[doc = "Generated from \'VK_KHR_ray_tracing\'"] +#[doc = "Generated from \'VK_KHR_acceleration_structure\'"] impl StructureType { pub const COPY_ACCELERATION_STRUCTURE_TO_MEMORY_INFO_KHR: Self = Self(1_000_150_011); } -#[doc = "Generated from \'VK_KHR_ray_tracing\'"] +#[doc = "Generated from \'VK_KHR_acceleration_structure\'"] impl StructureType { pub const COPY_MEMORY_TO_ACCELERATION_STRUCTURE_INFO_KHR: Self = Self(1_000_150_012); } -#[doc = "Generated from \'VK_KHR_ray_tracing\'"] -impl StructureType { - pub const PHYSICAL_DEVICE_RAY_TRACING_FEATURES_KHR: Self = Self(1_000_150_013); -} -#[doc = "Generated from \'VK_KHR_ray_tracing\'"] +#[doc = "Generated from \'VK_KHR_acceleration_structure\'"] impl StructureType { - pub const PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_KHR: Self = Self(1_000_150_014); + pub const PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR: Self = Self(1_000_150_013); } -#[doc = "Generated from \'VK_KHR_ray_tracing\'"] +#[doc = "Generated from \'VK_KHR_acceleration_structure\'"] impl StructureType { - pub const RAY_TRACING_PIPELINE_CREATE_INFO_KHR: Self = Self(1_000_150_015); -} -#[doc = "Generated from \'VK_KHR_ray_tracing\'"] -impl StructureType { - pub const RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR: Self = Self(1_000_150_016); + pub const PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR: Self = Self(1_000_150_014); } -#[doc = "Generated from \'VK_KHR_ray_tracing\'"] +#[doc = "Generated from \'VK_KHR_acceleration_structure\'"] impl StructureType { pub const ACCELERATION_STRUCTURE_CREATE_INFO_KHR: Self = Self(1_000_150_017); } -#[doc = "Generated from \'VK_KHR_ray_tracing\'"] +#[doc = "Generated from \'VK_KHR_acceleration_structure\'"] impl StructureType { - pub const RAY_TRACING_PIPELINE_INTERFACE_CREATE_INFO_KHR: Self = Self(1_000_150_018); -} -#[doc = "Generated from \'VK_KHR_ray_tracing\'"] -impl ShaderStageFlags { - pub const RAYGEN_KHR: Self = Self(0b1_0000_0000); -} -#[doc = "Generated from \'VK_KHR_ray_tracing\'"] -impl ShaderStageFlags { - pub const ANY_HIT_KHR: Self = Self(0b10_0000_0000); -} -#[doc = "Generated from \'VK_KHR_ray_tracing\'"] -impl ShaderStageFlags { - pub const CLOSEST_HIT_KHR: Self = Self(0b100_0000_0000); -} -#[doc = "Generated from \'VK_KHR_ray_tracing\'"] -impl ShaderStageFlags { - pub const MISS_KHR: Self = Self(0b1000_0000_0000); -} -#[doc = "Generated from \'VK_KHR_ray_tracing\'"] -impl ShaderStageFlags { - pub const INTERSECTION_KHR: Self = Self(0b1_0000_0000_0000); + pub const ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR: Self = Self(1_000_150_020); } -#[doc = "Generated from \'VK_KHR_ray_tracing\'"] -impl ShaderStageFlags { - pub const CALLABLE_KHR: Self = Self(0b10_0000_0000_0000); -} -#[doc = "Generated from \'VK_KHR_ray_tracing\'"] -impl PipelineStageFlags { - pub const RAY_TRACING_SHADER_KHR: Self = Self(0b10_0000_0000_0000_0000_0000); -} -#[doc = "Generated from \'VK_KHR_ray_tracing\'"] +#[doc = "Generated from \'VK_KHR_acceleration_structure\'"] impl PipelineStageFlags { pub const ACCELERATION_STRUCTURE_BUILD_KHR: Self = Self(0b10_0000_0000_0000_0000_0000_0000); } -#[doc = "Generated from \'VK_KHR_ray_tracing\'"] -impl BufferUsageFlags { - pub const RAY_TRACING_KHR: Self = Self(0b100_0000_0000); -} -#[doc = "Generated from \'VK_KHR_ray_tracing\'"] -impl PipelineBindPoint { - pub const RAY_TRACING_KHR: Self = Self(1_000_165_000); -} -#[doc = "Generated from \'VK_KHR_ray_tracing\'"] +#[doc = "Generated from \'VK_KHR_acceleration_structure\'"] impl DescriptorType { - pub const ACCELERATION_STRUCTURE_KHR: Self = Self(1_000_165_000); + pub const ACCELERATION_STRUCTURE_KHR: Self = Self(1_000_150_000); } -#[doc = "Generated from \'VK_KHR_ray_tracing\'"] +#[doc = "Generated from \'VK_KHR_acceleration_structure\'"] impl AccessFlags { pub const ACCELERATION_STRUCTURE_READ_KHR: Self = Self(0b10_0000_0000_0000_0000_0000); } -#[doc = "Generated from \'VK_KHR_ray_tracing\'"] +#[doc = "Generated from \'VK_KHR_acceleration_structure\'"] impl AccessFlags { pub const ACCELERATION_STRUCTURE_WRITE_KHR: Self = Self(0b100_0000_0000_0000_0000_0000); } -#[doc = "Generated from \'VK_KHR_ray_tracing\'"] +#[doc = "Generated from \'VK_KHR_acceleration_structure\'"] impl QueryType { - pub const ACCELERATION_STRUCTURE_COMPACTED_SIZE_KHR: Self = Self(1_000_165_000); + pub const ACCELERATION_STRUCTURE_COMPACTED_SIZE_KHR: Self = Self(1_000_150_000); } -#[doc = "Generated from \'VK_KHR_ray_tracing\'"] +#[doc = "Generated from \'VK_KHR_acceleration_structure\'"] impl QueryType { - pub const ACCELERATION_STRUCTURE_SERIALIZATION_SIZE_KHR: Self = Self(1_000_150_000); + pub const ACCELERATION_STRUCTURE_SERIALIZATION_SIZE_KHR: Self = Self(1_000_150_001); } -#[doc = "Generated from \'VK_KHR_ray_tracing\'"] +#[doc = "Generated from \'VK_KHR_acceleration_structure\'"] impl ObjectType { - pub const ACCELERATION_STRUCTURE_KHR: Self = Self(1_000_165_000); + pub const ACCELERATION_STRUCTURE_KHR: Self = Self(1_000_150_000); } -#[doc = "Generated from \'VK_KHR_ray_tracing\'"] +#[doc = "Generated from \'VK_KHR_acceleration_structure\'"] impl DebugReportObjectTypeEXT { - pub const ACCELERATION_STRUCTURE_KHR: Self = Self(1_000_165_000); + pub const ACCELERATION_STRUCTURE_KHR: Self = Self(1_000_150_000); } -#[doc = "Generated from \'VK_KHR_ray_tracing\'"] +#[doc = "Generated from \'VK_KHR_acceleration_structure\'"] impl IndexType { pub const NONE_KHR: Self = Self(1_000_165_000); } -#[doc = "Generated from \'VK_KHR_ray_tracing\'"] -impl GeometryTypeKHR { - pub const INSTANCES: Self = Self(1_000_150_000); -} -#[doc = "Generated from \'VK_KHR_ray_tracing\'"] -impl Result { - pub const ERROR_INCOMPATIBLE_VERSION_KHR: Self = Self(-1_000_150_000); -} -#[doc = "Generated from \'VK_KHR_ray_tracing\'"] +#[doc = "Generated from \'VK_KHR_acceleration_structure\'"] impl FormatFeatureFlags { pub const ACCELERATION_STRUCTURE_VERTEX_BUFFER_KHR: Self = Self(0b10_0000_0000_0000_0000_0000_0000_0000); } -#[doc = "Generated from \'VK_KHR_ray_tracing\'"] -impl PipelineCreateFlags { - pub const RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_KHR: Self = Self(0b100_0000_0000_0000); -} -#[doc = "Generated from \'VK_KHR_ray_tracing\'"] -impl PipelineCreateFlags { - pub const RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS_KHR: Self = Self(0b1000_0000_0000_0000); +#[doc = "Generated from \'VK_KHR_acceleration_structure\'"] +impl BufferUsageFlags { + pub const ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_KHR: Self = + Self(0b1000_0000_0000_0000_0000); } -#[doc = "Generated from \'VK_KHR_ray_tracing\'"] -impl PipelineCreateFlags { - pub const RAY_TRACING_NO_NULL_MISS_SHADERS_KHR: Self = Self(0b1_0000_0000_0000_0000); +#[doc = "Generated from \'VK_KHR_acceleration_structure\'"] +impl BufferUsageFlags { + pub const ACCELERATION_STRUCTURE_STORAGE_KHR: Self = Self(0b1_0000_0000_0000_0000_0000); } -#[doc = "Generated from \'VK_KHR_ray_tracing\'"] -impl PipelineCreateFlags { - pub const RAY_TRACING_NO_NULL_INTERSECTION_SHADERS_KHR: Self = Self(0b10_0000_0000_0000_0000); -} -#[doc = "Generated from \'VK_KHR_ray_tracing\'"] -impl PipelineCreateFlags { - pub const RAY_TRACING_SKIP_TRIANGLES_KHR: Self = Self(0b1_0000_0000_0000); -} -#[doc = "Generated from \'VK_KHR_ray_tracing\'"] -impl PipelineCreateFlags { - pub const RAY_TRACING_SKIP_AABBS_KHR: Self = Self(0b10_0000_0000_0000); -} -impl NvExtension152Fn { - pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_extension_152\0") - .expect("Wrong extension string") - } - pub const SPEC_VERSION: u32 = 0u32; -} -pub struct NvExtension152Fn {} -unsafe impl Send for NvExtension152Fn {} -unsafe impl Sync for NvExtension152Fn {} -impl ::std::clone::Clone for NvExtension152Fn { - fn clone(&self) -> Self { - NvExtension152Fn {} - } -} -impl NvExtension152Fn { - pub fn load(mut _f: F) -> Self - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - NvExtension152Fn {} - } -} -impl NvFramebufferMixedSamplesFn { - pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_framebuffer_mixed_samples\0") - .expect("Wrong extension string") - } - pub const SPEC_VERSION: u32 = 1u32; -} -pub struct NvFramebufferMixedSamplesFn {} -unsafe impl Send for NvFramebufferMixedSamplesFn {} -unsafe impl Sync for NvFramebufferMixedSamplesFn {} -impl ::std::clone::Clone for NvFramebufferMixedSamplesFn { - fn clone(&self) -> Self { - NvFramebufferMixedSamplesFn {} - } -} -impl NvFramebufferMixedSamplesFn { - pub fn load(mut _f: F) -> Self - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - NvFramebufferMixedSamplesFn {} - } -} -#[doc = "Generated from \'VK_NV_framebuffer_mixed_samples\'"] -impl StructureType { - pub const PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV: Self = Self(1_000_152_000); -} -impl NvFillRectangleFn { - pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_fill_rectangle\0") - .expect("Wrong extension string") - } - pub const SPEC_VERSION: u32 = 1u32; -} -pub struct NvFillRectangleFn {} -unsafe impl Send for NvFillRectangleFn {} -unsafe impl Sync for NvFillRectangleFn {} -impl ::std::clone::Clone for NvFillRectangleFn { - fn clone(&self) -> Self { - NvFillRectangleFn {} - } -} -impl NvFillRectangleFn { - pub fn load(mut _f: F) -> Self - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - NvFillRectangleFn {} - } -} -#[doc = "Generated from \'VK_NV_fill_rectangle\'"] -impl PolygonMode { - pub const FILL_RECTANGLE_NV: Self = Self(1_000_153_000); -} -impl NvShaderSmBuiltinsFn { - pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_shader_sm_builtins\0") - .expect("Wrong extension string") - } - pub const SPEC_VERSION: u32 = 1u32; -} -pub struct NvShaderSmBuiltinsFn {} -unsafe impl Send for NvShaderSmBuiltinsFn {} -unsafe impl Sync for NvShaderSmBuiltinsFn {} -impl ::std::clone::Clone for NvShaderSmBuiltinsFn { - fn clone(&self) -> Self { - NvShaderSmBuiltinsFn {} - } -} -impl NvShaderSmBuiltinsFn { - pub fn load(mut _f: F) -> Self - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - NvShaderSmBuiltinsFn {} - } -} -#[doc = "Generated from \'VK_NV_shader_sm_builtins\'"] -impl StructureType { - pub const PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV: Self = Self(1_000_154_000); -} -#[doc = "Generated from \'VK_NV_shader_sm_builtins\'"] -impl StructureType { - pub const PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV: Self = Self(1_000_154_001); -} -impl ExtPostDepthCoverageFn { +impl KhrRayTracingPipelineFn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_post_depth_coverage\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_ray_tracing_pipeline\0") .expect("Wrong extension string") } pub const SPEC_VERSION: u32 = 1u32; } -pub struct ExtPostDepthCoverageFn {} -unsafe impl Send for ExtPostDepthCoverageFn {} -unsafe impl Sync for ExtPostDepthCoverageFn {} -impl ::std::clone::Clone for ExtPostDepthCoverageFn { - fn clone(&self) -> Self { - ExtPostDepthCoverageFn {} - } -} -impl ExtPostDepthCoverageFn { - pub fn load(mut _f: F) -> Self - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - ExtPostDepthCoverageFn {} - } -} -impl KhrSamplerYcbcrConversionFn { - pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_sampler_ycbcr_conversion\0") - .expect("Wrong extension string") - } - pub const SPEC_VERSION: u32 = 14u32; -} #[allow(non_camel_case_types)] -pub type PFN_vkCreateSamplerYcbcrConversion = extern "system" fn( +pub type PFN_vkCmdTraceRaysKHR = extern "system" fn( + command_buffer: CommandBuffer, + p_raygen_shader_binding_table: *const StridedDeviceAddressRegionKHR, + p_miss_shader_binding_table: *const StridedDeviceAddressRegionKHR, + p_hit_shader_binding_table: *const StridedDeviceAddressRegionKHR, + p_callable_shader_binding_table: *const StridedDeviceAddressRegionKHR, + width: u32, + height: u32, + depth: u32, +) -> c_void; +#[allow(non_camel_case_types)] +pub type PFN_vkCreateRayTracingPipelinesKHR = extern "system" fn( device: Device, - p_create_info: *const SamplerYcbcrConversionCreateInfo, + deferred_operation: DeferredOperationKHR, + pipeline_cache: PipelineCache, + create_info_count: u32, + p_create_infos: *const RayTracingPipelineCreateInfoKHR, p_allocator: *const AllocationCallbacks, - p_ycbcr_conversion: *mut SamplerYcbcrConversion, + p_pipelines: *mut Pipeline, ) -> Result; #[allow(non_camel_case_types)] -pub type PFN_vkDestroySamplerYcbcrConversion = extern "system" fn( +pub type PFN_vkGetRayTracingShaderGroupHandlesKHR = extern "system" fn( device: Device, - ycbcr_conversion: SamplerYcbcrConversion, - p_allocator: *const AllocationCallbacks, + pipeline: Pipeline, + first_group: u32, + group_count: u32, + data_size: usize, + p_data: *mut c_void, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR = extern "system" fn( + device: Device, + pipeline: Pipeline, + first_group: u32, + group_count: u32, + data_size: usize, + p_data: *mut c_void, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkCmdTraceRaysIndirectKHR = extern "system" fn( + command_buffer: CommandBuffer, + p_raygen_shader_binding_table: *const StridedDeviceAddressRegionKHR, + p_miss_shader_binding_table: *const StridedDeviceAddressRegionKHR, + p_hit_shader_binding_table: *const StridedDeviceAddressRegionKHR, + p_callable_shader_binding_table: *const StridedDeviceAddressRegionKHR, + indirect_device_address: DeviceAddress, ) -> c_void; -pub struct KhrSamplerYcbcrConversionFn { - pub create_sampler_ycbcr_conversion_khr: extern "system" fn( +#[allow(non_camel_case_types)] +pub type PFN_vkGetRayTracingShaderGroupStackSizeKHR = extern "system" fn( + device: Device, + pipeline: Pipeline, + group: u32, + group_shader: ShaderGroupShaderKHR, +) -> DeviceSize; +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetRayTracingPipelineStackSizeKHR = + extern "system" fn(command_buffer: CommandBuffer, pipeline_stack_size: u32) -> c_void; +pub struct KhrRayTracingPipelineFn { + pub cmd_trace_rays_khr: extern "system" fn( + command_buffer: CommandBuffer, + p_raygen_shader_binding_table: *const StridedDeviceAddressRegionKHR, + p_miss_shader_binding_table: *const StridedDeviceAddressRegionKHR, + p_hit_shader_binding_table: *const StridedDeviceAddressRegionKHR, + p_callable_shader_binding_table: *const StridedDeviceAddressRegionKHR, + width: u32, + height: u32, + depth: u32, + ) -> c_void, + pub create_ray_tracing_pipelines_khr: extern "system" fn( device: Device, - p_create_info: *const SamplerYcbcrConversionCreateInfo, + deferred_operation: DeferredOperationKHR, + pipeline_cache: PipelineCache, + create_info_count: u32, + p_create_infos: *const RayTracingPipelineCreateInfoKHR, p_allocator: *const AllocationCallbacks, - p_ycbcr_conversion: *mut SamplerYcbcrConversion, + p_pipelines: *mut Pipeline, ) -> Result, - pub destroy_sampler_ycbcr_conversion_khr: extern "system" fn( + pub get_ray_tracing_shader_group_handles_khr: extern "system" fn( device: Device, - ycbcr_conversion: SamplerYcbcrConversion, - p_allocator: *const AllocationCallbacks, + pipeline: Pipeline, + first_group: u32, + group_count: u32, + data_size: usize, + p_data: *mut c_void, + ) -> Result, + pub get_ray_tracing_capture_replay_shader_group_handles_khr: extern "system" fn( + device: Device, + pipeline: Pipeline, + first_group: u32, + group_count: u32, + data_size: usize, + p_data: *mut c_void, + ) -> Result, + pub cmd_trace_rays_indirect_khr: extern "system" fn( + command_buffer: CommandBuffer, + p_raygen_shader_binding_table: *const StridedDeviceAddressRegionKHR, + p_miss_shader_binding_table: *const StridedDeviceAddressRegionKHR, + p_hit_shader_binding_table: *const StridedDeviceAddressRegionKHR, + p_callable_shader_binding_table: *const StridedDeviceAddressRegionKHR, + indirect_device_address: DeviceAddress, ) -> c_void, + pub get_ray_tracing_shader_group_stack_size_khr: extern "system" fn( + device: Device, + pipeline: Pipeline, + group: u32, + group_shader: ShaderGroupShaderKHR, + ) -> DeviceSize, + pub cmd_set_ray_tracing_pipeline_stack_size_khr: + extern "system" fn(command_buffer: CommandBuffer, pipeline_stack_size: u32) -> c_void, } -unsafe impl Send for KhrSamplerYcbcrConversionFn {} -unsafe impl Sync for KhrSamplerYcbcrConversionFn {} -impl ::std::clone::Clone for KhrSamplerYcbcrConversionFn { +unsafe impl Send for KhrRayTracingPipelineFn {} +unsafe impl Sync for KhrRayTracingPipelineFn {} +impl ::std::clone::Clone for KhrRayTracingPipelineFn { fn clone(&self) -> Self { - KhrSamplerYcbcrConversionFn { - create_sampler_ycbcr_conversion_khr: self.create_sampler_ycbcr_conversion_khr, - destroy_sampler_ycbcr_conversion_khr: self.destroy_sampler_ycbcr_conversion_khr, + KhrRayTracingPipelineFn { + cmd_trace_rays_khr: self.cmd_trace_rays_khr, + create_ray_tracing_pipelines_khr: self.create_ray_tracing_pipelines_khr, + get_ray_tracing_shader_group_handles_khr: self.get_ray_tracing_shader_group_handles_khr, + get_ray_tracing_capture_replay_shader_group_handles_khr: self + .get_ray_tracing_capture_replay_shader_group_handles_khr, + cmd_trace_rays_indirect_khr: self.cmd_trace_rays_indirect_khr, + get_ray_tracing_shader_group_stack_size_khr: self + .get_ray_tracing_shader_group_stack_size_khr, + cmd_set_ray_tracing_pipeline_stack_size_khr: self + .cmd_set_ray_tracing_pipeline_stack_size_khr, } } } -impl KhrSamplerYcbcrConversionFn { +impl KhrRayTracingPipelineFn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - KhrSamplerYcbcrConversionFn { - create_sampler_ycbcr_conversion_khr: unsafe { - extern "system" fn create_sampler_ycbcr_conversion_khr( - _device: Device, - _p_create_info: *const SamplerYcbcrConversionCreateInfo, - _p_allocator: *const AllocationCallbacks, - _p_ycbcr_conversion: *mut SamplerYcbcrConversion, - ) -> Result { - panic!(concat!( - "Unable to load ", - stringify!(create_sampler_ycbcr_conversion_khr) - )) + KhrRayTracingPipelineFn { + cmd_trace_rays_khr: unsafe { + extern "system" fn cmd_trace_rays_khr( + _command_buffer: CommandBuffer, + _p_raygen_shader_binding_table: *const StridedDeviceAddressRegionKHR, + _p_miss_shader_binding_table: *const StridedDeviceAddressRegionKHR, + _p_hit_shader_binding_table: *const StridedDeviceAddressRegionKHR, + _p_callable_shader_binding_table: *const StridedDeviceAddressRegionKHR, + _width: u32, + _height: u32, + _depth: u32, + ) -> c_void { + panic!(concat!("Unable to load ", stringify!(cmd_trace_rays_khr))) } - let raw_name = stringify!(vkCreateSamplerYcbcrConversionKHR); + let raw_name = stringify!(vkCmdTraceRaysKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - create_sampler_ycbcr_conversion_khr + cmd_trace_rays_khr } else { ::std::mem::transmute(val) } }, - destroy_sampler_ycbcr_conversion_khr: unsafe { - extern "system" fn destroy_sampler_ycbcr_conversion_khr( + create_ray_tracing_pipelines_khr: unsafe { + extern "system" fn create_ray_tracing_pipelines_khr( _device: Device, - _ycbcr_conversion: SamplerYcbcrConversion, + _deferred_operation: DeferredOperationKHR, + _pipeline_cache: PipelineCache, + _create_info_count: u32, + _p_create_infos: *const RayTracingPipelineCreateInfoKHR, _p_allocator: *const AllocationCallbacks, + _p_pipelines: *mut Pipeline, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(create_ray_tracing_pipelines_khr) + )) + } + let raw_name = stringify!(vkCreateRayTracingPipelinesKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + create_ray_tracing_pipelines_khr + } else { + ::std::mem::transmute(val) + } + }, + get_ray_tracing_shader_group_handles_khr: unsafe { + extern "system" fn get_ray_tracing_shader_group_handles_khr( + _device: Device, + _pipeline: Pipeline, + _first_group: u32, + _group_count: u32, + _data_size: usize, + _p_data: *mut c_void, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_ray_tracing_shader_group_handles_khr) + )) + } + let raw_name = stringify!(vkGetRayTracingShaderGroupHandlesKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + get_ray_tracing_shader_group_handles_khr + } else { + ::std::mem::transmute(val) + } + }, + get_ray_tracing_capture_replay_shader_group_handles_khr: unsafe { + extern "system" fn get_ray_tracing_capture_replay_shader_group_handles_khr( + _device: Device, + _pipeline: Pipeline, + _first_group: u32, + _group_count: u32, + _data_size: usize, + _p_data: *mut c_void, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_ray_tracing_capture_replay_shader_group_handles_khr) + )) + } + let raw_name = stringify!(vkGetRayTracingCaptureReplayShaderGroupHandlesKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + get_ray_tracing_capture_replay_shader_group_handles_khr + } else { + ::std::mem::transmute(val) + } + }, + cmd_trace_rays_indirect_khr: unsafe { + extern "system" fn cmd_trace_rays_indirect_khr( + _command_buffer: CommandBuffer, + _p_raygen_shader_binding_table: *const StridedDeviceAddressRegionKHR, + _p_miss_shader_binding_table: *const StridedDeviceAddressRegionKHR, + _p_hit_shader_binding_table: *const StridedDeviceAddressRegionKHR, + _p_callable_shader_binding_table: *const StridedDeviceAddressRegionKHR, + _indirect_device_address: DeviceAddress, ) -> c_void { panic!(concat!( "Unable to load ", - stringify!(destroy_sampler_ycbcr_conversion_khr) + stringify!(cmd_trace_rays_indirect_khr) )) } - let raw_name = stringify!(vkDestroySamplerYcbcrConversionKHR); + let raw_name = stringify!(vkCmdTraceRaysIndirectKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - destroy_sampler_ycbcr_conversion_khr + cmd_trace_rays_indirect_khr + } else { + ::std::mem::transmute(val) + } + }, + get_ray_tracing_shader_group_stack_size_khr: unsafe { + extern "system" fn get_ray_tracing_shader_group_stack_size_khr( + _device: Device, + _pipeline: Pipeline, + _group: u32, + _group_shader: ShaderGroupShaderKHR, + ) -> DeviceSize { + panic!(concat!( + "Unable to load ", + stringify!(get_ray_tracing_shader_group_stack_size_khr) + )) + } + let raw_name = stringify!(vkGetRayTracingShaderGroupStackSizeKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + get_ray_tracing_shader_group_stack_size_khr + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_ray_tracing_pipeline_stack_size_khr: unsafe { + extern "system" fn cmd_set_ray_tracing_pipeline_stack_size_khr( + _command_buffer: CommandBuffer, + _pipeline_stack_size: u32, + ) -> c_void { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_ray_tracing_pipeline_stack_size_khr) + )) + } + let raw_name = stringify!(vkCmdSetRayTracingPipelineStackSizeKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + cmd_set_ray_tracing_pipeline_stack_size_khr } else { ::std::mem::transmute(val) } }, } } - #[doc = ""] - pub unsafe fn create_sampler_ycbcr_conversion_khr( + #[doc = ""] + pub unsafe fn cmd_trace_rays_khr( + &self, + command_buffer: CommandBuffer, + p_raygen_shader_binding_table: *const StridedDeviceAddressRegionKHR, + p_miss_shader_binding_table: *const StridedDeviceAddressRegionKHR, + p_hit_shader_binding_table: *const StridedDeviceAddressRegionKHR, + p_callable_shader_binding_table: *const StridedDeviceAddressRegionKHR, + width: u32, + height: u32, + depth: u32, + ) -> c_void { + (self.cmd_trace_rays_khr)( + command_buffer, + p_raygen_shader_binding_table, + p_miss_shader_binding_table, + p_hit_shader_binding_table, + p_callable_shader_binding_table, + width, + height, + depth, + ) + } + #[doc = ""] + pub unsafe fn create_ray_tracing_pipelines_khr( &self, device: Device, - p_create_info: *const SamplerYcbcrConversionCreateInfo, + deferred_operation: DeferredOperationKHR, + pipeline_cache: PipelineCache, + create_info_count: u32, + p_create_infos: *const RayTracingPipelineCreateInfoKHR, p_allocator: *const AllocationCallbacks, - p_ycbcr_conversion: *mut SamplerYcbcrConversion, + p_pipelines: *mut Pipeline, ) -> Result { - (self.create_sampler_ycbcr_conversion_khr)( + (self.create_ray_tracing_pipelines_khr)( device, - p_create_info, + deferred_operation, + pipeline_cache, + create_info_count, + p_create_infos, p_allocator, - p_ycbcr_conversion, + p_pipelines, ) } - #[doc = ""] - pub unsafe fn destroy_sampler_ycbcr_conversion_khr( + #[doc = ""] + pub unsafe fn get_ray_tracing_shader_group_handles_khr( &self, device: Device, - ycbcr_conversion: SamplerYcbcrConversion, - p_allocator: *const AllocationCallbacks, + pipeline: Pipeline, + first_group: u32, + group_count: u32, + data_size: usize, + p_data: *mut c_void, + ) -> Result { + (self.get_ray_tracing_shader_group_handles_khr)( + device, + pipeline, + first_group, + group_count, + data_size, + p_data, + ) + } + #[doc = ""] + pub unsafe fn get_ray_tracing_capture_replay_shader_group_handles_khr( + &self, + device: Device, + pipeline: Pipeline, + first_group: u32, + group_count: u32, + data_size: usize, + p_data: *mut c_void, + ) -> Result { + (self.get_ray_tracing_capture_replay_shader_group_handles_khr)( + device, + pipeline, + first_group, + group_count, + data_size, + p_data, + ) + } + #[doc = ""] + pub unsafe fn cmd_trace_rays_indirect_khr( + &self, + command_buffer: CommandBuffer, + p_raygen_shader_binding_table: *const StridedDeviceAddressRegionKHR, + p_miss_shader_binding_table: *const StridedDeviceAddressRegionKHR, + p_hit_shader_binding_table: *const StridedDeviceAddressRegionKHR, + p_callable_shader_binding_table: *const StridedDeviceAddressRegionKHR, + indirect_device_address: DeviceAddress, ) -> c_void { - (self.destroy_sampler_ycbcr_conversion_khr)(device, ycbcr_conversion, p_allocator) + (self.cmd_trace_rays_indirect_khr)( + command_buffer, + p_raygen_shader_binding_table, + p_miss_shader_binding_table, + p_hit_shader_binding_table, + p_callable_shader_binding_table, + indirect_device_address, + ) + } + #[doc = ""] + pub unsafe fn get_ray_tracing_shader_group_stack_size_khr( + &self, + device: Device, + pipeline: Pipeline, + group: u32, + group_shader: ShaderGroupShaderKHR, + ) -> DeviceSize { + (self.get_ray_tracing_shader_group_stack_size_khr)(device, pipeline, group, group_shader) + } + #[doc = ""] + pub unsafe fn cmd_set_ray_tracing_pipeline_stack_size_khr( + &self, + command_buffer: CommandBuffer, + pipeline_stack_size: u32, + ) -> c_void { + (self.cmd_set_ray_tracing_pipeline_stack_size_khr)(command_buffer, pipeline_stack_size) } } -#[doc = "Generated from \'VK_KHR_sampler_ycbcr_conversion\'"] -impl StructureType { - pub const SAMPLER_YCBCR_CONVERSION_CREATE_INFO_KHR: Self = - StructureType::SAMPLER_YCBCR_CONVERSION_CREATE_INFO; -} -#[doc = "Generated from \'VK_KHR_sampler_ycbcr_conversion\'"] +#[doc = "Generated from \'VK_KHR_ray_tracing_pipeline\'"] impl StructureType { - pub const SAMPLER_YCBCR_CONVERSION_INFO_KHR: Self = - StructureType::SAMPLER_YCBCR_CONVERSION_INFO; + pub const PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR: Self = Self(1_000_347_000); } -#[doc = "Generated from \'VK_KHR_sampler_ycbcr_conversion\'"] +#[doc = "Generated from \'VK_KHR_ray_tracing_pipeline\'"] impl StructureType { - pub const BIND_IMAGE_PLANE_MEMORY_INFO_KHR: Self = StructureType::BIND_IMAGE_PLANE_MEMORY_INFO; + pub const PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR: Self = Self(1_000_347_001); } -#[doc = "Generated from \'VK_KHR_sampler_ycbcr_conversion\'"] +#[doc = "Generated from \'VK_KHR_ray_tracing_pipeline\'"] impl StructureType { - pub const IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO_KHR: Self = - StructureType::IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO; + pub const RAY_TRACING_PIPELINE_CREATE_INFO_KHR: Self = Self(1_000_150_015); } -#[doc = "Generated from \'VK_KHR_sampler_ycbcr_conversion\'"] +#[doc = "Generated from \'VK_KHR_ray_tracing_pipeline\'"] impl StructureType { - pub const PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES_KHR: Self = - StructureType::PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES; + pub const RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR: Self = Self(1_000_150_016); } -#[doc = "Generated from \'VK_KHR_sampler_ycbcr_conversion\'"] +#[doc = "Generated from \'VK_KHR_ray_tracing_pipeline\'"] impl StructureType { - pub const SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES_KHR: Self = - StructureType::SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES; + pub const RAY_TRACING_PIPELINE_INTERFACE_CREATE_INFO_KHR: Self = Self(1_000_150_018); } -#[doc = "Generated from \'VK_KHR_sampler_ycbcr_conversion\'"] -impl DebugReportObjectTypeEXT { - pub const SAMPLER_YCBCR_CONVERSION_KHR: Self = - DebugReportObjectTypeEXT::SAMPLER_YCBCR_CONVERSION; +#[doc = "Generated from \'VK_KHR_ray_tracing_pipeline\'"] +impl ShaderStageFlags { + pub const RAYGEN_KHR: Self = Self(0b1_0000_0000); } -#[doc = "Generated from \'VK_KHR_sampler_ycbcr_conversion\'"] -impl ObjectType { - pub const SAMPLER_YCBCR_CONVERSION_KHR: Self = ObjectType::SAMPLER_YCBCR_CONVERSION; +#[doc = "Generated from \'VK_KHR_ray_tracing_pipeline\'"] +impl ShaderStageFlags { + pub const ANY_HIT_KHR: Self = Self(0b10_0000_0000); } -#[doc = "Generated from \'VK_KHR_sampler_ycbcr_conversion\'"] -impl Format { - pub const G8B8G8R8_422_UNORM_KHR: Self = Format::G8B8G8R8_422_UNORM; +#[doc = "Generated from \'VK_KHR_ray_tracing_pipeline\'"] +impl ShaderStageFlags { + pub const CLOSEST_HIT_KHR: Self = Self(0b100_0000_0000); } -#[doc = "Generated from \'VK_KHR_sampler_ycbcr_conversion\'"] -impl Format { - pub const B8G8R8G8_422_UNORM_KHR: Self = Format::B8G8R8G8_422_UNORM; +#[doc = "Generated from \'VK_KHR_ray_tracing_pipeline\'"] +impl ShaderStageFlags { + pub const MISS_KHR: Self = Self(0b1000_0000_0000); } -#[doc = "Generated from \'VK_KHR_sampler_ycbcr_conversion\'"] -impl Format { - pub const G8_B8_R8_3PLANE_420_UNORM_KHR: Self = Format::G8_B8_R8_3PLANE_420_UNORM; +#[doc = "Generated from \'VK_KHR_ray_tracing_pipeline\'"] +impl ShaderStageFlags { + pub const INTERSECTION_KHR: Self = Self(0b1_0000_0000_0000); } -#[doc = "Generated from \'VK_KHR_sampler_ycbcr_conversion\'"] -impl Format { - pub const G8_B8R8_2PLANE_420_UNORM_KHR: Self = Format::G8_B8R8_2PLANE_420_UNORM; +#[doc = "Generated from \'VK_KHR_ray_tracing_pipeline\'"] +impl ShaderStageFlags { + pub const CALLABLE_KHR: Self = Self(0b10_0000_0000_0000); } -#[doc = "Generated from \'VK_KHR_sampler_ycbcr_conversion\'"] -impl Format { - pub const G8_B8_R8_3PLANE_422_UNORM_KHR: Self = Format::G8_B8_R8_3PLANE_422_UNORM; -} -#[doc = "Generated from \'VK_KHR_sampler_ycbcr_conversion\'"] -impl Format { - pub const G8_B8R8_2PLANE_422_UNORM_KHR: Self = Format::G8_B8R8_2PLANE_422_UNORM; +#[doc = "Generated from \'VK_KHR_ray_tracing_pipeline\'"] +impl PipelineStageFlags { + pub const RAY_TRACING_SHADER_KHR: Self = Self(0b10_0000_0000_0000_0000_0000); } -#[doc = "Generated from \'VK_KHR_sampler_ycbcr_conversion\'"] -impl Format { - pub const G8_B8_R8_3PLANE_444_UNORM_KHR: Self = Format::G8_B8_R8_3PLANE_444_UNORM; +#[doc = "Generated from \'VK_KHR_ray_tracing_pipeline\'"] +impl BufferUsageFlags { + pub const SHADER_BINDING_TABLE_KHR: Self = Self(0b100_0000_0000); } -#[doc = "Generated from \'VK_KHR_sampler_ycbcr_conversion\'"] -impl Format { - pub const R10X6_UNORM_PACK16_KHR: Self = Format::R10X6_UNORM_PACK16; +#[doc = "Generated from \'VK_KHR_ray_tracing_pipeline\'"] +impl PipelineBindPoint { + pub const RAY_TRACING_KHR: Self = Self(1_000_165_000); } -#[doc = "Generated from \'VK_KHR_sampler_ycbcr_conversion\'"] -impl Format { - pub const R10X6G10X6_UNORM_2PACK16_KHR: Self = Format::R10X6G10X6_UNORM_2PACK16; +#[doc = "Generated from \'VK_KHR_ray_tracing_pipeline\'"] +impl PipelineCreateFlags { + pub const RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_KHR: Self = Self(0b100_0000_0000_0000); } -#[doc = "Generated from \'VK_KHR_sampler_ycbcr_conversion\'"] -impl Format { - pub const R10X6G10X6B10X6A10X6_UNORM_4PACK16_KHR: Self = - Format::R10X6G10X6B10X6A10X6_UNORM_4PACK16; +#[doc = "Generated from \'VK_KHR_ray_tracing_pipeline\'"] +impl PipelineCreateFlags { + pub const RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS_KHR: Self = Self(0b1000_0000_0000_0000); } -#[doc = "Generated from \'VK_KHR_sampler_ycbcr_conversion\'"] -impl Format { - pub const G10X6B10X6G10X6R10X6_422_UNORM_4PACK16_KHR: Self = - Format::G10X6B10X6G10X6R10X6_422_UNORM_4PACK16; +#[doc = "Generated from \'VK_KHR_ray_tracing_pipeline\'"] +impl PipelineCreateFlags { + pub const RAY_TRACING_NO_NULL_MISS_SHADERS_KHR: Self = Self(0b1_0000_0000_0000_0000); } -#[doc = "Generated from \'VK_KHR_sampler_ycbcr_conversion\'"] -impl Format { - pub const B10X6G10X6R10X6G10X6_422_UNORM_4PACK16_KHR: Self = - Format::B10X6G10X6R10X6G10X6_422_UNORM_4PACK16; +#[doc = "Generated from \'VK_KHR_ray_tracing_pipeline\'"] +impl PipelineCreateFlags { + pub const RAY_TRACING_NO_NULL_INTERSECTION_SHADERS_KHR: Self = Self(0b10_0000_0000_0000_0000); } -#[doc = "Generated from \'VK_KHR_sampler_ycbcr_conversion\'"] -impl Format { - pub const G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16_KHR: Self = - Format::G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16; +#[doc = "Generated from \'VK_KHR_ray_tracing_pipeline\'"] +impl PipelineCreateFlags { + pub const RAY_TRACING_SKIP_TRIANGLES_KHR: Self = Self(0b1_0000_0000_0000); } -#[doc = "Generated from \'VK_KHR_sampler_ycbcr_conversion\'"] -impl Format { - pub const G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16_KHR: Self = - Format::G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16; +#[doc = "Generated from \'VK_KHR_ray_tracing_pipeline\'"] +impl PipelineCreateFlags { + pub const RAY_TRACING_SKIP_AABBS_KHR: Self = Self(0b10_0000_0000_0000); } -#[doc = "Generated from \'VK_KHR_sampler_ycbcr_conversion\'"] -impl Format { - pub const G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16_KHR: Self = - Format::G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16; +#[doc = "Generated from \'VK_KHR_ray_tracing_pipeline\'"] +impl PipelineCreateFlags { + pub const RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY_KHR: Self = + Self(0b1000_0000_0000_0000_0000); } -#[doc = "Generated from \'VK_KHR_sampler_ycbcr_conversion\'"] -impl Format { - pub const G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16_KHR: Self = - Format::G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16; +#[doc = "Generated from \'VK_KHR_ray_tracing_pipeline\'"] +impl DynamicState { + pub const RAY_TRACING_PIPELINE_STACK_SIZE_KHR: Self = Self(1_000_347_000); } -#[doc = "Generated from \'VK_KHR_sampler_ycbcr_conversion\'"] -impl Format { - pub const G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16_KHR: Self = - Format::G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16; +impl KhrRayQueryFn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_ray_query\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 1u32; } -#[doc = "Generated from \'VK_KHR_sampler_ycbcr_conversion\'"] -impl Format { - pub const R12X4_UNORM_PACK16_KHR: Self = Format::R12X4_UNORM_PACK16; +pub struct KhrRayQueryFn {} +unsafe impl Send for KhrRayQueryFn {} +unsafe impl Sync for KhrRayQueryFn {} +impl ::std::clone::Clone for KhrRayQueryFn { + fn clone(&self) -> Self { + KhrRayQueryFn {} + } } -#[doc = "Generated from \'VK_KHR_sampler_ycbcr_conversion\'"] -impl Format { - pub const R12X4G12X4_UNORM_2PACK16_KHR: Self = Format::R12X4G12X4_UNORM_2PACK16; +impl KhrRayQueryFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + KhrRayQueryFn {} + } } -#[doc = "Generated from \'VK_KHR_sampler_ycbcr_conversion\'"] -impl Format { - pub const R12X4G12X4B12X4A12X4_UNORM_4PACK16_KHR: Self = - Format::R12X4G12X4B12X4A12X4_UNORM_4PACK16; +#[doc = "Generated from \'VK_KHR_ray_query\'"] +impl StructureType { + pub const PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR: Self = Self(1_000_348_013); } -#[doc = "Generated from \'VK_KHR_sampler_ycbcr_conversion\'"] -impl Format { - pub const G12X4B12X4G12X4R12X4_422_UNORM_4PACK16_KHR: Self = - Format::G12X4B12X4G12X4R12X4_422_UNORM_4PACK16; +impl NvExtension152Fn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_extension_152\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 0u32; } -#[doc = "Generated from \'VK_KHR_sampler_ycbcr_conversion\'"] -impl Format { - pub const B12X4G12X4R12X4G12X4_422_UNORM_4PACK16_KHR: Self = - Format::B12X4G12X4R12X4G12X4_422_UNORM_4PACK16; +pub struct NvExtension152Fn {} +unsafe impl Send for NvExtension152Fn {} +unsafe impl Sync for NvExtension152Fn {} +impl ::std::clone::Clone for NvExtension152Fn { + fn clone(&self) -> Self { + NvExtension152Fn {} + } } -#[doc = "Generated from \'VK_KHR_sampler_ycbcr_conversion\'"] -impl Format { - pub const G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16_KHR: Self = - Format::G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16; +impl NvExtension152Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + NvExtension152Fn {} + } } -#[doc = "Generated from \'VK_KHR_sampler_ycbcr_conversion\'"] -impl Format { - pub const G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16_KHR: Self = - Format::G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16; +impl NvFramebufferMixedSamplesFn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_framebuffer_mixed_samples\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 1u32; } -#[doc = "Generated from \'VK_KHR_sampler_ycbcr_conversion\'"] -impl Format { - pub const G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16_KHR: Self = - Format::G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16; +pub struct NvFramebufferMixedSamplesFn {} +unsafe impl Send for NvFramebufferMixedSamplesFn {} +unsafe impl Sync for NvFramebufferMixedSamplesFn {} +impl ::std::clone::Clone for NvFramebufferMixedSamplesFn { + fn clone(&self) -> Self { + NvFramebufferMixedSamplesFn {} + } } -#[doc = "Generated from \'VK_KHR_sampler_ycbcr_conversion\'"] -impl Format { - pub const G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16_KHR: Self = - Format::G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16; +impl NvFramebufferMixedSamplesFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + NvFramebufferMixedSamplesFn {} + } } -#[doc = "Generated from \'VK_KHR_sampler_ycbcr_conversion\'"] -impl Format { - pub const G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16_KHR: Self = - Format::G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16; +#[doc = "Generated from \'VK_NV_framebuffer_mixed_samples\'"] +impl StructureType { + pub const PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV: Self = Self(1_000_152_000); } -#[doc = "Generated from \'VK_KHR_sampler_ycbcr_conversion\'"] -impl Format { - pub const G16B16G16R16_422_UNORM_KHR: Self = Format::G16B16G16R16_422_UNORM; +impl NvFillRectangleFn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_fill_rectangle\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 1u32; } -#[doc = "Generated from \'VK_KHR_sampler_ycbcr_conversion\'"] -impl Format { - pub const B16G16R16G16_422_UNORM_KHR: Self = Format::B16G16R16G16_422_UNORM; +pub struct NvFillRectangleFn {} +unsafe impl Send for NvFillRectangleFn {} +unsafe impl Sync for NvFillRectangleFn {} +impl ::std::clone::Clone for NvFillRectangleFn { + fn clone(&self) -> Self { + NvFillRectangleFn {} + } } -#[doc = "Generated from \'VK_KHR_sampler_ycbcr_conversion\'"] -impl Format { - pub const G16_B16_R16_3PLANE_420_UNORM_KHR: Self = Format::G16_B16_R16_3PLANE_420_UNORM; +impl NvFillRectangleFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + NvFillRectangleFn {} + } } -#[doc = "Generated from \'VK_KHR_sampler_ycbcr_conversion\'"] -impl Format { - pub const G16_B16R16_2PLANE_420_UNORM_KHR: Self = Format::G16_B16R16_2PLANE_420_UNORM; +#[doc = "Generated from \'VK_NV_fill_rectangle\'"] +impl PolygonMode { + pub const FILL_RECTANGLE_NV: Self = Self(1_000_153_000); } -#[doc = "Generated from \'VK_KHR_sampler_ycbcr_conversion\'"] -impl Format { - pub const G16_B16_R16_3PLANE_422_UNORM_KHR: Self = Format::G16_B16_R16_3PLANE_422_UNORM; +impl NvShaderSmBuiltinsFn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_shader_sm_builtins\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 1u32; } -#[doc = "Generated from \'VK_KHR_sampler_ycbcr_conversion\'"] -impl Format { - pub const G16_B16R16_2PLANE_422_UNORM_KHR: Self = Format::G16_B16R16_2PLANE_422_UNORM; +pub struct NvShaderSmBuiltinsFn {} +unsafe impl Send for NvShaderSmBuiltinsFn {} +unsafe impl Sync for NvShaderSmBuiltinsFn {} +impl ::std::clone::Clone for NvShaderSmBuiltinsFn { + fn clone(&self) -> Self { + NvShaderSmBuiltinsFn {} + } } -#[doc = "Generated from \'VK_KHR_sampler_ycbcr_conversion\'"] -impl Format { - pub const G16_B16_R16_3PLANE_444_UNORM_KHR: Self = Format::G16_B16_R16_3PLANE_444_UNORM; +impl NvShaderSmBuiltinsFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + NvShaderSmBuiltinsFn {} + } } -#[doc = "Generated from \'VK_KHR_sampler_ycbcr_conversion\'"] -impl ImageAspectFlags { - pub const PLANE_0_KHR: Self = ImageAspectFlags::PLANE_0; +#[doc = "Generated from \'VK_NV_shader_sm_builtins\'"] +impl StructureType { + pub const PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV: Self = Self(1_000_154_000); } -#[doc = "Generated from \'VK_KHR_sampler_ycbcr_conversion\'"] -impl ImageAspectFlags { - pub const PLANE_1_KHR: Self = ImageAspectFlags::PLANE_1; +#[doc = "Generated from \'VK_NV_shader_sm_builtins\'"] +impl StructureType { + pub const PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV: Self = Self(1_000_154_001); } -#[doc = "Generated from \'VK_KHR_sampler_ycbcr_conversion\'"] -impl ImageAspectFlags { - pub const PLANE_2_KHR: Self = ImageAspectFlags::PLANE_2; +impl ExtPostDepthCoverageFn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_post_depth_coverage\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 1u32; } -#[doc = "Generated from \'VK_KHR_sampler_ycbcr_conversion\'"] -impl ImageCreateFlags { - pub const DISJOINT_KHR: Self = ImageCreateFlags::DISJOINT; +pub struct ExtPostDepthCoverageFn {} +unsafe impl Send for ExtPostDepthCoverageFn {} +unsafe impl Sync for ExtPostDepthCoverageFn {} +impl ::std::clone::Clone for ExtPostDepthCoverageFn { + fn clone(&self) -> Self { + ExtPostDepthCoverageFn {} + } } -#[doc = "Generated from \'VK_KHR_sampler_ycbcr_conversion\'"] -impl FormatFeatureFlags { - pub const MIDPOINT_CHROMA_SAMPLES_KHR: Self = FormatFeatureFlags::MIDPOINT_CHROMA_SAMPLES; -} -#[doc = "Generated from \'VK_KHR_sampler_ycbcr_conversion\'"] -impl FormatFeatureFlags { - pub const SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_KHR: Self = - FormatFeatureFlags::SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER; -} -#[doc = "Generated from \'VK_KHR_sampler_ycbcr_conversion\'"] -impl FormatFeatureFlags { - pub const SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_KHR: Self = - FormatFeatureFlags::SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER; -} -#[doc = "Generated from \'VK_KHR_sampler_ycbcr_conversion\'"] -impl FormatFeatureFlags { - pub const SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_KHR: Self = - FormatFeatureFlags::SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT; -} -#[doc = "Generated from \'VK_KHR_sampler_ycbcr_conversion\'"] -impl FormatFeatureFlags { - pub const SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_KHR: Self = - FormatFeatureFlags::SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE; -} -#[doc = "Generated from \'VK_KHR_sampler_ycbcr_conversion\'"] -impl FormatFeatureFlags { - pub const DISJOINT_KHR: Self = FormatFeatureFlags::DISJOINT; -} -#[doc = "Generated from \'VK_KHR_sampler_ycbcr_conversion\'"] -impl FormatFeatureFlags { - pub const COSITED_CHROMA_SAMPLES_KHR: Self = FormatFeatureFlags::COSITED_CHROMA_SAMPLES; -} -#[doc = "Generated from \'VK_KHR_sampler_ycbcr_conversion\'"] -impl SamplerYcbcrModelConversion { - pub const RGB_IDENTITY_KHR: Self = SamplerYcbcrModelConversion::RGB_IDENTITY; -} -#[doc = "Generated from \'VK_KHR_sampler_ycbcr_conversion\'"] -impl SamplerYcbcrModelConversion { - pub const YCBCR_IDENTITY_KHR: Self = SamplerYcbcrModelConversion::YCBCR_IDENTITY; -} -#[doc = "Generated from \'VK_KHR_sampler_ycbcr_conversion\'"] -impl SamplerYcbcrModelConversion { - pub const YCBCR_709_KHR: Self = SamplerYcbcrModelConversion::YCBCR_709; -} -#[doc = "Generated from \'VK_KHR_sampler_ycbcr_conversion\'"] -impl SamplerYcbcrModelConversion { - pub const YCBCR_601_KHR: Self = SamplerYcbcrModelConversion::YCBCR_601; -} -#[doc = "Generated from \'VK_KHR_sampler_ycbcr_conversion\'"] -impl SamplerYcbcrModelConversion { - pub const YCBCR_2020_KHR: Self = SamplerYcbcrModelConversion::YCBCR_2020; -} -#[doc = "Generated from \'VK_KHR_sampler_ycbcr_conversion\'"] -impl SamplerYcbcrRange { - pub const ITU_FULL_KHR: Self = SamplerYcbcrRange::ITU_FULL; -} -#[doc = "Generated from \'VK_KHR_sampler_ycbcr_conversion\'"] -impl SamplerYcbcrRange { - pub const ITU_NARROW_KHR: Self = SamplerYcbcrRange::ITU_NARROW; -} -#[doc = "Generated from \'VK_KHR_sampler_ycbcr_conversion\'"] -impl ChromaLocation { - pub const COSITED_EVEN_KHR: Self = ChromaLocation::COSITED_EVEN; -} -#[doc = "Generated from \'VK_KHR_sampler_ycbcr_conversion\'"] -impl ChromaLocation { - pub const MIDPOINT_KHR: Self = ChromaLocation::MIDPOINT; +impl ExtPostDepthCoverageFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + ExtPostDepthCoverageFn {} + } } -impl KhrBindMemory2Fn { +impl KhrSamplerYcbcrConversionFn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_bind_memory2\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_sampler_ycbcr_conversion\0") .expect("Wrong extension string") } - pub const SPEC_VERSION: u32 = 1u32; + pub const SPEC_VERSION: u32 = 14u32; } #[allow(non_camel_case_types)] -pub type PFN_vkBindBufferMemory2 = extern "system" fn( +pub type PFN_vkCreateSamplerYcbcrConversion = extern "system" fn( device: Device, - bind_info_count: u32, - p_bind_infos: *const BindBufferMemoryInfo, + p_create_info: *const SamplerYcbcrConversionCreateInfo, + p_allocator: *const AllocationCallbacks, + p_ycbcr_conversion: *mut SamplerYcbcrConversion, ) -> Result; #[allow(non_camel_case_types)] -pub type PFN_vkBindImageMemory2 = extern "system" fn( +pub type PFN_vkDestroySamplerYcbcrConversion = extern "system" fn( device: Device, - bind_info_count: u32, - p_bind_infos: *const BindImageMemoryInfo, -) -> Result; -pub struct KhrBindMemory2Fn { - pub bind_buffer_memory2_khr: extern "system" fn( + ycbcr_conversion: SamplerYcbcrConversion, + p_allocator: *const AllocationCallbacks, +) -> c_void; +pub struct KhrSamplerYcbcrConversionFn { + pub create_sampler_ycbcr_conversion_khr: extern "system" fn( device: Device, - bind_info_count: u32, - p_bind_infos: *const BindBufferMemoryInfo, + p_create_info: *const SamplerYcbcrConversionCreateInfo, + p_allocator: *const AllocationCallbacks, + p_ycbcr_conversion: *mut SamplerYcbcrConversion, ) -> Result, - pub bind_image_memory2_khr: extern "system" fn( + pub destroy_sampler_ycbcr_conversion_khr: extern "system" fn( device: Device, - bind_info_count: u32, - p_bind_infos: *const BindImageMemoryInfo, - ) -> Result, + ycbcr_conversion: SamplerYcbcrConversion, + p_allocator: *const AllocationCallbacks, + ) -> c_void, } -unsafe impl Send for KhrBindMemory2Fn {} -unsafe impl Sync for KhrBindMemory2Fn {} -impl ::std::clone::Clone for KhrBindMemory2Fn { +unsafe impl Send for KhrSamplerYcbcrConversionFn {} +unsafe impl Sync for KhrSamplerYcbcrConversionFn {} +impl ::std::clone::Clone for KhrSamplerYcbcrConversionFn { fn clone(&self) -> Self { - KhrBindMemory2Fn { - bind_buffer_memory2_khr: self.bind_buffer_memory2_khr, - bind_image_memory2_khr: self.bind_image_memory2_khr, + KhrSamplerYcbcrConversionFn { + create_sampler_ycbcr_conversion_khr: self.create_sampler_ycbcr_conversion_khr, + destroy_sampler_ycbcr_conversion_khr: self.destroy_sampler_ycbcr_conversion_khr, } } } -impl KhrBindMemory2Fn { +impl KhrSamplerYcbcrConversionFn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - KhrBindMemory2Fn { - bind_buffer_memory2_khr: unsafe { - extern "system" fn bind_buffer_memory2_khr( + KhrSamplerYcbcrConversionFn { + create_sampler_ycbcr_conversion_khr: unsafe { + extern "system" fn create_sampler_ycbcr_conversion_khr( _device: Device, - _bind_info_count: u32, - _p_bind_infos: *const BindBufferMemoryInfo, + _p_create_info: *const SamplerYcbcrConversionCreateInfo, + _p_allocator: *const AllocationCallbacks, + _p_ycbcr_conversion: *mut SamplerYcbcrConversion, ) -> Result { panic!(concat!( "Unable to load ", - stringify!(bind_buffer_memory2_khr) + stringify!(create_sampler_ycbcr_conversion_khr) )) } - let raw_name = stringify!(vkBindBufferMemory2KHR); + let raw_name = stringify!(vkCreateSamplerYcbcrConversionKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - bind_buffer_memory2_khr + create_sampler_ycbcr_conversion_khr } else { ::std::mem::transmute(val) } }, - bind_image_memory2_khr: unsafe { - extern "system" fn bind_image_memory2_khr( + destroy_sampler_ycbcr_conversion_khr: unsafe { + extern "system" fn destroy_sampler_ycbcr_conversion_khr( _device: Device, - _bind_info_count: u32, - _p_bind_infos: *const BindImageMemoryInfo, - ) -> Result { + _ycbcr_conversion: SamplerYcbcrConversion, + _p_allocator: *const AllocationCallbacks, + ) -> c_void { panic!(concat!( "Unable to load ", - stringify!(bind_image_memory2_khr) + stringify!(destroy_sampler_ycbcr_conversion_khr) )) } - let raw_name = stringify!(vkBindImageMemory2KHR); + let raw_name = stringify!(vkDestroySamplerYcbcrConversionKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - bind_image_memory2_khr + destroy_sampler_ycbcr_conversion_khr } else { ::std::mem::transmute(val) } }, } } - #[doc = ""] - pub unsafe fn bind_buffer_memory2_khr( + #[doc = ""] + pub unsafe fn create_sampler_ycbcr_conversion_khr( &self, device: Device, - bind_info_count: u32, - p_bind_infos: *const BindBufferMemoryInfo, + p_create_info: *const SamplerYcbcrConversionCreateInfo, + p_allocator: *const AllocationCallbacks, + p_ycbcr_conversion: *mut SamplerYcbcrConversion, ) -> Result { - (self.bind_buffer_memory2_khr)(device, bind_info_count, p_bind_infos) + (self.create_sampler_ycbcr_conversion_khr)( + device, + p_create_info, + p_allocator, + p_ycbcr_conversion, + ) } - #[doc = ""] - pub unsafe fn bind_image_memory2_khr( + #[doc = ""] + pub unsafe fn destroy_sampler_ycbcr_conversion_khr( &self, device: Device, - bind_info_count: u32, - p_bind_infos: *const BindImageMemoryInfo, - ) -> Result { - (self.bind_image_memory2_khr)(device, bind_info_count, p_bind_infos) + ycbcr_conversion: SamplerYcbcrConversion, + p_allocator: *const AllocationCallbacks, + ) -> c_void { + (self.destroy_sampler_ycbcr_conversion_khr)(device, ycbcr_conversion, p_allocator) } } -#[doc = "Generated from \'VK_KHR_bind_memory2\'"] +#[doc = "Generated from \'VK_KHR_sampler_ycbcr_conversion\'"] impl StructureType { - pub const BIND_BUFFER_MEMORY_INFO_KHR: Self = StructureType::BIND_BUFFER_MEMORY_INFO; + pub const SAMPLER_YCBCR_CONVERSION_CREATE_INFO_KHR: Self = + StructureType::SAMPLER_YCBCR_CONVERSION_CREATE_INFO; } -#[doc = "Generated from \'VK_KHR_bind_memory2\'"] +#[doc = "Generated from \'VK_KHR_sampler_ycbcr_conversion\'"] impl StructureType { - pub const BIND_IMAGE_MEMORY_INFO_KHR: Self = StructureType::BIND_IMAGE_MEMORY_INFO; + pub const SAMPLER_YCBCR_CONVERSION_INFO_KHR: Self = + StructureType::SAMPLER_YCBCR_CONVERSION_INFO; } -#[doc = "Generated from \'VK_KHR_bind_memory2\'"] -impl ImageCreateFlags { - pub const ALIAS_KHR: Self = ImageCreateFlags::ALIAS; +#[doc = "Generated from \'VK_KHR_sampler_ycbcr_conversion\'"] +impl StructureType { + pub const BIND_IMAGE_PLANE_MEMORY_INFO_KHR: Self = StructureType::BIND_IMAGE_PLANE_MEMORY_INFO; } -impl ExtImageDrmFormatModifierFn { - pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_image_drm_format_modifier\0") - .expect("Wrong extension string") - } - pub const SPEC_VERSION: u32 = 1u32; +#[doc = "Generated from \'VK_KHR_sampler_ycbcr_conversion\'"] +impl StructureType { + pub const IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO_KHR: Self = + StructureType::IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO; } -#[allow(non_camel_case_types)] -pub type PFN_vkGetImageDrmFormatModifierPropertiesEXT = extern "system" fn( - device: Device, - image: Image, - p_properties: *mut ImageDrmFormatModifierPropertiesEXT, -) -> Result; -pub struct ExtImageDrmFormatModifierFn { - pub get_image_drm_format_modifier_properties_ext: extern "system" fn( - device: Device, - image: Image, - p_properties: *mut ImageDrmFormatModifierPropertiesEXT, - ) -> Result, +#[doc = "Generated from \'VK_KHR_sampler_ycbcr_conversion\'"] +impl StructureType { + pub const PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES_KHR: Self = + StructureType::PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES; } -unsafe impl Send for ExtImageDrmFormatModifierFn {} -unsafe impl Sync for ExtImageDrmFormatModifierFn {} -impl ::std::clone::Clone for ExtImageDrmFormatModifierFn { - fn clone(&self) -> Self { - ExtImageDrmFormatModifierFn { - get_image_drm_format_modifier_properties_ext: self - .get_image_drm_format_modifier_properties_ext, - } - } +#[doc = "Generated from \'VK_KHR_sampler_ycbcr_conversion\'"] +impl StructureType { + pub const SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES_KHR: Self = + StructureType::SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES; } -impl ExtImageDrmFormatModifierFn { - pub fn load(mut _f: F) -> Self - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - ExtImageDrmFormatModifierFn { - get_image_drm_format_modifier_properties_ext: unsafe { - extern "system" fn get_image_drm_format_modifier_properties_ext( - _device: Device, - _image: Image, - _p_properties: *mut ImageDrmFormatModifierPropertiesEXT, - ) -> Result { - panic!(concat!( - "Unable to load ", - stringify!(get_image_drm_format_modifier_properties_ext) - )) - } - let raw_name = stringify!(vkGetImageDrmFormatModifierPropertiesEXT); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - get_image_drm_format_modifier_properties_ext - } else { - ::std::mem::transmute(val) - } - }, - } - } - #[doc = ""] - pub unsafe fn get_image_drm_format_modifier_properties_ext( - &self, - device: Device, - image: Image, - p_properties: *mut ImageDrmFormatModifierPropertiesEXT, - ) -> Result { - (self.get_image_drm_format_modifier_properties_ext)(device, image, p_properties) - } +#[doc = "Generated from \'VK_KHR_sampler_ycbcr_conversion\'"] +impl DebugReportObjectTypeEXT { + pub const SAMPLER_YCBCR_CONVERSION_KHR: Self = + DebugReportObjectTypeEXT::SAMPLER_YCBCR_CONVERSION; } -#[doc = "Generated from \'VK_EXT_image_drm_format_modifier\'"] -impl Result { - pub const ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT: Self = Self(-1_000_158_000); +#[doc = "Generated from \'VK_KHR_sampler_ycbcr_conversion\'"] +impl ObjectType { + pub const SAMPLER_YCBCR_CONVERSION_KHR: Self = ObjectType::SAMPLER_YCBCR_CONVERSION; } -#[doc = "Generated from \'VK_EXT_image_drm_format_modifier\'"] -impl StructureType { - pub const DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT: Self = Self(1_000_158_000); +#[doc = "Generated from \'VK_KHR_sampler_ycbcr_conversion\'"] +impl Format { + pub const G8B8G8R8_422_UNORM_KHR: Self = Format::G8B8G8R8_422_UNORM; } -#[doc = "Generated from \'VK_EXT_image_drm_format_modifier\'"] -impl StructureType { - pub const DRM_FORMAT_MODIFIER_PROPERTIES_EXT: Self = Self(1_000_158_001); +#[doc = "Generated from \'VK_KHR_sampler_ycbcr_conversion\'"] +impl Format { + pub const B8G8R8G8_422_UNORM_KHR: Self = Format::B8G8R8G8_422_UNORM; } -#[doc = "Generated from \'VK_EXT_image_drm_format_modifier\'"] -impl StructureType { - pub const PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT: Self = Self(1_000_158_002); +#[doc = "Generated from \'VK_KHR_sampler_ycbcr_conversion\'"] +impl Format { + pub const G8_B8_R8_3PLANE_420_UNORM_KHR: Self = Format::G8_B8_R8_3PLANE_420_UNORM; } -#[doc = "Generated from \'VK_EXT_image_drm_format_modifier\'"] -impl StructureType { - pub const IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT: Self = Self(1_000_158_003); +#[doc = "Generated from \'VK_KHR_sampler_ycbcr_conversion\'"] +impl Format { + pub const G8_B8R8_2PLANE_420_UNORM_KHR: Self = Format::G8_B8R8_2PLANE_420_UNORM; } -#[doc = "Generated from \'VK_EXT_image_drm_format_modifier\'"] -impl StructureType { - pub const IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT: Self = Self(1_000_158_004); +#[doc = "Generated from \'VK_KHR_sampler_ycbcr_conversion\'"] +impl Format { + pub const G8_B8_R8_3PLANE_422_UNORM_KHR: Self = Format::G8_B8_R8_3PLANE_422_UNORM; } -#[doc = "Generated from \'VK_EXT_image_drm_format_modifier\'"] -impl StructureType { - pub const IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT: Self = Self(1_000_158_005); +#[doc = "Generated from \'VK_KHR_sampler_ycbcr_conversion\'"] +impl Format { + pub const G8_B8R8_2PLANE_422_UNORM_KHR: Self = Format::G8_B8R8_2PLANE_422_UNORM; } -#[doc = "Generated from \'VK_EXT_image_drm_format_modifier\'"] -impl ImageTiling { - pub const DRM_FORMAT_MODIFIER_EXT: Self = Self(1_000_158_000); +#[doc = "Generated from \'VK_KHR_sampler_ycbcr_conversion\'"] +impl Format { + pub const G8_B8_R8_3PLANE_444_UNORM_KHR: Self = Format::G8_B8_R8_3PLANE_444_UNORM; } -#[doc = "Generated from \'VK_EXT_image_drm_format_modifier\'"] -impl ImageAspectFlags { - pub const MEMORY_PLANE_0_EXT: Self = Self(0b1000_0000); +#[doc = "Generated from \'VK_KHR_sampler_ycbcr_conversion\'"] +impl Format { + pub const R10X6_UNORM_PACK16_KHR: Self = Format::R10X6_UNORM_PACK16; } -#[doc = "Generated from \'VK_EXT_image_drm_format_modifier\'"] +#[doc = "Generated from \'VK_KHR_sampler_ycbcr_conversion\'"] +impl Format { + pub const R10X6G10X6_UNORM_2PACK16_KHR: Self = Format::R10X6G10X6_UNORM_2PACK16; +} +#[doc = "Generated from \'VK_KHR_sampler_ycbcr_conversion\'"] +impl Format { + pub const R10X6G10X6B10X6A10X6_UNORM_4PACK16_KHR: Self = + Format::R10X6G10X6B10X6A10X6_UNORM_4PACK16; +} +#[doc = "Generated from \'VK_KHR_sampler_ycbcr_conversion\'"] +impl Format { + pub const G10X6B10X6G10X6R10X6_422_UNORM_4PACK16_KHR: Self = + Format::G10X6B10X6G10X6R10X6_422_UNORM_4PACK16; +} +#[doc = "Generated from \'VK_KHR_sampler_ycbcr_conversion\'"] +impl Format { + pub const B10X6G10X6R10X6G10X6_422_UNORM_4PACK16_KHR: Self = + Format::B10X6G10X6R10X6G10X6_422_UNORM_4PACK16; +} +#[doc = "Generated from \'VK_KHR_sampler_ycbcr_conversion\'"] +impl Format { + pub const G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16_KHR: Self = + Format::G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16; +} +#[doc = "Generated from \'VK_KHR_sampler_ycbcr_conversion\'"] +impl Format { + pub const G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16_KHR: Self = + Format::G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16; +} +#[doc = "Generated from \'VK_KHR_sampler_ycbcr_conversion\'"] +impl Format { + pub const G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16_KHR: Self = + Format::G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16; +} +#[doc = "Generated from \'VK_KHR_sampler_ycbcr_conversion\'"] +impl Format { + pub const G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16_KHR: Self = + Format::G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16; +} +#[doc = "Generated from \'VK_KHR_sampler_ycbcr_conversion\'"] +impl Format { + pub const G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16_KHR: Self = + Format::G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16; +} +#[doc = "Generated from \'VK_KHR_sampler_ycbcr_conversion\'"] +impl Format { + pub const R12X4_UNORM_PACK16_KHR: Self = Format::R12X4_UNORM_PACK16; +} +#[doc = "Generated from \'VK_KHR_sampler_ycbcr_conversion\'"] +impl Format { + pub const R12X4G12X4_UNORM_2PACK16_KHR: Self = Format::R12X4G12X4_UNORM_2PACK16; +} +#[doc = "Generated from \'VK_KHR_sampler_ycbcr_conversion\'"] +impl Format { + pub const R12X4G12X4B12X4A12X4_UNORM_4PACK16_KHR: Self = + Format::R12X4G12X4B12X4A12X4_UNORM_4PACK16; +} +#[doc = "Generated from \'VK_KHR_sampler_ycbcr_conversion\'"] +impl Format { + pub const G12X4B12X4G12X4R12X4_422_UNORM_4PACK16_KHR: Self = + Format::G12X4B12X4G12X4R12X4_422_UNORM_4PACK16; +} +#[doc = "Generated from \'VK_KHR_sampler_ycbcr_conversion\'"] +impl Format { + pub const B12X4G12X4R12X4G12X4_422_UNORM_4PACK16_KHR: Self = + Format::B12X4G12X4R12X4G12X4_422_UNORM_4PACK16; +} +#[doc = "Generated from \'VK_KHR_sampler_ycbcr_conversion\'"] +impl Format { + pub const G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16_KHR: Self = + Format::G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16; +} +#[doc = "Generated from \'VK_KHR_sampler_ycbcr_conversion\'"] +impl Format { + pub const G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16_KHR: Self = + Format::G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16; +} +#[doc = "Generated from \'VK_KHR_sampler_ycbcr_conversion\'"] +impl Format { + pub const G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16_KHR: Self = + Format::G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16; +} +#[doc = "Generated from \'VK_KHR_sampler_ycbcr_conversion\'"] +impl Format { + pub const G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16_KHR: Self = + Format::G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16; +} +#[doc = "Generated from \'VK_KHR_sampler_ycbcr_conversion\'"] +impl Format { + pub const G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16_KHR: Self = + Format::G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16; +} +#[doc = "Generated from \'VK_KHR_sampler_ycbcr_conversion\'"] +impl Format { + pub const G16B16G16R16_422_UNORM_KHR: Self = Format::G16B16G16R16_422_UNORM; +} +#[doc = "Generated from \'VK_KHR_sampler_ycbcr_conversion\'"] +impl Format { + pub const B16G16R16G16_422_UNORM_KHR: Self = Format::B16G16R16G16_422_UNORM; +} +#[doc = "Generated from \'VK_KHR_sampler_ycbcr_conversion\'"] +impl Format { + pub const G16_B16_R16_3PLANE_420_UNORM_KHR: Self = Format::G16_B16_R16_3PLANE_420_UNORM; +} +#[doc = "Generated from \'VK_KHR_sampler_ycbcr_conversion\'"] +impl Format { + pub const G16_B16R16_2PLANE_420_UNORM_KHR: Self = Format::G16_B16R16_2PLANE_420_UNORM; +} +#[doc = "Generated from \'VK_KHR_sampler_ycbcr_conversion\'"] +impl Format { + pub const G16_B16_R16_3PLANE_422_UNORM_KHR: Self = Format::G16_B16_R16_3PLANE_422_UNORM; +} +#[doc = "Generated from \'VK_KHR_sampler_ycbcr_conversion\'"] +impl Format { + pub const G16_B16R16_2PLANE_422_UNORM_KHR: Self = Format::G16_B16R16_2PLANE_422_UNORM; +} +#[doc = "Generated from \'VK_KHR_sampler_ycbcr_conversion\'"] +impl Format { + pub const G16_B16_R16_3PLANE_444_UNORM_KHR: Self = Format::G16_B16_R16_3PLANE_444_UNORM; +} +#[doc = "Generated from \'VK_KHR_sampler_ycbcr_conversion\'"] impl ImageAspectFlags { - pub const MEMORY_PLANE_1_EXT: Self = Self(0b1_0000_0000); + pub const PLANE_0_KHR: Self = ImageAspectFlags::PLANE_0; } -#[doc = "Generated from \'VK_EXT_image_drm_format_modifier\'"] +#[doc = "Generated from \'VK_KHR_sampler_ycbcr_conversion\'"] impl ImageAspectFlags { - pub const MEMORY_PLANE_2_EXT: Self = Self(0b10_0000_0000); + pub const PLANE_1_KHR: Self = ImageAspectFlags::PLANE_1; } -#[doc = "Generated from \'VK_EXT_image_drm_format_modifier\'"] +#[doc = "Generated from \'VK_KHR_sampler_ycbcr_conversion\'"] impl ImageAspectFlags { - pub const MEMORY_PLANE_3_EXT: Self = Self(0b100_0000_0000); + pub const PLANE_2_KHR: Self = ImageAspectFlags::PLANE_2; } -impl ExtExtension160Fn { - pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_extension_160\0") - .expect("Wrong extension string") - } - pub const SPEC_VERSION: u32 = 0u32; +#[doc = "Generated from \'VK_KHR_sampler_ycbcr_conversion\'"] +impl ImageCreateFlags { + pub const DISJOINT_KHR: Self = ImageCreateFlags::DISJOINT; } -pub struct ExtExtension160Fn {} -unsafe impl Send for ExtExtension160Fn {} -unsafe impl Sync for ExtExtension160Fn {} -impl ::std::clone::Clone for ExtExtension160Fn { - fn clone(&self) -> Self { - ExtExtension160Fn {} - } +#[doc = "Generated from \'VK_KHR_sampler_ycbcr_conversion\'"] +impl FormatFeatureFlags { + pub const MIDPOINT_CHROMA_SAMPLES_KHR: Self = FormatFeatureFlags::MIDPOINT_CHROMA_SAMPLES; } -impl ExtExtension160Fn { - pub fn load(mut _f: F) -> Self - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - ExtExtension160Fn {} - } +#[doc = "Generated from \'VK_KHR_sampler_ycbcr_conversion\'"] +impl FormatFeatureFlags { + pub const SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_KHR: Self = + FormatFeatureFlags::SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER; } -impl ExtValidationCacheFn { - pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_validation_cache\0") - .expect("Wrong extension string") - } - pub const SPEC_VERSION: u32 = 1u32; +#[doc = "Generated from \'VK_KHR_sampler_ycbcr_conversion\'"] +impl FormatFeatureFlags { + pub const SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_KHR: Self = + FormatFeatureFlags::SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER; +} +#[doc = "Generated from \'VK_KHR_sampler_ycbcr_conversion\'"] +impl FormatFeatureFlags { + pub const SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_KHR: Self = + FormatFeatureFlags::SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT; +} +#[doc = "Generated from \'VK_KHR_sampler_ycbcr_conversion\'"] +impl FormatFeatureFlags { + pub const SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_KHR: Self = + FormatFeatureFlags::SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE; +} +#[doc = "Generated from \'VK_KHR_sampler_ycbcr_conversion\'"] +impl FormatFeatureFlags { + pub const DISJOINT_KHR: Self = FormatFeatureFlags::DISJOINT; +} +#[doc = "Generated from \'VK_KHR_sampler_ycbcr_conversion\'"] +impl FormatFeatureFlags { + pub const COSITED_CHROMA_SAMPLES_KHR: Self = FormatFeatureFlags::COSITED_CHROMA_SAMPLES; +} +#[doc = "Generated from \'VK_KHR_sampler_ycbcr_conversion\'"] +impl SamplerYcbcrModelConversion { + pub const RGB_IDENTITY_KHR: Self = SamplerYcbcrModelConversion::RGB_IDENTITY; +} +#[doc = "Generated from \'VK_KHR_sampler_ycbcr_conversion\'"] +impl SamplerYcbcrModelConversion { + pub const YCBCR_IDENTITY_KHR: Self = SamplerYcbcrModelConversion::YCBCR_IDENTITY; +} +#[doc = "Generated from \'VK_KHR_sampler_ycbcr_conversion\'"] +impl SamplerYcbcrModelConversion { + pub const YCBCR_709_KHR: Self = SamplerYcbcrModelConversion::YCBCR_709; +} +#[doc = "Generated from \'VK_KHR_sampler_ycbcr_conversion\'"] +impl SamplerYcbcrModelConversion { + pub const YCBCR_601_KHR: Self = SamplerYcbcrModelConversion::YCBCR_601; +} +#[doc = "Generated from \'VK_KHR_sampler_ycbcr_conversion\'"] +impl SamplerYcbcrModelConversion { + pub const YCBCR_2020_KHR: Self = SamplerYcbcrModelConversion::YCBCR_2020; +} +#[doc = "Generated from \'VK_KHR_sampler_ycbcr_conversion\'"] +impl SamplerYcbcrRange { + pub const ITU_FULL_KHR: Self = SamplerYcbcrRange::ITU_FULL; +} +#[doc = "Generated from \'VK_KHR_sampler_ycbcr_conversion\'"] +impl SamplerYcbcrRange { + pub const ITU_NARROW_KHR: Self = SamplerYcbcrRange::ITU_NARROW; +} +#[doc = "Generated from \'VK_KHR_sampler_ycbcr_conversion\'"] +impl ChromaLocation { + pub const COSITED_EVEN_KHR: Self = ChromaLocation::COSITED_EVEN; +} +#[doc = "Generated from \'VK_KHR_sampler_ycbcr_conversion\'"] +impl ChromaLocation { + pub const MIDPOINT_KHR: Self = ChromaLocation::MIDPOINT; +} +impl KhrBindMemory2Fn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_bind_memory2\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 1u32; } #[allow(non_camel_case_types)] -pub type PFN_vkCreateValidationCacheEXT = extern "system" fn( - device: Device, - p_create_info: *const ValidationCacheCreateInfoEXT, - p_allocator: *const AllocationCallbacks, - p_validation_cache: *mut ValidationCacheEXT, -) -> Result; -#[allow(non_camel_case_types)] -pub type PFN_vkDestroyValidationCacheEXT = extern "system" fn( - device: Device, - validation_cache: ValidationCacheEXT, - p_allocator: *const AllocationCallbacks, -) -> c_void; -#[allow(non_camel_case_types)] -pub type PFN_vkMergeValidationCachesEXT = extern "system" fn( +pub type PFN_vkBindBufferMemory2 = extern "system" fn( device: Device, - dst_cache: ValidationCacheEXT, - src_cache_count: u32, - p_src_caches: *const ValidationCacheEXT, + bind_info_count: u32, + p_bind_infos: *const BindBufferMemoryInfo, ) -> Result; #[allow(non_camel_case_types)] -pub type PFN_vkGetValidationCacheDataEXT = extern "system" fn( +pub type PFN_vkBindImageMemory2 = extern "system" fn( device: Device, - validation_cache: ValidationCacheEXT, - p_data_size: *mut usize, - p_data: *mut c_void, + bind_info_count: u32, + p_bind_infos: *const BindImageMemoryInfo, ) -> Result; -pub struct ExtValidationCacheFn { - pub create_validation_cache_ext: extern "system" fn( - device: Device, - p_create_info: *const ValidationCacheCreateInfoEXT, - p_allocator: *const AllocationCallbacks, - p_validation_cache: *mut ValidationCacheEXT, - ) -> Result, - pub destroy_validation_cache_ext: extern "system" fn( - device: Device, - validation_cache: ValidationCacheEXT, - p_allocator: *const AllocationCallbacks, - ) -> c_void, - pub merge_validation_caches_ext: extern "system" fn( +pub struct KhrBindMemory2Fn { + pub bind_buffer_memory2_khr: extern "system" fn( device: Device, - dst_cache: ValidationCacheEXT, - src_cache_count: u32, - p_src_caches: *const ValidationCacheEXT, + bind_info_count: u32, + p_bind_infos: *const BindBufferMemoryInfo, ) -> Result, - pub get_validation_cache_data_ext: extern "system" fn( + pub bind_image_memory2_khr: extern "system" fn( device: Device, - validation_cache: ValidationCacheEXT, - p_data_size: *mut usize, - p_data: *mut c_void, + bind_info_count: u32, + p_bind_infos: *const BindImageMemoryInfo, ) -> Result, } -unsafe impl Send for ExtValidationCacheFn {} -unsafe impl Sync for ExtValidationCacheFn {} -impl ::std::clone::Clone for ExtValidationCacheFn { +unsafe impl Send for KhrBindMemory2Fn {} +unsafe impl Sync for KhrBindMemory2Fn {} +impl ::std::clone::Clone for KhrBindMemory2Fn { fn clone(&self) -> Self { - ExtValidationCacheFn { - create_validation_cache_ext: self.create_validation_cache_ext, - destroy_validation_cache_ext: self.destroy_validation_cache_ext, - merge_validation_caches_ext: self.merge_validation_caches_ext, - get_validation_cache_data_ext: self.get_validation_cache_data_ext, + KhrBindMemory2Fn { + bind_buffer_memory2_khr: self.bind_buffer_memory2_khr, + bind_image_memory2_khr: self.bind_image_memory2_khr, } } } -impl ExtValidationCacheFn { +impl KhrBindMemory2Fn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - ExtValidationCacheFn { - create_validation_cache_ext: unsafe { - extern "system" fn create_validation_cache_ext( - _device: Device, - _p_create_info: *const ValidationCacheCreateInfoEXT, - _p_allocator: *const AllocationCallbacks, - _p_validation_cache: *mut ValidationCacheEXT, - ) -> Result { - panic!(concat!( - "Unable to load ", - stringify!(create_validation_cache_ext) - )) - } - let raw_name = stringify!(vkCreateValidationCacheEXT); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - create_validation_cache_ext - } else { - ::std::mem::transmute(val) - } - }, - destroy_validation_cache_ext: unsafe { - extern "system" fn destroy_validation_cache_ext( - _device: Device, - _validation_cache: ValidationCacheEXT, - _p_allocator: *const AllocationCallbacks, - ) -> c_void { - panic!(concat!( - "Unable to load ", - stringify!(destroy_validation_cache_ext) - )) - } - let raw_name = stringify!(vkDestroyValidationCacheEXT); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - destroy_validation_cache_ext - } else { - ::std::mem::transmute(val) - } - }, - merge_validation_caches_ext: unsafe { - extern "system" fn merge_validation_caches_ext( + KhrBindMemory2Fn { + bind_buffer_memory2_khr: unsafe { + extern "system" fn bind_buffer_memory2_khr( _device: Device, - _dst_cache: ValidationCacheEXT, - _src_cache_count: u32, - _p_src_caches: *const ValidationCacheEXT, + _bind_info_count: u32, + _p_bind_infos: *const BindBufferMemoryInfo, ) -> Result { panic!(concat!( "Unable to load ", - stringify!(merge_validation_caches_ext) + stringify!(bind_buffer_memory2_khr) )) } - let raw_name = stringify!(vkMergeValidationCachesEXT); + let raw_name = stringify!(vkBindBufferMemory2KHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - merge_validation_caches_ext + bind_buffer_memory2_khr } else { ::std::mem::transmute(val) } }, - get_validation_cache_data_ext: unsafe { - extern "system" fn get_validation_cache_data_ext( + bind_image_memory2_khr: unsafe { + extern "system" fn bind_image_memory2_khr( _device: Device, - _validation_cache: ValidationCacheEXT, - _p_data_size: *mut usize, - _p_data: *mut c_void, + _bind_info_count: u32, + _p_bind_infos: *const BindImageMemoryInfo, ) -> Result { panic!(concat!( "Unable to load ", - stringify!(get_validation_cache_data_ext) + stringify!(bind_image_memory2_khr) )) } - let raw_name = stringify!(vkGetValidationCacheDataEXT); + let raw_name = stringify!(vkBindImageMemory2KHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - get_validation_cache_data_ext + bind_image_memory2_khr } else { ::std::mem::transmute(val) } }, } } - #[doc = ""] - pub unsafe fn create_validation_cache_ext( - &self, - device: Device, - p_create_info: *const ValidationCacheCreateInfoEXT, - p_allocator: *const AllocationCallbacks, - p_validation_cache: *mut ValidationCacheEXT, - ) -> Result { - (self.create_validation_cache_ext)(device, p_create_info, p_allocator, p_validation_cache) - } - #[doc = ""] - pub unsafe fn destroy_validation_cache_ext( - &self, - device: Device, - validation_cache: ValidationCacheEXT, - p_allocator: *const AllocationCallbacks, - ) -> c_void { - (self.destroy_validation_cache_ext)(device, validation_cache, p_allocator) - } - #[doc = ""] - pub unsafe fn merge_validation_caches_ext( + #[doc = ""] + pub unsafe fn bind_buffer_memory2_khr( &self, device: Device, - dst_cache: ValidationCacheEXT, - src_cache_count: u32, - p_src_caches: *const ValidationCacheEXT, + bind_info_count: u32, + p_bind_infos: *const BindBufferMemoryInfo, ) -> Result { - (self.merge_validation_caches_ext)(device, dst_cache, src_cache_count, p_src_caches) + (self.bind_buffer_memory2_khr)(device, bind_info_count, p_bind_infos) } - #[doc = ""] - pub unsafe fn get_validation_cache_data_ext( + #[doc = ""] + pub unsafe fn bind_image_memory2_khr( &self, device: Device, - validation_cache: ValidationCacheEXT, - p_data_size: *mut usize, - p_data: *mut c_void, + bind_info_count: u32, + p_bind_infos: *const BindImageMemoryInfo, ) -> Result { - (self.get_validation_cache_data_ext)(device, validation_cache, p_data_size, p_data) + (self.bind_image_memory2_khr)(device, bind_info_count, p_bind_infos) } } -#[doc = "Generated from \'VK_EXT_validation_cache\'"] +#[doc = "Generated from \'VK_KHR_bind_memory2\'"] impl StructureType { - pub const VALIDATION_CACHE_CREATE_INFO_EXT: Self = Self(1_000_160_000); + pub const BIND_BUFFER_MEMORY_INFO_KHR: Self = StructureType::BIND_BUFFER_MEMORY_INFO; } -#[doc = "Generated from \'VK_EXT_validation_cache\'"] +#[doc = "Generated from \'VK_KHR_bind_memory2\'"] impl StructureType { - pub const SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT: Self = Self(1_000_160_001); + pub const BIND_IMAGE_MEMORY_INFO_KHR: Self = StructureType::BIND_IMAGE_MEMORY_INFO; } -#[doc = "Generated from \'VK_EXT_validation_cache\'"] -impl ObjectType { - pub const VALIDATION_CACHE_EXT: Self = Self(1_000_160_000); +#[doc = "Generated from \'VK_KHR_bind_memory2\'"] +impl ImageCreateFlags { + pub const ALIAS_KHR: Self = ImageCreateFlags::ALIAS; } -impl ExtDescriptorIndexingFn { +impl ExtImageDrmFormatModifierFn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_descriptor_indexing\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_image_drm_format_modifier\0") .expect("Wrong extension string") } - pub const SPEC_VERSION: u32 = 2u32; + pub const SPEC_VERSION: u32 = 1u32; } -pub struct ExtDescriptorIndexingFn {} -unsafe impl Send for ExtDescriptorIndexingFn {} -unsafe impl Sync for ExtDescriptorIndexingFn {} -impl ::std::clone::Clone for ExtDescriptorIndexingFn { +#[allow(non_camel_case_types)] +pub type PFN_vkGetImageDrmFormatModifierPropertiesEXT = extern "system" fn( + device: Device, + image: Image, + p_properties: *mut ImageDrmFormatModifierPropertiesEXT, +) -> Result; +pub struct ExtImageDrmFormatModifierFn { + pub get_image_drm_format_modifier_properties_ext: extern "system" fn( + device: Device, + image: Image, + p_properties: *mut ImageDrmFormatModifierPropertiesEXT, + ) -> Result, +} +unsafe impl Send for ExtImageDrmFormatModifierFn {} +unsafe impl Sync for ExtImageDrmFormatModifierFn {} +impl ::std::clone::Clone for ExtImageDrmFormatModifierFn { fn clone(&self) -> Self { - ExtDescriptorIndexingFn {} + ExtImageDrmFormatModifierFn { + get_image_drm_format_modifier_properties_ext: self + .get_image_drm_format_modifier_properties_ext, + } } } -impl ExtDescriptorIndexingFn { +impl ExtImageDrmFormatModifierFn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - ExtDescriptorIndexingFn {} + ExtImageDrmFormatModifierFn { + get_image_drm_format_modifier_properties_ext: unsafe { + extern "system" fn get_image_drm_format_modifier_properties_ext( + _device: Device, + _image: Image, + _p_properties: *mut ImageDrmFormatModifierPropertiesEXT, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_image_drm_format_modifier_properties_ext) + )) + } + let raw_name = stringify!(vkGetImageDrmFormatModifierPropertiesEXT); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + get_image_drm_format_modifier_properties_ext + } else { + ::std::mem::transmute(val) + } + }, + } + } + #[doc = ""] + pub unsafe fn get_image_drm_format_modifier_properties_ext( + &self, + device: Device, + image: Image, + p_properties: *mut ImageDrmFormatModifierPropertiesEXT, + ) -> Result { + (self.get_image_drm_format_modifier_properties_ext)(device, image, p_properties) } } -#[doc = "Generated from \'VK_EXT_descriptor_indexing\'"] -impl StructureType { - pub const DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO_EXT: Self = - StructureType::DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO; +#[doc = "Generated from \'VK_EXT_image_drm_format_modifier\'"] +impl Result { + pub const ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT: Self = Self(-1_000_158_000); } -#[doc = "Generated from \'VK_EXT_descriptor_indexing\'"] +#[doc = "Generated from \'VK_EXT_image_drm_format_modifier\'"] impl StructureType { - pub const PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES_EXT: Self = - StructureType::PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES; + pub const DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT: Self = Self(1_000_158_000); } -#[doc = "Generated from \'VK_EXT_descriptor_indexing\'"] +#[doc = "Generated from \'VK_EXT_image_drm_format_modifier\'"] impl StructureType { - pub const PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES_EXT: Self = - StructureType::PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES; + pub const PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT: Self = Self(1_000_158_002); } -#[doc = "Generated from \'VK_EXT_descriptor_indexing\'"] +#[doc = "Generated from \'VK_EXT_image_drm_format_modifier\'"] impl StructureType { - pub const DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO_EXT: Self = - StructureType::DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO; + pub const IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT: Self = Self(1_000_158_003); } -#[doc = "Generated from \'VK_EXT_descriptor_indexing\'"] +#[doc = "Generated from \'VK_EXT_image_drm_format_modifier\'"] impl StructureType { - pub const DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT_EXT: Self = - StructureType::DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT; -} -#[doc = "Generated from \'VK_EXT_descriptor_indexing\'"] -impl DescriptorBindingFlags { - pub const UPDATE_AFTER_BIND_EXT: Self = DescriptorBindingFlags::UPDATE_AFTER_BIND; -} -#[doc = "Generated from \'VK_EXT_descriptor_indexing\'"] -impl DescriptorBindingFlags { - pub const UPDATE_UNUSED_WHILE_PENDING_EXT: Self = - DescriptorBindingFlags::UPDATE_UNUSED_WHILE_PENDING; -} -#[doc = "Generated from \'VK_EXT_descriptor_indexing\'"] -impl DescriptorBindingFlags { - pub const PARTIALLY_BOUND_EXT: Self = DescriptorBindingFlags::PARTIALLY_BOUND; -} -#[doc = "Generated from \'VK_EXT_descriptor_indexing\'"] -impl DescriptorBindingFlags { - pub const VARIABLE_DESCRIPTOR_COUNT_EXT: Self = - DescriptorBindingFlags::VARIABLE_DESCRIPTOR_COUNT; + pub const IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT: Self = Self(1_000_158_004); } -#[doc = "Generated from \'VK_EXT_descriptor_indexing\'"] -impl DescriptorPoolCreateFlags { - pub const UPDATE_AFTER_BIND_EXT: Self = DescriptorPoolCreateFlags::UPDATE_AFTER_BIND; +#[doc = "Generated from \'VK_EXT_image_drm_format_modifier\'"] +impl StructureType { + pub const IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT: Self = Self(1_000_158_005); } -#[doc = "Generated from \'VK_EXT_descriptor_indexing\'"] -impl DescriptorSetLayoutCreateFlags { - pub const UPDATE_AFTER_BIND_POOL_EXT: Self = - DescriptorSetLayoutCreateFlags::UPDATE_AFTER_BIND_POOL; +#[doc = "Generated from \'VK_EXT_image_drm_format_modifier\'"] +impl ImageTiling { + pub const DRM_FORMAT_MODIFIER_EXT: Self = Self(1_000_158_000); } -#[doc = "Generated from \'VK_EXT_descriptor_indexing\'"] -impl Result { - pub const ERROR_FRAGMENTATION_EXT: Self = Result::ERROR_FRAGMENTATION; +#[doc = "Generated from \'VK_EXT_image_drm_format_modifier\'"] +impl ImageAspectFlags { + pub const MEMORY_PLANE_0_EXT: Self = Self(0b1000_0000); } -impl ExtShaderViewportIndexLayerFn { - pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_shader_viewport_index_layer\0") - .expect("Wrong extension string") - } - pub const SPEC_VERSION: u32 = 1u32; +#[doc = "Generated from \'VK_EXT_image_drm_format_modifier\'"] +impl ImageAspectFlags { + pub const MEMORY_PLANE_1_EXT: Self = Self(0b1_0000_0000); } -pub struct ExtShaderViewportIndexLayerFn {} -unsafe impl Send for ExtShaderViewportIndexLayerFn {} -unsafe impl Sync for ExtShaderViewportIndexLayerFn {} -impl ::std::clone::Clone for ExtShaderViewportIndexLayerFn { - fn clone(&self) -> Self { - ExtShaderViewportIndexLayerFn {} - } +#[doc = "Generated from \'VK_EXT_image_drm_format_modifier\'"] +impl ImageAspectFlags { + pub const MEMORY_PLANE_2_EXT: Self = Self(0b10_0000_0000); } -impl ExtShaderViewportIndexLayerFn { - pub fn load(mut _f: F) -> Self - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - ExtShaderViewportIndexLayerFn {} - } +#[doc = "Generated from \'VK_EXT_image_drm_format_modifier\'"] +impl ImageAspectFlags { + pub const MEMORY_PLANE_3_EXT: Self = Self(0b100_0000_0000); } -impl NvExtension164Fn { +impl ExtExtension160Fn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_extension_164\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_extension_160\0") .expect("Wrong extension string") } pub const SPEC_VERSION: u32 = 0u32; } -pub struct NvExtension164Fn {} -unsafe impl Send for NvExtension164Fn {} -unsafe impl Sync for NvExtension164Fn {} -impl ::std::clone::Clone for NvExtension164Fn { +pub struct ExtExtension160Fn {} +unsafe impl Send for ExtExtension160Fn {} +unsafe impl Sync for ExtExtension160Fn {} +impl ::std::clone::Clone for ExtExtension160Fn { fn clone(&self) -> Self { - NvExtension164Fn {} + ExtExtension160Fn {} } } -impl NvExtension164Fn { +impl ExtExtension160Fn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - NvExtension164Fn {} + ExtExtension160Fn {} } } -impl NvShadingRateImageFn { +impl ExtValidationCacheFn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_shading_rate_image\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_validation_cache\0") .expect("Wrong extension string") } - pub const SPEC_VERSION: u32 = 3u32; + pub const SPEC_VERSION: u32 = 1u32; } #[allow(non_camel_case_types)] -pub type PFN_vkCmdBindShadingRateImageNV = extern "system" fn( - command_buffer: CommandBuffer, - image_view: ImageView, - image_layout: ImageLayout, -) -> c_void; +pub type PFN_vkCreateValidationCacheEXT = extern "system" fn( + device: Device, + p_create_info: *const ValidationCacheCreateInfoEXT, + p_allocator: *const AllocationCallbacks, + p_validation_cache: *mut ValidationCacheEXT, +) -> Result; #[allow(non_camel_case_types)] -pub type PFN_vkCmdSetViewportShadingRatePaletteNV = extern "system" fn( - command_buffer: CommandBuffer, - first_viewport: u32, - viewport_count: u32, - p_shading_rate_palettes: *const ShadingRatePaletteNV, +pub type PFN_vkDestroyValidationCacheEXT = extern "system" fn( + device: Device, + validation_cache: ValidationCacheEXT, + p_allocator: *const AllocationCallbacks, ) -> c_void; #[allow(non_camel_case_types)] -pub type PFN_vkCmdSetCoarseSampleOrderNV = extern "system" fn( - command_buffer: CommandBuffer, - sample_order_type: CoarseSampleOrderTypeNV, - custom_sample_order_count: u32, - p_custom_sample_orders: *const CoarseSampleOrderCustomNV, -) -> c_void; -pub struct NvShadingRateImageFn { - pub cmd_bind_shading_rate_image_nv: extern "system" fn( - command_buffer: CommandBuffer, - image_view: ImageView, - image_layout: ImageLayout, - ) -> c_void, - pub cmd_set_viewport_shading_rate_palette_nv: extern "system" fn( - command_buffer: CommandBuffer, - first_viewport: u32, - viewport_count: u32, - p_shading_rate_palettes: *const ShadingRatePaletteNV, - ) -> c_void, - pub cmd_set_coarse_sample_order_nv: extern "system" fn( - command_buffer: CommandBuffer, - sample_order_type: CoarseSampleOrderTypeNV, - custom_sample_order_count: u32, - p_custom_sample_orders: *const CoarseSampleOrderCustomNV, +pub type PFN_vkMergeValidationCachesEXT = extern "system" fn( + device: Device, + dst_cache: ValidationCacheEXT, + src_cache_count: u32, + p_src_caches: *const ValidationCacheEXT, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetValidationCacheDataEXT = extern "system" fn( + device: Device, + validation_cache: ValidationCacheEXT, + p_data_size: *mut usize, + p_data: *mut c_void, +) -> Result; +pub struct ExtValidationCacheFn { + pub create_validation_cache_ext: extern "system" fn( + device: Device, + p_create_info: *const ValidationCacheCreateInfoEXT, + p_allocator: *const AllocationCallbacks, + p_validation_cache: *mut ValidationCacheEXT, + ) -> Result, + pub destroy_validation_cache_ext: extern "system" fn( + device: Device, + validation_cache: ValidationCacheEXT, + p_allocator: *const AllocationCallbacks, ) -> c_void, + pub merge_validation_caches_ext: extern "system" fn( + device: Device, + dst_cache: ValidationCacheEXT, + src_cache_count: u32, + p_src_caches: *const ValidationCacheEXT, + ) -> Result, + pub get_validation_cache_data_ext: extern "system" fn( + device: Device, + validation_cache: ValidationCacheEXT, + p_data_size: *mut usize, + p_data: *mut c_void, + ) -> Result, } -unsafe impl Send for NvShadingRateImageFn {} -unsafe impl Sync for NvShadingRateImageFn {} -impl ::std::clone::Clone for NvShadingRateImageFn { +unsafe impl Send for ExtValidationCacheFn {} +unsafe impl Sync for ExtValidationCacheFn {} +impl ::std::clone::Clone for ExtValidationCacheFn { fn clone(&self) -> Self { - NvShadingRateImageFn { - cmd_bind_shading_rate_image_nv: self.cmd_bind_shading_rate_image_nv, - cmd_set_viewport_shading_rate_palette_nv: self.cmd_set_viewport_shading_rate_palette_nv, - cmd_set_coarse_sample_order_nv: self.cmd_set_coarse_sample_order_nv, + ExtValidationCacheFn { + create_validation_cache_ext: self.create_validation_cache_ext, + destroy_validation_cache_ext: self.destroy_validation_cache_ext, + merge_validation_caches_ext: self.merge_validation_caches_ext, + get_validation_cache_data_ext: self.get_validation_cache_data_ext, } } } -impl NvShadingRateImageFn { +impl ExtValidationCacheFn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - NvShadingRateImageFn { - cmd_bind_shading_rate_image_nv: unsafe { - extern "system" fn cmd_bind_shading_rate_image_nv( - _command_buffer: CommandBuffer, - _image_view: ImageView, - _image_layout: ImageLayout, - ) -> c_void { + ExtValidationCacheFn { + create_validation_cache_ext: unsafe { + extern "system" fn create_validation_cache_ext( + _device: Device, + _p_create_info: *const ValidationCacheCreateInfoEXT, + _p_allocator: *const AllocationCallbacks, + _p_validation_cache: *mut ValidationCacheEXT, + ) -> Result { panic!(concat!( "Unable to load ", - stringify!(cmd_bind_shading_rate_image_nv) + stringify!(create_validation_cache_ext) )) } - let raw_name = stringify!(vkCmdBindShadingRateImageNV); + let raw_name = stringify!(vkCreateValidationCacheEXT); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - cmd_bind_shading_rate_image_nv + create_validation_cache_ext } else { ::std::mem::transmute(val) } }, - cmd_set_viewport_shading_rate_palette_nv: unsafe { - extern "system" fn cmd_set_viewport_shading_rate_palette_nv( - _command_buffer: CommandBuffer, - _first_viewport: u32, - _viewport_count: u32, - _p_shading_rate_palettes: *const ShadingRatePaletteNV, + destroy_validation_cache_ext: unsafe { + extern "system" fn destroy_validation_cache_ext( + _device: Device, + _validation_cache: ValidationCacheEXT, + _p_allocator: *const AllocationCallbacks, ) -> c_void { panic!(concat!( "Unable to load ", - stringify!(cmd_set_viewport_shading_rate_palette_nv) + stringify!(destroy_validation_cache_ext) )) } - let raw_name = stringify!(vkCmdSetViewportShadingRatePaletteNV); + let raw_name = stringify!(vkDestroyValidationCacheEXT); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - cmd_set_viewport_shading_rate_palette_nv + destroy_validation_cache_ext } else { ::std::mem::transmute(val) } }, - cmd_set_coarse_sample_order_nv: unsafe { - extern "system" fn cmd_set_coarse_sample_order_nv( - _command_buffer: CommandBuffer, - _sample_order_type: CoarseSampleOrderTypeNV, - _custom_sample_order_count: u32, - _p_custom_sample_orders: *const CoarseSampleOrderCustomNV, - ) -> c_void { + merge_validation_caches_ext: unsafe { + extern "system" fn merge_validation_caches_ext( + _device: Device, + _dst_cache: ValidationCacheEXT, + _src_cache_count: u32, + _p_src_caches: *const ValidationCacheEXT, + ) -> Result { panic!(concat!( "Unable to load ", - stringify!(cmd_set_coarse_sample_order_nv) + stringify!(merge_validation_caches_ext) )) } - let raw_name = stringify!(vkCmdSetCoarseSampleOrderNV); + let raw_name = stringify!(vkMergeValidationCachesEXT); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - cmd_set_coarse_sample_order_nv + merge_validation_caches_ext + } else { + ::std::mem::transmute(val) + } + }, + get_validation_cache_data_ext: unsafe { + extern "system" fn get_validation_cache_data_ext( + _device: Device, + _validation_cache: ValidationCacheEXT, + _p_data_size: *mut usize, + _p_data: *mut c_void, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_validation_cache_data_ext) + )) + } + let raw_name = stringify!(vkGetValidationCacheDataEXT); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + get_validation_cache_data_ext } else { ::std::mem::transmute(val) } }, } } - #[doc = ""] - pub unsafe fn cmd_bind_shading_rate_image_nv( + #[doc = ""] + pub unsafe fn create_validation_cache_ext( &self, - command_buffer: CommandBuffer, - image_view: ImageView, - image_layout: ImageLayout, - ) -> c_void { - (self.cmd_bind_shading_rate_image_nv)(command_buffer, image_view, image_layout) + device: Device, + p_create_info: *const ValidationCacheCreateInfoEXT, + p_allocator: *const AllocationCallbacks, + p_validation_cache: *mut ValidationCacheEXT, + ) -> Result { + (self.create_validation_cache_ext)(device, p_create_info, p_allocator, p_validation_cache) } - #[doc = ""] - pub unsafe fn cmd_set_viewport_shading_rate_palette_nv( + #[doc = ""] + pub unsafe fn destroy_validation_cache_ext( &self, - command_buffer: CommandBuffer, - first_viewport: u32, - viewport_count: u32, - p_shading_rate_palettes: *const ShadingRatePaletteNV, + device: Device, + validation_cache: ValidationCacheEXT, + p_allocator: *const AllocationCallbacks, ) -> c_void { - (self.cmd_set_viewport_shading_rate_palette_nv)( - command_buffer, - first_viewport, - viewport_count, - p_shading_rate_palettes, - ) + (self.destroy_validation_cache_ext)(device, validation_cache, p_allocator) } - #[doc = ""] - pub unsafe fn cmd_set_coarse_sample_order_nv( + #[doc = ""] + pub unsafe fn merge_validation_caches_ext( &self, - command_buffer: CommandBuffer, - sample_order_type: CoarseSampleOrderTypeNV, - custom_sample_order_count: u32, - p_custom_sample_orders: *const CoarseSampleOrderCustomNV, - ) -> c_void { - (self.cmd_set_coarse_sample_order_nv)( - command_buffer, - sample_order_type, - custom_sample_order_count, - p_custom_sample_orders, - ) + device: Device, + dst_cache: ValidationCacheEXT, + src_cache_count: u32, + p_src_caches: *const ValidationCacheEXT, + ) -> Result { + (self.merge_validation_caches_ext)(device, dst_cache, src_cache_count, p_src_caches) + } + #[doc = ""] + pub unsafe fn get_validation_cache_data_ext( + &self, + device: Device, + validation_cache: ValidationCacheEXT, + p_data_size: *mut usize, + p_data: *mut c_void, + ) -> Result { + (self.get_validation_cache_data_ext)(device, validation_cache, p_data_size, p_data) } } -#[doc = "Generated from \'VK_NV_shading_rate_image\'"] +#[doc = "Generated from \'VK_EXT_validation_cache\'"] impl StructureType { - pub const PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV: Self = Self(1_000_164_000); + pub const VALIDATION_CACHE_CREATE_INFO_EXT: Self = Self(1_000_160_000); } -#[doc = "Generated from \'VK_NV_shading_rate_image\'"] +#[doc = "Generated from \'VK_EXT_validation_cache\'"] impl StructureType { - pub const PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV: Self = Self(1_000_164_001); + pub const SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT: Self = Self(1_000_160_001); } -#[doc = "Generated from \'VK_NV_shading_rate_image\'"] -impl StructureType { - pub const PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV: Self = Self(1_000_164_002); +#[doc = "Generated from \'VK_EXT_validation_cache\'"] +impl ObjectType { + pub const VALIDATION_CACHE_EXT: Self = Self(1_000_160_000); } -#[doc = "Generated from \'VK_NV_shading_rate_image\'"] -impl ImageLayout { - pub const SHADING_RATE_OPTIMAL_NV: Self = Self(1_000_164_003); +impl ExtDescriptorIndexingFn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_descriptor_indexing\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 2u32; } -#[doc = "Generated from \'VK_NV_shading_rate_image\'"] -impl DynamicState { - pub const VIEWPORT_SHADING_RATE_PALETTE_NV: Self = Self(1_000_164_004); +pub struct ExtDescriptorIndexingFn {} +unsafe impl Send for ExtDescriptorIndexingFn {} +unsafe impl Sync for ExtDescriptorIndexingFn {} +impl ::std::clone::Clone for ExtDescriptorIndexingFn { + fn clone(&self) -> Self { + ExtDescriptorIndexingFn {} + } } -#[doc = "Generated from \'VK_NV_shading_rate_image\'"] -impl AccessFlags { - pub const SHADING_RATE_IMAGE_READ_NV: Self = Self(0b1000_0000_0000_0000_0000_0000); +impl ExtDescriptorIndexingFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + ExtDescriptorIndexingFn {} + } } -#[doc = "Generated from \'VK_NV_shading_rate_image\'"] -impl ImageUsageFlags { - pub const SHADING_RATE_IMAGE_NV: Self = Self(0b1_0000_0000); +#[doc = "Generated from \'VK_EXT_descriptor_indexing\'"] +impl StructureType { + pub const DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO_EXT: Self = + StructureType::DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO; } -#[doc = "Generated from \'VK_NV_shading_rate_image\'"] -impl PipelineStageFlags { - pub const SHADING_RATE_IMAGE_NV: Self = Self(0b100_0000_0000_0000_0000_0000); +#[doc = "Generated from \'VK_EXT_descriptor_indexing\'"] +impl StructureType { + pub const PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES_EXT: Self = + StructureType::PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES; } -#[doc = "Generated from \'VK_NV_shading_rate_image\'"] +#[doc = "Generated from \'VK_EXT_descriptor_indexing\'"] impl StructureType { - pub const PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV: Self = - Self(1_000_164_005); + pub const PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES_EXT: Self = + StructureType::PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES; } -#[doc = "Generated from \'VK_NV_shading_rate_image\'"] -impl DynamicState { - pub const VIEWPORT_COARSE_SAMPLE_ORDER_NV: Self = Self(1_000_164_006); +#[doc = "Generated from \'VK_EXT_descriptor_indexing\'"] +impl StructureType { + pub const DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO_EXT: Self = + StructureType::DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO; } -impl NvRayTracingFn { - pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_ray_tracing\0") - .expect("Wrong extension string") - } - pub const SPEC_VERSION: u32 = 3u32; +#[doc = "Generated from \'VK_EXT_descriptor_indexing\'"] +impl StructureType { + pub const DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT_EXT: Self = + StructureType::DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT; +} +#[doc = "Generated from \'VK_EXT_descriptor_indexing\'"] +impl DescriptorBindingFlags { + pub const UPDATE_AFTER_BIND_EXT: Self = DescriptorBindingFlags::UPDATE_AFTER_BIND; +} +#[doc = "Generated from \'VK_EXT_descriptor_indexing\'"] +impl DescriptorBindingFlags { + pub const UPDATE_UNUSED_WHILE_PENDING_EXT: Self = + DescriptorBindingFlags::UPDATE_UNUSED_WHILE_PENDING; +} +#[doc = "Generated from \'VK_EXT_descriptor_indexing\'"] +impl DescriptorBindingFlags { + pub const PARTIALLY_BOUND_EXT: Self = DescriptorBindingFlags::PARTIALLY_BOUND; +} +#[doc = "Generated from \'VK_EXT_descriptor_indexing\'"] +impl DescriptorBindingFlags { + pub const VARIABLE_DESCRIPTOR_COUNT_EXT: Self = + DescriptorBindingFlags::VARIABLE_DESCRIPTOR_COUNT; +} +#[doc = "Generated from \'VK_EXT_descriptor_indexing\'"] +impl DescriptorPoolCreateFlags { + pub const UPDATE_AFTER_BIND_EXT: Self = DescriptorPoolCreateFlags::UPDATE_AFTER_BIND; +} +#[doc = "Generated from \'VK_EXT_descriptor_indexing\'"] +impl DescriptorSetLayoutCreateFlags { + pub const UPDATE_AFTER_BIND_POOL_EXT: Self = + DescriptorSetLayoutCreateFlags::UPDATE_AFTER_BIND_POOL; +} +#[doc = "Generated from \'VK_EXT_descriptor_indexing\'"] +impl Result { + pub const ERROR_FRAGMENTATION_EXT: Self = Result::ERROR_FRAGMENTATION; +} +impl ExtShaderViewportIndexLayerFn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_shader_viewport_index_layer\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 1u32; +} +pub struct ExtShaderViewportIndexLayerFn {} +unsafe impl Send for ExtShaderViewportIndexLayerFn {} +unsafe impl Sync for ExtShaderViewportIndexLayerFn {} +impl ::std::clone::Clone for ExtShaderViewportIndexLayerFn { + fn clone(&self) -> Self { + ExtShaderViewportIndexLayerFn {} + } +} +impl ExtShaderViewportIndexLayerFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + ExtShaderViewportIndexLayerFn {} + } +} +impl KhrPortabilitySubsetFn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_portability_subset\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 1u32; +} +pub struct KhrPortabilitySubsetFn {} +unsafe impl Send for KhrPortabilitySubsetFn {} +unsafe impl Sync for KhrPortabilitySubsetFn {} +impl ::std::clone::Clone for KhrPortabilitySubsetFn { + fn clone(&self) -> Self { + KhrPortabilitySubsetFn {} + } +} +impl KhrPortabilitySubsetFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + KhrPortabilitySubsetFn {} + } +} +#[doc = "Generated from \'VK_KHR_portability_subset\'"] +impl StructureType { + pub const PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR: Self = Self(1_000_163_000); +} +#[doc = "Generated from \'VK_KHR_portability_subset\'"] +impl StructureType { + pub const PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR: Self = Self(1_000_163_001); +} +impl NvShadingRateImageFn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_shading_rate_image\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 3u32; } #[allow(non_camel_case_types)] -pub type PFN_vkCreateAccelerationStructureNV = extern "system" fn( - device: Device, - p_create_info: *const AccelerationStructureCreateInfoNV, - p_allocator: *const AllocationCallbacks, - p_acceleration_structure: *mut AccelerationStructureNV, -) -> Result; -#[allow(non_camel_case_types)] -pub type PFN_vkGetAccelerationStructureMemoryRequirementsNV = extern "system" fn( - device: Device, - acceleration_structure: AccelerationStructureKHR, - p_allocator: *const AllocationCallbacks, -) -> c_void; -#[allow(non_camel_case_types)] -pub type PFN_vkCmdBuildAccelerationStructureNV = extern "system" fn( - device: Device, - p_info: *const AccelerationStructureMemoryRequirementsInfoNV, - p_memory_requirements: *mut MemoryRequirements2KHR, -) -> c_void; -#[allow(non_camel_case_types)] -pub type PFN_vkCmdCopyAccelerationStructureNV = extern "system" fn( - device: Device, - bind_info_count: u32, - p_bind_infos: *const BindAccelerationStructureMemoryInfoKHR, -) -> Result; -#[allow(non_camel_case_types)] -pub type PFN_vkCmdTraceRaysNV = extern "system" fn( +pub type PFN_vkCmdBindShadingRateImageNV = extern "system" fn( command_buffer: CommandBuffer, - p_info: *const AccelerationStructureInfoNV, - instance_data: Buffer, - instance_offset: DeviceSize, - update: Bool32, - dst: AccelerationStructureKHR, - src: AccelerationStructureKHR, - scratch: Buffer, - scratch_offset: DeviceSize, + image_view: ImageView, + image_layout: ImageLayout, ) -> c_void; #[allow(non_camel_case_types)] -pub type PFN_vkCreateRayTracingPipelinesNV = extern "system" fn( +pub type PFN_vkCmdSetViewportShadingRatePaletteNV = extern "system" fn( command_buffer: CommandBuffer, - dst: AccelerationStructureKHR, - src: AccelerationStructureKHR, - mode: CopyAccelerationStructureModeKHR, + first_viewport: u32, + viewport_count: u32, + p_shading_rate_palettes: *const ShadingRatePaletteNV, ) -> c_void; #[allow(non_camel_case_types)] -pub type PFN_vkGetAccelerationStructureHandleNV = extern "system" fn( +pub type PFN_vkCmdSetCoarseSampleOrderNV = extern "system" fn( command_buffer: CommandBuffer, - raygen_shader_binding_table_buffer: Buffer, - raygen_shader_binding_offset: DeviceSize, - miss_shader_binding_table_buffer: Buffer, - miss_shader_binding_offset: DeviceSize, - miss_shader_binding_stride: DeviceSize, - hit_shader_binding_table_buffer: Buffer, - hit_shader_binding_offset: DeviceSize, - hit_shader_binding_stride: DeviceSize, - callable_shader_binding_table_buffer: Buffer, - callable_shader_binding_offset: DeviceSize, - callable_shader_binding_stride: DeviceSize, - width: u32, - height: u32, - depth: u32, + sample_order_type: CoarseSampleOrderTypeNV, + custom_sample_order_count: u32, + p_custom_sample_orders: *const CoarseSampleOrderCustomNV, ) -> c_void; -#[allow(non_camel_case_types)] -pub type PFN_vkCompileDeferredNV = extern "system" fn( - device: Device, - pipeline_cache: PipelineCache, - create_info_count: u32, - p_create_infos: *const RayTracingPipelineCreateInfoNV, - p_allocator: *const AllocationCallbacks, - p_pipelines: *mut Pipeline, -) -> Result; -pub struct NvRayTracingFn { - pub create_acceleration_structure_nv: extern "system" fn( - device: Device, - p_create_info: *const AccelerationStructureCreateInfoNV, - p_allocator: *const AllocationCallbacks, - p_acceleration_structure: *mut AccelerationStructureNV, - ) -> Result, - pub destroy_acceleration_structure_nv: extern "system" fn( - device: Device, - acceleration_structure: AccelerationStructureKHR, - p_allocator: *const AllocationCallbacks, - ) -> c_void, - pub get_acceleration_structure_memory_requirements_nv: extern "system" fn( - device: Device, - p_info: *const AccelerationStructureMemoryRequirementsInfoNV, - p_memory_requirements: *mut MemoryRequirements2KHR, - ) -> c_void, - pub bind_acceleration_structure_memory_nv: extern "system" fn( - device: Device, - bind_info_count: u32, - p_bind_infos: *const BindAccelerationStructureMemoryInfoKHR, - ) -> Result, - pub cmd_build_acceleration_structure_nv: extern "system" fn( - command_buffer: CommandBuffer, - p_info: *const AccelerationStructureInfoNV, - instance_data: Buffer, - instance_offset: DeviceSize, - update: Bool32, - dst: AccelerationStructureKHR, - src: AccelerationStructureKHR, - scratch: Buffer, - scratch_offset: DeviceSize, - ) -> c_void, - pub cmd_copy_acceleration_structure_nv: extern "system" fn( +pub struct NvShadingRateImageFn { + pub cmd_bind_shading_rate_image_nv: extern "system" fn( command_buffer: CommandBuffer, - dst: AccelerationStructureKHR, - src: AccelerationStructureKHR, - mode: CopyAccelerationStructureModeKHR, + image_view: ImageView, + image_layout: ImageLayout, ) -> c_void, - pub cmd_trace_rays_nv: extern "system" fn( + pub cmd_set_viewport_shading_rate_palette_nv: extern "system" fn( command_buffer: CommandBuffer, - raygen_shader_binding_table_buffer: Buffer, - raygen_shader_binding_offset: DeviceSize, - miss_shader_binding_table_buffer: Buffer, - miss_shader_binding_offset: DeviceSize, - miss_shader_binding_stride: DeviceSize, - hit_shader_binding_table_buffer: Buffer, - hit_shader_binding_offset: DeviceSize, - hit_shader_binding_stride: DeviceSize, - callable_shader_binding_table_buffer: Buffer, - callable_shader_binding_offset: DeviceSize, - callable_shader_binding_stride: DeviceSize, - width: u32, - height: u32, - depth: u32, + first_viewport: u32, + viewport_count: u32, + p_shading_rate_palettes: *const ShadingRatePaletteNV, ) -> c_void, - pub create_ray_tracing_pipelines_nv: extern "system" fn( - device: Device, - pipeline_cache: PipelineCache, - create_info_count: u32, - p_create_infos: *const RayTracingPipelineCreateInfoNV, - p_allocator: *const AllocationCallbacks, - p_pipelines: *mut Pipeline, - ) -> Result, - pub get_ray_tracing_shader_group_handles_nv: extern "system" fn( - device: Device, - pipeline: Pipeline, - first_group: u32, - group_count: u32, - data_size: usize, - p_data: *mut c_void, - ) -> Result, - pub get_acceleration_structure_handle_nv: extern "system" fn( - device: Device, - acceleration_structure: AccelerationStructureKHR, - data_size: usize, - p_data: *mut c_void, - ) -> Result, - pub cmd_write_acceleration_structures_properties_nv: extern "system" fn( + pub cmd_set_coarse_sample_order_nv: extern "system" fn( command_buffer: CommandBuffer, - acceleration_structure_count: u32, - p_acceleration_structures: *const AccelerationStructureKHR, - query_type: QueryType, - query_pool: QueryPool, - first_query: u32, + sample_order_type: CoarseSampleOrderTypeNV, + custom_sample_order_count: u32, + p_custom_sample_orders: *const CoarseSampleOrderCustomNV, ) -> c_void, - pub compile_deferred_nv: - extern "system" fn(device: Device, pipeline: Pipeline, shader: u32) -> Result, } -unsafe impl Send for NvRayTracingFn {} -unsafe impl Sync for NvRayTracingFn {} -impl ::std::clone::Clone for NvRayTracingFn { +unsafe impl Send for NvShadingRateImageFn {} +unsafe impl Sync for NvShadingRateImageFn {} +impl ::std::clone::Clone for NvShadingRateImageFn { fn clone(&self) -> Self { - NvRayTracingFn { - create_acceleration_structure_nv: self.create_acceleration_structure_nv, - destroy_acceleration_structure_nv: self.destroy_acceleration_structure_nv, - get_acceleration_structure_memory_requirements_nv: self - .get_acceleration_structure_memory_requirements_nv, - bind_acceleration_structure_memory_nv: self.bind_acceleration_structure_memory_nv, - cmd_build_acceleration_structure_nv: self.cmd_build_acceleration_structure_nv, - cmd_copy_acceleration_structure_nv: self.cmd_copy_acceleration_structure_nv, - cmd_trace_rays_nv: self.cmd_trace_rays_nv, - create_ray_tracing_pipelines_nv: self.create_ray_tracing_pipelines_nv, - get_ray_tracing_shader_group_handles_nv: self.get_ray_tracing_shader_group_handles_nv, - get_acceleration_structure_handle_nv: self.get_acceleration_structure_handle_nv, - cmd_write_acceleration_structures_properties_nv: self - .cmd_write_acceleration_structures_properties_nv, - compile_deferred_nv: self.compile_deferred_nv, + NvShadingRateImageFn { + cmd_bind_shading_rate_image_nv: self.cmd_bind_shading_rate_image_nv, + cmd_set_viewport_shading_rate_palette_nv: self.cmd_set_viewport_shading_rate_palette_nv, + cmd_set_coarse_sample_order_nv: self.cmd_set_coarse_sample_order_nv, } } } -impl NvRayTracingFn { +impl NvShadingRateImageFn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - NvRayTracingFn { - create_acceleration_structure_nv: unsafe { - extern "system" fn create_acceleration_structure_nv( - _device: Device, - _p_create_info: *const AccelerationStructureCreateInfoNV, - _p_allocator: *const AllocationCallbacks, - _p_acceleration_structure: *mut AccelerationStructureNV, - ) -> Result { + NvShadingRateImageFn { + cmd_bind_shading_rate_image_nv: unsafe { + extern "system" fn cmd_bind_shading_rate_image_nv( + _command_buffer: CommandBuffer, + _image_view: ImageView, + _image_layout: ImageLayout, + ) -> c_void { panic!(concat!( "Unable to load ", - stringify!(create_acceleration_structure_nv) - )) - } - let raw_name = stringify!(vkCreateAccelerationStructureNV); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - create_acceleration_structure_nv - } else { - ::std::mem::transmute(val) - } - }, - destroy_acceleration_structure_nv: unsafe { - extern "system" fn destroy_acceleration_structure_nv( - _device: Device, - _acceleration_structure: AccelerationStructureKHR, - _p_allocator: *const AllocationCallbacks, - ) -> c_void { - panic!(concat!( - "Unable to load ", - stringify!(destroy_acceleration_structure_nv) - )) - } - let raw_name = stringify!(vkDestroyAccelerationStructureNV); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - destroy_acceleration_structure_nv - } else { - ::std::mem::transmute(val) - } - }, - get_acceleration_structure_memory_requirements_nv: unsafe { - extern "system" fn get_acceleration_structure_memory_requirements_nv( - _device: Device, - _p_info: *const AccelerationStructureMemoryRequirementsInfoNV, - _p_memory_requirements: *mut MemoryRequirements2KHR, - ) -> c_void { - panic!(concat!( - "Unable to load ", - stringify!(get_acceleration_structure_memory_requirements_nv) - )) - } - let raw_name = stringify!(vkGetAccelerationStructureMemoryRequirementsNV); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - get_acceleration_structure_memory_requirements_nv - } else { - ::std::mem::transmute(val) - } - }, - bind_acceleration_structure_memory_nv: unsafe { - extern "system" fn bind_acceleration_structure_memory_nv( - _device: Device, - _bind_info_count: u32, - _p_bind_infos: *const BindAccelerationStructureMemoryInfoKHR, - ) -> Result { - panic!(concat!( - "Unable to load ", - stringify!(bind_acceleration_structure_memory_nv) - )) - } - let raw_name = stringify!(vkBindAccelerationStructureMemoryNV); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - bind_acceleration_structure_memory_nv - } else { - ::std::mem::transmute(val) - } - }, - cmd_build_acceleration_structure_nv: unsafe { - extern "system" fn cmd_build_acceleration_structure_nv( - _command_buffer: CommandBuffer, - _p_info: *const AccelerationStructureInfoNV, - _instance_data: Buffer, - _instance_offset: DeviceSize, - _update: Bool32, - _dst: AccelerationStructureKHR, - _src: AccelerationStructureKHR, - _scratch: Buffer, - _scratch_offset: DeviceSize, - ) -> c_void { - panic!(concat!( - "Unable to load ", - stringify!(cmd_build_acceleration_structure_nv) - )) - } - let raw_name = stringify!(vkCmdBuildAccelerationStructureNV); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - cmd_build_acceleration_structure_nv - } else { - ::std::mem::transmute(val) - } - }, - cmd_copy_acceleration_structure_nv: unsafe { - extern "system" fn cmd_copy_acceleration_structure_nv( - _command_buffer: CommandBuffer, - _dst: AccelerationStructureKHR, - _src: AccelerationStructureKHR, - _mode: CopyAccelerationStructureModeKHR, - ) -> c_void { - panic!(concat!( - "Unable to load ", - stringify!(cmd_copy_acceleration_structure_nv) + stringify!(cmd_bind_shading_rate_image_nv) )) } - let raw_name = stringify!(vkCmdCopyAccelerationStructureNV); + let raw_name = stringify!(vkCmdBindShadingRateImageNV); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - cmd_copy_acceleration_structure_nv + cmd_bind_shading_rate_image_nv } else { ::std::mem::transmute(val) } }, - cmd_trace_rays_nv: unsafe { - extern "system" fn cmd_trace_rays_nv( + cmd_set_viewport_shading_rate_palette_nv: unsafe { + extern "system" fn cmd_set_viewport_shading_rate_palette_nv( _command_buffer: CommandBuffer, - _raygen_shader_binding_table_buffer: Buffer, - _raygen_shader_binding_offset: DeviceSize, - _miss_shader_binding_table_buffer: Buffer, - _miss_shader_binding_offset: DeviceSize, - _miss_shader_binding_stride: DeviceSize, - _hit_shader_binding_table_buffer: Buffer, - _hit_shader_binding_offset: DeviceSize, - _hit_shader_binding_stride: DeviceSize, - _callable_shader_binding_table_buffer: Buffer, - _callable_shader_binding_offset: DeviceSize, - _callable_shader_binding_stride: DeviceSize, - _width: u32, - _height: u32, - _depth: u32, + _first_viewport: u32, + _viewport_count: u32, + _p_shading_rate_palettes: *const ShadingRatePaletteNV, ) -> c_void { - panic!(concat!("Unable to load ", stringify!(cmd_trace_rays_nv))) - } - let raw_name = stringify!(vkCmdTraceRaysNV); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - cmd_trace_rays_nv - } else { - ::std::mem::transmute(val) - } - }, - create_ray_tracing_pipelines_nv: unsafe { - extern "system" fn create_ray_tracing_pipelines_nv( - _device: Device, - _pipeline_cache: PipelineCache, - _create_info_count: u32, - _p_create_infos: *const RayTracingPipelineCreateInfoNV, - _p_allocator: *const AllocationCallbacks, - _p_pipelines: *mut Pipeline, - ) -> Result { - panic!(concat!( - "Unable to load ", - stringify!(create_ray_tracing_pipelines_nv) - )) - } - let raw_name = stringify!(vkCreateRayTracingPipelinesNV); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - create_ray_tracing_pipelines_nv - } else { - ::std::mem::transmute(val) - } - }, - get_ray_tracing_shader_group_handles_nv: unsafe { - extern "system" fn get_ray_tracing_shader_group_handles_nv( - _device: Device, - _pipeline: Pipeline, - _first_group: u32, - _group_count: u32, - _data_size: usize, - _p_data: *mut c_void, - ) -> Result { - panic!(concat!( - "Unable to load ", - stringify!(get_ray_tracing_shader_group_handles_nv) - )) - } - let raw_name = stringify!(vkGetRayTracingShaderGroupHandlesNV); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - get_ray_tracing_shader_group_handles_nv - } else { - ::std::mem::transmute(val) - } - }, - get_acceleration_structure_handle_nv: unsafe { - extern "system" fn get_acceleration_structure_handle_nv( - _device: Device, - _acceleration_structure: AccelerationStructureKHR, - _data_size: usize, - _p_data: *mut c_void, - ) -> Result { panic!(concat!( "Unable to load ", - stringify!(get_acceleration_structure_handle_nv) + stringify!(cmd_set_viewport_shading_rate_palette_nv) )) } - let raw_name = stringify!(vkGetAccelerationStructureHandleNV); + let raw_name = stringify!(vkCmdSetViewportShadingRatePaletteNV); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - get_acceleration_structure_handle_nv + cmd_set_viewport_shading_rate_palette_nv } else { ::std::mem::transmute(val) } }, - cmd_write_acceleration_structures_properties_nv: unsafe { - extern "system" fn cmd_write_acceleration_structures_properties_nv( + cmd_set_coarse_sample_order_nv: unsafe { + extern "system" fn cmd_set_coarse_sample_order_nv( _command_buffer: CommandBuffer, - _acceleration_structure_count: u32, - _p_acceleration_structures: *const AccelerationStructureKHR, - _query_type: QueryType, - _query_pool: QueryPool, - _first_query: u32, + _sample_order_type: CoarseSampleOrderTypeNV, + _custom_sample_order_count: u32, + _p_custom_sample_orders: *const CoarseSampleOrderCustomNV, ) -> c_void { panic!(concat!( "Unable to load ", - stringify!(cmd_write_acceleration_structures_properties_nv) + stringify!(cmd_set_coarse_sample_order_nv) )) } - let raw_name = stringify!(vkCmdWriteAccelerationStructuresPropertiesNV); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - cmd_write_acceleration_structures_properties_nv - } else { - ::std::mem::transmute(val) - } - }, - compile_deferred_nv: unsafe { - extern "system" fn compile_deferred_nv( - _device: Device, - _pipeline: Pipeline, - _shader: u32, - ) -> Result { - panic!(concat!("Unable to load ", stringify!(compile_deferred_nv))) - } - let raw_name = stringify!(vkCompileDeferredNV); + let raw_name = stringify!(vkCmdSetCoarseSampleOrderNV); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - compile_deferred_nv + cmd_set_coarse_sample_order_nv } else { ::std::mem::transmute(val) } }, } } - #[doc = ""] - pub unsafe fn create_acceleration_structure_nv( + #[doc = ""] + pub unsafe fn cmd_bind_shading_rate_image_nv( &self, - device: Device, - p_create_info: *const AccelerationStructureCreateInfoNV, - p_allocator: *const AllocationCallbacks, - p_acceleration_structure: *mut AccelerationStructureNV, - ) -> Result { - (self.create_acceleration_structure_nv)( - device, - p_create_info, - p_allocator, - p_acceleration_structure, - ) + command_buffer: CommandBuffer, + image_view: ImageView, + image_layout: ImageLayout, + ) -> c_void { + (self.cmd_bind_shading_rate_image_nv)(command_buffer, image_view, image_layout) } - #[doc = ""] - pub unsafe fn destroy_acceleration_structure_nv( + #[doc = ""] + pub unsafe fn cmd_set_viewport_shading_rate_palette_nv( &self, - device: Device, - acceleration_structure: AccelerationStructureKHR, - p_allocator: *const AllocationCallbacks, + command_buffer: CommandBuffer, + first_viewport: u32, + viewport_count: u32, + p_shading_rate_palettes: *const ShadingRatePaletteNV, ) -> c_void { - (self.destroy_acceleration_structure_nv)(device, acceleration_structure, p_allocator) + (self.cmd_set_viewport_shading_rate_palette_nv)( + command_buffer, + first_viewport, + viewport_count, + p_shading_rate_palettes, + ) } - #[doc = ""] - pub unsafe fn get_acceleration_structure_memory_requirements_nv( + #[doc = ""] + pub unsafe fn cmd_set_coarse_sample_order_nv( &self, - device: Device, - p_info: *const AccelerationStructureMemoryRequirementsInfoNV, - p_memory_requirements: *mut MemoryRequirements2KHR, + command_buffer: CommandBuffer, + sample_order_type: CoarseSampleOrderTypeNV, + custom_sample_order_count: u32, + p_custom_sample_orders: *const CoarseSampleOrderCustomNV, ) -> c_void { - (self.get_acceleration_structure_memory_requirements_nv)( - device, - p_info, - p_memory_requirements, + (self.cmd_set_coarse_sample_order_nv)( + command_buffer, + sample_order_type, + custom_sample_order_count, + p_custom_sample_orders, ) } - #[doc = ""] - pub unsafe fn bind_acceleration_structure_memory_nv( - &self, +} +#[doc = "Generated from \'VK_NV_shading_rate_image\'"] +impl StructureType { + pub const PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV: Self = Self(1_000_164_000); +} +#[doc = "Generated from \'VK_NV_shading_rate_image\'"] +impl StructureType { + pub const PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV: Self = Self(1_000_164_001); +} +#[doc = "Generated from \'VK_NV_shading_rate_image\'"] +impl StructureType { + pub const PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV: Self = Self(1_000_164_002); +} +#[doc = "Generated from \'VK_NV_shading_rate_image\'"] +impl ImageLayout { + pub const SHADING_RATE_OPTIMAL_NV: Self = Self(1_000_164_003); +} +#[doc = "Generated from \'VK_NV_shading_rate_image\'"] +impl DynamicState { + pub const VIEWPORT_SHADING_RATE_PALETTE_NV: Self = Self(1_000_164_004); +} +#[doc = "Generated from \'VK_NV_shading_rate_image\'"] +impl AccessFlags { + pub const SHADING_RATE_IMAGE_READ_NV: Self = Self(0b1000_0000_0000_0000_0000_0000); +} +#[doc = "Generated from \'VK_NV_shading_rate_image\'"] +impl ImageUsageFlags { + pub const SHADING_RATE_IMAGE_NV: Self = Self(0b1_0000_0000); +} +#[doc = "Generated from \'VK_NV_shading_rate_image\'"] +impl PipelineStageFlags { + pub const SHADING_RATE_IMAGE_NV: Self = Self(0b100_0000_0000_0000_0000_0000); +} +#[doc = "Generated from \'VK_NV_shading_rate_image\'"] +impl StructureType { + pub const PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV: Self = + Self(1_000_164_005); +} +#[doc = "Generated from \'VK_NV_shading_rate_image\'"] +impl DynamicState { + pub const VIEWPORT_COARSE_SAMPLE_ORDER_NV: Self = Self(1_000_164_006); +} +impl NvRayTracingFn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_ray_tracing\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 3u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkCreateAccelerationStructureNV = extern "system" fn( + device: Device, + p_create_info: *const AccelerationStructureCreateInfoNV, + p_allocator: *const AllocationCallbacks, + p_acceleration_structure: *mut AccelerationStructureNV, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkDestroyAccelerationStructureNV = extern "system" fn( + device: Device, + acceleration_structure: AccelerationStructureNV, + p_allocator: *const AllocationCallbacks, +) -> c_void; +#[allow(non_camel_case_types)] +pub type PFN_vkGetAccelerationStructureMemoryRequirementsNV = extern "system" fn( + device: Device, + p_info: *const AccelerationStructureMemoryRequirementsInfoNV, + p_memory_requirements: *mut MemoryRequirements2KHR, +) -> c_void; +#[allow(non_camel_case_types)] +pub type PFN_vkBindAccelerationStructureMemoryNV = extern "system" fn( + device: Device, + bind_info_count: u32, + p_bind_infos: *const BindAccelerationStructureMemoryInfoNV, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkCmdBuildAccelerationStructureNV = extern "system" fn( + command_buffer: CommandBuffer, + p_info: *const AccelerationStructureInfoNV, + instance_data: Buffer, + instance_offset: DeviceSize, + update: Bool32, + dst: AccelerationStructureNV, + src: AccelerationStructureNV, + scratch: Buffer, + scratch_offset: DeviceSize, +) -> c_void; +#[allow(non_camel_case_types)] +pub type PFN_vkCmdCopyAccelerationStructureNV = extern "system" fn( + command_buffer: CommandBuffer, + dst: AccelerationStructureNV, + src: AccelerationStructureNV, + mode: CopyAccelerationStructureModeKHR, +) -> c_void; +#[allow(non_camel_case_types)] +pub type PFN_vkCmdTraceRaysNV = extern "system" fn( + command_buffer: CommandBuffer, + raygen_shader_binding_table_buffer: Buffer, + raygen_shader_binding_offset: DeviceSize, + miss_shader_binding_table_buffer: Buffer, + miss_shader_binding_offset: DeviceSize, + miss_shader_binding_stride: DeviceSize, + hit_shader_binding_table_buffer: Buffer, + hit_shader_binding_offset: DeviceSize, + hit_shader_binding_stride: DeviceSize, + callable_shader_binding_table_buffer: Buffer, + callable_shader_binding_offset: DeviceSize, + callable_shader_binding_stride: DeviceSize, + width: u32, + height: u32, + depth: u32, +) -> c_void; +#[allow(non_camel_case_types)] +pub type PFN_vkCreateRayTracingPipelinesNV = extern "system" fn( + device: Device, + pipeline_cache: PipelineCache, + create_info_count: u32, + p_create_infos: *const RayTracingPipelineCreateInfoNV, + p_allocator: *const AllocationCallbacks, + p_pipelines: *mut Pipeline, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetAccelerationStructureHandleNV = extern "system" fn( + device: Device, + pipeline: Pipeline, + first_group: u32, + group_count: u32, + data_size: usize, + p_data: *mut c_void, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkCmdWriteAccelerationStructuresPropertiesNV = extern "system" fn( + device: Device, + acceleration_structure: AccelerationStructureNV, + data_size: usize, + p_data: *mut c_void, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkCompileDeferredNV = extern "system" fn( + command_buffer: CommandBuffer, + acceleration_structure_count: u32, + p_acceleration_structures: *const AccelerationStructureNV, + query_type: QueryType, + query_pool: QueryPool, + first_query: u32, +) -> c_void; +pub struct NvRayTracingFn { + pub create_acceleration_structure_nv: extern "system" fn( + device: Device, + p_create_info: *const AccelerationStructureCreateInfoNV, + p_allocator: *const AllocationCallbacks, + p_acceleration_structure: *mut AccelerationStructureNV, + ) -> Result, + pub destroy_acceleration_structure_nv: extern "system" fn( + device: Device, + acceleration_structure: AccelerationStructureNV, + p_allocator: *const AllocationCallbacks, + ) -> c_void, + pub get_acceleration_structure_memory_requirements_nv: extern "system" fn( + device: Device, + p_info: *const AccelerationStructureMemoryRequirementsInfoNV, + p_memory_requirements: *mut MemoryRequirements2KHR, + ) -> c_void, + pub bind_acceleration_structure_memory_nv: extern "system" fn( device: Device, bind_info_count: u32, - p_bind_infos: *const BindAccelerationStructureMemoryInfoKHR, - ) -> Result { - (self.bind_acceleration_structure_memory_nv)(device, bind_info_count, p_bind_infos) - } - #[doc = ""] - pub unsafe fn cmd_build_acceleration_structure_nv( - &self, + p_bind_infos: *const BindAccelerationStructureMemoryInfoNV, + ) -> Result, + pub cmd_build_acceleration_structure_nv: extern "system" fn( command_buffer: CommandBuffer, p_info: *const AccelerationStructureInfoNV, instance_data: Buffer, instance_offset: DeviceSize, update: Bool32, - dst: AccelerationStructureKHR, - src: AccelerationStructureKHR, + dst: AccelerationStructureNV, + src: AccelerationStructureNV, scratch: Buffer, scratch_offset: DeviceSize, - ) -> c_void { - (self.cmd_build_acceleration_structure_nv)( - command_buffer, - p_info, - instance_data, - instance_offset, - update, - dst, - src, - scratch, - scratch_offset, - ) - } - #[doc = ""] - pub unsafe fn cmd_copy_acceleration_structure_nv( - &self, + ) -> c_void, + pub cmd_copy_acceleration_structure_nv: extern "system" fn( command_buffer: CommandBuffer, - dst: AccelerationStructureKHR, - src: AccelerationStructureKHR, + dst: AccelerationStructureNV, + src: AccelerationStructureNV, mode: CopyAccelerationStructureModeKHR, - ) -> c_void { - (self.cmd_copy_acceleration_structure_nv)(command_buffer, dst, src, mode) - } - #[doc = ""] - pub unsafe fn cmd_trace_rays_nv( - &self, + ) -> c_void, + pub cmd_trace_rays_nv: extern "system" fn( command_buffer: CommandBuffer, raygen_shader_binding_table_buffer: Buffer, raygen_shader_binding_offset: DeviceSize, @@ -14865,7278 +14655,10284 @@ impl NvRayTracingFn { width: u32, height: u32, depth: u32, - ) -> c_void { - (self.cmd_trace_rays_nv)( - command_buffer, - raygen_shader_binding_table_buffer, - raygen_shader_binding_offset, - miss_shader_binding_table_buffer, - miss_shader_binding_offset, - miss_shader_binding_stride, - hit_shader_binding_table_buffer, - hit_shader_binding_offset, - hit_shader_binding_stride, - callable_shader_binding_table_buffer, - callable_shader_binding_offset, - callable_shader_binding_stride, - width, - height, - depth, - ) - } - #[doc = ""] - pub unsafe fn create_ray_tracing_pipelines_nv( - &self, + ) -> c_void, + pub create_ray_tracing_pipelines_nv: extern "system" fn( device: Device, pipeline_cache: PipelineCache, create_info_count: u32, p_create_infos: *const RayTracingPipelineCreateInfoNV, p_allocator: *const AllocationCallbacks, p_pipelines: *mut Pipeline, - ) -> Result { - (self.create_ray_tracing_pipelines_nv)( - device, - pipeline_cache, - create_info_count, - p_create_infos, - p_allocator, - p_pipelines, - ) - } - #[doc = ""] - pub unsafe fn get_ray_tracing_shader_group_handles_nv( - &self, + ) -> Result, + pub get_ray_tracing_shader_group_handles_nv: extern "system" fn( device: Device, pipeline: Pipeline, first_group: u32, group_count: u32, data_size: usize, p_data: *mut c_void, - ) -> Result { - (self.get_ray_tracing_shader_group_handles_nv)( - device, - pipeline, - first_group, - group_count, - data_size, - p_data, - ) - } - #[doc = ""] - pub unsafe fn get_acceleration_structure_handle_nv( - &self, + ) -> Result, + pub get_acceleration_structure_handle_nv: extern "system" fn( device: Device, - acceleration_structure: AccelerationStructureKHR, + acceleration_structure: AccelerationStructureNV, data_size: usize, p_data: *mut c_void, - ) -> Result { - (self.get_acceleration_structure_handle_nv)( - device, - acceleration_structure, - data_size, - p_data, - ) - } - #[doc = ""] - pub unsafe fn cmd_write_acceleration_structures_properties_nv( - &self, + ) -> Result, + pub cmd_write_acceleration_structures_properties_nv: extern "system" fn( command_buffer: CommandBuffer, acceleration_structure_count: u32, - p_acceleration_structures: *const AccelerationStructureKHR, + p_acceleration_structures: *const AccelerationStructureNV, query_type: QueryType, query_pool: QueryPool, first_query: u32, - ) -> c_void { - (self.cmd_write_acceleration_structures_properties_nv)( - command_buffer, - acceleration_structure_count, - p_acceleration_structures, - query_type, - query_pool, - first_query, - ) - } - #[doc = ""] - pub unsafe fn compile_deferred_nv( - &self, - device: Device, - pipeline: Pipeline, - shader: u32, - ) -> Result { - (self.compile_deferred_nv)(device, pipeline, shader) - } -} -#[doc = "Generated from \'VK_NV_ray_tracing\'"] -impl StructureType { - pub const RAY_TRACING_PIPELINE_CREATE_INFO_NV: Self = Self(1_000_165_000); -} -#[doc = "Generated from \'VK_NV_ray_tracing\'"] -impl StructureType { - pub const ACCELERATION_STRUCTURE_CREATE_INFO_NV: Self = Self(1_000_165_001); -} -#[doc = "Generated from \'VK_NV_ray_tracing\'"] -impl StructureType { - pub const GEOMETRY_NV: Self = Self(1_000_165_003); -} -#[doc = "Generated from \'VK_NV_ray_tracing\'"] -impl StructureType { - pub const GEOMETRY_TRIANGLES_NV: Self = Self(1_000_165_004); -} -#[doc = "Generated from \'VK_NV_ray_tracing\'"] -impl StructureType { - pub const GEOMETRY_AABB_NV: Self = Self(1_000_165_005); -} -#[doc = "Generated from \'VK_NV_ray_tracing\'"] -impl StructureType { - pub const BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NV: Self = - StructureType::BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_KHR; -} -#[doc = "Generated from \'VK_NV_ray_tracing\'"] -impl StructureType { - pub const WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV: Self = - StructureType::WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR; -} -#[doc = "Generated from \'VK_NV_ray_tracing\'"] -impl StructureType { - pub const ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV: Self = Self(1_000_165_008); -} -#[doc = "Generated from \'VK_NV_ray_tracing\'"] -impl StructureType { - pub const PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV: Self = Self(1_000_165_009); -} -#[doc = "Generated from \'VK_NV_ray_tracing\'"] -impl StructureType { - pub const RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV: Self = Self(1_000_165_011); -} -#[doc = "Generated from \'VK_NV_ray_tracing\'"] -impl StructureType { - pub const ACCELERATION_STRUCTURE_INFO_NV: Self = Self(1_000_165_012); -} -#[doc = "Generated from \'VK_NV_ray_tracing\'"] -impl ShaderStageFlags { - pub const RAYGEN_NV: Self = ShaderStageFlags::RAYGEN_KHR; -} -#[doc = "Generated from \'VK_NV_ray_tracing\'"] -impl ShaderStageFlags { - pub const ANY_HIT_NV: Self = ShaderStageFlags::ANY_HIT_KHR; -} -#[doc = "Generated from \'VK_NV_ray_tracing\'"] -impl ShaderStageFlags { - pub const CLOSEST_HIT_NV: Self = ShaderStageFlags::CLOSEST_HIT_KHR; -} -#[doc = "Generated from \'VK_NV_ray_tracing\'"] -impl ShaderStageFlags { - pub const MISS_NV: Self = ShaderStageFlags::MISS_KHR; -} -#[doc = "Generated from \'VK_NV_ray_tracing\'"] -impl ShaderStageFlags { - pub const INTERSECTION_NV: Self = ShaderStageFlags::INTERSECTION_KHR; -} -#[doc = "Generated from \'VK_NV_ray_tracing\'"] -impl ShaderStageFlags { - pub const CALLABLE_NV: Self = ShaderStageFlags::CALLABLE_KHR; -} -#[doc = "Generated from \'VK_NV_ray_tracing\'"] -impl PipelineStageFlags { - pub const RAY_TRACING_SHADER_NV: Self = PipelineStageFlags::RAY_TRACING_SHADER_KHR; -} -#[doc = "Generated from \'VK_NV_ray_tracing\'"] -impl PipelineStageFlags { - pub const ACCELERATION_STRUCTURE_BUILD_NV: Self = - PipelineStageFlags::ACCELERATION_STRUCTURE_BUILD_KHR; -} -#[doc = "Generated from \'VK_NV_ray_tracing\'"] -impl BufferUsageFlags { - pub const RAY_TRACING_NV: Self = BufferUsageFlags::RAY_TRACING_KHR; -} -#[doc = "Generated from \'VK_NV_ray_tracing\'"] -impl PipelineBindPoint { - pub const RAY_TRACING_NV: Self = PipelineBindPoint::RAY_TRACING_KHR; -} -#[doc = "Generated from \'VK_NV_ray_tracing\'"] -impl DescriptorType { - pub const ACCELERATION_STRUCTURE_NV: Self = DescriptorType::ACCELERATION_STRUCTURE_KHR; -} -#[doc = "Generated from \'VK_NV_ray_tracing\'"] -impl AccessFlags { - pub const ACCELERATION_STRUCTURE_READ_NV: Self = AccessFlags::ACCELERATION_STRUCTURE_READ_KHR; -} -#[doc = "Generated from \'VK_NV_ray_tracing\'"] -impl AccessFlags { - pub const ACCELERATION_STRUCTURE_WRITE_NV: Self = AccessFlags::ACCELERATION_STRUCTURE_WRITE_KHR; -} -#[doc = "Generated from \'VK_NV_ray_tracing\'"] -impl QueryType { - pub const ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV: Self = - QueryType::ACCELERATION_STRUCTURE_COMPACTED_SIZE_KHR; -} -#[doc = "Generated from \'VK_NV_ray_tracing\'"] -impl PipelineCreateFlags { - pub const DEFER_COMPILE_NV: Self = Self(0b10_0000); -} -#[doc = "Generated from \'VK_NV_ray_tracing\'"] -impl ObjectType { - pub const ACCELERATION_STRUCTURE_NV: Self = ObjectType::ACCELERATION_STRUCTURE_KHR; -} -#[doc = "Generated from \'VK_NV_ray_tracing\'"] -impl DebugReportObjectTypeEXT { - pub const ACCELERATION_STRUCTURE_NV: Self = - DebugReportObjectTypeEXT::ACCELERATION_STRUCTURE_KHR; -} -#[doc = "Generated from \'VK_NV_ray_tracing\'"] -impl IndexType { - pub const NONE_NV: Self = IndexType::NONE_KHR; -} -#[doc = "Generated from \'VK_NV_ray_tracing\'"] -impl RayTracingShaderGroupTypeKHR { - pub const GENERAL_NV: Self = RayTracingShaderGroupTypeKHR::GENERAL; -} -#[doc = "Generated from \'VK_NV_ray_tracing\'"] -impl RayTracingShaderGroupTypeKHR { - pub const TRIANGLES_HIT_GROUP_NV: Self = RayTracingShaderGroupTypeKHR::TRIANGLES_HIT_GROUP; -} -#[doc = "Generated from \'VK_NV_ray_tracing\'"] -impl RayTracingShaderGroupTypeKHR { - pub const PROCEDURAL_HIT_GROUP_NV: Self = RayTracingShaderGroupTypeKHR::PROCEDURAL_HIT_GROUP; -} -#[doc = "Generated from \'VK_NV_ray_tracing\'"] -impl GeometryTypeKHR { - pub const TRIANGLES_NV: Self = GeometryTypeKHR::TRIANGLES; -} -#[doc = "Generated from \'VK_NV_ray_tracing\'"] -impl GeometryTypeKHR { - pub const AABBS_NV: Self = GeometryTypeKHR::AABBS; -} -#[doc = "Generated from \'VK_NV_ray_tracing\'"] -impl AccelerationStructureTypeKHR { - pub const TOP_LEVEL_NV: Self = AccelerationStructureTypeKHR::TOP_LEVEL; -} -#[doc = "Generated from \'VK_NV_ray_tracing\'"] -impl AccelerationStructureTypeKHR { - pub const BOTTOM_LEVEL_NV: Self = AccelerationStructureTypeKHR::BOTTOM_LEVEL; -} -#[doc = "Generated from \'VK_NV_ray_tracing\'"] -impl GeometryFlagsKHR { - pub const OPAQUE_NV: Self = GeometryFlagsKHR::OPAQUE; -} -#[doc = "Generated from \'VK_NV_ray_tracing\'"] -impl GeometryFlagsKHR { - pub const NO_DUPLICATE_ANY_HIT_INVOCATION_NV: Self = - GeometryFlagsKHR::NO_DUPLICATE_ANY_HIT_INVOCATION; -} -#[doc = "Generated from \'VK_NV_ray_tracing\'"] -impl GeometryInstanceFlagsKHR { - pub const TRIANGLE_CULL_DISABLE_NV: Self = - GeometryInstanceFlagsKHR::TRIANGLE_FACING_CULL_DISABLE; -} -#[doc = "Generated from \'VK_NV_ray_tracing\'"] -impl GeometryInstanceFlagsKHR { - pub const TRIANGLE_FRONT_COUNTERCLOCKWISE_NV: Self = - GeometryInstanceFlagsKHR::TRIANGLE_FRONT_COUNTERCLOCKWISE; -} -#[doc = "Generated from \'VK_NV_ray_tracing\'"] -impl GeometryInstanceFlagsKHR { - pub const FORCE_OPAQUE_NV: Self = GeometryInstanceFlagsKHR::FORCE_OPAQUE; -} -#[doc = "Generated from \'VK_NV_ray_tracing\'"] -impl GeometryInstanceFlagsKHR { - pub const FORCE_NO_OPAQUE_NV: Self = GeometryInstanceFlagsKHR::FORCE_NO_OPAQUE; -} -#[doc = "Generated from \'VK_NV_ray_tracing\'"] -impl BuildAccelerationStructureFlagsKHR { - pub const ALLOW_UPDATE_NV: Self = BuildAccelerationStructureFlagsKHR::ALLOW_UPDATE; -} -#[doc = "Generated from \'VK_NV_ray_tracing\'"] -impl BuildAccelerationStructureFlagsKHR { - pub const ALLOW_COMPACTION_NV: Self = BuildAccelerationStructureFlagsKHR::ALLOW_COMPACTION; + ) -> c_void, + pub compile_deferred_nv: + extern "system" fn(device: Device, pipeline: Pipeline, shader: u32) -> Result, } -#[doc = "Generated from \'VK_NV_ray_tracing\'"] -impl BuildAccelerationStructureFlagsKHR { - pub const PREFER_FAST_TRACE_NV: Self = BuildAccelerationStructureFlagsKHR::PREFER_FAST_TRACE; +unsafe impl Send for NvRayTracingFn {} +unsafe impl Sync for NvRayTracingFn {} +impl ::std::clone::Clone for NvRayTracingFn { + fn clone(&self) -> Self { + NvRayTracingFn { + create_acceleration_structure_nv: self.create_acceleration_structure_nv, + destroy_acceleration_structure_nv: self.destroy_acceleration_structure_nv, + get_acceleration_structure_memory_requirements_nv: self + .get_acceleration_structure_memory_requirements_nv, + bind_acceleration_structure_memory_nv: self.bind_acceleration_structure_memory_nv, + cmd_build_acceleration_structure_nv: self.cmd_build_acceleration_structure_nv, + cmd_copy_acceleration_structure_nv: self.cmd_copy_acceleration_structure_nv, + cmd_trace_rays_nv: self.cmd_trace_rays_nv, + create_ray_tracing_pipelines_nv: self.create_ray_tracing_pipelines_nv, + get_ray_tracing_shader_group_handles_nv: self.get_ray_tracing_shader_group_handles_nv, + get_acceleration_structure_handle_nv: self.get_acceleration_structure_handle_nv, + cmd_write_acceleration_structures_properties_nv: self + .cmd_write_acceleration_structures_properties_nv, + compile_deferred_nv: self.compile_deferred_nv, + } + } } -#[doc = "Generated from \'VK_NV_ray_tracing\'"] -impl BuildAccelerationStructureFlagsKHR { - pub const PREFER_FAST_BUILD_NV: Self = BuildAccelerationStructureFlagsKHR::PREFER_FAST_BUILD; -} -#[doc = "Generated from \'VK_NV_ray_tracing\'"] -impl BuildAccelerationStructureFlagsKHR { - pub const LOW_MEMORY_NV: Self = BuildAccelerationStructureFlagsKHR::LOW_MEMORY; -} -#[doc = "Generated from \'VK_NV_ray_tracing\'"] -impl CopyAccelerationStructureModeKHR { - pub const CLONE_NV: Self = CopyAccelerationStructureModeKHR::CLONE; -} -#[doc = "Generated from \'VK_NV_ray_tracing\'"] -impl CopyAccelerationStructureModeKHR { - pub const COMPACT_NV: Self = CopyAccelerationStructureModeKHR::COMPACT; -} -#[doc = "Generated from \'VK_NV_ray_tracing\'"] -impl AccelerationStructureMemoryRequirementsTypeKHR { - pub const OBJECT_NV: Self = AccelerationStructureMemoryRequirementsTypeKHR::OBJECT; -} -#[doc = "Generated from \'VK_NV_ray_tracing\'"] -impl AccelerationStructureMemoryRequirementsTypeKHR { - pub const BUILD_SCRATCH_NV: Self = - AccelerationStructureMemoryRequirementsTypeKHR::BUILD_SCRATCH; -} -#[doc = "Generated from \'VK_NV_ray_tracing\'"] -impl AccelerationStructureMemoryRequirementsTypeKHR { - pub const UPDATE_SCRATCH_NV: Self = - AccelerationStructureMemoryRequirementsTypeKHR::UPDATE_SCRATCH; -} -impl NvRepresentativeFragmentTestFn { - pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_representative_fragment_test\0") - .expect("Wrong extension string") - } - pub const SPEC_VERSION: u32 = 2u32; -} -pub struct NvRepresentativeFragmentTestFn {} -unsafe impl Send for NvRepresentativeFragmentTestFn {} -unsafe impl Sync for NvRepresentativeFragmentTestFn {} -impl ::std::clone::Clone for NvRepresentativeFragmentTestFn { - fn clone(&self) -> Self { - NvRepresentativeFragmentTestFn {} - } -} -impl NvRepresentativeFragmentTestFn { - pub fn load(mut _f: F) -> Self - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - NvRepresentativeFragmentTestFn {} - } -} -#[doc = "Generated from \'VK_NV_representative_fragment_test\'"] -impl StructureType { - pub const PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV: Self = Self(1_000_166_000); -} -#[doc = "Generated from \'VK_NV_representative_fragment_test\'"] -impl StructureType { - pub const PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV: Self = - Self(1_000_166_001); -} -impl NvExtension168Fn { - pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_extension_168\0") - .expect("Wrong extension string") - } - pub const SPEC_VERSION: u32 = 0u32; -} -pub struct NvExtension168Fn {} -unsafe impl Send for NvExtension168Fn {} -unsafe impl Sync for NvExtension168Fn {} -impl ::std::clone::Clone for NvExtension168Fn { - fn clone(&self) -> Self { - NvExtension168Fn {} - } -} -impl NvExtension168Fn { - pub fn load(mut _f: F) -> Self - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - NvExtension168Fn {} - } -} -impl KhrMaintenance3Fn { - pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_maintenance3\0") - .expect("Wrong extension string") - } - pub const SPEC_VERSION: u32 = 1u32; -} -#[allow(non_camel_case_types)] -pub type PFN_vkGetDescriptorSetLayoutSupport = extern "system" fn( - device: Device, - p_create_info: *const DescriptorSetLayoutCreateInfo, - p_support: *mut DescriptorSetLayoutSupport, -) -> c_void; -pub struct KhrMaintenance3Fn { - pub get_descriptor_set_layout_support_khr: extern "system" fn( - device: Device, - p_create_info: *const DescriptorSetLayoutCreateInfo, - p_support: *mut DescriptorSetLayoutSupport, - ) -> c_void, -} -unsafe impl Send for KhrMaintenance3Fn {} -unsafe impl Sync for KhrMaintenance3Fn {} -impl ::std::clone::Clone for KhrMaintenance3Fn { - fn clone(&self) -> Self { - KhrMaintenance3Fn { - get_descriptor_set_layout_support_khr: self.get_descriptor_set_layout_support_khr, - } - } -} -impl KhrMaintenance3Fn { +impl NvRayTracingFn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - KhrMaintenance3Fn { - get_descriptor_set_layout_support_khr: unsafe { - extern "system" fn get_descriptor_set_layout_support_khr( + NvRayTracingFn { + create_acceleration_structure_nv: unsafe { + extern "system" fn create_acceleration_structure_nv( _device: Device, - _p_create_info: *const DescriptorSetLayoutCreateInfo, - _p_support: *mut DescriptorSetLayoutSupport, - ) -> c_void { + _p_create_info: *const AccelerationStructureCreateInfoNV, + _p_allocator: *const AllocationCallbacks, + _p_acceleration_structure: *mut AccelerationStructureNV, + ) -> Result { panic!(concat!( "Unable to load ", - stringify!(get_descriptor_set_layout_support_khr) + stringify!(create_acceleration_structure_nv) )) } - let raw_name = stringify!(vkGetDescriptorSetLayoutSupportKHR); + let raw_name = stringify!(vkCreateAccelerationStructureNV); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - get_descriptor_set_layout_support_khr + create_acceleration_structure_nv } else { ::std::mem::transmute(val) } }, - } - } - #[doc = ""] - pub unsafe fn get_descriptor_set_layout_support_khr( - &self, - device: Device, - p_create_info: *const DescriptorSetLayoutCreateInfo, - p_support: *mut DescriptorSetLayoutSupport, - ) -> c_void { - (self.get_descriptor_set_layout_support_khr)(device, p_create_info, p_support) - } -} -#[doc = "Generated from \'VK_KHR_maintenance3\'"] -impl StructureType { - pub const PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES_KHR: Self = - StructureType::PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES; -} -#[doc = "Generated from \'VK_KHR_maintenance3\'"] -impl StructureType { - pub const DESCRIPTOR_SET_LAYOUT_SUPPORT_KHR: Self = - StructureType::DESCRIPTOR_SET_LAYOUT_SUPPORT; -} -impl KhrDrawIndirectCountFn { - pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_draw_indirect_count\0") - .expect("Wrong extension string") - } - pub const SPEC_VERSION: u32 = 1u32; -} -pub struct KhrDrawIndirectCountFn { - pub cmd_draw_indirect_count_khr: extern "system" fn( - command_buffer: CommandBuffer, - buffer: Buffer, - offset: DeviceSize, - count_buffer: Buffer, - count_buffer_offset: DeviceSize, - max_draw_count: u32, - stride: u32, - ) -> c_void, - pub cmd_draw_indexed_indirect_count_khr: extern "system" fn( - command_buffer: CommandBuffer, - buffer: Buffer, - offset: DeviceSize, - count_buffer: Buffer, - count_buffer_offset: DeviceSize, - max_draw_count: u32, - stride: u32, - ) -> c_void, -} -unsafe impl Send for KhrDrawIndirectCountFn {} -unsafe impl Sync for KhrDrawIndirectCountFn {} -impl ::std::clone::Clone for KhrDrawIndirectCountFn { - fn clone(&self) -> Self { - KhrDrawIndirectCountFn { - cmd_draw_indirect_count_khr: self.cmd_draw_indirect_count_khr, - cmd_draw_indexed_indirect_count_khr: self.cmd_draw_indexed_indirect_count_khr, - } - } -} -impl KhrDrawIndirectCountFn { - pub fn load(mut _f: F) -> Self - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - KhrDrawIndirectCountFn { - cmd_draw_indirect_count_khr: unsafe { - extern "system" fn cmd_draw_indirect_count_khr( - _command_buffer: CommandBuffer, - _buffer: Buffer, - _offset: DeviceSize, - _count_buffer: Buffer, - _count_buffer_offset: DeviceSize, - _max_draw_count: u32, - _stride: u32, + destroy_acceleration_structure_nv: unsafe { + extern "system" fn destroy_acceleration_structure_nv( + _device: Device, + _acceleration_structure: AccelerationStructureNV, + _p_allocator: *const AllocationCallbacks, ) -> c_void { panic!(concat!( "Unable to load ", - stringify!(cmd_draw_indirect_count_khr) + stringify!(destroy_acceleration_structure_nv) )) } - let raw_name = stringify!(vkCmdDrawIndirectCountKHR); + let raw_name = stringify!(vkDestroyAccelerationStructureNV); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - cmd_draw_indirect_count_khr + destroy_acceleration_structure_nv } else { ::std::mem::transmute(val) } }, - cmd_draw_indexed_indirect_count_khr: unsafe { - extern "system" fn cmd_draw_indexed_indirect_count_khr( - _command_buffer: CommandBuffer, - _buffer: Buffer, - _offset: DeviceSize, - _count_buffer: Buffer, - _count_buffer_offset: DeviceSize, - _max_draw_count: u32, - _stride: u32, + get_acceleration_structure_memory_requirements_nv: unsafe { + extern "system" fn get_acceleration_structure_memory_requirements_nv( + _device: Device, + _p_info: *const AccelerationStructureMemoryRequirementsInfoNV, + _p_memory_requirements: *mut MemoryRequirements2KHR, ) -> c_void { panic!(concat!( "Unable to load ", - stringify!(cmd_draw_indexed_indirect_count_khr) + stringify!(get_acceleration_structure_memory_requirements_nv) )) } - let raw_name = stringify!(vkCmdDrawIndexedIndirectCountKHR); + let raw_name = stringify!(vkGetAccelerationStructureMemoryRequirementsNV); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - cmd_draw_indexed_indirect_count_khr + get_acceleration_structure_memory_requirements_nv } else { ::std::mem::transmute(val) } }, - } - } - #[doc = ""] - pub unsafe fn cmd_draw_indirect_count_khr( - &self, - command_buffer: CommandBuffer, - buffer: Buffer, - offset: DeviceSize, - count_buffer: Buffer, - count_buffer_offset: DeviceSize, - max_draw_count: u32, - stride: u32, - ) -> c_void { - (self.cmd_draw_indirect_count_khr)( - command_buffer, - buffer, - offset, - count_buffer, - count_buffer_offset, - max_draw_count, - stride, - ) - } - #[doc = ""] - pub unsafe fn cmd_draw_indexed_indirect_count_khr( + bind_acceleration_structure_memory_nv: unsafe { + extern "system" fn bind_acceleration_structure_memory_nv( + _device: Device, + _bind_info_count: u32, + _p_bind_infos: *const BindAccelerationStructureMemoryInfoNV, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(bind_acceleration_structure_memory_nv) + )) + } + let raw_name = stringify!(vkBindAccelerationStructureMemoryNV); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + bind_acceleration_structure_memory_nv + } else { + ::std::mem::transmute(val) + } + }, + cmd_build_acceleration_structure_nv: unsafe { + extern "system" fn cmd_build_acceleration_structure_nv( + _command_buffer: CommandBuffer, + _p_info: *const AccelerationStructureInfoNV, + _instance_data: Buffer, + _instance_offset: DeviceSize, + _update: Bool32, + _dst: AccelerationStructureNV, + _src: AccelerationStructureNV, + _scratch: Buffer, + _scratch_offset: DeviceSize, + ) -> c_void { + panic!(concat!( + "Unable to load ", + stringify!(cmd_build_acceleration_structure_nv) + )) + } + let raw_name = stringify!(vkCmdBuildAccelerationStructureNV); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + cmd_build_acceleration_structure_nv + } else { + ::std::mem::transmute(val) + } + }, + cmd_copy_acceleration_structure_nv: unsafe { + extern "system" fn cmd_copy_acceleration_structure_nv( + _command_buffer: CommandBuffer, + _dst: AccelerationStructureNV, + _src: AccelerationStructureNV, + _mode: CopyAccelerationStructureModeKHR, + ) -> c_void { + panic!(concat!( + "Unable to load ", + stringify!(cmd_copy_acceleration_structure_nv) + )) + } + let raw_name = stringify!(vkCmdCopyAccelerationStructureNV); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + cmd_copy_acceleration_structure_nv + } else { + ::std::mem::transmute(val) + } + }, + cmd_trace_rays_nv: unsafe { + extern "system" fn cmd_trace_rays_nv( + _command_buffer: CommandBuffer, + _raygen_shader_binding_table_buffer: Buffer, + _raygen_shader_binding_offset: DeviceSize, + _miss_shader_binding_table_buffer: Buffer, + _miss_shader_binding_offset: DeviceSize, + _miss_shader_binding_stride: DeviceSize, + _hit_shader_binding_table_buffer: Buffer, + _hit_shader_binding_offset: DeviceSize, + _hit_shader_binding_stride: DeviceSize, + _callable_shader_binding_table_buffer: Buffer, + _callable_shader_binding_offset: DeviceSize, + _callable_shader_binding_stride: DeviceSize, + _width: u32, + _height: u32, + _depth: u32, + ) -> c_void { + panic!(concat!("Unable to load ", stringify!(cmd_trace_rays_nv))) + } + let raw_name = stringify!(vkCmdTraceRaysNV); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + cmd_trace_rays_nv + } else { + ::std::mem::transmute(val) + } + }, + create_ray_tracing_pipelines_nv: unsafe { + extern "system" fn create_ray_tracing_pipelines_nv( + _device: Device, + _pipeline_cache: PipelineCache, + _create_info_count: u32, + _p_create_infos: *const RayTracingPipelineCreateInfoNV, + _p_allocator: *const AllocationCallbacks, + _p_pipelines: *mut Pipeline, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(create_ray_tracing_pipelines_nv) + )) + } + let raw_name = stringify!(vkCreateRayTracingPipelinesNV); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + create_ray_tracing_pipelines_nv + } else { + ::std::mem::transmute(val) + } + }, + get_ray_tracing_shader_group_handles_nv: unsafe { + extern "system" fn get_ray_tracing_shader_group_handles_nv( + _device: Device, + _pipeline: Pipeline, + _first_group: u32, + _group_count: u32, + _data_size: usize, + _p_data: *mut c_void, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_ray_tracing_shader_group_handles_nv) + )) + } + let raw_name = stringify!(vkGetRayTracingShaderGroupHandlesNV); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + get_ray_tracing_shader_group_handles_nv + } else { + ::std::mem::transmute(val) + } + }, + get_acceleration_structure_handle_nv: unsafe { + extern "system" fn get_acceleration_structure_handle_nv( + _device: Device, + _acceleration_structure: AccelerationStructureNV, + _data_size: usize, + _p_data: *mut c_void, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_acceleration_structure_handle_nv) + )) + } + let raw_name = stringify!(vkGetAccelerationStructureHandleNV); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + get_acceleration_structure_handle_nv + } else { + ::std::mem::transmute(val) + } + }, + cmd_write_acceleration_structures_properties_nv: unsafe { + extern "system" fn cmd_write_acceleration_structures_properties_nv( + _command_buffer: CommandBuffer, + _acceleration_structure_count: u32, + _p_acceleration_structures: *const AccelerationStructureNV, + _query_type: QueryType, + _query_pool: QueryPool, + _first_query: u32, + ) -> c_void { + panic!(concat!( + "Unable to load ", + stringify!(cmd_write_acceleration_structures_properties_nv) + )) + } + let raw_name = stringify!(vkCmdWriteAccelerationStructuresPropertiesNV); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + cmd_write_acceleration_structures_properties_nv + } else { + ::std::mem::transmute(val) + } + }, + compile_deferred_nv: unsafe { + extern "system" fn compile_deferred_nv( + _device: Device, + _pipeline: Pipeline, + _shader: u32, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(compile_deferred_nv))) + } + let raw_name = stringify!(vkCompileDeferredNV); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + compile_deferred_nv + } else { + ::std::mem::transmute(val) + } + }, + } + } + #[doc = ""] + pub unsafe fn create_acceleration_structure_nv( &self, - command_buffer: CommandBuffer, - buffer: Buffer, - offset: DeviceSize, - count_buffer: Buffer, - count_buffer_offset: DeviceSize, - max_draw_count: u32, - stride: u32, + device: Device, + p_create_info: *const AccelerationStructureCreateInfoNV, + p_allocator: *const AllocationCallbacks, + p_acceleration_structure: *mut AccelerationStructureNV, + ) -> Result { + (self.create_acceleration_structure_nv)( + device, + p_create_info, + p_allocator, + p_acceleration_structure, + ) + } + #[doc = ""] + pub unsafe fn destroy_acceleration_structure_nv( + &self, + device: Device, + acceleration_structure: AccelerationStructureNV, + p_allocator: *const AllocationCallbacks, ) -> c_void { - (self.cmd_draw_indexed_indirect_count_khr)( - command_buffer, - buffer, - offset, - count_buffer, - count_buffer_offset, - max_draw_count, - stride, + (self.destroy_acceleration_structure_nv)(device, acceleration_structure, p_allocator) + } + #[doc = ""] + pub unsafe fn get_acceleration_structure_memory_requirements_nv( + &self, + device: Device, + p_info: *const AccelerationStructureMemoryRequirementsInfoNV, + p_memory_requirements: *mut MemoryRequirements2KHR, + ) -> c_void { + (self.get_acceleration_structure_memory_requirements_nv)( + device, + p_info, + p_memory_requirements, ) } -} -impl ExtFilterCubicFn { + #[doc = ""] + pub unsafe fn bind_acceleration_structure_memory_nv( + &self, + device: Device, + bind_info_count: u32, + p_bind_infos: *const BindAccelerationStructureMemoryInfoNV, + ) -> Result { + (self.bind_acceleration_structure_memory_nv)(device, bind_info_count, p_bind_infos) + } + #[doc = ""] + pub unsafe fn cmd_build_acceleration_structure_nv( + &self, + command_buffer: CommandBuffer, + p_info: *const AccelerationStructureInfoNV, + instance_data: Buffer, + instance_offset: DeviceSize, + update: Bool32, + dst: AccelerationStructureNV, + src: AccelerationStructureNV, + scratch: Buffer, + scratch_offset: DeviceSize, + ) -> c_void { + (self.cmd_build_acceleration_structure_nv)( + command_buffer, + p_info, + instance_data, + instance_offset, + update, + dst, + src, + scratch, + scratch_offset, + ) + } + #[doc = ""] + pub unsafe fn cmd_copy_acceleration_structure_nv( + &self, + command_buffer: CommandBuffer, + dst: AccelerationStructureNV, + src: AccelerationStructureNV, + mode: CopyAccelerationStructureModeKHR, + ) -> c_void { + (self.cmd_copy_acceleration_structure_nv)(command_buffer, dst, src, mode) + } + #[doc = ""] + pub unsafe fn cmd_trace_rays_nv( + &self, + command_buffer: CommandBuffer, + raygen_shader_binding_table_buffer: Buffer, + raygen_shader_binding_offset: DeviceSize, + miss_shader_binding_table_buffer: Buffer, + miss_shader_binding_offset: DeviceSize, + miss_shader_binding_stride: DeviceSize, + hit_shader_binding_table_buffer: Buffer, + hit_shader_binding_offset: DeviceSize, + hit_shader_binding_stride: DeviceSize, + callable_shader_binding_table_buffer: Buffer, + callable_shader_binding_offset: DeviceSize, + callable_shader_binding_stride: DeviceSize, + width: u32, + height: u32, + depth: u32, + ) -> c_void { + (self.cmd_trace_rays_nv)( + command_buffer, + raygen_shader_binding_table_buffer, + raygen_shader_binding_offset, + miss_shader_binding_table_buffer, + miss_shader_binding_offset, + miss_shader_binding_stride, + hit_shader_binding_table_buffer, + hit_shader_binding_offset, + hit_shader_binding_stride, + callable_shader_binding_table_buffer, + callable_shader_binding_offset, + callable_shader_binding_stride, + width, + height, + depth, + ) + } + #[doc = ""] + pub unsafe fn create_ray_tracing_pipelines_nv( + &self, + device: Device, + pipeline_cache: PipelineCache, + create_info_count: u32, + p_create_infos: *const RayTracingPipelineCreateInfoNV, + p_allocator: *const AllocationCallbacks, + p_pipelines: *mut Pipeline, + ) -> Result { + (self.create_ray_tracing_pipelines_nv)( + device, + pipeline_cache, + create_info_count, + p_create_infos, + p_allocator, + p_pipelines, + ) + } + #[doc = ""] + pub unsafe fn get_ray_tracing_shader_group_handles_nv( + &self, + device: Device, + pipeline: Pipeline, + first_group: u32, + group_count: u32, + data_size: usize, + p_data: *mut c_void, + ) -> Result { + (self.get_ray_tracing_shader_group_handles_nv)( + device, + pipeline, + first_group, + group_count, + data_size, + p_data, + ) + } + #[doc = ""] + pub unsafe fn get_acceleration_structure_handle_nv( + &self, + device: Device, + acceleration_structure: AccelerationStructureNV, + data_size: usize, + p_data: *mut c_void, + ) -> Result { + (self.get_acceleration_structure_handle_nv)( + device, + acceleration_structure, + data_size, + p_data, + ) + } + #[doc = ""] + pub unsafe fn cmd_write_acceleration_structures_properties_nv( + &self, + command_buffer: CommandBuffer, + acceleration_structure_count: u32, + p_acceleration_structures: *const AccelerationStructureNV, + query_type: QueryType, + query_pool: QueryPool, + first_query: u32, + ) -> c_void { + (self.cmd_write_acceleration_structures_properties_nv)( + command_buffer, + acceleration_structure_count, + p_acceleration_structures, + query_type, + query_pool, + first_query, + ) + } + #[doc = ""] + pub unsafe fn compile_deferred_nv( + &self, + device: Device, + pipeline: Pipeline, + shader: u32, + ) -> Result { + (self.compile_deferred_nv)(device, pipeline, shader) + } +} +#[doc = "Generated from \'VK_NV_ray_tracing\'"] +impl StructureType { + pub const RAY_TRACING_PIPELINE_CREATE_INFO_NV: Self = Self(1_000_165_000); +} +#[doc = "Generated from \'VK_NV_ray_tracing\'"] +impl StructureType { + pub const ACCELERATION_STRUCTURE_CREATE_INFO_NV: Self = Self(1_000_165_001); +} +#[doc = "Generated from \'VK_NV_ray_tracing\'"] +impl StructureType { + pub const GEOMETRY_NV: Self = Self(1_000_165_003); +} +#[doc = "Generated from \'VK_NV_ray_tracing\'"] +impl StructureType { + pub const GEOMETRY_TRIANGLES_NV: Self = Self(1_000_165_004); +} +#[doc = "Generated from \'VK_NV_ray_tracing\'"] +impl StructureType { + pub const GEOMETRY_AABB_NV: Self = Self(1_000_165_005); +} +#[doc = "Generated from \'VK_NV_ray_tracing\'"] +impl StructureType { + pub const BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NV: Self = Self(1_000_165_006); +} +#[doc = "Generated from \'VK_NV_ray_tracing\'"] +impl StructureType { + pub const WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV: Self = Self(1_000_165_007); +} +#[doc = "Generated from \'VK_NV_ray_tracing\'"] +impl StructureType { + pub const ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV: Self = Self(1_000_165_008); +} +#[doc = "Generated from \'VK_NV_ray_tracing\'"] +impl StructureType { + pub const PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV: Self = Self(1_000_165_009); +} +#[doc = "Generated from \'VK_NV_ray_tracing\'"] +impl StructureType { + pub const RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV: Self = Self(1_000_165_011); +} +#[doc = "Generated from \'VK_NV_ray_tracing\'"] +impl StructureType { + pub const ACCELERATION_STRUCTURE_INFO_NV: Self = Self(1_000_165_012); +} +#[doc = "Generated from \'VK_NV_ray_tracing\'"] +impl ShaderStageFlags { + pub const RAYGEN_NV: Self = ShaderStageFlags::RAYGEN_KHR; +} +#[doc = "Generated from \'VK_NV_ray_tracing\'"] +impl ShaderStageFlags { + pub const ANY_HIT_NV: Self = ShaderStageFlags::ANY_HIT_KHR; +} +#[doc = "Generated from \'VK_NV_ray_tracing\'"] +impl ShaderStageFlags { + pub const CLOSEST_HIT_NV: Self = ShaderStageFlags::CLOSEST_HIT_KHR; +} +#[doc = "Generated from \'VK_NV_ray_tracing\'"] +impl ShaderStageFlags { + pub const MISS_NV: Self = ShaderStageFlags::MISS_KHR; +} +#[doc = "Generated from \'VK_NV_ray_tracing\'"] +impl ShaderStageFlags { + pub const INTERSECTION_NV: Self = ShaderStageFlags::INTERSECTION_KHR; +} +#[doc = "Generated from \'VK_NV_ray_tracing\'"] +impl ShaderStageFlags { + pub const CALLABLE_NV: Self = ShaderStageFlags::CALLABLE_KHR; +} +#[doc = "Generated from \'VK_NV_ray_tracing\'"] +impl PipelineStageFlags { + pub const RAY_TRACING_SHADER_NV: Self = PipelineStageFlags::RAY_TRACING_SHADER_KHR; +} +#[doc = "Generated from \'VK_NV_ray_tracing\'"] +impl PipelineStageFlags { + pub const ACCELERATION_STRUCTURE_BUILD_NV: Self = + PipelineStageFlags::ACCELERATION_STRUCTURE_BUILD_KHR; +} +#[doc = "Generated from \'VK_NV_ray_tracing\'"] +impl BufferUsageFlags { + pub const RAY_TRACING_NV: Self = BufferUsageFlags::SHADER_BINDING_TABLE_KHR; +} +#[doc = "Generated from \'VK_NV_ray_tracing\'"] +impl PipelineBindPoint { + pub const RAY_TRACING_NV: Self = PipelineBindPoint::RAY_TRACING_KHR; +} +#[doc = "Generated from \'VK_NV_ray_tracing\'"] +impl DescriptorType { + pub const ACCELERATION_STRUCTURE_NV: Self = Self(1_000_165_000); +} +#[doc = "Generated from \'VK_NV_ray_tracing\'"] +impl AccessFlags { + pub const ACCELERATION_STRUCTURE_READ_NV: Self = AccessFlags::ACCELERATION_STRUCTURE_READ_KHR; +} +#[doc = "Generated from \'VK_NV_ray_tracing\'"] +impl AccessFlags { + pub const ACCELERATION_STRUCTURE_WRITE_NV: Self = AccessFlags::ACCELERATION_STRUCTURE_WRITE_KHR; +} +#[doc = "Generated from \'VK_NV_ray_tracing\'"] +impl QueryType { + pub const ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV: Self = Self(1_000_165_000); +} +#[doc = "Generated from \'VK_NV_ray_tracing\'"] +impl PipelineCreateFlags { + pub const DEFER_COMPILE_NV: Self = Self(0b10_0000); +} +#[doc = "Generated from \'VK_NV_ray_tracing\'"] +impl ObjectType { + pub const ACCELERATION_STRUCTURE_NV: Self = Self(1_000_165_000); +} +#[doc = "Generated from \'VK_NV_ray_tracing\'"] +impl DebugReportObjectTypeEXT { + pub const ACCELERATION_STRUCTURE_NV: Self = Self(1_000_165_000); +} +#[doc = "Generated from \'VK_NV_ray_tracing\'"] +impl IndexType { + pub const NONE_NV: Self = IndexType::NONE_KHR; +} +#[doc = "Generated from \'VK_NV_ray_tracing\'"] +impl RayTracingShaderGroupTypeKHR { + pub const GENERAL_NV: Self = RayTracingShaderGroupTypeKHR::GENERAL; +} +#[doc = "Generated from \'VK_NV_ray_tracing\'"] +impl RayTracingShaderGroupTypeKHR { + pub const TRIANGLES_HIT_GROUP_NV: Self = RayTracingShaderGroupTypeKHR::TRIANGLES_HIT_GROUP; +} +#[doc = "Generated from \'VK_NV_ray_tracing\'"] +impl RayTracingShaderGroupTypeKHR { + pub const PROCEDURAL_HIT_GROUP_NV: Self = RayTracingShaderGroupTypeKHR::PROCEDURAL_HIT_GROUP; +} +#[doc = "Generated from \'VK_NV_ray_tracing\'"] +impl GeometryTypeKHR { + pub const TRIANGLES_NV: Self = GeometryTypeKHR::TRIANGLES; +} +#[doc = "Generated from \'VK_NV_ray_tracing\'"] +impl GeometryTypeKHR { + pub const AABBS_NV: Self = GeometryTypeKHR::AABBS; +} +#[doc = "Generated from \'VK_NV_ray_tracing\'"] +impl AccelerationStructureTypeKHR { + pub const TOP_LEVEL_NV: Self = AccelerationStructureTypeKHR::TOP_LEVEL; +} +#[doc = "Generated from \'VK_NV_ray_tracing\'"] +impl AccelerationStructureTypeKHR { + pub const BOTTOM_LEVEL_NV: Self = AccelerationStructureTypeKHR::BOTTOM_LEVEL; +} +#[doc = "Generated from \'VK_NV_ray_tracing\'"] +impl GeometryFlagsKHR { + pub const OPAQUE_NV: Self = GeometryFlagsKHR::OPAQUE; +} +#[doc = "Generated from \'VK_NV_ray_tracing\'"] +impl GeometryFlagsKHR { + pub const NO_DUPLICATE_ANY_HIT_INVOCATION_NV: Self = + GeometryFlagsKHR::NO_DUPLICATE_ANY_HIT_INVOCATION; +} +#[doc = "Generated from \'VK_NV_ray_tracing\'"] +impl GeometryInstanceFlagsKHR { + pub const TRIANGLE_CULL_DISABLE_NV: Self = + GeometryInstanceFlagsKHR::TRIANGLE_FACING_CULL_DISABLE; +} +#[doc = "Generated from \'VK_NV_ray_tracing\'"] +impl GeometryInstanceFlagsKHR { + pub const TRIANGLE_FRONT_COUNTERCLOCKWISE_NV: Self = + GeometryInstanceFlagsKHR::TRIANGLE_FRONT_COUNTERCLOCKWISE; +} +#[doc = "Generated from \'VK_NV_ray_tracing\'"] +impl GeometryInstanceFlagsKHR { + pub const FORCE_OPAQUE_NV: Self = GeometryInstanceFlagsKHR::FORCE_OPAQUE; +} +#[doc = "Generated from \'VK_NV_ray_tracing\'"] +impl GeometryInstanceFlagsKHR { + pub const FORCE_NO_OPAQUE_NV: Self = GeometryInstanceFlagsKHR::FORCE_NO_OPAQUE; +} +#[doc = "Generated from \'VK_NV_ray_tracing\'"] +impl BuildAccelerationStructureFlagsKHR { + pub const ALLOW_UPDATE_NV: Self = BuildAccelerationStructureFlagsKHR::ALLOW_UPDATE; +} +#[doc = "Generated from \'VK_NV_ray_tracing\'"] +impl BuildAccelerationStructureFlagsKHR { + pub const ALLOW_COMPACTION_NV: Self = BuildAccelerationStructureFlagsKHR::ALLOW_COMPACTION; +} +#[doc = "Generated from \'VK_NV_ray_tracing\'"] +impl BuildAccelerationStructureFlagsKHR { + pub const PREFER_FAST_TRACE_NV: Self = BuildAccelerationStructureFlagsKHR::PREFER_FAST_TRACE; +} +#[doc = "Generated from \'VK_NV_ray_tracing\'"] +impl BuildAccelerationStructureFlagsKHR { + pub const PREFER_FAST_BUILD_NV: Self = BuildAccelerationStructureFlagsKHR::PREFER_FAST_BUILD; +} +#[doc = "Generated from \'VK_NV_ray_tracing\'"] +impl BuildAccelerationStructureFlagsKHR { + pub const LOW_MEMORY_NV: Self = BuildAccelerationStructureFlagsKHR::LOW_MEMORY; +} +#[doc = "Generated from \'VK_NV_ray_tracing\'"] +impl CopyAccelerationStructureModeKHR { + pub const CLONE_NV: Self = CopyAccelerationStructureModeKHR::CLONE; +} +#[doc = "Generated from \'VK_NV_ray_tracing\'"] +impl CopyAccelerationStructureModeKHR { + pub const COMPACT_NV: Self = CopyAccelerationStructureModeKHR::COMPACT; +} +impl NvRepresentativeFragmentTestFn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_representative_fragment_test\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 2u32; +} +pub struct NvRepresentativeFragmentTestFn {} +unsafe impl Send for NvRepresentativeFragmentTestFn {} +unsafe impl Sync for NvRepresentativeFragmentTestFn {} +impl ::std::clone::Clone for NvRepresentativeFragmentTestFn { + fn clone(&self) -> Self { + NvRepresentativeFragmentTestFn {} + } +} +impl NvRepresentativeFragmentTestFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + NvRepresentativeFragmentTestFn {} + } +} +#[doc = "Generated from \'VK_NV_representative_fragment_test\'"] +impl StructureType { + pub const PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV: Self = Self(1_000_166_000); +} +#[doc = "Generated from \'VK_NV_representative_fragment_test\'"] +impl StructureType { + pub const PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV: Self = + Self(1_000_166_001); +} +impl NvExtension168Fn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_extension_168\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 0u32; +} +pub struct NvExtension168Fn {} +unsafe impl Send for NvExtension168Fn {} +unsafe impl Sync for NvExtension168Fn {} +impl ::std::clone::Clone for NvExtension168Fn { + fn clone(&self) -> Self { + NvExtension168Fn {} + } +} +impl NvExtension168Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + NvExtension168Fn {} + } +} +impl KhrMaintenance3Fn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_maintenance3\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkGetDescriptorSetLayoutSupport = extern "system" fn( + device: Device, + p_create_info: *const DescriptorSetLayoutCreateInfo, + p_support: *mut DescriptorSetLayoutSupport, +) -> c_void; +pub struct KhrMaintenance3Fn { + pub get_descriptor_set_layout_support_khr: extern "system" fn( + device: Device, + p_create_info: *const DescriptorSetLayoutCreateInfo, + p_support: *mut DescriptorSetLayoutSupport, + ) -> c_void, +} +unsafe impl Send for KhrMaintenance3Fn {} +unsafe impl Sync for KhrMaintenance3Fn {} +impl ::std::clone::Clone for KhrMaintenance3Fn { + fn clone(&self) -> Self { + KhrMaintenance3Fn { + get_descriptor_set_layout_support_khr: self.get_descriptor_set_layout_support_khr, + } + } +} +impl KhrMaintenance3Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + KhrMaintenance3Fn { + get_descriptor_set_layout_support_khr: unsafe { + extern "system" fn get_descriptor_set_layout_support_khr( + _device: Device, + _p_create_info: *const DescriptorSetLayoutCreateInfo, + _p_support: *mut DescriptorSetLayoutSupport, + ) -> c_void { + panic!(concat!( + "Unable to load ", + stringify!(get_descriptor_set_layout_support_khr) + )) + } + let raw_name = stringify!(vkGetDescriptorSetLayoutSupportKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + get_descriptor_set_layout_support_khr + } else { + ::std::mem::transmute(val) + } + }, + } + } + #[doc = ""] + pub unsafe fn get_descriptor_set_layout_support_khr( + &self, + device: Device, + p_create_info: *const DescriptorSetLayoutCreateInfo, + p_support: *mut DescriptorSetLayoutSupport, + ) -> c_void { + (self.get_descriptor_set_layout_support_khr)(device, p_create_info, p_support) + } +} +#[doc = "Generated from \'VK_KHR_maintenance3\'"] +impl StructureType { + pub const PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES_KHR: Self = + StructureType::PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES; +} +#[doc = "Generated from \'VK_KHR_maintenance3\'"] +impl StructureType { + pub const DESCRIPTOR_SET_LAYOUT_SUPPORT_KHR: Self = + StructureType::DESCRIPTOR_SET_LAYOUT_SUPPORT; +} +impl KhrDrawIndirectCountFn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_draw_indirect_count\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 1u32; +} +pub struct KhrDrawIndirectCountFn { + pub cmd_draw_indirect_count_khr: extern "system" fn( + command_buffer: CommandBuffer, + buffer: Buffer, + offset: DeviceSize, + count_buffer: Buffer, + count_buffer_offset: DeviceSize, + max_draw_count: u32, + stride: u32, + ) -> c_void, + pub cmd_draw_indexed_indirect_count_khr: extern "system" fn( + command_buffer: CommandBuffer, + buffer: Buffer, + offset: DeviceSize, + count_buffer: Buffer, + count_buffer_offset: DeviceSize, + max_draw_count: u32, + stride: u32, + ) -> c_void, +} +unsafe impl Send for KhrDrawIndirectCountFn {} +unsafe impl Sync for KhrDrawIndirectCountFn {} +impl ::std::clone::Clone for KhrDrawIndirectCountFn { + fn clone(&self) -> Self { + KhrDrawIndirectCountFn { + cmd_draw_indirect_count_khr: self.cmd_draw_indirect_count_khr, + cmd_draw_indexed_indirect_count_khr: self.cmd_draw_indexed_indirect_count_khr, + } + } +} +impl KhrDrawIndirectCountFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + KhrDrawIndirectCountFn { + cmd_draw_indirect_count_khr: unsafe { + extern "system" fn cmd_draw_indirect_count_khr( + _command_buffer: CommandBuffer, + _buffer: Buffer, + _offset: DeviceSize, + _count_buffer: Buffer, + _count_buffer_offset: DeviceSize, + _max_draw_count: u32, + _stride: u32, + ) -> c_void { + panic!(concat!( + "Unable to load ", + stringify!(cmd_draw_indirect_count_khr) + )) + } + let raw_name = stringify!(vkCmdDrawIndirectCountKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + cmd_draw_indirect_count_khr + } else { + ::std::mem::transmute(val) + } + }, + cmd_draw_indexed_indirect_count_khr: unsafe { + extern "system" fn cmd_draw_indexed_indirect_count_khr( + _command_buffer: CommandBuffer, + _buffer: Buffer, + _offset: DeviceSize, + _count_buffer: Buffer, + _count_buffer_offset: DeviceSize, + _max_draw_count: u32, + _stride: u32, + ) -> c_void { + panic!(concat!( + "Unable to load ", + stringify!(cmd_draw_indexed_indirect_count_khr) + )) + } + let raw_name = stringify!(vkCmdDrawIndexedIndirectCountKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + cmd_draw_indexed_indirect_count_khr + } else { + ::std::mem::transmute(val) + } + }, + } + } + #[doc = ""] + pub unsafe fn cmd_draw_indirect_count_khr( + &self, + command_buffer: CommandBuffer, + buffer: Buffer, + offset: DeviceSize, + count_buffer: Buffer, + count_buffer_offset: DeviceSize, + max_draw_count: u32, + stride: u32, + ) -> c_void { + (self.cmd_draw_indirect_count_khr)( + command_buffer, + buffer, + offset, + count_buffer, + count_buffer_offset, + max_draw_count, + stride, + ) + } + #[doc = ""] + pub unsafe fn cmd_draw_indexed_indirect_count_khr( + &self, + command_buffer: CommandBuffer, + buffer: Buffer, + offset: DeviceSize, + count_buffer: Buffer, + count_buffer_offset: DeviceSize, + max_draw_count: u32, + stride: u32, + ) -> c_void { + (self.cmd_draw_indexed_indirect_count_khr)( + command_buffer, + buffer, + offset, + count_buffer, + count_buffer_offset, + max_draw_count, + stride, + ) + } +} +impl ExtFilterCubicFn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_filter_cubic\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 3u32; +} +pub struct ExtFilterCubicFn {} +unsafe impl Send for ExtFilterCubicFn {} +unsafe impl Sync for ExtFilterCubicFn {} +impl ::std::clone::Clone for ExtFilterCubicFn { + fn clone(&self) -> Self { + ExtFilterCubicFn {} + } +} +impl ExtFilterCubicFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + ExtFilterCubicFn {} + } +} +#[doc = "Generated from \'VK_EXT_filter_cubic\'"] +impl Filter { + pub const CUBIC_EXT: Self = Filter::CUBIC_IMG; +} +#[doc = "Generated from \'VK_EXT_filter_cubic\'"] +impl FormatFeatureFlags { + pub const SAMPLED_IMAGE_FILTER_CUBIC_EXT: Self = + FormatFeatureFlags::SAMPLED_IMAGE_FILTER_CUBIC_IMG; +} +#[doc = "Generated from \'VK_EXT_filter_cubic\'"] +impl StructureType { + pub const PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT: Self = Self(1_000_170_000); +} +#[doc = "Generated from \'VK_EXT_filter_cubic\'"] +impl StructureType { + pub const FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT: Self = Self(1_000_170_001); +} +impl QcomRenderPassShaderResolveFn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_QCOM_render_pass_shader_resolve\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 4u32; +} +pub struct QcomRenderPassShaderResolveFn {} +unsafe impl Send for QcomRenderPassShaderResolveFn {} +unsafe impl Sync for QcomRenderPassShaderResolveFn {} +impl ::std::clone::Clone for QcomRenderPassShaderResolveFn { + fn clone(&self) -> Self { + QcomRenderPassShaderResolveFn {} + } +} +impl QcomRenderPassShaderResolveFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + QcomRenderPassShaderResolveFn {} + } +} +#[doc = "Generated from \'VK_QCOM_render_pass_shader_resolve\'"] +impl SubpassDescriptionFlags { + pub const FRAGMENT_REGION_QCOM: Self = Self(0b100); +} +#[doc = "Generated from \'VK_QCOM_render_pass_shader_resolve\'"] +impl SubpassDescriptionFlags { + pub const SHADER_RESOLVE_QCOM: Self = Self(0b1000); +} +impl QcomExtension173Fn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_QCOM_extension_173\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 0u32; +} +pub struct QcomExtension173Fn {} +unsafe impl Send for QcomExtension173Fn {} +unsafe impl Sync for QcomExtension173Fn {} +impl ::std::clone::Clone for QcomExtension173Fn { + fn clone(&self) -> Self { + QcomExtension173Fn {} + } +} +impl QcomExtension173Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + QcomExtension173Fn {} + } +} +#[doc = "Generated from \'VK_QCOM_extension_173\'"] +impl BufferUsageFlags { + pub const RESERVED_18_QCOM: Self = Self(0b100_0000_0000_0000_0000); +} +#[doc = "Generated from \'VK_QCOM_extension_173\'"] +impl ImageUsageFlags { + pub const RESERVED_16_QCOM: Self = Self(0b1_0000_0000_0000_0000); +} +#[doc = "Generated from \'VK_QCOM_extension_173\'"] +impl ImageUsageFlags { + pub const RESERVED_17_QCOM: Self = Self(0b10_0000_0000_0000_0000); +} +impl QcomExtension174Fn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_QCOM_extension_174\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 0u32; +} +pub struct QcomExtension174Fn {} +unsafe impl Send for QcomExtension174Fn {} +unsafe impl Sync for QcomExtension174Fn {} +impl ::std::clone::Clone for QcomExtension174Fn { + fn clone(&self) -> Self { + QcomExtension174Fn {} + } +} +impl QcomExtension174Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + QcomExtension174Fn {} + } +} +impl ExtGlobalPriorityFn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_global_priority\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 2u32; +} +pub struct ExtGlobalPriorityFn {} +unsafe impl Send for ExtGlobalPriorityFn {} +unsafe impl Sync for ExtGlobalPriorityFn {} +impl ::std::clone::Clone for ExtGlobalPriorityFn { + fn clone(&self) -> Self { + ExtGlobalPriorityFn {} + } +} +impl ExtGlobalPriorityFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + ExtGlobalPriorityFn {} + } +} +#[doc = "Generated from \'VK_EXT_global_priority\'"] +impl StructureType { + pub const DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT: Self = Self(1_000_174_000); +} +#[doc = "Generated from \'VK_EXT_global_priority\'"] +impl Result { + pub const ERROR_NOT_PERMITTED_EXT: Self = Self(-1_000_174_001); +} +impl KhrShaderSubgroupExtendedTypesFn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_shader_subgroup_extended_types\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 1u32; +} +pub struct KhrShaderSubgroupExtendedTypesFn {} +unsafe impl Send for KhrShaderSubgroupExtendedTypesFn {} +unsafe impl Sync for KhrShaderSubgroupExtendedTypesFn {} +impl ::std::clone::Clone for KhrShaderSubgroupExtendedTypesFn { + fn clone(&self) -> Self { + KhrShaderSubgroupExtendedTypesFn {} + } +} +impl KhrShaderSubgroupExtendedTypesFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + KhrShaderSubgroupExtendedTypesFn {} + } +} +#[doc = "Generated from \'VK_KHR_shader_subgroup_extended_types\'"] +impl StructureType { + pub const PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES_KHR: Self = + StructureType::PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES; +} +impl ExtExtension177Fn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_extension_177\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 0u32; +} +pub struct ExtExtension177Fn {} +unsafe impl Send for ExtExtension177Fn {} +unsafe impl Sync for ExtExtension177Fn {} +impl ::std::clone::Clone for ExtExtension177Fn { + fn clone(&self) -> Self { + ExtExtension177Fn {} + } +} +impl ExtExtension177Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + ExtExtension177Fn {} + } +} +impl Khr8bitStorageFn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_8bit_storage\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 1u32; +} +pub struct Khr8bitStorageFn {} +unsafe impl Send for Khr8bitStorageFn {} +unsafe impl Sync for Khr8bitStorageFn {} +impl ::std::clone::Clone for Khr8bitStorageFn { + fn clone(&self) -> Self { + Khr8bitStorageFn {} + } +} +impl Khr8bitStorageFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Khr8bitStorageFn {} + } +} +#[doc = "Generated from \'VK_KHR_8bit_storage\'"] +impl StructureType { + pub const PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES_KHR: Self = + StructureType::PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES; +} +impl ExtExternalMemoryHostFn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_external_memory_host\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkGetMemoryHostPointerPropertiesEXT = extern "system" fn( + device: Device, + handle_type: ExternalMemoryHandleTypeFlags, + p_host_pointer: *const c_void, + p_memory_host_pointer_properties: *mut MemoryHostPointerPropertiesEXT, +) -> Result; +pub struct ExtExternalMemoryHostFn { + pub get_memory_host_pointer_properties_ext: extern "system" fn( + device: Device, + handle_type: ExternalMemoryHandleTypeFlags, + p_host_pointer: *const c_void, + p_memory_host_pointer_properties: *mut MemoryHostPointerPropertiesEXT, + ) -> Result, +} +unsafe impl Send for ExtExternalMemoryHostFn {} +unsafe impl Sync for ExtExternalMemoryHostFn {} +impl ::std::clone::Clone for ExtExternalMemoryHostFn { + fn clone(&self) -> Self { + ExtExternalMemoryHostFn { + get_memory_host_pointer_properties_ext: self.get_memory_host_pointer_properties_ext, + } + } +} +impl ExtExternalMemoryHostFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + ExtExternalMemoryHostFn { + get_memory_host_pointer_properties_ext: unsafe { + extern "system" fn get_memory_host_pointer_properties_ext( + _device: Device, + _handle_type: ExternalMemoryHandleTypeFlags, + _p_host_pointer: *const c_void, + _p_memory_host_pointer_properties: *mut MemoryHostPointerPropertiesEXT, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_memory_host_pointer_properties_ext) + )) + } + let raw_name = stringify!(vkGetMemoryHostPointerPropertiesEXT); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + get_memory_host_pointer_properties_ext + } else { + ::std::mem::transmute(val) + } + }, + } + } + #[doc = ""] + pub unsafe fn get_memory_host_pointer_properties_ext( + &self, + device: Device, + handle_type: ExternalMemoryHandleTypeFlags, + p_host_pointer: *const c_void, + p_memory_host_pointer_properties: *mut MemoryHostPointerPropertiesEXT, + ) -> Result { + (self.get_memory_host_pointer_properties_ext)( + device, + handle_type, + p_host_pointer, + p_memory_host_pointer_properties, + ) + } +} +#[doc = "Generated from \'VK_EXT_external_memory_host\'"] +impl StructureType { + pub const IMPORT_MEMORY_HOST_POINTER_INFO_EXT: Self = Self(1_000_178_000); +} +#[doc = "Generated from \'VK_EXT_external_memory_host\'"] +impl StructureType { + pub const MEMORY_HOST_POINTER_PROPERTIES_EXT: Self = Self(1_000_178_001); +} +#[doc = "Generated from \'VK_EXT_external_memory_host\'"] +impl StructureType { + pub const PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT: Self = Self(1_000_178_002); +} +#[doc = "Generated from \'VK_EXT_external_memory_host\'"] +impl ExternalMemoryHandleTypeFlags { + pub const EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION: Self = Self(0b1000_0000); +} +#[doc = "Generated from \'VK_EXT_external_memory_host\'"] +impl ExternalMemoryHandleTypeFlags { + pub const EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY: Self = Self(0b1_0000_0000); +} +impl AmdBufferMarkerFn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_AMD_buffer_marker\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkCmdWriteBufferMarkerAMD = extern "system" fn( + command_buffer: CommandBuffer, + pipeline_stage: PipelineStageFlags, + dst_buffer: Buffer, + dst_offset: DeviceSize, + marker: u32, +) -> c_void; +pub struct AmdBufferMarkerFn { + pub cmd_write_buffer_marker_amd: extern "system" fn( + command_buffer: CommandBuffer, + pipeline_stage: PipelineStageFlags, + dst_buffer: Buffer, + dst_offset: DeviceSize, + marker: u32, + ) -> c_void, +} +unsafe impl Send for AmdBufferMarkerFn {} +unsafe impl Sync for AmdBufferMarkerFn {} +impl ::std::clone::Clone for AmdBufferMarkerFn { + fn clone(&self) -> Self { + AmdBufferMarkerFn { + cmd_write_buffer_marker_amd: self.cmd_write_buffer_marker_amd, + } + } +} +impl AmdBufferMarkerFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + AmdBufferMarkerFn { + cmd_write_buffer_marker_amd: unsafe { + extern "system" fn cmd_write_buffer_marker_amd( + _command_buffer: CommandBuffer, + _pipeline_stage: PipelineStageFlags, + _dst_buffer: Buffer, + _dst_offset: DeviceSize, + _marker: u32, + ) -> c_void { + panic!(concat!( + "Unable to load ", + stringify!(cmd_write_buffer_marker_amd) + )) + } + let raw_name = stringify!(vkCmdWriteBufferMarkerAMD); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + cmd_write_buffer_marker_amd + } else { + ::std::mem::transmute(val) + } + }, + } + } + #[doc = ""] + pub unsafe fn cmd_write_buffer_marker_amd( + &self, + command_buffer: CommandBuffer, + pipeline_stage: PipelineStageFlags, + dst_buffer: Buffer, + dst_offset: DeviceSize, + marker: u32, + ) -> c_void { + (self.cmd_write_buffer_marker_amd)( + command_buffer, + pipeline_stage, + dst_buffer, + dst_offset, + marker, + ) + } +} +impl KhrShaderAtomicInt64Fn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_shader_atomic_int64\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 1u32; +} +pub struct KhrShaderAtomicInt64Fn {} +unsafe impl Send for KhrShaderAtomicInt64Fn {} +unsafe impl Sync for KhrShaderAtomicInt64Fn {} +impl ::std::clone::Clone for KhrShaderAtomicInt64Fn { + fn clone(&self) -> Self { + KhrShaderAtomicInt64Fn {} + } +} +impl KhrShaderAtomicInt64Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + KhrShaderAtomicInt64Fn {} + } +} +#[doc = "Generated from \'VK_KHR_shader_atomic_int64\'"] +impl StructureType { + pub const PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES_KHR: Self = + StructureType::PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES; +} +impl KhrShaderClockFn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_shader_clock\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 1u32; +} +pub struct KhrShaderClockFn {} +unsafe impl Send for KhrShaderClockFn {} +unsafe impl Sync for KhrShaderClockFn {} +impl ::std::clone::Clone for KhrShaderClockFn { + fn clone(&self) -> Self { + KhrShaderClockFn {} + } +} +impl KhrShaderClockFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + KhrShaderClockFn {} + } +} +#[doc = "Generated from \'VK_KHR_shader_clock\'"] +impl StructureType { + pub const PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR: Self = Self(1_000_181_000); +} +impl AmdExtension183Fn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_AMD_extension_183\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 0u32; +} +pub struct AmdExtension183Fn {} +unsafe impl Send for AmdExtension183Fn {} +unsafe impl Sync for AmdExtension183Fn {} +impl ::std::clone::Clone for AmdExtension183Fn { + fn clone(&self) -> Self { + AmdExtension183Fn {} + } +} +impl AmdExtension183Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + AmdExtension183Fn {} + } +} +impl AmdPipelineCompilerControlFn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_AMD_pipeline_compiler_control\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 1u32; +} +pub struct AmdPipelineCompilerControlFn {} +unsafe impl Send for AmdPipelineCompilerControlFn {} +unsafe impl Sync for AmdPipelineCompilerControlFn {} +impl ::std::clone::Clone for AmdPipelineCompilerControlFn { + fn clone(&self) -> Self { + AmdPipelineCompilerControlFn {} + } +} +impl AmdPipelineCompilerControlFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + AmdPipelineCompilerControlFn {} + } +} +#[doc = "Generated from \'VK_AMD_pipeline_compiler_control\'"] +impl StructureType { + pub const PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD: Self = Self(1_000_183_000); +} +impl ExtCalibratedTimestampsFn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_calibrated_timestamps\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT = extern "system" fn( + physical_device: PhysicalDevice, + p_time_domain_count: *mut u32, + p_time_domains: *mut TimeDomainEXT, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetCalibratedTimestampsEXT = extern "system" fn( + device: Device, + timestamp_count: u32, + p_timestamp_infos: *const CalibratedTimestampInfoEXT, + p_timestamps: *mut u64, + p_max_deviation: *mut u64, +) -> Result; +pub struct ExtCalibratedTimestampsFn { + pub get_physical_device_calibrateable_time_domains_ext: extern "system" fn( + physical_device: PhysicalDevice, + p_time_domain_count: *mut u32, + p_time_domains: *mut TimeDomainEXT, + ) -> Result, + pub get_calibrated_timestamps_ext: extern "system" fn( + device: Device, + timestamp_count: u32, + p_timestamp_infos: *const CalibratedTimestampInfoEXT, + p_timestamps: *mut u64, + p_max_deviation: *mut u64, + ) -> Result, +} +unsafe impl Send for ExtCalibratedTimestampsFn {} +unsafe impl Sync for ExtCalibratedTimestampsFn {} +impl ::std::clone::Clone for ExtCalibratedTimestampsFn { + fn clone(&self) -> Self { + ExtCalibratedTimestampsFn { + get_physical_device_calibrateable_time_domains_ext: self + .get_physical_device_calibrateable_time_domains_ext, + get_calibrated_timestamps_ext: self.get_calibrated_timestamps_ext, + } + } +} +impl ExtCalibratedTimestampsFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + ExtCalibratedTimestampsFn { + get_physical_device_calibrateable_time_domains_ext: unsafe { + extern "system" fn get_physical_device_calibrateable_time_domains_ext( + _physical_device: PhysicalDevice, + _p_time_domain_count: *mut u32, + _p_time_domains: *mut TimeDomainEXT, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_calibrateable_time_domains_ext) + )) + } + let raw_name = stringify!(vkGetPhysicalDeviceCalibrateableTimeDomainsEXT); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + get_physical_device_calibrateable_time_domains_ext + } else { + ::std::mem::transmute(val) + } + }, + get_calibrated_timestamps_ext: unsafe { + extern "system" fn get_calibrated_timestamps_ext( + _device: Device, + _timestamp_count: u32, + _p_timestamp_infos: *const CalibratedTimestampInfoEXT, + _p_timestamps: *mut u64, + _p_max_deviation: *mut u64, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_calibrated_timestamps_ext) + )) + } + let raw_name = stringify!(vkGetCalibratedTimestampsEXT); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + get_calibrated_timestamps_ext + } else { + ::std::mem::transmute(val) + } + }, + } + } + #[doc = ""] + pub unsafe fn get_physical_device_calibrateable_time_domains_ext( + &self, + physical_device: PhysicalDevice, + p_time_domain_count: *mut u32, + p_time_domains: *mut TimeDomainEXT, + ) -> Result { + (self.get_physical_device_calibrateable_time_domains_ext)( + physical_device, + p_time_domain_count, + p_time_domains, + ) + } + #[doc = ""] + pub unsafe fn get_calibrated_timestamps_ext( + &self, + device: Device, + timestamp_count: u32, + p_timestamp_infos: *const CalibratedTimestampInfoEXT, + p_timestamps: *mut u64, + p_max_deviation: *mut u64, + ) -> Result { + (self.get_calibrated_timestamps_ext)( + device, + timestamp_count, + p_timestamp_infos, + p_timestamps, + p_max_deviation, + ) + } +} +#[doc = "Generated from \'VK_EXT_calibrated_timestamps\'"] +impl StructureType { + pub const CALIBRATED_TIMESTAMP_INFO_EXT: Self = Self(1_000_184_000); +} +impl AmdShaderCorePropertiesFn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_AMD_shader_core_properties\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 2u32; +} +pub struct AmdShaderCorePropertiesFn {} +unsafe impl Send for AmdShaderCorePropertiesFn {} +unsafe impl Sync for AmdShaderCorePropertiesFn {} +impl ::std::clone::Clone for AmdShaderCorePropertiesFn { + fn clone(&self) -> Self { + AmdShaderCorePropertiesFn {} + } +} +impl AmdShaderCorePropertiesFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + AmdShaderCorePropertiesFn {} + } +} +#[doc = "Generated from \'VK_AMD_shader_core_properties\'"] +impl StructureType { + pub const PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD: Self = Self(1_000_185_000); +} +impl AmdExtension187Fn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_AMD_extension_187\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 0u32; +} +pub struct AmdExtension187Fn {} +unsafe impl Send for AmdExtension187Fn {} +unsafe impl Sync for AmdExtension187Fn {} +impl ::std::clone::Clone for AmdExtension187Fn { + fn clone(&self) -> Self { + AmdExtension187Fn {} + } +} +impl AmdExtension187Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + AmdExtension187Fn {} + } +} +impl AmdExtension188Fn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_AMD_extension_188\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 0u32; +} +pub struct AmdExtension188Fn {} +unsafe impl Send for AmdExtension188Fn {} +unsafe impl Sync for AmdExtension188Fn {} +impl ::std::clone::Clone for AmdExtension188Fn { + fn clone(&self) -> Self { + AmdExtension188Fn {} + } +} +impl AmdExtension188Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + AmdExtension188Fn {} + } +} +impl AmdExtension189Fn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_AMD_extension_189\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 0u32; +} +pub struct AmdExtension189Fn {} +unsafe impl Send for AmdExtension189Fn {} +unsafe impl Sync for AmdExtension189Fn {} +impl ::std::clone::Clone for AmdExtension189Fn { + fn clone(&self) -> Self { + AmdExtension189Fn {} + } +} +impl AmdExtension189Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + AmdExtension189Fn {} + } +} +impl AmdMemoryOverallocationBehaviorFn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_AMD_memory_overallocation_behavior\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 1u32; +} +pub struct AmdMemoryOverallocationBehaviorFn {} +unsafe impl Send for AmdMemoryOverallocationBehaviorFn {} +unsafe impl Sync for AmdMemoryOverallocationBehaviorFn {} +impl ::std::clone::Clone for AmdMemoryOverallocationBehaviorFn { + fn clone(&self) -> Self { + AmdMemoryOverallocationBehaviorFn {} + } +} +impl AmdMemoryOverallocationBehaviorFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + AmdMemoryOverallocationBehaviorFn {} + } +} +#[doc = "Generated from \'VK_AMD_memory_overallocation_behavior\'"] +impl StructureType { + pub const DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD: Self = Self(1_000_189_000); +} +impl ExtVertexAttributeDivisorFn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_vertex_attribute_divisor\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 3u32; +} +pub struct ExtVertexAttributeDivisorFn {} +unsafe impl Send for ExtVertexAttributeDivisorFn {} +unsafe impl Sync for ExtVertexAttributeDivisorFn {} +impl ::std::clone::Clone for ExtVertexAttributeDivisorFn { + fn clone(&self) -> Self { + ExtVertexAttributeDivisorFn {} + } +} +impl ExtVertexAttributeDivisorFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + ExtVertexAttributeDivisorFn {} + } +} +#[doc = "Generated from \'VK_EXT_vertex_attribute_divisor\'"] +impl StructureType { + pub const PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT: Self = Self(1_000_190_000); +} +#[doc = "Generated from \'VK_EXT_vertex_attribute_divisor\'"] +impl StructureType { + pub const PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT: Self = Self(1_000_190_001); +} +#[doc = "Generated from \'VK_EXT_vertex_attribute_divisor\'"] +impl StructureType { + pub const PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT: Self = Self(1_000_190_002); +} +impl GgpFrameTokenFn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_GGP_frame_token\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 1u32; +} +pub struct GgpFrameTokenFn {} +unsafe impl Send for GgpFrameTokenFn {} +unsafe impl Sync for GgpFrameTokenFn {} +impl ::std::clone::Clone for GgpFrameTokenFn { + fn clone(&self) -> Self { + GgpFrameTokenFn {} + } +} +impl GgpFrameTokenFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + GgpFrameTokenFn {} + } +} +#[doc = "Generated from \'VK_GGP_frame_token\'"] +impl StructureType { + pub const PRESENT_FRAME_TOKEN_GGP: Self = Self(1_000_191_000); +} +impl ExtPipelineCreationFeedbackFn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_pipeline_creation_feedback\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 1u32; +} +pub struct ExtPipelineCreationFeedbackFn {} +unsafe impl Send for ExtPipelineCreationFeedbackFn {} +unsafe impl Sync for ExtPipelineCreationFeedbackFn {} +impl ::std::clone::Clone for ExtPipelineCreationFeedbackFn { + fn clone(&self) -> Self { + ExtPipelineCreationFeedbackFn {} + } +} +impl ExtPipelineCreationFeedbackFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + ExtPipelineCreationFeedbackFn {} + } +} +#[doc = "Generated from \'VK_EXT_pipeline_creation_feedback\'"] +impl StructureType { + pub const PIPELINE_CREATION_FEEDBACK_CREATE_INFO_EXT: Self = Self(1_000_192_000); +} +impl GoogleExtension194Fn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_GOOGLE_extension_194\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 0u32; +} +pub struct GoogleExtension194Fn {} +unsafe impl Send for GoogleExtension194Fn {} +unsafe impl Sync for GoogleExtension194Fn {} +impl ::std::clone::Clone for GoogleExtension194Fn { + fn clone(&self) -> Self { + GoogleExtension194Fn {} + } +} +impl GoogleExtension194Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + GoogleExtension194Fn {} + } +} +impl GoogleExtension195Fn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_GOOGLE_extension_195\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 0u32; +} +pub struct GoogleExtension195Fn {} +unsafe impl Send for GoogleExtension195Fn {} +unsafe impl Sync for GoogleExtension195Fn {} +impl ::std::clone::Clone for GoogleExtension195Fn { + fn clone(&self) -> Self { + GoogleExtension195Fn {} + } +} +impl GoogleExtension195Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + GoogleExtension195Fn {} + } +} +impl GoogleExtension196Fn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_GOOGLE_extension_196\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 0u32; +} +pub struct GoogleExtension196Fn {} +unsafe impl Send for GoogleExtension196Fn {} +unsafe impl Sync for GoogleExtension196Fn {} +impl ::std::clone::Clone for GoogleExtension196Fn { + fn clone(&self) -> Self { + GoogleExtension196Fn {} + } +} +impl GoogleExtension196Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + GoogleExtension196Fn {} + } +} +#[doc = "Generated from \'VK_GOOGLE_extension_196\'"] +impl PipelineCacheCreateFlags { + pub const RESERVED_1_EXT: Self = Self(0b10); +} +impl KhrDriverPropertiesFn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_driver_properties\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 1u32; +} +pub struct KhrDriverPropertiesFn {} +unsafe impl Send for KhrDriverPropertiesFn {} +unsafe impl Sync for KhrDriverPropertiesFn {} +impl ::std::clone::Clone for KhrDriverPropertiesFn { + fn clone(&self) -> Self { + KhrDriverPropertiesFn {} + } +} +impl KhrDriverPropertiesFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + KhrDriverPropertiesFn {} + } +} +#[doc = "Generated from \'VK_KHR_driver_properties\'"] +impl StructureType { + pub const PHYSICAL_DEVICE_DRIVER_PROPERTIES_KHR: Self = + StructureType::PHYSICAL_DEVICE_DRIVER_PROPERTIES; +} +#[doc = "Generated from \'VK_KHR_driver_properties\'"] +impl DriverId { + pub const AMD_PROPRIETARY_KHR: Self = DriverId::AMD_PROPRIETARY; +} +#[doc = "Generated from \'VK_KHR_driver_properties\'"] +impl DriverId { + pub const AMD_OPEN_SOURCE_KHR: Self = DriverId::AMD_OPEN_SOURCE; +} +#[doc = "Generated from \'VK_KHR_driver_properties\'"] +impl DriverId { + pub const MESA_RADV_KHR: Self = DriverId::MESA_RADV; +} +#[doc = "Generated from \'VK_KHR_driver_properties\'"] +impl DriverId { + pub const NVIDIA_PROPRIETARY_KHR: Self = DriverId::NVIDIA_PROPRIETARY; +} +#[doc = "Generated from \'VK_KHR_driver_properties\'"] +impl DriverId { + pub const INTEL_PROPRIETARY_WINDOWS_KHR: Self = DriverId::INTEL_PROPRIETARY_WINDOWS; +} +#[doc = "Generated from \'VK_KHR_driver_properties\'"] +impl DriverId { + pub const INTEL_OPEN_SOURCE_MESA_KHR: Self = DriverId::INTEL_OPEN_SOURCE_MESA; +} +#[doc = "Generated from \'VK_KHR_driver_properties\'"] +impl DriverId { + pub const IMAGINATION_PROPRIETARY_KHR: Self = DriverId::IMAGINATION_PROPRIETARY; +} +#[doc = "Generated from \'VK_KHR_driver_properties\'"] +impl DriverId { + pub const QUALCOMM_PROPRIETARY_KHR: Self = DriverId::QUALCOMM_PROPRIETARY; +} +#[doc = "Generated from \'VK_KHR_driver_properties\'"] +impl DriverId { + pub const ARM_PROPRIETARY_KHR: Self = DriverId::ARM_PROPRIETARY; +} +#[doc = "Generated from \'VK_KHR_driver_properties\'"] +impl DriverId { + pub const GOOGLE_SWIFTSHADER_KHR: Self = DriverId::GOOGLE_SWIFTSHADER; +} +#[doc = "Generated from \'VK_KHR_driver_properties\'"] +impl DriverId { + pub const GGP_PROPRIETARY_KHR: Self = DriverId::GGP_PROPRIETARY; +} +#[doc = "Generated from \'VK_KHR_driver_properties\'"] +impl DriverId { + pub const BROADCOM_PROPRIETARY_KHR: Self = DriverId::BROADCOM_PROPRIETARY; +} +impl KhrShaderFloatControlsFn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_shader_float_controls\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 4u32; +} +pub struct KhrShaderFloatControlsFn {} +unsafe impl Send for KhrShaderFloatControlsFn {} +unsafe impl Sync for KhrShaderFloatControlsFn {} +impl ::std::clone::Clone for KhrShaderFloatControlsFn { + fn clone(&self) -> Self { + KhrShaderFloatControlsFn {} + } +} +impl KhrShaderFloatControlsFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + KhrShaderFloatControlsFn {} + } +} +#[doc = "Generated from \'VK_KHR_shader_float_controls\'"] +impl StructureType { + pub const PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES_KHR: Self = + StructureType::PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES; +} +#[doc = "Generated from \'VK_KHR_shader_float_controls\'"] +impl ShaderFloatControlsIndependence { + pub const TYPE_32_ONLY_KHR: Self = ShaderFloatControlsIndependence::TYPE_32_ONLY; +} +#[doc = "Generated from \'VK_KHR_shader_float_controls\'"] +impl ShaderFloatControlsIndependence { + pub const ALL_KHR: Self = ShaderFloatControlsIndependence::ALL; +} +#[doc = "Generated from \'VK_KHR_shader_float_controls\'"] +impl ShaderFloatControlsIndependence { + pub const NONE_KHR: Self = ShaderFloatControlsIndependence::NONE; +} +impl NvShaderSubgroupPartitionedFn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_shader_subgroup_partitioned\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 1u32; +} +pub struct NvShaderSubgroupPartitionedFn {} +unsafe impl Send for NvShaderSubgroupPartitionedFn {} +unsafe impl Sync for NvShaderSubgroupPartitionedFn {} +impl ::std::clone::Clone for NvShaderSubgroupPartitionedFn { + fn clone(&self) -> Self { + NvShaderSubgroupPartitionedFn {} + } +} +impl NvShaderSubgroupPartitionedFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + NvShaderSubgroupPartitionedFn {} + } +} +#[doc = "Generated from \'VK_NV_shader_subgroup_partitioned\'"] +impl SubgroupFeatureFlags { + pub const PARTITIONED_NV: Self = Self(0b1_0000_0000); +} +impl KhrDepthStencilResolveFn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_depth_stencil_resolve\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 1u32; +} +pub struct KhrDepthStencilResolveFn {} +unsafe impl Send for KhrDepthStencilResolveFn {} +unsafe impl Sync for KhrDepthStencilResolveFn {} +impl ::std::clone::Clone for KhrDepthStencilResolveFn { + fn clone(&self) -> Self { + KhrDepthStencilResolveFn {} + } +} +impl KhrDepthStencilResolveFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + KhrDepthStencilResolveFn {} + } +} +#[doc = "Generated from \'VK_KHR_depth_stencil_resolve\'"] +impl StructureType { + pub const PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES_KHR: Self = + StructureType::PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES; +} +#[doc = "Generated from \'VK_KHR_depth_stencil_resolve\'"] +impl StructureType { + pub const SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE_KHR: Self = + StructureType::SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE; +} +#[doc = "Generated from \'VK_KHR_depth_stencil_resolve\'"] +impl ResolveModeFlags { + pub const NONE_KHR: Self = ResolveModeFlags::NONE; +} +#[doc = "Generated from \'VK_KHR_depth_stencil_resolve\'"] +impl ResolveModeFlags { + pub const SAMPLE_ZERO_KHR: Self = ResolveModeFlags::SAMPLE_ZERO; +} +#[doc = "Generated from \'VK_KHR_depth_stencil_resolve\'"] +impl ResolveModeFlags { + pub const AVERAGE_KHR: Self = ResolveModeFlags::AVERAGE; +} +#[doc = "Generated from \'VK_KHR_depth_stencil_resolve\'"] +impl ResolveModeFlags { + pub const MIN_KHR: Self = ResolveModeFlags::MIN; +} +#[doc = "Generated from \'VK_KHR_depth_stencil_resolve\'"] +impl ResolveModeFlags { + pub const MAX_KHR: Self = ResolveModeFlags::MAX; +} +impl KhrSwapchainMutableFormatFn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_swapchain_mutable_format\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 1u32; +} +pub struct KhrSwapchainMutableFormatFn {} +unsafe impl Send for KhrSwapchainMutableFormatFn {} +unsafe impl Sync for KhrSwapchainMutableFormatFn {} +impl ::std::clone::Clone for KhrSwapchainMutableFormatFn { + fn clone(&self) -> Self { + KhrSwapchainMutableFormatFn {} + } +} +impl KhrSwapchainMutableFormatFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + KhrSwapchainMutableFormatFn {} + } +} +#[doc = "Generated from \'VK_KHR_swapchain_mutable_format\'"] +impl SwapchainCreateFlagsKHR { + pub const MUTABLE_FORMAT: Self = Self(0b100); +} +impl NvComputeShaderDerivativesFn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_compute_shader_derivatives\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 1u32; +} +pub struct NvComputeShaderDerivativesFn {} +unsafe impl Send for NvComputeShaderDerivativesFn {} +unsafe impl Sync for NvComputeShaderDerivativesFn {} +impl ::std::clone::Clone for NvComputeShaderDerivativesFn { + fn clone(&self) -> Self { + NvComputeShaderDerivativesFn {} + } +} +impl NvComputeShaderDerivativesFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + NvComputeShaderDerivativesFn {} + } +} +#[doc = "Generated from \'VK_NV_compute_shader_derivatives\'"] +impl StructureType { + pub const PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV: Self = Self(1_000_201_000); +} +impl NvMeshShaderFn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_mesh_shader\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkCmdDrawMeshTasksNV = + extern "system" fn(command_buffer: CommandBuffer, task_count: u32, first_task: u32) -> c_void; +#[allow(non_camel_case_types)] +pub type PFN_vkCmdDrawMeshTasksIndirectNV = extern "system" fn( + command_buffer: CommandBuffer, + buffer: Buffer, + offset: DeviceSize, + draw_count: u32, + stride: u32, +) -> c_void; +#[allow(non_camel_case_types)] +pub type PFN_vkCmdDrawMeshTasksIndirectCountNV = extern "system" fn( + command_buffer: CommandBuffer, + buffer: Buffer, + offset: DeviceSize, + count_buffer: Buffer, + count_buffer_offset: DeviceSize, + max_draw_count: u32, + stride: u32, +) -> c_void; +pub struct NvMeshShaderFn { + pub cmd_draw_mesh_tasks_nv: extern "system" fn( + command_buffer: CommandBuffer, + task_count: u32, + first_task: u32, + ) -> c_void, + pub cmd_draw_mesh_tasks_indirect_nv: extern "system" fn( + command_buffer: CommandBuffer, + buffer: Buffer, + offset: DeviceSize, + draw_count: u32, + stride: u32, + ) -> c_void, + pub cmd_draw_mesh_tasks_indirect_count_nv: extern "system" fn( + command_buffer: CommandBuffer, + buffer: Buffer, + offset: DeviceSize, + count_buffer: Buffer, + count_buffer_offset: DeviceSize, + max_draw_count: u32, + stride: u32, + ) -> c_void, +} +unsafe impl Send for NvMeshShaderFn {} +unsafe impl Sync for NvMeshShaderFn {} +impl ::std::clone::Clone for NvMeshShaderFn { + fn clone(&self) -> Self { + NvMeshShaderFn { + cmd_draw_mesh_tasks_nv: self.cmd_draw_mesh_tasks_nv, + cmd_draw_mesh_tasks_indirect_nv: self.cmd_draw_mesh_tasks_indirect_nv, + cmd_draw_mesh_tasks_indirect_count_nv: self.cmd_draw_mesh_tasks_indirect_count_nv, + } + } +} +impl NvMeshShaderFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + NvMeshShaderFn { + cmd_draw_mesh_tasks_nv: unsafe { + extern "system" fn cmd_draw_mesh_tasks_nv( + _command_buffer: CommandBuffer, + _task_count: u32, + _first_task: u32, + ) -> c_void { + panic!(concat!( + "Unable to load ", + stringify!(cmd_draw_mesh_tasks_nv) + )) + } + let raw_name = stringify!(vkCmdDrawMeshTasksNV); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + cmd_draw_mesh_tasks_nv + } else { + ::std::mem::transmute(val) + } + }, + cmd_draw_mesh_tasks_indirect_nv: unsafe { + extern "system" fn cmd_draw_mesh_tasks_indirect_nv( + _command_buffer: CommandBuffer, + _buffer: Buffer, + _offset: DeviceSize, + _draw_count: u32, + _stride: u32, + ) -> c_void { + panic!(concat!( + "Unable to load ", + stringify!(cmd_draw_mesh_tasks_indirect_nv) + )) + } + let raw_name = stringify!(vkCmdDrawMeshTasksIndirectNV); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + cmd_draw_mesh_tasks_indirect_nv + } else { + ::std::mem::transmute(val) + } + }, + cmd_draw_mesh_tasks_indirect_count_nv: unsafe { + extern "system" fn cmd_draw_mesh_tasks_indirect_count_nv( + _command_buffer: CommandBuffer, + _buffer: Buffer, + _offset: DeviceSize, + _count_buffer: Buffer, + _count_buffer_offset: DeviceSize, + _max_draw_count: u32, + _stride: u32, + ) -> c_void { + panic!(concat!( + "Unable to load ", + stringify!(cmd_draw_mesh_tasks_indirect_count_nv) + )) + } + let raw_name = stringify!(vkCmdDrawMeshTasksIndirectCountNV); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + cmd_draw_mesh_tasks_indirect_count_nv + } else { + ::std::mem::transmute(val) + } + }, + } + } + #[doc = ""] + pub unsafe fn cmd_draw_mesh_tasks_nv( + &self, + command_buffer: CommandBuffer, + task_count: u32, + first_task: u32, + ) -> c_void { + (self.cmd_draw_mesh_tasks_nv)(command_buffer, task_count, first_task) + } + #[doc = ""] + pub unsafe fn cmd_draw_mesh_tasks_indirect_nv( + &self, + command_buffer: CommandBuffer, + buffer: Buffer, + offset: DeviceSize, + draw_count: u32, + stride: u32, + ) -> c_void { + (self.cmd_draw_mesh_tasks_indirect_nv)(command_buffer, buffer, offset, draw_count, stride) + } + #[doc = ""] + pub unsafe fn cmd_draw_mesh_tasks_indirect_count_nv( + &self, + command_buffer: CommandBuffer, + buffer: Buffer, + offset: DeviceSize, + count_buffer: Buffer, + count_buffer_offset: DeviceSize, + max_draw_count: u32, + stride: u32, + ) -> c_void { + (self.cmd_draw_mesh_tasks_indirect_count_nv)( + command_buffer, + buffer, + offset, + count_buffer, + count_buffer_offset, + max_draw_count, + stride, + ) + } +} +#[doc = "Generated from \'VK_NV_mesh_shader\'"] +impl StructureType { + pub const PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV: Self = Self(1_000_202_000); +} +#[doc = "Generated from \'VK_NV_mesh_shader\'"] +impl StructureType { + pub const PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV: Self = Self(1_000_202_001); +} +#[doc = "Generated from \'VK_NV_mesh_shader\'"] +impl ShaderStageFlags { + pub const TASK_NV: Self = Self(0b100_0000); +} +#[doc = "Generated from \'VK_NV_mesh_shader\'"] +impl ShaderStageFlags { + pub const MESH_NV: Self = Self(0b1000_0000); +} +#[doc = "Generated from \'VK_NV_mesh_shader\'"] +impl PipelineStageFlags { + pub const TASK_SHADER_NV: Self = Self(0b1000_0000_0000_0000_0000); +} +#[doc = "Generated from \'VK_NV_mesh_shader\'"] +impl PipelineStageFlags { + pub const MESH_SHADER_NV: Self = Self(0b1_0000_0000_0000_0000_0000); +} +impl NvFragmentShaderBarycentricFn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_fragment_shader_barycentric\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 1u32; +} +pub struct NvFragmentShaderBarycentricFn {} +unsafe impl Send for NvFragmentShaderBarycentricFn {} +unsafe impl Sync for NvFragmentShaderBarycentricFn {} +impl ::std::clone::Clone for NvFragmentShaderBarycentricFn { + fn clone(&self) -> Self { + NvFragmentShaderBarycentricFn {} + } +} +impl NvFragmentShaderBarycentricFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + NvFragmentShaderBarycentricFn {} + } +} +#[doc = "Generated from \'VK_NV_fragment_shader_barycentric\'"] +impl StructureType { + pub const PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV: Self = Self(1_000_203_000); +} +impl NvShaderImageFootprintFn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_shader_image_footprint\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 2u32; +} +pub struct NvShaderImageFootprintFn {} +unsafe impl Send for NvShaderImageFootprintFn {} +unsafe impl Sync for NvShaderImageFootprintFn {} +impl ::std::clone::Clone for NvShaderImageFootprintFn { + fn clone(&self) -> Self { + NvShaderImageFootprintFn {} + } +} +impl NvShaderImageFootprintFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + NvShaderImageFootprintFn {} + } +} +#[doc = "Generated from \'VK_NV_shader_image_footprint\'"] +impl StructureType { + pub const PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV: Self = Self(1_000_204_000); +} +impl NvScissorExclusiveFn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_scissor_exclusive\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetExclusiveScissorNV = extern "system" fn( + command_buffer: CommandBuffer, + first_exclusive_scissor: u32, + exclusive_scissor_count: u32, + p_exclusive_scissors: *const Rect2D, +) -> c_void; +pub struct NvScissorExclusiveFn { + pub cmd_set_exclusive_scissor_nv: extern "system" fn( + command_buffer: CommandBuffer, + first_exclusive_scissor: u32, + exclusive_scissor_count: u32, + p_exclusive_scissors: *const Rect2D, + ) -> c_void, +} +unsafe impl Send for NvScissorExclusiveFn {} +unsafe impl Sync for NvScissorExclusiveFn {} +impl ::std::clone::Clone for NvScissorExclusiveFn { + fn clone(&self) -> Self { + NvScissorExclusiveFn { + cmd_set_exclusive_scissor_nv: self.cmd_set_exclusive_scissor_nv, + } + } +} +impl NvScissorExclusiveFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + NvScissorExclusiveFn { + cmd_set_exclusive_scissor_nv: unsafe { + extern "system" fn cmd_set_exclusive_scissor_nv( + _command_buffer: CommandBuffer, + _first_exclusive_scissor: u32, + _exclusive_scissor_count: u32, + _p_exclusive_scissors: *const Rect2D, + ) -> c_void { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_exclusive_scissor_nv) + )) + } + let raw_name = stringify!(vkCmdSetExclusiveScissorNV); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + cmd_set_exclusive_scissor_nv + } else { + ::std::mem::transmute(val) + } + }, + } + } + #[doc = ""] + pub unsafe fn cmd_set_exclusive_scissor_nv( + &self, + command_buffer: CommandBuffer, + first_exclusive_scissor: u32, + exclusive_scissor_count: u32, + p_exclusive_scissors: *const Rect2D, + ) -> c_void { + (self.cmd_set_exclusive_scissor_nv)( + command_buffer, + first_exclusive_scissor, + exclusive_scissor_count, + p_exclusive_scissors, + ) + } +} +#[doc = "Generated from \'VK_NV_scissor_exclusive\'"] +impl StructureType { + pub const PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV: Self = Self(1_000_205_000); +} +#[doc = "Generated from \'VK_NV_scissor_exclusive\'"] +impl DynamicState { + pub const EXCLUSIVE_SCISSOR_NV: Self = Self(1_000_205_001); +} +#[doc = "Generated from \'VK_NV_scissor_exclusive\'"] +impl StructureType { + pub const PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV: Self = Self(1_000_205_002); +} +impl NvDeviceDiagnosticCheckpointsFn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_device_diagnostic_checkpoints\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 2u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetCheckpointNV = + extern "system" fn(command_buffer: CommandBuffer, p_checkpoint_marker: *const c_void) -> c_void; +#[allow(non_camel_case_types)] +pub type PFN_vkGetQueueCheckpointDataNV = extern "system" fn( + queue: Queue, + p_checkpoint_data_count: *mut u32, + p_checkpoint_data: *mut CheckpointDataNV, +) -> c_void; +pub struct NvDeviceDiagnosticCheckpointsFn { + pub cmd_set_checkpoint_nv: extern "system" fn( + command_buffer: CommandBuffer, + p_checkpoint_marker: *const c_void, + ) -> c_void, + pub get_queue_checkpoint_data_nv: extern "system" fn( + queue: Queue, + p_checkpoint_data_count: *mut u32, + p_checkpoint_data: *mut CheckpointDataNV, + ) -> c_void, +} +unsafe impl Send for NvDeviceDiagnosticCheckpointsFn {} +unsafe impl Sync for NvDeviceDiagnosticCheckpointsFn {} +impl ::std::clone::Clone for NvDeviceDiagnosticCheckpointsFn { + fn clone(&self) -> Self { + NvDeviceDiagnosticCheckpointsFn { + cmd_set_checkpoint_nv: self.cmd_set_checkpoint_nv, + get_queue_checkpoint_data_nv: self.get_queue_checkpoint_data_nv, + } + } +} +impl NvDeviceDiagnosticCheckpointsFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + NvDeviceDiagnosticCheckpointsFn { + cmd_set_checkpoint_nv: unsafe { + extern "system" fn cmd_set_checkpoint_nv( + _command_buffer: CommandBuffer, + _p_checkpoint_marker: *const c_void, + ) -> c_void { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_checkpoint_nv) + )) + } + let raw_name = stringify!(vkCmdSetCheckpointNV); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + cmd_set_checkpoint_nv + } else { + ::std::mem::transmute(val) + } + }, + get_queue_checkpoint_data_nv: unsafe { + extern "system" fn get_queue_checkpoint_data_nv( + _queue: Queue, + _p_checkpoint_data_count: *mut u32, + _p_checkpoint_data: *mut CheckpointDataNV, + ) -> c_void { + panic!(concat!( + "Unable to load ", + stringify!(get_queue_checkpoint_data_nv) + )) + } + let raw_name = stringify!(vkGetQueueCheckpointDataNV); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + get_queue_checkpoint_data_nv + } else { + ::std::mem::transmute(val) + } + }, + } + } + #[doc = ""] + pub unsafe fn cmd_set_checkpoint_nv( + &self, + command_buffer: CommandBuffer, + p_checkpoint_marker: *const c_void, + ) -> c_void { + (self.cmd_set_checkpoint_nv)(command_buffer, p_checkpoint_marker) + } + #[doc = ""] + pub unsafe fn get_queue_checkpoint_data_nv( + &self, + queue: Queue, + p_checkpoint_data_count: *mut u32, + p_checkpoint_data: *mut CheckpointDataNV, + ) -> c_void { + (self.get_queue_checkpoint_data_nv)(queue, p_checkpoint_data_count, p_checkpoint_data) + } +} +#[doc = "Generated from \'VK_NV_device_diagnostic_checkpoints\'"] +impl StructureType { + pub const CHECKPOINT_DATA_NV: Self = Self(1_000_206_000); +} +#[doc = "Generated from \'VK_NV_device_diagnostic_checkpoints\'"] +impl StructureType { + pub const QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV: Self = Self(1_000_206_001); +} +impl KhrTimelineSemaphoreFn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_timeline_semaphore\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 2u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkGetSemaphoreCounterValue = + extern "system" fn(device: Device, semaphore: Semaphore, p_value: *mut u64) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkWaitSemaphores = extern "system" fn( + device: Device, + p_wait_info: *const SemaphoreWaitInfo, + timeout: u64, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkSignalSemaphore = + extern "system" fn(device: Device, p_signal_info: *const SemaphoreSignalInfo) -> Result; +pub struct KhrTimelineSemaphoreFn { + pub get_semaphore_counter_value_khr: + extern "system" fn(device: Device, semaphore: Semaphore, p_value: *mut u64) -> Result, + pub wait_semaphores_khr: extern "system" fn( + device: Device, + p_wait_info: *const SemaphoreWaitInfo, + timeout: u64, + ) -> Result, + pub signal_semaphore_khr: + extern "system" fn(device: Device, p_signal_info: *const SemaphoreSignalInfo) -> Result, +} +unsafe impl Send for KhrTimelineSemaphoreFn {} +unsafe impl Sync for KhrTimelineSemaphoreFn {} +impl ::std::clone::Clone for KhrTimelineSemaphoreFn { + fn clone(&self) -> Self { + KhrTimelineSemaphoreFn { + get_semaphore_counter_value_khr: self.get_semaphore_counter_value_khr, + wait_semaphores_khr: self.wait_semaphores_khr, + signal_semaphore_khr: self.signal_semaphore_khr, + } + } +} +impl KhrTimelineSemaphoreFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + KhrTimelineSemaphoreFn { + get_semaphore_counter_value_khr: unsafe { + extern "system" fn get_semaphore_counter_value_khr( + _device: Device, + _semaphore: Semaphore, + _p_value: *mut u64, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_semaphore_counter_value_khr) + )) + } + let raw_name = stringify!(vkGetSemaphoreCounterValueKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + get_semaphore_counter_value_khr + } else { + ::std::mem::transmute(val) + } + }, + wait_semaphores_khr: unsafe { + extern "system" fn wait_semaphores_khr( + _device: Device, + _p_wait_info: *const SemaphoreWaitInfo, + _timeout: u64, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(wait_semaphores_khr))) + } + let raw_name = stringify!(vkWaitSemaphoresKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + wait_semaphores_khr + } else { + ::std::mem::transmute(val) + } + }, + signal_semaphore_khr: unsafe { + extern "system" fn signal_semaphore_khr( + _device: Device, + _p_signal_info: *const SemaphoreSignalInfo, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(signal_semaphore_khr))) + } + let raw_name = stringify!(vkSignalSemaphoreKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + signal_semaphore_khr + } else { + ::std::mem::transmute(val) + } + }, + } + } + #[doc = ""] + pub unsafe fn get_semaphore_counter_value_khr( + &self, + device: Device, + semaphore: Semaphore, + p_value: *mut u64, + ) -> Result { + (self.get_semaphore_counter_value_khr)(device, semaphore, p_value) + } + #[doc = ""] + pub unsafe fn wait_semaphores_khr( + &self, + device: Device, + p_wait_info: *const SemaphoreWaitInfo, + timeout: u64, + ) -> Result { + (self.wait_semaphores_khr)(device, p_wait_info, timeout) + } + #[doc = ""] + pub unsafe fn signal_semaphore_khr( + &self, + device: Device, + p_signal_info: *const SemaphoreSignalInfo, + ) -> Result { + (self.signal_semaphore_khr)(device, p_signal_info) + } +} +#[doc = "Generated from \'VK_KHR_timeline_semaphore\'"] +impl StructureType { + pub const PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES_KHR: Self = + StructureType::PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES; +} +#[doc = "Generated from \'VK_KHR_timeline_semaphore\'"] +impl StructureType { + pub const PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES_KHR: Self = + StructureType::PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES; +} +#[doc = "Generated from \'VK_KHR_timeline_semaphore\'"] +impl StructureType { + pub const SEMAPHORE_TYPE_CREATE_INFO_KHR: Self = StructureType::SEMAPHORE_TYPE_CREATE_INFO; +} +#[doc = "Generated from \'VK_KHR_timeline_semaphore\'"] +impl StructureType { + pub const TIMELINE_SEMAPHORE_SUBMIT_INFO_KHR: Self = + StructureType::TIMELINE_SEMAPHORE_SUBMIT_INFO; +} +#[doc = "Generated from \'VK_KHR_timeline_semaphore\'"] +impl StructureType { + pub const SEMAPHORE_WAIT_INFO_KHR: Self = StructureType::SEMAPHORE_WAIT_INFO; +} +#[doc = "Generated from \'VK_KHR_timeline_semaphore\'"] +impl StructureType { + pub const SEMAPHORE_SIGNAL_INFO_KHR: Self = StructureType::SEMAPHORE_SIGNAL_INFO; +} +#[doc = "Generated from \'VK_KHR_timeline_semaphore\'"] +impl SemaphoreType { + pub const BINARY_KHR: Self = SemaphoreType::BINARY; +} +#[doc = "Generated from \'VK_KHR_timeline_semaphore\'"] +impl SemaphoreType { + pub const TIMELINE_KHR: Self = SemaphoreType::TIMELINE; +} +#[doc = "Generated from \'VK_KHR_timeline_semaphore\'"] +impl SemaphoreWaitFlags { + pub const ANY_KHR: Self = SemaphoreWaitFlags::ANY; +} +impl KhrExtension209Fn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_extension_209\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 0u32; +} +pub struct KhrExtension209Fn {} +unsafe impl Send for KhrExtension209Fn {} +unsafe impl Sync for KhrExtension209Fn {} +impl ::std::clone::Clone for KhrExtension209Fn { + fn clone(&self) -> Self { + KhrExtension209Fn {} + } +} +impl KhrExtension209Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + KhrExtension209Fn {} + } +} +impl IntelShaderIntegerFunctions2Fn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_INTEL_shader_integer_functions2\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 1u32; +} +pub struct IntelShaderIntegerFunctions2Fn {} +unsafe impl Send for IntelShaderIntegerFunctions2Fn {} +unsafe impl Sync for IntelShaderIntegerFunctions2Fn {} +impl ::std::clone::Clone for IntelShaderIntegerFunctions2Fn { + fn clone(&self) -> Self { + IntelShaderIntegerFunctions2Fn {} + } +} +impl IntelShaderIntegerFunctions2Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + IntelShaderIntegerFunctions2Fn {} + } +} +#[doc = "Generated from \'VK_INTEL_shader_integer_functions2\'"] +impl StructureType { + pub const PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL: Self = Self(1_000_209_000); +} +impl IntelPerformanceQueryFn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_INTEL_performance_query\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 2u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkInitializePerformanceApiINTEL = extern "system" fn( + device: Device, + p_initialize_info: *const InitializePerformanceApiInfoINTEL, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkUninitializePerformanceApiINTEL = extern "system" fn(device: Device) -> c_void; +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetPerformanceMarkerINTEL = extern "system" fn( + command_buffer: CommandBuffer, + p_marker_info: *const PerformanceMarkerInfoINTEL, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetPerformanceStreamMarkerINTEL = extern "system" fn( + command_buffer: CommandBuffer, + p_marker_info: *const PerformanceStreamMarkerInfoINTEL, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetPerformanceOverrideINTEL = extern "system" fn( + command_buffer: CommandBuffer, + p_override_info: *const PerformanceOverrideInfoINTEL, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkAcquirePerformanceConfigurationINTEL = extern "system" fn( + device: Device, + p_acquire_info: *const PerformanceConfigurationAcquireInfoINTEL, + p_configuration: *mut PerformanceConfigurationINTEL, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkReleasePerformanceConfigurationINTEL = + extern "system" fn(device: Device, configuration: PerformanceConfigurationINTEL) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkQueueSetPerformanceConfigurationINTEL = + extern "system" fn(queue: Queue, configuration: PerformanceConfigurationINTEL) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetPerformanceParameterINTEL = extern "system" fn( + device: Device, + parameter: PerformanceParameterTypeINTEL, + p_value: *mut PerformanceValueINTEL, +) -> Result; +pub struct IntelPerformanceQueryFn { + pub initialize_performance_api_intel: extern "system" fn( + device: Device, + p_initialize_info: *const InitializePerformanceApiInfoINTEL, + ) -> Result, + pub uninitialize_performance_api_intel: extern "system" fn(device: Device) -> c_void, + pub cmd_set_performance_marker_intel: extern "system" fn( + command_buffer: CommandBuffer, + p_marker_info: *const PerformanceMarkerInfoINTEL, + ) -> Result, + pub cmd_set_performance_stream_marker_intel: extern "system" fn( + command_buffer: CommandBuffer, + p_marker_info: *const PerformanceStreamMarkerInfoINTEL, + ) -> Result, + pub cmd_set_performance_override_intel: extern "system" fn( + command_buffer: CommandBuffer, + p_override_info: *const PerformanceOverrideInfoINTEL, + ) -> Result, + pub acquire_performance_configuration_intel: extern "system" fn( + device: Device, + p_acquire_info: *const PerformanceConfigurationAcquireInfoINTEL, + p_configuration: *mut PerformanceConfigurationINTEL, + ) -> Result, + pub release_performance_configuration_intel: + extern "system" fn(device: Device, configuration: PerformanceConfigurationINTEL) -> Result, + pub queue_set_performance_configuration_intel: + extern "system" fn(queue: Queue, configuration: PerformanceConfigurationINTEL) -> Result, + pub get_performance_parameter_intel: extern "system" fn( + device: Device, + parameter: PerformanceParameterTypeINTEL, + p_value: *mut PerformanceValueINTEL, + ) -> Result, +} +unsafe impl Send for IntelPerformanceQueryFn {} +unsafe impl Sync for IntelPerformanceQueryFn {} +impl ::std::clone::Clone for IntelPerformanceQueryFn { + fn clone(&self) -> Self { + IntelPerformanceQueryFn { + initialize_performance_api_intel: self.initialize_performance_api_intel, + uninitialize_performance_api_intel: self.uninitialize_performance_api_intel, + cmd_set_performance_marker_intel: self.cmd_set_performance_marker_intel, + cmd_set_performance_stream_marker_intel: self.cmd_set_performance_stream_marker_intel, + cmd_set_performance_override_intel: self.cmd_set_performance_override_intel, + acquire_performance_configuration_intel: self.acquire_performance_configuration_intel, + release_performance_configuration_intel: self.release_performance_configuration_intel, + queue_set_performance_configuration_intel: self + .queue_set_performance_configuration_intel, + get_performance_parameter_intel: self.get_performance_parameter_intel, + } + } +} +impl IntelPerformanceQueryFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + IntelPerformanceQueryFn { + initialize_performance_api_intel: unsafe { + extern "system" fn initialize_performance_api_intel( + _device: Device, + _p_initialize_info: *const InitializePerformanceApiInfoINTEL, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(initialize_performance_api_intel) + )) + } + let raw_name = stringify!(vkInitializePerformanceApiINTEL); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + initialize_performance_api_intel + } else { + ::std::mem::transmute(val) + } + }, + uninitialize_performance_api_intel: unsafe { + extern "system" fn uninitialize_performance_api_intel(_device: Device) -> c_void { + panic!(concat!( + "Unable to load ", + stringify!(uninitialize_performance_api_intel) + )) + } + let raw_name = stringify!(vkUninitializePerformanceApiINTEL); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + uninitialize_performance_api_intel + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_performance_marker_intel: 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 raw_name = stringify!(vkCmdSetPerformanceMarkerINTEL); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + cmd_set_performance_marker_intel + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_performance_stream_marker_intel: unsafe { + 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 raw_name = stringify!(vkCmdSetPerformanceStreamMarkerINTEL); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + cmd_set_performance_stream_marker_intel + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_performance_override_intel: unsafe { + 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 raw_name = stringify!(vkCmdSetPerformanceOverrideINTEL); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + cmd_set_performance_override_intel + } else { + ::std::mem::transmute(val) + } + }, + acquire_performance_configuration_intel: unsafe { + extern "system" fn acquire_performance_configuration_intel( + _device: Device, + _p_acquire_info: *const PerformanceConfigurationAcquireInfoINTEL, + _p_configuration: *mut PerformanceConfigurationINTEL, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(acquire_performance_configuration_intel) + )) + } + let raw_name = stringify!(vkAcquirePerformanceConfigurationINTEL); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + acquire_performance_configuration_intel + } else { + ::std::mem::transmute(val) + } + }, + release_performance_configuration_intel: unsafe { + extern "system" fn release_performance_configuration_intel( + _device: Device, + _configuration: PerformanceConfigurationINTEL, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(release_performance_configuration_intel) + )) + } + let raw_name = stringify!(vkReleasePerformanceConfigurationINTEL); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + release_performance_configuration_intel + } else { + ::std::mem::transmute(val) + } + }, + queue_set_performance_configuration_intel: 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 raw_name = stringify!(vkQueueSetPerformanceConfigurationINTEL); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + queue_set_performance_configuration_intel + } else { + ::std::mem::transmute(val) + } + }, + get_performance_parameter_intel: unsafe { + extern "system" fn get_performance_parameter_intel( + _device: Device, + _parameter: PerformanceParameterTypeINTEL, + _p_value: *mut PerformanceValueINTEL, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_performance_parameter_intel) + )) + } + let raw_name = stringify!(vkGetPerformanceParameterINTEL); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + get_performance_parameter_intel + } else { + ::std::mem::transmute(val) + } + }, + } + } + #[doc = ""] + pub unsafe fn initialize_performance_api_intel( + &self, + device: Device, + p_initialize_info: *const InitializePerformanceApiInfoINTEL, + ) -> Result { + (self.initialize_performance_api_intel)(device, p_initialize_info) + } + #[doc = ""] + pub unsafe fn uninitialize_performance_api_intel(&self, device: Device) -> c_void { + (self.uninitialize_performance_api_intel)(device) + } + #[doc = ""] + pub unsafe fn cmd_set_performance_marker_intel( + &self, + command_buffer: CommandBuffer, + p_marker_info: *const PerformanceMarkerInfoINTEL, + ) -> Result { + (self.cmd_set_performance_marker_intel)(command_buffer, p_marker_info) + } + #[doc = ""] + pub unsafe fn cmd_set_performance_stream_marker_intel( + &self, + command_buffer: CommandBuffer, + p_marker_info: *const PerformanceStreamMarkerInfoINTEL, + ) -> Result { + (self.cmd_set_performance_stream_marker_intel)(command_buffer, p_marker_info) + } + #[doc = ""] + pub unsafe fn cmd_set_performance_override_intel( + &self, + command_buffer: CommandBuffer, + p_override_info: *const PerformanceOverrideInfoINTEL, + ) -> Result { + (self.cmd_set_performance_override_intel)(command_buffer, p_override_info) + } + #[doc = ""] + pub unsafe fn acquire_performance_configuration_intel( + &self, + device: Device, + p_acquire_info: *const PerformanceConfigurationAcquireInfoINTEL, + p_configuration: *mut PerformanceConfigurationINTEL, + ) -> Result { + (self.acquire_performance_configuration_intel)(device, p_acquire_info, p_configuration) + } + #[doc = ""] + pub unsafe fn release_performance_configuration_intel( + &self, + device: Device, + configuration: PerformanceConfigurationINTEL, + ) -> Result { + (self.release_performance_configuration_intel)(device, configuration) + } + #[doc = ""] + pub unsafe fn queue_set_performance_configuration_intel( + &self, + queue: Queue, + configuration: PerformanceConfigurationINTEL, + ) -> Result { + (self.queue_set_performance_configuration_intel)(queue, configuration) + } + #[doc = ""] + pub unsafe fn get_performance_parameter_intel( + &self, + device: Device, + parameter: PerformanceParameterTypeINTEL, + p_value: *mut PerformanceValueINTEL, + ) -> Result { + (self.get_performance_parameter_intel)(device, parameter, p_value) + } +} +#[doc = "Generated from \'VK_INTEL_performance_query\'"] +impl StructureType { + pub const QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL: Self = Self(1_000_210_000); +} +#[doc = "Generated from \'VK_INTEL_performance_query\'"] +impl StructureType { + pub const QUERY_POOL_CREATE_INFO_INTEL: Self = + StructureType::QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL; +} +#[doc = "Generated from \'VK_INTEL_performance_query\'"] +impl StructureType { + pub const INITIALIZE_PERFORMANCE_API_INFO_INTEL: Self = Self(1_000_210_001); +} +#[doc = "Generated from \'VK_INTEL_performance_query\'"] +impl StructureType { + pub const PERFORMANCE_MARKER_INFO_INTEL: Self = Self(1_000_210_002); +} +#[doc = "Generated from \'VK_INTEL_performance_query\'"] +impl StructureType { + pub const PERFORMANCE_STREAM_MARKER_INFO_INTEL: Self = Self(1_000_210_003); +} +#[doc = "Generated from \'VK_INTEL_performance_query\'"] +impl StructureType { + pub const PERFORMANCE_OVERRIDE_INFO_INTEL: Self = Self(1_000_210_004); +} +#[doc = "Generated from \'VK_INTEL_performance_query\'"] +impl StructureType { + pub const PERFORMANCE_CONFIGURATION_ACQUIRE_INFO_INTEL: Self = Self(1_000_210_005); +} +#[doc = "Generated from \'VK_INTEL_performance_query\'"] +impl QueryType { + pub const PERFORMANCE_QUERY_INTEL: Self = Self(1_000_210_000); +} +#[doc = "Generated from \'VK_INTEL_performance_query\'"] +impl ObjectType { + pub const PERFORMANCE_CONFIGURATION_INTEL: Self = Self(1_000_210_000); +} +impl KhrVulkanMemoryModelFn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_vulkan_memory_model\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 3u32; +} +pub struct KhrVulkanMemoryModelFn {} +unsafe impl Send for KhrVulkanMemoryModelFn {} +unsafe impl Sync for KhrVulkanMemoryModelFn {} +impl ::std::clone::Clone for KhrVulkanMemoryModelFn { + fn clone(&self) -> Self { + KhrVulkanMemoryModelFn {} + } +} +impl KhrVulkanMemoryModelFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + KhrVulkanMemoryModelFn {} + } +} +#[doc = "Generated from \'VK_KHR_vulkan_memory_model\'"] +impl StructureType { + pub const PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES_KHR: Self = + StructureType::PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES; +} +impl ExtPciBusInfoFn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_pci_bus_info\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 2u32; +} +pub struct ExtPciBusInfoFn {} +unsafe impl Send for ExtPciBusInfoFn {} +unsafe impl Sync for ExtPciBusInfoFn {} +impl ::std::clone::Clone for ExtPciBusInfoFn { + fn clone(&self) -> Self { + ExtPciBusInfoFn {} + } +} +impl ExtPciBusInfoFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + ExtPciBusInfoFn {} + } +} +#[doc = "Generated from \'VK_EXT_pci_bus_info\'"] +impl StructureType { + pub const PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT: Self = Self(1_000_212_000); +} +impl AmdDisplayNativeHdrFn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_AMD_display_native_hdr\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkSetLocalDimmingAMD = extern "system" fn( + device: Device, + swap_chain: SwapchainKHR, + local_dimming_enable: Bool32, +) -> c_void; +pub struct AmdDisplayNativeHdrFn { + pub set_local_dimming_amd: extern "system" fn( + device: Device, + swap_chain: SwapchainKHR, + local_dimming_enable: Bool32, + ) -> c_void, +} +unsafe impl Send for AmdDisplayNativeHdrFn {} +unsafe impl Sync for AmdDisplayNativeHdrFn {} +impl ::std::clone::Clone for AmdDisplayNativeHdrFn { + fn clone(&self) -> Self { + AmdDisplayNativeHdrFn { + set_local_dimming_amd: self.set_local_dimming_amd, + } + } +} +impl AmdDisplayNativeHdrFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + AmdDisplayNativeHdrFn { + set_local_dimming_amd: unsafe { + extern "system" fn set_local_dimming_amd( + _device: Device, + _swap_chain: SwapchainKHR, + _local_dimming_enable: Bool32, + ) -> c_void { + panic!(concat!( + "Unable to load ", + stringify!(set_local_dimming_amd) + )) + } + let raw_name = stringify!(vkSetLocalDimmingAMD); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + set_local_dimming_amd + } else { + ::std::mem::transmute(val) + } + }, + } + } + #[doc = ""] + pub unsafe fn set_local_dimming_amd( + &self, + device: Device, + swap_chain: SwapchainKHR, + local_dimming_enable: Bool32, + ) -> c_void { + (self.set_local_dimming_amd)(device, swap_chain, local_dimming_enable) + } +} +#[doc = "Generated from \'VK_AMD_display_native_hdr\'"] +impl StructureType { + pub const DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD: Self = Self(1_000_213_000); +} +#[doc = "Generated from \'VK_AMD_display_native_hdr\'"] +impl StructureType { + pub const SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD: Self = Self(1_000_213_001); +} +#[doc = "Generated from \'VK_AMD_display_native_hdr\'"] +impl ColorSpaceKHR { + pub const DISPLAY_NATIVE_AMD: Self = Self(1_000_213_000); +} +impl FuchsiaImagepipeSurfaceFn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_FUCHSIA_imagepipe_surface\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkCreateImagePipeSurfaceFUCHSIA = extern "system" fn( + instance: Instance, + p_create_info: *const ImagePipeSurfaceCreateInfoFUCHSIA, + p_allocator: *const AllocationCallbacks, + p_surface: *mut SurfaceKHR, +) -> Result; +pub struct FuchsiaImagepipeSurfaceFn { + pub create_image_pipe_surface_fuchsia: extern "system" fn( + instance: Instance, + p_create_info: *const ImagePipeSurfaceCreateInfoFUCHSIA, + p_allocator: *const AllocationCallbacks, + p_surface: *mut SurfaceKHR, + ) -> Result, +} +unsafe impl Send for FuchsiaImagepipeSurfaceFn {} +unsafe impl Sync for FuchsiaImagepipeSurfaceFn {} +impl ::std::clone::Clone for FuchsiaImagepipeSurfaceFn { + fn clone(&self) -> Self { + FuchsiaImagepipeSurfaceFn { + create_image_pipe_surface_fuchsia: self.create_image_pipe_surface_fuchsia, + } + } +} +impl FuchsiaImagepipeSurfaceFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + FuchsiaImagepipeSurfaceFn { + create_image_pipe_surface_fuchsia: unsafe { + extern "system" fn create_image_pipe_surface_fuchsia( + _instance: Instance, + _p_create_info: *const ImagePipeSurfaceCreateInfoFUCHSIA, + _p_allocator: *const AllocationCallbacks, + _p_surface: *mut SurfaceKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(create_image_pipe_surface_fuchsia) + )) + } + let raw_name = stringify!(vkCreateImagePipeSurfaceFUCHSIA); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + create_image_pipe_surface_fuchsia + } else { + ::std::mem::transmute(val) + } + }, + } + } + #[doc = ""] + pub unsafe fn create_image_pipe_surface_fuchsia( + &self, + instance: Instance, + p_create_info: *const ImagePipeSurfaceCreateInfoFUCHSIA, + p_allocator: *const AllocationCallbacks, + p_surface: *mut SurfaceKHR, + ) -> Result { + (self.create_image_pipe_surface_fuchsia)(instance, p_create_info, p_allocator, p_surface) + } +} +#[doc = "Generated from \'VK_FUCHSIA_imagepipe_surface\'"] +impl StructureType { + pub const IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA: Self = Self(1_000_214_000); +} +impl KhrShaderTerminateInvocationFn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_shader_terminate_invocation\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 1u32; +} +pub struct KhrShaderTerminateInvocationFn {} +unsafe impl Send for KhrShaderTerminateInvocationFn {} +unsafe impl Sync for KhrShaderTerminateInvocationFn {} +impl ::std::clone::Clone for KhrShaderTerminateInvocationFn { + fn clone(&self) -> Self { + KhrShaderTerminateInvocationFn {} + } +} +impl KhrShaderTerminateInvocationFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + KhrShaderTerminateInvocationFn {} + } +} +#[doc = "Generated from \'VK_KHR_shader_terminate_invocation\'"] +impl StructureType { + pub const PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES_KHR: Self = Self(1_000_215_000); +} +impl GoogleExtension217Fn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_GOOGLE_extension_217\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 0u32; +} +pub struct GoogleExtension217Fn {} +unsafe impl Send for GoogleExtension217Fn {} +unsafe impl Sync for GoogleExtension217Fn {} +impl ::std::clone::Clone for GoogleExtension217Fn { + fn clone(&self) -> Self { + GoogleExtension217Fn {} + } +} +impl GoogleExtension217Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + GoogleExtension217Fn {} + } +} +impl ExtMetalSurfaceFn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_metal_surface\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkCreateMetalSurfaceEXT = extern "system" fn( + instance: Instance, + p_create_info: *const MetalSurfaceCreateInfoEXT, + p_allocator: *const AllocationCallbacks, + p_surface: *mut SurfaceKHR, +) -> Result; +pub struct ExtMetalSurfaceFn { + pub create_metal_surface_ext: extern "system" fn( + instance: Instance, + p_create_info: *const MetalSurfaceCreateInfoEXT, + p_allocator: *const AllocationCallbacks, + p_surface: *mut SurfaceKHR, + ) -> Result, +} +unsafe impl Send for ExtMetalSurfaceFn {} +unsafe impl Sync for ExtMetalSurfaceFn {} +impl ::std::clone::Clone for ExtMetalSurfaceFn { + fn clone(&self) -> Self { + ExtMetalSurfaceFn { + create_metal_surface_ext: self.create_metal_surface_ext, + } + } +} +impl ExtMetalSurfaceFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + ExtMetalSurfaceFn { + create_metal_surface_ext: unsafe { + extern "system" fn create_metal_surface_ext( + _instance: Instance, + _p_create_info: *const MetalSurfaceCreateInfoEXT, + _p_allocator: *const AllocationCallbacks, + _p_surface: *mut SurfaceKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(create_metal_surface_ext) + )) + } + let raw_name = stringify!(vkCreateMetalSurfaceEXT); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + create_metal_surface_ext + } else { + ::std::mem::transmute(val) + } + }, + } + } + #[doc = ""] + pub unsafe fn create_metal_surface_ext( + &self, + instance: Instance, + p_create_info: *const MetalSurfaceCreateInfoEXT, + p_allocator: *const AllocationCallbacks, + p_surface: *mut SurfaceKHR, + ) -> Result { + (self.create_metal_surface_ext)(instance, p_create_info, p_allocator, p_surface) + } +} +#[doc = "Generated from \'VK_EXT_metal_surface\'"] +impl StructureType { + pub const METAL_SURFACE_CREATE_INFO_EXT: Self = Self(1_000_217_000); +} +impl ExtFragmentDensityMapFn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_fragment_density_map\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 1u32; +} +pub struct ExtFragmentDensityMapFn {} +unsafe impl Send for ExtFragmentDensityMapFn {} +unsafe impl Sync for ExtFragmentDensityMapFn {} +impl ::std::clone::Clone for ExtFragmentDensityMapFn { + fn clone(&self) -> Self { + ExtFragmentDensityMapFn {} + } +} +impl ExtFragmentDensityMapFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + ExtFragmentDensityMapFn {} + } +} +#[doc = "Generated from \'VK_EXT_fragment_density_map\'"] +impl StructureType { + pub const PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT: Self = Self(1_000_218_000); +} +#[doc = "Generated from \'VK_EXT_fragment_density_map\'"] +impl StructureType { + pub const PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT: Self = Self(1_000_218_001); +} +#[doc = "Generated from \'VK_EXT_fragment_density_map\'"] +impl StructureType { + pub const RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT: Self = Self(1_000_218_002); +} +#[doc = "Generated from \'VK_EXT_fragment_density_map\'"] +impl ImageCreateFlags { + pub const SUBSAMPLED_EXT: Self = Self(0b100_0000_0000_0000); +} +#[doc = "Generated from \'VK_EXT_fragment_density_map\'"] +impl ImageLayout { + pub const FRAGMENT_DENSITY_MAP_OPTIMAL_EXT: Self = Self(1_000_218_000); +} +#[doc = "Generated from \'VK_EXT_fragment_density_map\'"] +impl AccessFlags { + pub const FRAGMENT_DENSITY_MAP_READ_EXT: Self = Self(0b1_0000_0000_0000_0000_0000_0000); +} +#[doc = "Generated from \'VK_EXT_fragment_density_map\'"] +impl FormatFeatureFlags { + pub const FRAGMENT_DENSITY_MAP_EXT: Self = Self(0b1_0000_0000_0000_0000_0000_0000); +} +#[doc = "Generated from \'VK_EXT_fragment_density_map\'"] +impl ImageUsageFlags { + pub const FRAGMENT_DENSITY_MAP_EXT: Self = Self(0b10_0000_0000); +} +#[doc = "Generated from \'VK_EXT_fragment_density_map\'"] +impl ImageViewCreateFlags { + pub const FRAGMENT_DENSITY_MAP_DYNAMIC_EXT: Self = Self(0b1); +} +#[doc = "Generated from \'VK_EXT_fragment_density_map\'"] +impl PipelineStageFlags { + pub const FRAGMENT_DENSITY_PROCESS_EXT: Self = Self(0b1000_0000_0000_0000_0000_0000); +} +#[doc = "Generated from \'VK_EXT_fragment_density_map\'"] +impl SamplerCreateFlags { + pub const SUBSAMPLED_EXT: Self = Self(0b1); +} +#[doc = "Generated from \'VK_EXT_fragment_density_map\'"] +impl SamplerCreateFlags { + pub const SUBSAMPLED_COARSE_RECONSTRUCTION_EXT: Self = Self(0b10); +} +impl ExtExtension220Fn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_extension_220\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 0u32; +} +pub struct ExtExtension220Fn {} +unsafe impl Send for ExtExtension220Fn {} +unsafe impl Sync for ExtExtension220Fn {} +impl ::std::clone::Clone for ExtExtension220Fn { + fn clone(&self) -> Self { + ExtExtension220Fn {} + } +} +impl ExtExtension220Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + ExtExtension220Fn {} + } +} +impl KhrExtension221Fn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_filter_cubic\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_extension_221\0") .expect("Wrong extension string") } - pub const SPEC_VERSION: u32 = 3u32; + pub const SPEC_VERSION: u32 = 0u32; } -pub struct ExtFilterCubicFn {} -unsafe impl Send for ExtFilterCubicFn {} -unsafe impl Sync for ExtFilterCubicFn {} -impl ::std::clone::Clone for ExtFilterCubicFn { +pub struct KhrExtension221Fn {} +unsafe impl Send for KhrExtension221Fn {} +unsafe impl Sync for KhrExtension221Fn {} +impl ::std::clone::Clone for KhrExtension221Fn { fn clone(&self) -> Self { - ExtFilterCubicFn {} + KhrExtension221Fn {} } } -impl ExtFilterCubicFn { +impl KhrExtension221Fn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - ExtFilterCubicFn {} + KhrExtension221Fn {} } } -#[doc = "Generated from \'VK_EXT_filter_cubic\'"] -impl Filter { - pub const CUBIC_EXT: Self = Filter::CUBIC_IMG; +#[doc = "Generated from \'VK_KHR_extension_221\'"] +impl RenderPassCreateFlags { + pub const RESERVED_0_KHR: Self = Self(0b1); } -#[doc = "Generated from \'VK_EXT_filter_cubic\'"] -impl FormatFeatureFlags { - pub const SAMPLED_IMAGE_FILTER_CUBIC_EXT: Self = - FormatFeatureFlags::SAMPLED_IMAGE_FILTER_CUBIC_IMG; +impl ExtScalarBlockLayoutFn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_scalar_block_layout\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 1u32; } -#[doc = "Generated from \'VK_EXT_filter_cubic\'"] -impl StructureType { - pub const PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT: Self = Self(1_000_170_000); +pub struct ExtScalarBlockLayoutFn {} +unsafe impl Send for ExtScalarBlockLayoutFn {} +unsafe impl Sync for ExtScalarBlockLayoutFn {} +impl ::std::clone::Clone for ExtScalarBlockLayoutFn { + fn clone(&self) -> Self { + ExtScalarBlockLayoutFn {} + } } -#[doc = "Generated from \'VK_EXT_filter_cubic\'"] +impl ExtScalarBlockLayoutFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + ExtScalarBlockLayoutFn {} + } +} +#[doc = "Generated from \'VK_EXT_scalar_block_layout\'"] impl StructureType { - pub const FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT: Self = Self(1_000_170_001); + pub const PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES_EXT: Self = + StructureType::PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES; } -impl QcomExtension172Fn { +impl ExtExtension223Fn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_QCOM_extension_172\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_extension_223\0") .expect("Wrong extension string") } pub const SPEC_VERSION: u32 = 0u32; } -pub struct QcomExtension172Fn {} -unsafe impl Send for QcomExtension172Fn {} -unsafe impl Sync for QcomExtension172Fn {} -impl ::std::clone::Clone for QcomExtension172Fn { +pub struct ExtExtension223Fn {} +unsafe impl Send for ExtExtension223Fn {} +unsafe impl Sync for ExtExtension223Fn {} +impl ::std::clone::Clone for ExtExtension223Fn { fn clone(&self) -> Self { - QcomExtension172Fn {} + ExtExtension223Fn {} } } -impl QcomExtension172Fn { +impl ExtExtension223Fn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - QcomExtension172Fn {} + ExtExtension223Fn {} } } -#[doc = "Generated from \'VK_QCOM_extension_172\'"] -impl SubpassDescriptionFlags { - pub const RESERVED_2_QCOM: Self = Self(0b100); -} -#[doc = "Generated from \'VK_QCOM_extension_172\'"] -impl SubpassDescriptionFlags { - pub const RESERVED_3_QCOM: Self = Self(0b1000); -} -impl QcomExtension173Fn { +impl GoogleHlslFunctionality1Fn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_QCOM_extension_173\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_GOOGLE_hlsl_functionality1\0") .expect("Wrong extension string") } - pub const SPEC_VERSION: u32 = 0u32; + pub const SPEC_VERSION: u32 = 1u32; } -pub struct QcomExtension173Fn {} -unsafe impl Send for QcomExtension173Fn {} -unsafe impl Sync for QcomExtension173Fn {} -impl ::std::clone::Clone for QcomExtension173Fn { +pub struct GoogleHlslFunctionality1Fn {} +unsafe impl Send for GoogleHlslFunctionality1Fn {} +unsafe impl Sync for GoogleHlslFunctionality1Fn {} +impl ::std::clone::Clone for GoogleHlslFunctionality1Fn { fn clone(&self) -> Self { - QcomExtension173Fn {} + GoogleHlslFunctionality1Fn {} } } -impl QcomExtension173Fn { +impl GoogleHlslFunctionality1Fn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - QcomExtension173Fn {} + GoogleHlslFunctionality1Fn {} } } -#[doc = "Generated from \'VK_QCOM_extension_173\'"] -impl BufferUsageFlags { - pub const RESERVED_18_QCOM: Self = Self(0b100_0000_0000_0000_0000); +impl GoogleDecorateStringFn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_GOOGLE_decorate_string\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 1u32; } -#[doc = "Generated from \'VK_QCOM_extension_173\'"] -impl ImageUsageFlags { - pub const RESERVED_16_QCOM: Self = Self(0b1_0000_0000_0000_0000); +pub struct GoogleDecorateStringFn {} +unsafe impl Send for GoogleDecorateStringFn {} +unsafe impl Sync for GoogleDecorateStringFn {} +impl ::std::clone::Clone for GoogleDecorateStringFn { + fn clone(&self) -> Self { + GoogleDecorateStringFn {} + } } -#[doc = "Generated from \'VK_QCOM_extension_173\'"] -impl ImageUsageFlags { - pub const RESERVED_17_QCOM: Self = Self(0b10_0000_0000_0000_0000); +impl GoogleDecorateStringFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + GoogleDecorateStringFn {} + } } -impl QcomExtension174Fn { +impl ExtSubgroupSizeControlFn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_QCOM_extension_174\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_subgroup_size_control\0") .expect("Wrong extension string") } - pub const SPEC_VERSION: u32 = 0u32; + pub const SPEC_VERSION: u32 = 2u32; } -pub struct QcomExtension174Fn {} -unsafe impl Send for QcomExtension174Fn {} -unsafe impl Sync for QcomExtension174Fn {} -impl ::std::clone::Clone for QcomExtension174Fn { +pub struct ExtSubgroupSizeControlFn {} +unsafe impl Send for ExtSubgroupSizeControlFn {} +unsafe impl Sync for ExtSubgroupSizeControlFn {} +impl ::std::clone::Clone for ExtSubgroupSizeControlFn { fn clone(&self) -> Self { - QcomExtension174Fn {} + ExtSubgroupSizeControlFn {} } } -impl QcomExtension174Fn { +impl ExtSubgroupSizeControlFn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - QcomExtension174Fn {} + ExtSubgroupSizeControlFn {} } } -impl ExtGlobalPriorityFn { +#[doc = "Generated from \'VK_EXT_subgroup_size_control\'"] +impl StructureType { + pub const PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT: Self = Self(1_000_225_000); +} +#[doc = "Generated from \'VK_EXT_subgroup_size_control\'"] +impl StructureType { + pub const PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT: Self = + Self(1_000_225_001); +} +#[doc = "Generated from \'VK_EXT_subgroup_size_control\'"] +impl StructureType { + pub const PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT: Self = Self(1_000_225_002); +} +#[doc = "Generated from \'VK_EXT_subgroup_size_control\'"] +impl PipelineShaderStageCreateFlags { + pub const ALLOW_VARYING_SUBGROUP_SIZE_EXT: Self = Self(0b1); +} +#[doc = "Generated from \'VK_EXT_subgroup_size_control\'"] +impl PipelineShaderStageCreateFlags { + pub const REQUIRE_FULL_SUBGROUPS_EXT: Self = Self(0b10); +} +impl KhrFragmentShadingRateFn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_global_priority\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_fragment_shading_rate\0") .expect("Wrong extension string") } - pub const SPEC_VERSION: u32 = 2u32; + pub const SPEC_VERSION: u32 = 1u32; } -pub struct ExtGlobalPriorityFn {} -unsafe impl Send for ExtGlobalPriorityFn {} -unsafe impl Sync for ExtGlobalPriorityFn {} -impl ::std::clone::Clone for ExtGlobalPriorityFn { +#[allow(non_camel_case_types)] +pub type PFN_vkGetPhysicalDeviceFragmentShadingRatesKHR = extern "system" fn( + physical_device: PhysicalDevice, + p_fragment_shading_rate_count: *mut u32, + p_fragment_shading_rates: *mut PhysicalDeviceFragmentShadingRateKHR, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetFragmentShadingRateKHR = extern "system" fn( + command_buffer: CommandBuffer, + p_fragment_size: *const Extent2D, + combiner_ops: &[FragmentShadingRateCombinerOpKHR; 2], +) -> c_void; +pub struct KhrFragmentShadingRateFn { + pub get_physical_device_fragment_shading_rates_khr: extern "system" fn( + physical_device: PhysicalDevice, + p_fragment_shading_rate_count: *mut u32, + p_fragment_shading_rates: *mut PhysicalDeviceFragmentShadingRateKHR, + ) -> Result, + pub cmd_set_fragment_shading_rate_khr: extern "system" fn( + command_buffer: CommandBuffer, + p_fragment_size: *const Extent2D, + combiner_ops: &[FragmentShadingRateCombinerOpKHR; 2], + ) -> c_void, +} +unsafe impl Send for KhrFragmentShadingRateFn {} +unsafe impl Sync for KhrFragmentShadingRateFn {} +impl ::std::clone::Clone for KhrFragmentShadingRateFn { fn clone(&self) -> Self { - ExtGlobalPriorityFn {} + KhrFragmentShadingRateFn { + get_physical_device_fragment_shading_rates_khr: self + .get_physical_device_fragment_shading_rates_khr, + cmd_set_fragment_shading_rate_khr: self.cmd_set_fragment_shading_rate_khr, + } } } -impl ExtGlobalPriorityFn { +impl KhrFragmentShadingRateFn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - ExtGlobalPriorityFn {} + KhrFragmentShadingRateFn { + get_physical_device_fragment_shading_rates_khr: unsafe { + extern "system" fn get_physical_device_fragment_shading_rates_khr( + _physical_device: PhysicalDevice, + _p_fragment_shading_rate_count: *mut u32, + _p_fragment_shading_rates: *mut PhysicalDeviceFragmentShadingRateKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_fragment_shading_rates_khr) + )) + } + let raw_name = stringify!(vkGetPhysicalDeviceFragmentShadingRatesKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + get_physical_device_fragment_shading_rates_khr + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_fragment_shading_rate_khr: unsafe { + extern "system" fn cmd_set_fragment_shading_rate_khr( + _command_buffer: CommandBuffer, + _p_fragment_size: *const Extent2D, + _combiner_ops: &[FragmentShadingRateCombinerOpKHR; 2], + ) -> c_void { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_fragment_shading_rate_khr) + )) + } + let raw_name = stringify!(vkCmdSetFragmentShadingRateKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + cmd_set_fragment_shading_rate_khr + } else { + ::std::mem::transmute(val) + } + }, + } + } + #[doc = ""] + pub unsafe fn get_physical_device_fragment_shading_rates_khr( + &self, + physical_device: PhysicalDevice, + p_fragment_shading_rate_count: *mut u32, + p_fragment_shading_rates: *mut PhysicalDeviceFragmentShadingRateKHR, + ) -> Result { + (self.get_physical_device_fragment_shading_rates_khr)( + physical_device, + p_fragment_shading_rate_count, + p_fragment_shading_rates, + ) + } + #[doc = ""] + pub unsafe fn cmd_set_fragment_shading_rate_khr( + &self, + command_buffer: CommandBuffer, + p_fragment_size: *const Extent2D, + combiner_ops: &[FragmentShadingRateCombinerOpKHR; 2], + ) -> c_void { + (self.cmd_set_fragment_shading_rate_khr)(command_buffer, p_fragment_size, combiner_ops) } } -#[doc = "Generated from \'VK_EXT_global_priority\'"] +#[doc = "Generated from \'VK_KHR_fragment_shading_rate\'"] +impl ImageLayout { + pub const FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR: Self = + ImageLayout::SHADING_RATE_OPTIMAL_NV; +} +#[doc = "Generated from \'VK_KHR_fragment_shading_rate\'"] +impl DynamicState { + pub const FRAGMENT_SHADING_RATE_KHR: Self = Self(1_000_226_000); +} +#[doc = "Generated from \'VK_KHR_fragment_shading_rate\'"] impl StructureType { - pub const DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT: Self = Self(1_000_174_000); + pub const FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR: Self = Self(1_000_226_000); } -#[doc = "Generated from \'VK_EXT_global_priority\'"] -impl Result { - pub const ERROR_NOT_PERMITTED_EXT: Self = Self(-1_000_174_001); +#[doc = "Generated from \'VK_KHR_fragment_shading_rate\'"] +impl StructureType { + pub const PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR: Self = Self(1_000_226_001); } -impl KhrShaderSubgroupExtendedTypesFn { +#[doc = "Generated from \'VK_KHR_fragment_shading_rate\'"] +impl StructureType { + pub const PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR: Self = Self(1_000_226_002); +} +#[doc = "Generated from \'VK_KHR_fragment_shading_rate\'"] +impl StructureType { + pub const PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR: Self = Self(1_000_226_003); +} +#[doc = "Generated from \'VK_KHR_fragment_shading_rate\'"] +impl StructureType { + pub const PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR: Self = Self(1_000_226_004); +} +#[doc = "Generated from \'VK_KHR_fragment_shading_rate\'"] +impl AccessFlags { + pub const FRAGMENT_SHADING_RATE_ATTACHMENT_READ_KHR: Self = + AccessFlags::SHADING_RATE_IMAGE_READ_NV; +} +#[doc = "Generated from \'VK_KHR_fragment_shading_rate\'"] +impl ImageUsageFlags { + pub const FRAGMENT_SHADING_RATE_ATTACHMENT_KHR: Self = ImageUsageFlags::SHADING_RATE_IMAGE_NV; +} +#[doc = "Generated from \'VK_KHR_fragment_shading_rate\'"] +impl PipelineStageFlags { + pub const FRAGMENT_SHADING_RATE_ATTACHMENT_KHR: Self = + PipelineStageFlags::SHADING_RATE_IMAGE_NV; +} +#[doc = "Generated from \'VK_KHR_fragment_shading_rate\'"] +impl FormatFeatureFlags { + pub const FRAGMENT_SHADING_RATE_ATTACHMENT_KHR: Self = + Self(0b100_0000_0000_0000_0000_0000_0000_0000); +} +impl AmdShaderCoreProperties2Fn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_shader_subgroup_extended_types\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_AMD_shader_core_properties2\0") .expect("Wrong extension string") } pub const SPEC_VERSION: u32 = 1u32; } -pub struct KhrShaderSubgroupExtendedTypesFn {} -unsafe impl Send for KhrShaderSubgroupExtendedTypesFn {} -unsafe impl Sync for KhrShaderSubgroupExtendedTypesFn {} -impl ::std::clone::Clone for KhrShaderSubgroupExtendedTypesFn { +pub struct AmdShaderCoreProperties2Fn {} +unsafe impl Send for AmdShaderCoreProperties2Fn {} +unsafe impl Sync for AmdShaderCoreProperties2Fn {} +impl ::std::clone::Clone for AmdShaderCoreProperties2Fn { fn clone(&self) -> Self { - KhrShaderSubgroupExtendedTypesFn {} + AmdShaderCoreProperties2Fn {} } } -impl KhrShaderSubgroupExtendedTypesFn { +impl AmdShaderCoreProperties2Fn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - KhrShaderSubgroupExtendedTypesFn {} + AmdShaderCoreProperties2Fn {} } } -#[doc = "Generated from \'VK_KHR_shader_subgroup_extended_types\'"] +#[doc = "Generated from \'VK_AMD_shader_core_properties2\'"] impl StructureType { - pub const PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES_KHR: Self = - StructureType::PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES; + pub const PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD: Self = Self(1_000_227_000); } -impl ExtExtension177Fn { +impl AmdExtension229Fn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_extension_177\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_AMD_extension_229\0") .expect("Wrong extension string") } pub const SPEC_VERSION: u32 = 0u32; } -pub struct ExtExtension177Fn {} -unsafe impl Send for ExtExtension177Fn {} -unsafe impl Sync for ExtExtension177Fn {} -impl ::std::clone::Clone for ExtExtension177Fn { +pub struct AmdExtension229Fn {} +unsafe impl Send for AmdExtension229Fn {} +unsafe impl Sync for AmdExtension229Fn {} +impl ::std::clone::Clone for AmdExtension229Fn { fn clone(&self) -> Self { - ExtExtension177Fn {} + AmdExtension229Fn {} } } -impl ExtExtension177Fn { +impl AmdExtension229Fn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - ExtExtension177Fn {} + AmdExtension229Fn {} } } -impl Khr8bitStorageFn { +impl AmdDeviceCoherentMemoryFn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_8bit_storage\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_AMD_device_coherent_memory\0") .expect("Wrong extension string") } pub const SPEC_VERSION: u32 = 1u32; } -pub struct Khr8bitStorageFn {} -unsafe impl Send for Khr8bitStorageFn {} -unsafe impl Sync for Khr8bitStorageFn {} -impl ::std::clone::Clone for Khr8bitStorageFn { +pub struct AmdDeviceCoherentMemoryFn {} +unsafe impl Send for AmdDeviceCoherentMemoryFn {} +unsafe impl Sync for AmdDeviceCoherentMemoryFn {} +impl ::std::clone::Clone for AmdDeviceCoherentMemoryFn { fn clone(&self) -> Self { - Khr8bitStorageFn {} + AmdDeviceCoherentMemoryFn {} } } -impl Khr8bitStorageFn { +impl AmdDeviceCoherentMemoryFn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - Khr8bitStorageFn {} + AmdDeviceCoherentMemoryFn {} } } -#[doc = "Generated from \'VK_KHR_8bit_storage\'"] +#[doc = "Generated from \'VK_AMD_device_coherent_memory\'"] +impl MemoryPropertyFlags { + pub const DEVICE_COHERENT_AMD: Self = Self(0b100_0000); +} +#[doc = "Generated from \'VK_AMD_device_coherent_memory\'"] +impl MemoryPropertyFlags { + pub const DEVICE_UNCACHED_AMD: Self = Self(0b1000_0000); +} +#[doc = "Generated from \'VK_AMD_device_coherent_memory\'"] impl StructureType { - pub const PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES_KHR: Self = - StructureType::PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES; + pub const PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD: Self = Self(1_000_229_000); } -impl ExtExternalMemoryHostFn { +impl AmdExtension231Fn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_external_memory_host\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_AMD_extension_231\0") .expect("Wrong extension string") } - pub const SPEC_VERSION: u32 = 1u32; -} -#[allow(non_camel_case_types)] -pub type PFN_vkGetMemoryHostPointerPropertiesEXT = extern "system" fn( - device: Device, - handle_type: ExternalMemoryHandleTypeFlags, - p_host_pointer: *const c_void, - p_memory_host_pointer_properties: *mut MemoryHostPointerPropertiesEXT, -) -> Result; -pub struct ExtExternalMemoryHostFn { - pub get_memory_host_pointer_properties_ext: extern "system" fn( - device: Device, - handle_type: ExternalMemoryHandleTypeFlags, - p_host_pointer: *const c_void, - p_memory_host_pointer_properties: *mut MemoryHostPointerPropertiesEXT, - ) -> Result, + pub const SPEC_VERSION: u32 = 0u32; } -unsafe impl Send for ExtExternalMemoryHostFn {} -unsafe impl Sync for ExtExternalMemoryHostFn {} -impl ::std::clone::Clone for ExtExternalMemoryHostFn { +pub struct AmdExtension231Fn {} +unsafe impl Send for AmdExtension231Fn {} +unsafe impl Sync for AmdExtension231Fn {} +impl ::std::clone::Clone for AmdExtension231Fn { fn clone(&self) -> Self { - ExtExternalMemoryHostFn { - get_memory_host_pointer_properties_ext: self.get_memory_host_pointer_properties_ext, - } + AmdExtension231Fn {} } } -impl ExtExternalMemoryHostFn { +impl AmdExtension231Fn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - ExtExternalMemoryHostFn { - get_memory_host_pointer_properties_ext: unsafe { - extern "system" fn get_memory_host_pointer_properties_ext( - _device: Device, - _handle_type: ExternalMemoryHandleTypeFlags, - _p_host_pointer: *const c_void, - _p_memory_host_pointer_properties: *mut MemoryHostPointerPropertiesEXT, - ) -> Result { - panic!(concat!( - "Unable to load ", - stringify!(get_memory_host_pointer_properties_ext) - )) - } - let raw_name = stringify!(vkGetMemoryHostPointerPropertiesEXT); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - get_memory_host_pointer_properties_ext - } else { - ::std::mem::transmute(val) - } - }, - } - } - #[doc = ""] - pub unsafe fn get_memory_host_pointer_properties_ext( - &self, - device: Device, - handle_type: ExternalMemoryHandleTypeFlags, - p_host_pointer: *const c_void, - p_memory_host_pointer_properties: *mut MemoryHostPointerPropertiesEXT, - ) -> Result { - (self.get_memory_host_pointer_properties_ext)( - device, - handle_type, - p_host_pointer, - p_memory_host_pointer_properties, - ) + AmdExtension231Fn {} } } -#[doc = "Generated from \'VK_EXT_external_memory_host\'"] -impl StructureType { - pub const IMPORT_MEMORY_HOST_POINTER_INFO_EXT: Self = Self(1_000_178_000); -} -#[doc = "Generated from \'VK_EXT_external_memory_host\'"] -impl StructureType { - pub const MEMORY_HOST_POINTER_PROPERTIES_EXT: Self = Self(1_000_178_001); -} -#[doc = "Generated from \'VK_EXT_external_memory_host\'"] -impl StructureType { - pub const PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT: Self = Self(1_000_178_002); +impl AmdExtension232Fn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_AMD_extension_232\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 0u32; } -#[doc = "Generated from \'VK_EXT_external_memory_host\'"] -impl ExternalMemoryHandleTypeFlags { - pub const EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION: Self = Self(0b1000_0000); +pub struct AmdExtension232Fn {} +unsafe impl Send for AmdExtension232Fn {} +unsafe impl Sync for AmdExtension232Fn {} +impl ::std::clone::Clone for AmdExtension232Fn { + fn clone(&self) -> Self { + AmdExtension232Fn {} + } } -#[doc = "Generated from \'VK_EXT_external_memory_host\'"] -impl ExternalMemoryHandleTypeFlags { - pub const EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY: Self = Self(0b1_0000_0000); +impl AmdExtension232Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + AmdExtension232Fn {} + } } -impl AmdBufferMarkerFn { +impl AmdExtension233Fn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_AMD_buffer_marker\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_AMD_extension_233\0") .expect("Wrong extension string") } - pub const SPEC_VERSION: u32 = 1u32; -} -#[allow(non_camel_case_types)] -pub type PFN_vkCmdWriteBufferMarkerAMD = extern "system" fn( - command_buffer: CommandBuffer, - pipeline_stage: PipelineStageFlags, - dst_buffer: Buffer, - dst_offset: DeviceSize, - marker: u32, -) -> c_void; -pub struct AmdBufferMarkerFn { - pub cmd_write_buffer_marker_amd: extern "system" fn( - command_buffer: CommandBuffer, - pipeline_stage: PipelineStageFlags, - dst_buffer: Buffer, - dst_offset: DeviceSize, - marker: u32, - ) -> c_void, + pub const SPEC_VERSION: u32 = 0u32; } -unsafe impl Send for AmdBufferMarkerFn {} -unsafe impl Sync for AmdBufferMarkerFn {} -impl ::std::clone::Clone for AmdBufferMarkerFn { +pub struct AmdExtension233Fn {} +unsafe impl Send for AmdExtension233Fn {} +unsafe impl Sync for AmdExtension233Fn {} +impl ::std::clone::Clone for AmdExtension233Fn { fn clone(&self) -> Self { - AmdBufferMarkerFn { - cmd_write_buffer_marker_amd: self.cmd_write_buffer_marker_amd, - } + AmdExtension233Fn {} } } -impl AmdBufferMarkerFn { +impl AmdExtension233Fn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - AmdBufferMarkerFn { - cmd_write_buffer_marker_amd: unsafe { - extern "system" fn cmd_write_buffer_marker_amd( - _command_buffer: CommandBuffer, - _pipeline_stage: PipelineStageFlags, - _dst_buffer: Buffer, - _dst_offset: DeviceSize, - _marker: u32, - ) -> c_void { - panic!(concat!( - "Unable to load ", - stringify!(cmd_write_buffer_marker_amd) - )) - } - let raw_name = stringify!(vkCmdWriteBufferMarkerAMD); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - cmd_write_buffer_marker_amd - } else { - ::std::mem::transmute(val) - } - }, - } + AmdExtension233Fn {} } - #[doc = ""] - pub unsafe fn cmd_write_buffer_marker_amd( - &self, - command_buffer: CommandBuffer, - pipeline_stage: PipelineStageFlags, - dst_buffer: Buffer, - dst_offset: DeviceSize, - marker: u32, - ) -> c_void { - (self.cmd_write_buffer_marker_amd)( - command_buffer, - pipeline_stage, - dst_buffer, - dst_offset, - marker, - ) +} +impl AmdExtension234Fn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_AMD_extension_234\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 0u32; +} +pub struct AmdExtension234Fn {} +unsafe impl Send for AmdExtension234Fn {} +unsafe impl Sync for AmdExtension234Fn {} +impl ::std::clone::Clone for AmdExtension234Fn { + fn clone(&self) -> Self { + AmdExtension234Fn {} } } -impl KhrShaderAtomicInt64Fn { +impl AmdExtension234Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + AmdExtension234Fn {} + } +} +impl ExtShaderImageAtomicInt64Fn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_shader_atomic_int64\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_shader_image_atomic_int64\0") .expect("Wrong extension string") } pub const SPEC_VERSION: u32 = 1u32; } -pub struct KhrShaderAtomicInt64Fn {} -unsafe impl Send for KhrShaderAtomicInt64Fn {} -unsafe impl Sync for KhrShaderAtomicInt64Fn {} -impl ::std::clone::Clone for KhrShaderAtomicInt64Fn { +pub struct ExtShaderImageAtomicInt64Fn {} +unsafe impl Send for ExtShaderImageAtomicInt64Fn {} +unsafe impl Sync for ExtShaderImageAtomicInt64Fn {} +impl ::std::clone::Clone for ExtShaderImageAtomicInt64Fn { fn clone(&self) -> Self { - KhrShaderAtomicInt64Fn {} + ExtShaderImageAtomicInt64Fn {} } } -impl KhrShaderAtomicInt64Fn { +impl ExtShaderImageAtomicInt64Fn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - KhrShaderAtomicInt64Fn {} + ExtShaderImageAtomicInt64Fn {} } } -#[doc = "Generated from \'VK_KHR_shader_atomic_int64\'"] +#[doc = "Generated from \'VK_EXT_shader_image_atomic_int64\'"] impl StructureType { - pub const PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES_KHR: Self = - StructureType::PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES; + pub const PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT: Self = Self(1_000_234_000); } -impl KhrShaderClockFn { +impl AmdExtension236Fn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_shader_clock\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_AMD_extension_236\0") .expect("Wrong extension string") } - pub const SPEC_VERSION: u32 = 1u32; + pub const SPEC_VERSION: u32 = 0u32; } -pub struct KhrShaderClockFn {} -unsafe impl Send for KhrShaderClockFn {} -unsafe impl Sync for KhrShaderClockFn {} -impl ::std::clone::Clone for KhrShaderClockFn { +pub struct AmdExtension236Fn {} +unsafe impl Send for AmdExtension236Fn {} +unsafe impl Sync for AmdExtension236Fn {} +impl ::std::clone::Clone for AmdExtension236Fn { fn clone(&self) -> Self { - KhrShaderClockFn {} + AmdExtension236Fn {} } } -impl KhrShaderClockFn { +impl AmdExtension236Fn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - KhrShaderClockFn {} + AmdExtension236Fn {} } } -#[doc = "Generated from \'VK_KHR_shader_clock\'"] -impl StructureType { - pub const PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR: Self = Self(1_000_181_000); -} -impl AmdExtension183Fn { +impl KhrSpirv14Fn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_AMD_extension_183\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_spirv_1_4\0") .expect("Wrong extension string") } - pub const SPEC_VERSION: u32 = 0u32; + pub const SPEC_VERSION: u32 = 1u32; } -pub struct AmdExtension183Fn {} -unsafe impl Send for AmdExtension183Fn {} -unsafe impl Sync for AmdExtension183Fn {} -impl ::std::clone::Clone for AmdExtension183Fn { +pub struct KhrSpirv14Fn {} +unsafe impl Send for KhrSpirv14Fn {} +unsafe impl Sync for KhrSpirv14Fn {} +impl ::std::clone::Clone for KhrSpirv14Fn { fn clone(&self) -> Self { - AmdExtension183Fn {} + KhrSpirv14Fn {} } } -impl AmdExtension183Fn { +impl KhrSpirv14Fn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - AmdExtension183Fn {} + KhrSpirv14Fn {} } } -impl AmdPipelineCompilerControlFn { +impl ExtMemoryBudgetFn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_AMD_pipeline_compiler_control\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_memory_budget\0") .expect("Wrong extension string") } pub const SPEC_VERSION: u32 = 1u32; } -pub struct AmdPipelineCompilerControlFn {} -unsafe impl Send for AmdPipelineCompilerControlFn {} -unsafe impl Sync for AmdPipelineCompilerControlFn {} -impl ::std::clone::Clone for AmdPipelineCompilerControlFn { +pub struct ExtMemoryBudgetFn {} +unsafe impl Send for ExtMemoryBudgetFn {} +unsafe impl Sync for ExtMemoryBudgetFn {} +impl ::std::clone::Clone for ExtMemoryBudgetFn { fn clone(&self) -> Self { - AmdPipelineCompilerControlFn {} + ExtMemoryBudgetFn {} } } -impl AmdPipelineCompilerControlFn { +impl ExtMemoryBudgetFn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - AmdPipelineCompilerControlFn {} + ExtMemoryBudgetFn {} } } -#[doc = "Generated from \'VK_AMD_pipeline_compiler_control\'"] +#[doc = "Generated from \'VK_EXT_memory_budget\'"] impl StructureType { - pub const PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD: Self = Self(1_000_183_000); + pub const PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT: Self = Self(1_000_237_000); } -impl ExtCalibratedTimestampsFn { +impl ExtMemoryPriorityFn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_calibrated_timestamps\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_memory_priority\0") .expect("Wrong extension string") } pub const SPEC_VERSION: u32 = 1u32; } -#[allow(non_camel_case_types)] -pub type PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT = extern "system" fn( - physical_device: PhysicalDevice, - p_time_domain_count: *mut u32, - p_time_domains: *mut TimeDomainEXT, -) -> Result; -#[allow(non_camel_case_types)] -pub type PFN_vkGetCalibratedTimestampsEXT = extern "system" fn( - device: Device, - timestamp_count: u32, - p_timestamp_infos: *const CalibratedTimestampInfoEXT, - p_timestamps: *mut u64, - p_max_deviation: *mut u64, -) -> Result; -pub struct ExtCalibratedTimestampsFn { - pub get_physical_device_calibrateable_time_domains_ext: extern "system" fn( - physical_device: PhysicalDevice, - p_time_domain_count: *mut u32, - p_time_domains: *mut TimeDomainEXT, - ) -> Result, - pub get_calibrated_timestamps_ext: extern "system" fn( - device: Device, - timestamp_count: u32, - p_timestamp_infos: *const CalibratedTimestampInfoEXT, - p_timestamps: *mut u64, - p_max_deviation: *mut u64, - ) -> Result, -} -unsafe impl Send for ExtCalibratedTimestampsFn {} -unsafe impl Sync for ExtCalibratedTimestampsFn {} -impl ::std::clone::Clone for ExtCalibratedTimestampsFn { +pub struct ExtMemoryPriorityFn {} +unsafe impl Send for ExtMemoryPriorityFn {} +unsafe impl Sync for ExtMemoryPriorityFn {} +impl ::std::clone::Clone for ExtMemoryPriorityFn { fn clone(&self) -> Self { - ExtCalibratedTimestampsFn { - get_physical_device_calibrateable_time_domains_ext: self - .get_physical_device_calibrateable_time_domains_ext, - get_calibrated_timestamps_ext: self.get_calibrated_timestamps_ext, - } + ExtMemoryPriorityFn {} } } -impl ExtCalibratedTimestampsFn { +impl ExtMemoryPriorityFn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - ExtCalibratedTimestampsFn { - get_physical_device_calibrateable_time_domains_ext: unsafe { - extern "system" fn get_physical_device_calibrateable_time_domains_ext( - _physical_device: PhysicalDevice, - _p_time_domain_count: *mut u32, - _p_time_domains: *mut TimeDomainEXT, - ) -> Result { - panic!(concat!( - "Unable to load ", - stringify!(get_physical_device_calibrateable_time_domains_ext) - )) - } - let raw_name = stringify!(vkGetPhysicalDeviceCalibrateableTimeDomainsEXT); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - get_physical_device_calibrateable_time_domains_ext - } else { - ::std::mem::transmute(val) - } - }, - get_calibrated_timestamps_ext: unsafe { - extern "system" fn get_calibrated_timestamps_ext( - _device: Device, - _timestamp_count: u32, - _p_timestamp_infos: *const CalibratedTimestampInfoEXT, - _p_timestamps: *mut u64, - _p_max_deviation: *mut u64, - ) -> Result { - panic!(concat!( - "Unable to load ", - stringify!(get_calibrated_timestamps_ext) - )) - } - let raw_name = stringify!(vkGetCalibratedTimestampsEXT); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - get_calibrated_timestamps_ext - } else { - ::std::mem::transmute(val) - } - }, - } - } - #[doc = ""] - pub unsafe fn get_physical_device_calibrateable_time_domains_ext( - &self, - physical_device: PhysicalDevice, - p_time_domain_count: *mut u32, - p_time_domains: *mut TimeDomainEXT, - ) -> Result { - (self.get_physical_device_calibrateable_time_domains_ext)( - physical_device, - p_time_domain_count, - p_time_domains, - ) - } - #[doc = ""] - pub unsafe fn get_calibrated_timestamps_ext( - &self, - device: Device, - timestamp_count: u32, - p_timestamp_infos: *const CalibratedTimestampInfoEXT, - p_timestamps: *mut u64, - p_max_deviation: *mut u64, - ) -> Result { - (self.get_calibrated_timestamps_ext)( - device, - timestamp_count, - p_timestamp_infos, - p_timestamps, - p_max_deviation, - ) + ExtMemoryPriorityFn {} } } -#[doc = "Generated from \'VK_EXT_calibrated_timestamps\'"] +#[doc = "Generated from \'VK_EXT_memory_priority\'"] impl StructureType { - pub const CALIBRATED_TIMESTAMP_INFO_EXT: Self = Self(1_000_184_000); + pub const PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT: Self = Self(1_000_238_000); } -impl AmdShaderCorePropertiesFn { +#[doc = "Generated from \'VK_EXT_memory_priority\'"] +impl StructureType { + pub const MEMORY_PRIORITY_ALLOCATE_INFO_EXT: Self = Self(1_000_238_001); +} +impl KhrSurfaceProtectedCapabilitiesFn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_AMD_shader_core_properties\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_surface_protected_capabilities\0") .expect("Wrong extension string") } - pub const SPEC_VERSION: u32 = 2u32; + pub const SPEC_VERSION: u32 = 1u32; } -pub struct AmdShaderCorePropertiesFn {} -unsafe impl Send for AmdShaderCorePropertiesFn {} -unsafe impl Sync for AmdShaderCorePropertiesFn {} -impl ::std::clone::Clone for AmdShaderCorePropertiesFn { +pub struct KhrSurfaceProtectedCapabilitiesFn {} +unsafe impl Send for KhrSurfaceProtectedCapabilitiesFn {} +unsafe impl Sync for KhrSurfaceProtectedCapabilitiesFn {} +impl ::std::clone::Clone for KhrSurfaceProtectedCapabilitiesFn { fn clone(&self) -> Self { - AmdShaderCorePropertiesFn {} + KhrSurfaceProtectedCapabilitiesFn {} } } -impl AmdShaderCorePropertiesFn { +impl KhrSurfaceProtectedCapabilitiesFn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - AmdShaderCorePropertiesFn {} + KhrSurfaceProtectedCapabilitiesFn {} } } -#[doc = "Generated from \'VK_AMD_shader_core_properties\'"] +#[doc = "Generated from \'VK_KHR_surface_protected_capabilities\'"] impl StructureType { - pub const PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD: Self = Self(1_000_185_000); + pub const SURFACE_PROTECTED_CAPABILITIES_KHR: Self = Self(1_000_239_000); } -impl AmdExtension187Fn { +impl NvDedicatedAllocationImageAliasingFn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_AMD_extension_187\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_dedicated_allocation_image_aliasing\0") .expect("Wrong extension string") - } - pub const SPEC_VERSION: u32 = 0u32; -} -pub struct AmdExtension187Fn {} -unsafe impl Send for AmdExtension187Fn {} -unsafe impl Sync for AmdExtension187Fn {} -impl ::std::clone::Clone for AmdExtension187Fn { + } + pub const SPEC_VERSION: u32 = 1u32; +} +pub struct NvDedicatedAllocationImageAliasingFn {} +unsafe impl Send for NvDedicatedAllocationImageAliasingFn {} +unsafe impl Sync for NvDedicatedAllocationImageAliasingFn {} +impl ::std::clone::Clone for NvDedicatedAllocationImageAliasingFn { fn clone(&self) -> Self { - AmdExtension187Fn {} + NvDedicatedAllocationImageAliasingFn {} } } -impl AmdExtension187Fn { +impl NvDedicatedAllocationImageAliasingFn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - AmdExtension187Fn {} + NvDedicatedAllocationImageAliasingFn {} } } -impl AmdExtension188Fn { +#[doc = "Generated from \'VK_NV_dedicated_allocation_image_aliasing\'"] +impl StructureType { + pub const PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV: Self = + Self(1_000_240_000); +} +impl KhrSeparateDepthStencilLayoutsFn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_AMD_extension_188\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_separate_depth_stencil_layouts\0") .expect("Wrong extension string") } - pub const SPEC_VERSION: u32 = 0u32; + pub const SPEC_VERSION: u32 = 1u32; } -pub struct AmdExtension188Fn {} -unsafe impl Send for AmdExtension188Fn {} -unsafe impl Sync for AmdExtension188Fn {} -impl ::std::clone::Clone for AmdExtension188Fn { +pub struct KhrSeparateDepthStencilLayoutsFn {} +unsafe impl Send for KhrSeparateDepthStencilLayoutsFn {} +unsafe impl Sync for KhrSeparateDepthStencilLayoutsFn {} +impl ::std::clone::Clone for KhrSeparateDepthStencilLayoutsFn { fn clone(&self) -> Self { - AmdExtension188Fn {} + KhrSeparateDepthStencilLayoutsFn {} } } -impl AmdExtension188Fn { +impl KhrSeparateDepthStencilLayoutsFn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - AmdExtension188Fn {} + KhrSeparateDepthStencilLayoutsFn {} } } -impl AmdExtension189Fn { +#[doc = "Generated from \'VK_KHR_separate_depth_stencil_layouts\'"] +impl StructureType { + pub const PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES_KHR: Self = + StructureType::PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES; +} +#[doc = "Generated from \'VK_KHR_separate_depth_stencil_layouts\'"] +impl StructureType { + pub const ATTACHMENT_REFERENCE_STENCIL_LAYOUT_KHR: Self = + StructureType::ATTACHMENT_REFERENCE_STENCIL_LAYOUT; +} +#[doc = "Generated from \'VK_KHR_separate_depth_stencil_layouts\'"] +impl StructureType { + pub const ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT_KHR: Self = + StructureType::ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT; +} +#[doc = "Generated from \'VK_KHR_separate_depth_stencil_layouts\'"] +impl ImageLayout { + pub const DEPTH_ATTACHMENT_OPTIMAL_KHR: Self = ImageLayout::DEPTH_ATTACHMENT_OPTIMAL; +} +#[doc = "Generated from \'VK_KHR_separate_depth_stencil_layouts\'"] +impl ImageLayout { + pub const DEPTH_READ_ONLY_OPTIMAL_KHR: Self = ImageLayout::DEPTH_READ_ONLY_OPTIMAL; +} +#[doc = "Generated from \'VK_KHR_separate_depth_stencil_layouts\'"] +impl ImageLayout { + pub const STENCIL_ATTACHMENT_OPTIMAL_KHR: Self = ImageLayout::STENCIL_ATTACHMENT_OPTIMAL; +} +#[doc = "Generated from \'VK_KHR_separate_depth_stencil_layouts\'"] +impl ImageLayout { + pub const STENCIL_READ_ONLY_OPTIMAL_KHR: Self = ImageLayout::STENCIL_READ_ONLY_OPTIMAL; +} +impl IntelExtension243Fn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_AMD_extension_189\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_INTEL_extension_243\0") .expect("Wrong extension string") } pub const SPEC_VERSION: u32 = 0u32; } -pub struct AmdExtension189Fn {} -unsafe impl Send for AmdExtension189Fn {} -unsafe impl Sync for AmdExtension189Fn {} -impl ::std::clone::Clone for AmdExtension189Fn { +pub struct IntelExtension243Fn {} +unsafe impl Send for IntelExtension243Fn {} +unsafe impl Sync for IntelExtension243Fn {} +impl ::std::clone::Clone for IntelExtension243Fn { fn clone(&self) -> Self { - AmdExtension189Fn {} + IntelExtension243Fn {} } } -impl AmdExtension189Fn { +impl IntelExtension243Fn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - AmdExtension189Fn {} + IntelExtension243Fn {} } } -impl AmdMemoryOverallocationBehaviorFn { +impl MesaExtension244Fn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_AMD_memory_overallocation_behavior\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_MESA_extension_244\0") .expect("Wrong extension string") } - pub const SPEC_VERSION: u32 = 1u32; + pub const SPEC_VERSION: u32 = 0u32; } -pub struct AmdMemoryOverallocationBehaviorFn {} -unsafe impl Send for AmdMemoryOverallocationBehaviorFn {} -unsafe impl Sync for AmdMemoryOverallocationBehaviorFn {} -impl ::std::clone::Clone for AmdMemoryOverallocationBehaviorFn { +pub struct MesaExtension244Fn {} +unsafe impl Send for MesaExtension244Fn {} +unsafe impl Sync for MesaExtension244Fn {} +impl ::std::clone::Clone for MesaExtension244Fn { fn clone(&self) -> Self { - AmdMemoryOverallocationBehaviorFn {} + MesaExtension244Fn {} } } -impl AmdMemoryOverallocationBehaviorFn { +impl MesaExtension244Fn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - AmdMemoryOverallocationBehaviorFn {} + MesaExtension244Fn {} } } -#[doc = "Generated from \'VK_AMD_memory_overallocation_behavior\'"] -impl StructureType { - pub const DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD: Self = Self(1_000_189_000); -} -impl ExtVertexAttributeDivisorFn { +impl ExtBufferDeviceAddressFn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_vertex_attribute_divisor\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_buffer_device_address\0") .expect("Wrong extension string") } - pub const SPEC_VERSION: u32 = 3u32; + pub const SPEC_VERSION: u32 = 2u32; } -pub struct ExtVertexAttributeDivisorFn {} -unsafe impl Send for ExtVertexAttributeDivisorFn {} -unsafe impl Sync for ExtVertexAttributeDivisorFn {} -impl ::std::clone::Clone for ExtVertexAttributeDivisorFn { +#[allow(non_camel_case_types)] +pub type PFN_vkGetBufferDeviceAddress = + extern "system" fn(device: Device, p_info: *const BufferDeviceAddressInfo) -> DeviceAddress; +pub struct ExtBufferDeviceAddressFn { + pub get_buffer_device_address_ext: + extern "system" fn(device: Device, p_info: *const BufferDeviceAddressInfo) -> DeviceAddress, +} +unsafe impl Send for ExtBufferDeviceAddressFn {} +unsafe impl Sync for ExtBufferDeviceAddressFn {} +impl ::std::clone::Clone for ExtBufferDeviceAddressFn { fn clone(&self) -> Self { - ExtVertexAttributeDivisorFn {} + ExtBufferDeviceAddressFn { + get_buffer_device_address_ext: self.get_buffer_device_address_ext, + } } } -impl ExtVertexAttributeDivisorFn { +impl ExtBufferDeviceAddressFn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - ExtVertexAttributeDivisorFn {} + ExtBufferDeviceAddressFn { + get_buffer_device_address_ext: unsafe { + extern "system" fn get_buffer_device_address_ext( + _device: Device, + _p_info: *const BufferDeviceAddressInfo, + ) -> DeviceAddress { + panic!(concat!( + "Unable to load ", + stringify!(get_buffer_device_address_ext) + )) + } + let raw_name = stringify!(vkGetBufferDeviceAddressEXT); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + get_buffer_device_address_ext + } else { + ::std::mem::transmute(val) + } + }, + } + } + #[doc = ""] + pub unsafe fn get_buffer_device_address_ext( + &self, + device: Device, + p_info: *const BufferDeviceAddressInfo, + ) -> DeviceAddress { + (self.get_buffer_device_address_ext)(device, p_info) } } -#[doc = "Generated from \'VK_EXT_vertex_attribute_divisor\'"] +#[doc = "Generated from \'VK_EXT_buffer_device_address\'"] impl StructureType { - pub const PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT: Self = Self(1_000_190_000); + pub const PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT: Self = Self(1_000_244_000); } -#[doc = "Generated from \'VK_EXT_vertex_attribute_divisor\'"] +#[doc = "Generated from \'VK_EXT_buffer_device_address\'"] impl StructureType { - pub const PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT: Self = Self(1_000_190_001); + pub const PHYSICAL_DEVICE_BUFFER_ADDRESS_FEATURES_EXT: Self = + StructureType::PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT; } -#[doc = "Generated from \'VK_EXT_vertex_attribute_divisor\'"] +#[doc = "Generated from \'VK_EXT_buffer_device_address\'"] impl StructureType { - pub const PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT: Self = Self(1_000_190_002); + pub const BUFFER_DEVICE_ADDRESS_INFO_EXT: Self = StructureType::BUFFER_DEVICE_ADDRESS_INFO; } -impl GgpFrameTokenFn { +#[doc = "Generated from \'VK_EXT_buffer_device_address\'"] +impl StructureType { + pub const BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT: Self = Self(1_000_244_002); +} +#[doc = "Generated from \'VK_EXT_buffer_device_address\'"] +impl BufferUsageFlags { + pub const SHADER_DEVICE_ADDRESS_EXT: Self = BufferUsageFlags::SHADER_DEVICE_ADDRESS; +} +#[doc = "Generated from \'VK_EXT_buffer_device_address\'"] +impl BufferCreateFlags { + pub const DEVICE_ADDRESS_CAPTURE_REPLAY_EXT: Self = + BufferCreateFlags::DEVICE_ADDRESS_CAPTURE_REPLAY; +} +#[doc = "Generated from \'VK_EXT_buffer_device_address\'"] +impl Result { + pub const ERROR_INVALID_DEVICE_ADDRESS_EXT: Self = Result::ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS; +} +impl ExtToolingInfoFn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_GGP_frame_token\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_tooling_info\0") .expect("Wrong extension string") } pub const SPEC_VERSION: u32 = 1u32; } -pub struct GgpFrameTokenFn {} -unsafe impl Send for GgpFrameTokenFn {} -unsafe impl Sync for GgpFrameTokenFn {} -impl ::std::clone::Clone for GgpFrameTokenFn { +#[allow(non_camel_case_types)] +pub type PFN_vkGetPhysicalDeviceToolPropertiesEXT = extern "system" fn( + physical_device: PhysicalDevice, + p_tool_count: *mut u32, + p_tool_properties: *mut PhysicalDeviceToolPropertiesEXT, +) -> Result; +pub struct ExtToolingInfoFn { + pub get_physical_device_tool_properties_ext: extern "system" fn( + physical_device: PhysicalDevice, + p_tool_count: *mut u32, + p_tool_properties: *mut PhysicalDeviceToolPropertiesEXT, + ) -> Result, +} +unsafe impl Send for ExtToolingInfoFn {} +unsafe impl Sync for ExtToolingInfoFn {} +impl ::std::clone::Clone for ExtToolingInfoFn { fn clone(&self) -> Self { - GgpFrameTokenFn {} + ExtToolingInfoFn { + get_physical_device_tool_properties_ext: self.get_physical_device_tool_properties_ext, + } } } -impl GgpFrameTokenFn { +impl ExtToolingInfoFn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - GgpFrameTokenFn {} + ExtToolingInfoFn { + get_physical_device_tool_properties_ext: unsafe { + extern "system" fn get_physical_device_tool_properties_ext( + _physical_device: PhysicalDevice, + _p_tool_count: *mut u32, + _p_tool_properties: *mut PhysicalDeviceToolPropertiesEXT, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_tool_properties_ext) + )) + } + let raw_name = stringify!(vkGetPhysicalDeviceToolPropertiesEXT); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + get_physical_device_tool_properties_ext + } else { + ::std::mem::transmute(val) + } + }, + } + } + #[doc = ""] + pub unsafe fn get_physical_device_tool_properties_ext( + &self, + physical_device: PhysicalDevice, + p_tool_count: *mut u32, + p_tool_properties: *mut PhysicalDeviceToolPropertiesEXT, + ) -> Result { + (self.get_physical_device_tool_properties_ext)( + physical_device, + p_tool_count, + p_tool_properties, + ) } } -#[doc = "Generated from \'VK_GGP_frame_token\'"] +#[doc = "Generated from \'VK_EXT_tooling_info\'"] impl StructureType { - pub const PRESENT_FRAME_TOKEN_GGP: Self = Self(1_000_191_000); + pub const PHYSICAL_DEVICE_TOOL_PROPERTIES_EXT: Self = Self(1_000_245_000); } -impl ExtPipelineCreationFeedbackFn { +#[doc = "Generated from \'VK_EXT_tooling_info\'"] +impl ToolPurposeFlagsEXT { + pub const DEBUG_REPORTING: Self = Self(0b10_0000); +} +#[doc = "Generated from \'VK_EXT_tooling_info\'"] +impl ToolPurposeFlagsEXT { + pub const DEBUG_MARKERS: Self = Self(0b100_0000); +} +impl ExtSeparateStencilUsageFn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_pipeline_creation_feedback\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_separate_stencil_usage\0") .expect("Wrong extension string") } pub const SPEC_VERSION: u32 = 1u32; } -pub struct ExtPipelineCreationFeedbackFn {} -unsafe impl Send for ExtPipelineCreationFeedbackFn {} -unsafe impl Sync for ExtPipelineCreationFeedbackFn {} -impl ::std::clone::Clone for ExtPipelineCreationFeedbackFn { +pub struct ExtSeparateStencilUsageFn {} +unsafe impl Send for ExtSeparateStencilUsageFn {} +unsafe impl Sync for ExtSeparateStencilUsageFn {} +impl ::std::clone::Clone for ExtSeparateStencilUsageFn { fn clone(&self) -> Self { - ExtPipelineCreationFeedbackFn {} + ExtSeparateStencilUsageFn {} } } -impl ExtPipelineCreationFeedbackFn { +impl ExtSeparateStencilUsageFn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - ExtPipelineCreationFeedbackFn {} + ExtSeparateStencilUsageFn {} } } -#[doc = "Generated from \'VK_EXT_pipeline_creation_feedback\'"] +#[doc = "Generated from \'VK_EXT_separate_stencil_usage\'"] impl StructureType { - pub const PIPELINE_CREATION_FEEDBACK_CREATE_INFO_EXT: Self = Self(1_000_192_000); + pub const IMAGE_STENCIL_USAGE_CREATE_INFO_EXT: Self = + StructureType::IMAGE_STENCIL_USAGE_CREATE_INFO; } -impl GoogleExtension194Fn { +impl ExtValidationFeaturesFn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_GOOGLE_extension_194\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_validation_features\0") .expect("Wrong extension string") } - pub const SPEC_VERSION: u32 = 0u32; + pub const SPEC_VERSION: u32 = 4u32; } -pub struct GoogleExtension194Fn {} -unsafe impl Send for GoogleExtension194Fn {} -unsafe impl Sync for GoogleExtension194Fn {} -impl ::std::clone::Clone for GoogleExtension194Fn { +pub struct ExtValidationFeaturesFn {} +unsafe impl Send for ExtValidationFeaturesFn {} +unsafe impl Sync for ExtValidationFeaturesFn {} +impl ::std::clone::Clone for ExtValidationFeaturesFn { fn clone(&self) -> Self { - GoogleExtension194Fn {} + ExtValidationFeaturesFn {} } } -impl GoogleExtension194Fn { +impl ExtValidationFeaturesFn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - GoogleExtension194Fn {} - } -} -impl GoogleExtension195Fn { - pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_GOOGLE_extension_195\0") - .expect("Wrong extension string") - } - pub const SPEC_VERSION: u32 = 0u32; -} -pub struct GoogleExtension195Fn {} -unsafe impl Send for GoogleExtension195Fn {} -unsafe impl Sync for GoogleExtension195Fn {} -impl ::std::clone::Clone for GoogleExtension195Fn { - fn clone(&self) -> Self { - GoogleExtension195Fn {} + ExtValidationFeaturesFn {} } } -impl GoogleExtension195Fn { - pub fn load(mut _f: F) -> Self - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - GoogleExtension195Fn {} - } +#[doc = "Generated from \'VK_EXT_validation_features\'"] +impl StructureType { + pub const VALIDATION_FEATURES_EXT: Self = Self(1_000_247_000); } -impl GoogleExtension196Fn { +impl KhrExtension249Fn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_GOOGLE_extension_196\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_extension_249\0") .expect("Wrong extension string") } pub const SPEC_VERSION: u32 = 0u32; } -pub struct GoogleExtension196Fn {} -unsafe impl Send for GoogleExtension196Fn {} -unsafe impl Sync for GoogleExtension196Fn {} -impl ::std::clone::Clone for GoogleExtension196Fn { +pub struct KhrExtension249Fn {} +unsafe impl Send for KhrExtension249Fn {} +unsafe impl Sync for KhrExtension249Fn {} +impl ::std::clone::Clone for KhrExtension249Fn { fn clone(&self) -> Self { - GoogleExtension196Fn {} + KhrExtension249Fn {} } } -impl GoogleExtension196Fn { +impl KhrExtension249Fn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - GoogleExtension196Fn {} + KhrExtension249Fn {} } } -impl KhrDriverPropertiesFn { +impl NvCooperativeMatrixFn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_driver_properties\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_cooperative_matrix\0") .expect("Wrong extension string") } pub const SPEC_VERSION: u32 = 1u32; } -pub struct KhrDriverPropertiesFn {} -unsafe impl Send for KhrDriverPropertiesFn {} -unsafe impl Sync for KhrDriverPropertiesFn {} -impl ::std::clone::Clone for KhrDriverPropertiesFn { +#[allow(non_camel_case_types)] +pub type PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV = extern "system" fn( + physical_device: PhysicalDevice, + p_property_count: *mut u32, + p_properties: *mut CooperativeMatrixPropertiesNV, +) -> Result; +pub struct NvCooperativeMatrixFn { + pub get_physical_device_cooperative_matrix_properties_nv: extern "system" fn( + physical_device: PhysicalDevice, + p_property_count: *mut u32, + p_properties: *mut CooperativeMatrixPropertiesNV, + ) -> Result, +} +unsafe impl Send for NvCooperativeMatrixFn {} +unsafe impl Sync for NvCooperativeMatrixFn {} +impl ::std::clone::Clone for NvCooperativeMatrixFn { fn clone(&self) -> Self { - KhrDriverPropertiesFn {} + NvCooperativeMatrixFn { + get_physical_device_cooperative_matrix_properties_nv: self + .get_physical_device_cooperative_matrix_properties_nv, + } } } -impl KhrDriverPropertiesFn { +impl NvCooperativeMatrixFn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - KhrDriverPropertiesFn {} + NvCooperativeMatrixFn { + get_physical_device_cooperative_matrix_properties_nv: unsafe { + extern "system" fn get_physical_device_cooperative_matrix_properties_nv( + _physical_device: PhysicalDevice, + _p_property_count: *mut u32, + _p_properties: *mut CooperativeMatrixPropertiesNV, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_cooperative_matrix_properties_nv) + )) + } + let raw_name = stringify!(vkGetPhysicalDeviceCooperativeMatrixPropertiesNV); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + get_physical_device_cooperative_matrix_properties_nv + } else { + ::std::mem::transmute(val) + } + }, + } + } + #[doc = ""] + pub unsafe fn get_physical_device_cooperative_matrix_properties_nv( + &self, + physical_device: PhysicalDevice, + p_property_count: *mut u32, + p_properties: *mut CooperativeMatrixPropertiesNV, + ) -> Result { + (self.get_physical_device_cooperative_matrix_properties_nv)( + physical_device, + p_property_count, + p_properties, + ) } } -#[doc = "Generated from \'VK_KHR_driver_properties\'"] +#[doc = "Generated from \'VK_NV_cooperative_matrix\'"] impl StructureType { - pub const PHYSICAL_DEVICE_DRIVER_PROPERTIES_KHR: Self = - StructureType::PHYSICAL_DEVICE_DRIVER_PROPERTIES; -} -#[doc = "Generated from \'VK_KHR_driver_properties\'"] -impl DriverId { - pub const AMD_PROPRIETARY_KHR: Self = DriverId::AMD_PROPRIETARY; -} -#[doc = "Generated from \'VK_KHR_driver_properties\'"] -impl DriverId { - pub const AMD_OPEN_SOURCE_KHR: Self = DriverId::AMD_OPEN_SOURCE; -} -#[doc = "Generated from \'VK_KHR_driver_properties\'"] -impl DriverId { - pub const MESA_RADV_KHR: Self = DriverId::MESA_RADV; -} -#[doc = "Generated from \'VK_KHR_driver_properties\'"] -impl DriverId { - pub const NVIDIA_PROPRIETARY_KHR: Self = DriverId::NVIDIA_PROPRIETARY; -} -#[doc = "Generated from \'VK_KHR_driver_properties\'"] -impl DriverId { - pub const INTEL_PROPRIETARY_WINDOWS_KHR: Self = DriverId::INTEL_PROPRIETARY_WINDOWS; -} -#[doc = "Generated from \'VK_KHR_driver_properties\'"] -impl DriverId { - pub const INTEL_OPEN_SOURCE_MESA_KHR: Self = DriverId::INTEL_OPEN_SOURCE_MESA; -} -#[doc = "Generated from \'VK_KHR_driver_properties\'"] -impl DriverId { - pub const IMAGINATION_PROPRIETARY_KHR: Self = DriverId::IMAGINATION_PROPRIETARY; -} -#[doc = "Generated from \'VK_KHR_driver_properties\'"] -impl DriverId { - pub const QUALCOMM_PROPRIETARY_KHR: Self = DriverId::QUALCOMM_PROPRIETARY; -} -#[doc = "Generated from \'VK_KHR_driver_properties\'"] -impl DriverId { - pub const ARM_PROPRIETARY_KHR: Self = DriverId::ARM_PROPRIETARY; -} -#[doc = "Generated from \'VK_KHR_driver_properties\'"] -impl DriverId { - pub const GOOGLE_SWIFTSHADER_KHR: Self = DriverId::GOOGLE_SWIFTSHADER; + pub const PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV: Self = Self(1_000_249_000); } -#[doc = "Generated from \'VK_KHR_driver_properties\'"] -impl DriverId { - pub const GGP_PROPRIETARY_KHR: Self = DriverId::GGP_PROPRIETARY; +#[doc = "Generated from \'VK_NV_cooperative_matrix\'"] +impl StructureType { + pub const COOPERATIVE_MATRIX_PROPERTIES_NV: Self = Self(1_000_249_001); } -#[doc = "Generated from \'VK_KHR_driver_properties\'"] -impl DriverId { - pub const BROADCOM_PROPRIETARY_KHR: Self = DriverId::BROADCOM_PROPRIETARY; +#[doc = "Generated from \'VK_NV_cooperative_matrix\'"] +impl StructureType { + pub const PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV: Self = Self(1_000_249_002); } -impl KhrShaderFloatControlsFn { +impl NvCoverageReductionModeFn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_shader_float_controls\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_coverage_reduction_mode\0") .expect("Wrong extension string") } - pub const SPEC_VERSION: u32 = 4u32; + pub const SPEC_VERSION: u32 = 1u32; } -pub struct KhrShaderFloatControlsFn {} -unsafe impl Send for KhrShaderFloatControlsFn {} -unsafe impl Sync for KhrShaderFloatControlsFn {} -impl ::std::clone::Clone for KhrShaderFloatControlsFn { +#[allow(non_camel_case_types)] +pub type PFN_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV = + extern "system" fn( + physical_device: PhysicalDevice, + p_combination_count: *mut u32, + p_combinations: *mut FramebufferMixedSamplesCombinationNV, + ) -> Result; +pub struct NvCoverageReductionModeFn { + pub get_physical_device_supported_framebuffer_mixed_samples_combinations_nv: + extern "system" fn( + physical_device: PhysicalDevice, + p_combination_count: *mut u32, + p_combinations: *mut FramebufferMixedSamplesCombinationNV, + ) -> Result, +} +unsafe impl Send for NvCoverageReductionModeFn {} +unsafe impl Sync for NvCoverageReductionModeFn {} +impl ::std::clone::Clone for NvCoverageReductionModeFn { fn clone(&self) -> Self { - KhrShaderFloatControlsFn {} + NvCoverageReductionModeFn { + get_physical_device_supported_framebuffer_mixed_samples_combinations_nv: self + .get_physical_device_supported_framebuffer_mixed_samples_combinations_nv, + } } } -impl KhrShaderFloatControlsFn { +impl NvCoverageReductionModeFn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - KhrShaderFloatControlsFn {} + NvCoverageReductionModeFn { + get_physical_device_supported_framebuffer_mixed_samples_combinations_nv: unsafe { + extern "system" fn get_physical_device_supported_framebuffer_mixed_samples_combinations_nv( + _physical_device: PhysicalDevice, + _p_combination_count: *mut u32, + _p_combinations: *mut FramebufferMixedSamplesCombinationNV, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!( + get_physical_device_supported_framebuffer_mixed_samples_combinations_nv + ) + )) + } + let raw_name = + stringify!(vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + get_physical_device_supported_framebuffer_mixed_samples_combinations_nv + } else { + ::std::mem::transmute(val) + } + }, + } + } + #[doc = ""] + pub unsafe fn get_physical_device_supported_framebuffer_mixed_samples_combinations_nv( + &self, + physical_device: PhysicalDevice, + p_combination_count: *mut u32, + p_combinations: *mut FramebufferMixedSamplesCombinationNV, + ) -> Result { + (self.get_physical_device_supported_framebuffer_mixed_samples_combinations_nv)( + physical_device, + p_combination_count, + p_combinations, + ) } } -#[doc = "Generated from \'VK_KHR_shader_float_controls\'"] +#[doc = "Generated from \'VK_NV_coverage_reduction_mode\'"] impl StructureType { - pub const PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES_KHR: Self = - StructureType::PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES; -} -#[doc = "Generated from \'VK_KHR_shader_float_controls\'"] -impl ShaderFloatControlsIndependence { - pub const TYPE_32_ONLY_KHR: Self = ShaderFloatControlsIndependence::TYPE_32_ONLY; + pub const PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV: Self = Self(1_000_250_000); } -#[doc = "Generated from \'VK_KHR_shader_float_controls\'"] -impl ShaderFloatControlsIndependence { - pub const ALL_KHR: Self = ShaderFloatControlsIndependence::ALL; +#[doc = "Generated from \'VK_NV_coverage_reduction_mode\'"] +impl StructureType { + pub const PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV: Self = Self(1_000_250_001); } -#[doc = "Generated from \'VK_KHR_shader_float_controls\'"] -impl ShaderFloatControlsIndependence { - pub const NONE_KHR: Self = ShaderFloatControlsIndependence::NONE; +#[doc = "Generated from \'VK_NV_coverage_reduction_mode\'"] +impl StructureType { + pub const FRAMEBUFFER_MIXED_SAMPLES_COMBINATION_NV: Self = Self(1_000_250_002); } -impl NvShaderSubgroupPartitionedFn { +impl ExtFragmentShaderInterlockFn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_shader_subgroup_partitioned\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_fragment_shader_interlock\0") .expect("Wrong extension string") } pub const SPEC_VERSION: u32 = 1u32; } -pub struct NvShaderSubgroupPartitionedFn {} -unsafe impl Send for NvShaderSubgroupPartitionedFn {} -unsafe impl Sync for NvShaderSubgroupPartitionedFn {} -impl ::std::clone::Clone for NvShaderSubgroupPartitionedFn { +pub struct ExtFragmentShaderInterlockFn {} +unsafe impl Send for ExtFragmentShaderInterlockFn {} +unsafe impl Sync for ExtFragmentShaderInterlockFn {} +impl ::std::clone::Clone for ExtFragmentShaderInterlockFn { fn clone(&self) -> Self { - NvShaderSubgroupPartitionedFn {} + ExtFragmentShaderInterlockFn {} } } -impl NvShaderSubgroupPartitionedFn { +impl ExtFragmentShaderInterlockFn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - NvShaderSubgroupPartitionedFn {} + ExtFragmentShaderInterlockFn {} } } -#[doc = "Generated from \'VK_NV_shader_subgroup_partitioned\'"] -impl SubgroupFeatureFlags { - pub const PARTITIONED_NV: Self = Self(0b1_0000_0000); +#[doc = "Generated from \'VK_EXT_fragment_shader_interlock\'"] +impl StructureType { + pub const PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT: Self = Self(1_000_251_000); } -impl KhrDepthStencilResolveFn { +impl ExtYcbcrImageArraysFn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_depth_stencil_resolve\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_ycbcr_image_arrays\0") .expect("Wrong extension string") } pub const SPEC_VERSION: u32 = 1u32; } -pub struct KhrDepthStencilResolveFn {} -unsafe impl Send for KhrDepthStencilResolveFn {} -unsafe impl Sync for KhrDepthStencilResolveFn {} -impl ::std::clone::Clone for KhrDepthStencilResolveFn { +pub struct ExtYcbcrImageArraysFn {} +unsafe impl Send for ExtYcbcrImageArraysFn {} +unsafe impl Sync for ExtYcbcrImageArraysFn {} +impl ::std::clone::Clone for ExtYcbcrImageArraysFn { fn clone(&self) -> Self { - KhrDepthStencilResolveFn {} + ExtYcbcrImageArraysFn {} } } -impl KhrDepthStencilResolveFn { +impl ExtYcbcrImageArraysFn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - KhrDepthStencilResolveFn {} + ExtYcbcrImageArraysFn {} } } -#[doc = "Generated from \'VK_KHR_depth_stencil_resolve\'"] -impl StructureType { - pub const PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES_KHR: Self = - StructureType::PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES; -} -#[doc = "Generated from \'VK_KHR_depth_stencil_resolve\'"] +#[doc = "Generated from \'VK_EXT_ycbcr_image_arrays\'"] impl StructureType { - pub const SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE_KHR: Self = - StructureType::SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE; -} -#[doc = "Generated from \'VK_KHR_depth_stencil_resolve\'"] -impl ResolveModeFlags { - pub const NONE_KHR: Self = ResolveModeFlags::NONE; -} -#[doc = "Generated from \'VK_KHR_depth_stencil_resolve\'"] -impl ResolveModeFlags { - pub const SAMPLE_ZERO_KHR: Self = ResolveModeFlags::SAMPLE_ZERO; -} -#[doc = "Generated from \'VK_KHR_depth_stencil_resolve\'"] -impl ResolveModeFlags { - pub const AVERAGE_KHR: Self = ResolveModeFlags::AVERAGE; -} -#[doc = "Generated from \'VK_KHR_depth_stencil_resolve\'"] -impl ResolveModeFlags { - pub const MIN_KHR: Self = ResolveModeFlags::MIN; -} -#[doc = "Generated from \'VK_KHR_depth_stencil_resolve\'"] -impl ResolveModeFlags { - pub const MAX_KHR: Self = ResolveModeFlags::MAX; + pub const PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT: Self = Self(1_000_252_000); } -impl KhrSwapchainMutableFormatFn { +impl KhrUniformBufferStandardLayoutFn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_swapchain_mutable_format\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_uniform_buffer_standard_layout\0") .expect("Wrong extension string") } pub const SPEC_VERSION: u32 = 1u32; } -pub struct KhrSwapchainMutableFormatFn {} -unsafe impl Send for KhrSwapchainMutableFormatFn {} -unsafe impl Sync for KhrSwapchainMutableFormatFn {} -impl ::std::clone::Clone for KhrSwapchainMutableFormatFn { +pub struct KhrUniformBufferStandardLayoutFn {} +unsafe impl Send for KhrUniformBufferStandardLayoutFn {} +unsafe impl Sync for KhrUniformBufferStandardLayoutFn {} +impl ::std::clone::Clone for KhrUniformBufferStandardLayoutFn { fn clone(&self) -> Self { - KhrSwapchainMutableFormatFn {} + KhrUniformBufferStandardLayoutFn {} } } -impl KhrSwapchainMutableFormatFn { +impl KhrUniformBufferStandardLayoutFn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - KhrSwapchainMutableFormatFn {} + KhrUniformBufferStandardLayoutFn {} } } -#[doc = "Generated from \'VK_KHR_swapchain_mutable_format\'"] -impl SwapchainCreateFlagsKHR { - pub const MUTABLE_FORMAT: Self = Self(0b100); +#[doc = "Generated from \'VK_KHR_uniform_buffer_standard_layout\'"] +impl StructureType { + pub const PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES_KHR: Self = + StructureType::PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES; } -impl NvComputeShaderDerivativesFn { +impl ExtExtension255Fn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_compute_shader_derivatives\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_extension_255\0") .expect("Wrong extension string") } - pub const SPEC_VERSION: u32 = 1u32; + pub const SPEC_VERSION: u32 = 0u32; } -pub struct NvComputeShaderDerivativesFn {} -unsafe impl Send for NvComputeShaderDerivativesFn {} -unsafe impl Sync for NvComputeShaderDerivativesFn {} -impl ::std::clone::Clone for NvComputeShaderDerivativesFn { +pub struct ExtExtension255Fn {} +unsafe impl Send for ExtExtension255Fn {} +unsafe impl Sync for ExtExtension255Fn {} +impl ::std::clone::Clone for ExtExtension255Fn { fn clone(&self) -> Self { - NvComputeShaderDerivativesFn {} + ExtExtension255Fn {} } } -impl NvComputeShaderDerivativesFn { +impl ExtExtension255Fn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - NvComputeShaderDerivativesFn {} + ExtExtension255Fn {} } } -#[doc = "Generated from \'VK_NV_compute_shader_derivatives\'"] -impl StructureType { - pub const PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV: Self = Self(1_000_201_000); -} -impl NvMeshShaderFn { +impl ExtFullScreenExclusiveFn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_mesh_shader\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_full_screen_exclusive\0") .expect("Wrong extension string") } - pub const SPEC_VERSION: u32 = 1u32; + pub const SPEC_VERSION: u32 = 4u32; } #[allow(non_camel_case_types)] -pub type PFN_vkCmdDrawMeshTasksNV = - extern "system" fn(command_buffer: CommandBuffer, task_count: u32, first_task: u32) -> c_void; +pub type PFN_vkGetPhysicalDeviceSurfacePresentModes2EXT = extern "system" fn( + physical_device: PhysicalDevice, + p_surface_info: *const PhysicalDeviceSurfaceInfo2KHR, + p_present_mode_count: *mut u32, + p_present_modes: *mut PresentModeKHR, +) -> Result; #[allow(non_camel_case_types)] -pub type PFN_vkCmdDrawMeshTasksIndirectNV = extern "system" fn( - command_buffer: CommandBuffer, - buffer: Buffer, - offset: DeviceSize, - draw_count: u32, - stride: u32, -) -> c_void; +pub type PFN_vkAcquireFullScreenExclusiveModeEXT = + extern "system" fn(device: Device, swapchain: SwapchainKHR) -> Result; #[allow(non_camel_case_types)] -pub type PFN_vkCmdDrawMeshTasksIndirectCountNV = extern "system" fn( - command_buffer: CommandBuffer, - buffer: Buffer, - offset: DeviceSize, - count_buffer: Buffer, - count_buffer_offset: DeviceSize, - max_draw_count: u32, - stride: u32, -) -> c_void; -pub struct NvMeshShaderFn { - pub cmd_draw_mesh_tasks_nv: extern "system" fn( - command_buffer: CommandBuffer, - task_count: u32, - first_task: u32, - ) -> c_void, - pub cmd_draw_mesh_tasks_indirect_nv: extern "system" fn( - command_buffer: CommandBuffer, - buffer: Buffer, - offset: DeviceSize, - draw_count: u32, - stride: u32, - ) -> c_void, - pub cmd_draw_mesh_tasks_indirect_count_nv: extern "system" fn( - command_buffer: CommandBuffer, - buffer: Buffer, - offset: DeviceSize, - count_buffer: Buffer, - count_buffer_offset: DeviceSize, - max_draw_count: u32, - stride: u32, - ) -> c_void, +pub type PFN_vkReleaseFullScreenExclusiveModeEXT = + extern "system" fn(device: Device, swapchain: SwapchainKHR) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetDeviceGroupSurfacePresentModes2EXT = extern "system" fn( + device: Device, + p_surface_info: *const PhysicalDeviceSurfaceInfo2KHR, + p_modes: *mut DeviceGroupPresentModeFlagsKHR, +) -> Result; +pub struct ExtFullScreenExclusiveFn { + pub get_physical_device_surface_present_modes2_ext: extern "system" fn( + physical_device: PhysicalDevice, + p_surface_info: *const PhysicalDeviceSurfaceInfo2KHR, + p_present_mode_count: *mut u32, + p_present_modes: *mut PresentModeKHR, + ) -> Result, + pub acquire_full_screen_exclusive_mode_ext: + extern "system" fn(device: Device, swapchain: SwapchainKHR) -> Result, + pub release_full_screen_exclusive_mode_ext: + extern "system" fn(device: Device, swapchain: SwapchainKHR) -> Result, + pub get_device_group_surface_present_modes2_ext: extern "system" fn( + device: Device, + p_surface_info: *const PhysicalDeviceSurfaceInfo2KHR, + p_modes: *mut DeviceGroupPresentModeFlagsKHR, + ) -> Result, } -unsafe impl Send for NvMeshShaderFn {} -unsafe impl Sync for NvMeshShaderFn {} -impl ::std::clone::Clone for NvMeshShaderFn { +unsafe impl Send for ExtFullScreenExclusiveFn {} +unsafe impl Sync for ExtFullScreenExclusiveFn {} +impl ::std::clone::Clone for ExtFullScreenExclusiveFn { fn clone(&self) -> Self { - NvMeshShaderFn { - cmd_draw_mesh_tasks_nv: self.cmd_draw_mesh_tasks_nv, - cmd_draw_mesh_tasks_indirect_nv: self.cmd_draw_mesh_tasks_indirect_nv, - cmd_draw_mesh_tasks_indirect_count_nv: self.cmd_draw_mesh_tasks_indirect_count_nv, + ExtFullScreenExclusiveFn { + get_physical_device_surface_present_modes2_ext: self + .get_physical_device_surface_present_modes2_ext, + acquire_full_screen_exclusive_mode_ext: self.acquire_full_screen_exclusive_mode_ext, + release_full_screen_exclusive_mode_ext: self.release_full_screen_exclusive_mode_ext, + get_device_group_surface_present_modes2_ext: self + .get_device_group_surface_present_modes2_ext, } } } -impl NvMeshShaderFn { +impl ExtFullScreenExclusiveFn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - NvMeshShaderFn { - cmd_draw_mesh_tasks_nv: unsafe { - extern "system" fn cmd_draw_mesh_tasks_nv( - _command_buffer: CommandBuffer, - _task_count: u32, - _first_task: u32, - ) -> c_void { + ExtFullScreenExclusiveFn { + get_physical_device_surface_present_modes2_ext: 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!(cmd_draw_mesh_tasks_nv) + stringify!(get_physical_device_surface_present_modes2_ext) )) } - let raw_name = stringify!(vkCmdDrawMeshTasksNV); + let raw_name = stringify!(vkGetPhysicalDeviceSurfacePresentModes2EXT); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - cmd_draw_mesh_tasks_nv + get_physical_device_surface_present_modes2_ext } else { ::std::mem::transmute(val) } }, - cmd_draw_mesh_tasks_indirect_nv: unsafe { - extern "system" fn cmd_draw_mesh_tasks_indirect_nv( - _command_buffer: CommandBuffer, - _buffer: Buffer, - _offset: DeviceSize, - _draw_count: u32, - _stride: u32, - ) -> c_void { + acquire_full_screen_exclusive_mode_ext: unsafe { + extern "system" fn acquire_full_screen_exclusive_mode_ext( + _device: Device, + _swapchain: SwapchainKHR, + ) -> Result { panic!(concat!( "Unable to load ", - stringify!(cmd_draw_mesh_tasks_indirect_nv) + stringify!(acquire_full_screen_exclusive_mode_ext) )) } - let raw_name = stringify!(vkCmdDrawMeshTasksIndirectNV); + let raw_name = stringify!(vkAcquireFullScreenExclusiveModeEXT); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - cmd_draw_mesh_tasks_indirect_nv + acquire_full_screen_exclusive_mode_ext } else { ::std::mem::transmute(val) } }, - cmd_draw_mesh_tasks_indirect_count_nv: unsafe { - extern "system" fn cmd_draw_mesh_tasks_indirect_count_nv( - _command_buffer: CommandBuffer, - _buffer: Buffer, - _offset: DeviceSize, - _count_buffer: Buffer, - _count_buffer_offset: DeviceSize, - _max_draw_count: u32, - _stride: u32, - ) -> c_void { + release_full_screen_exclusive_mode_ext: unsafe { + extern "system" fn release_full_screen_exclusive_mode_ext( + _device: Device, + _swapchain: SwapchainKHR, + ) -> Result { panic!(concat!( "Unable to load ", - stringify!(cmd_draw_mesh_tasks_indirect_count_nv) + stringify!(release_full_screen_exclusive_mode_ext) )) } - let raw_name = stringify!(vkCmdDrawMeshTasksIndirectCountNV); + let raw_name = stringify!(vkReleaseFullScreenExclusiveModeEXT); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - cmd_draw_mesh_tasks_indirect_count_nv + release_full_screen_exclusive_mode_ext + } else { + ::std::mem::transmute(val) + } + }, + get_device_group_surface_present_modes2_ext: unsafe { + extern "system" fn get_device_group_surface_present_modes2_ext( + _device: Device, + _p_surface_info: *const PhysicalDeviceSurfaceInfo2KHR, + _p_modes: *mut DeviceGroupPresentModeFlagsKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_device_group_surface_present_modes2_ext) + )) + } + let raw_name = stringify!(vkGetDeviceGroupSurfacePresentModes2EXT); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + get_device_group_surface_present_modes2_ext } else { ::std::mem::transmute(val) } }, } } - #[doc = ""] - pub unsafe fn cmd_draw_mesh_tasks_nv( + #[doc = ""] + pub unsafe fn get_physical_device_surface_present_modes2_ext( &self, - command_buffer: CommandBuffer, - task_count: u32, - first_task: u32, - ) -> c_void { - (self.cmd_draw_mesh_tasks_nv)(command_buffer, task_count, first_task) + physical_device: PhysicalDevice, + p_surface_info: *const PhysicalDeviceSurfaceInfo2KHR, + p_present_mode_count: *mut u32, + p_present_modes: *mut PresentModeKHR, + ) -> Result { + (self.get_physical_device_surface_present_modes2_ext)( + physical_device, + p_surface_info, + p_present_mode_count, + p_present_modes, + ) } - #[doc = ""] - pub unsafe fn cmd_draw_mesh_tasks_indirect_nv( + #[doc = ""] + pub unsafe fn acquire_full_screen_exclusive_mode_ext( &self, - command_buffer: CommandBuffer, - buffer: Buffer, - offset: DeviceSize, - draw_count: u32, - stride: u32, - ) -> c_void { - (self.cmd_draw_mesh_tasks_indirect_nv)(command_buffer, buffer, offset, draw_count, stride) + device: Device, + swapchain: SwapchainKHR, + ) -> Result { + (self.acquire_full_screen_exclusive_mode_ext)(device, swapchain) } - #[doc = ""] - pub unsafe fn cmd_draw_mesh_tasks_indirect_count_nv( + #[doc = ""] + pub unsafe fn release_full_screen_exclusive_mode_ext( &self, - command_buffer: CommandBuffer, - buffer: Buffer, - offset: DeviceSize, - count_buffer: Buffer, - count_buffer_offset: DeviceSize, - max_draw_count: u32, - stride: u32, - ) -> c_void { - (self.cmd_draw_mesh_tasks_indirect_count_nv)( - command_buffer, - buffer, - offset, - count_buffer, - count_buffer_offset, - max_draw_count, - stride, - ) + device: Device, + swapchain: SwapchainKHR, + ) -> Result { + (self.release_full_screen_exclusive_mode_ext)(device, swapchain) + } + #[doc = ""] + pub unsafe fn get_device_group_surface_present_modes2_ext( + &self, + device: Device, + p_surface_info: *const PhysicalDeviceSurfaceInfo2KHR, + p_modes: *mut DeviceGroupPresentModeFlagsKHR, + ) -> Result { + (self.get_device_group_surface_present_modes2_ext)(device, p_surface_info, p_modes) } } -#[doc = "Generated from \'VK_NV_mesh_shader\'"] +#[doc = "Generated from \'VK_EXT_full_screen_exclusive\'"] impl StructureType { - pub const PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV: Self = Self(1_000_202_000); + pub const SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT: Self = Self(1_000_255_000); } -#[doc = "Generated from \'VK_NV_mesh_shader\'"] +#[doc = "Generated from \'VK_EXT_full_screen_exclusive\'"] impl StructureType { - pub const PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV: Self = Self(1_000_202_001); -} -#[doc = "Generated from \'VK_NV_mesh_shader\'"] -impl ShaderStageFlags { - pub const TASK_NV: Self = Self(0b100_0000); -} -#[doc = "Generated from \'VK_NV_mesh_shader\'"] -impl ShaderStageFlags { - pub const MESH_NV: Self = Self(0b1000_0000); + pub const SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT: Self = Self(1_000_255_002); } -#[doc = "Generated from \'VK_NV_mesh_shader\'"] -impl PipelineStageFlags { - pub const TASK_SHADER_NV: Self = Self(0b1000_0000_0000_0000_0000); +#[doc = "Generated from \'VK_EXT_full_screen_exclusive\'"] +impl Result { + pub const ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT: Self = Self(-1_000_255_000); } -#[doc = "Generated from \'VK_NV_mesh_shader\'"] -impl PipelineStageFlags { - pub const MESH_SHADER_NV: Self = Self(0b1_0000_0000_0000_0000_0000); +#[doc = "Generated from \'VK_EXT_full_screen_exclusive\'"] +impl StructureType { + pub const SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT: Self = Self(1_000_255_001); } -impl NvFragmentShaderBarycentricFn { +impl ExtHeadlessSurfaceFn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_fragment_shader_barycentric\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_headless_surface\0") .expect("Wrong extension string") } pub const SPEC_VERSION: u32 = 1u32; } -pub struct NvFragmentShaderBarycentricFn {} -unsafe impl Send for NvFragmentShaderBarycentricFn {} -unsafe impl Sync for NvFragmentShaderBarycentricFn {} -impl ::std::clone::Clone for NvFragmentShaderBarycentricFn { - fn clone(&self) -> Self { - NvFragmentShaderBarycentricFn {} - } -} -impl NvFragmentShaderBarycentricFn { - pub fn load(mut _f: F) -> Self - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - NvFragmentShaderBarycentricFn {} - } -} -#[doc = "Generated from \'VK_NV_fragment_shader_barycentric\'"] -impl StructureType { - pub const PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV: Self = Self(1_000_203_000); -} -impl NvShaderImageFootprintFn { - pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_shader_image_footprint\0") - .expect("Wrong extension string") - } - pub const SPEC_VERSION: u32 = 2u32; +#[allow(non_camel_case_types)] +pub type PFN_vkCreateHeadlessSurfaceEXT = extern "system" fn( + instance: Instance, + p_create_info: *const HeadlessSurfaceCreateInfoEXT, + p_allocator: *const AllocationCallbacks, + p_surface: *mut SurfaceKHR, +) -> Result; +pub struct ExtHeadlessSurfaceFn { + pub create_headless_surface_ext: extern "system" fn( + instance: Instance, + p_create_info: *const HeadlessSurfaceCreateInfoEXT, + p_allocator: *const AllocationCallbacks, + p_surface: *mut SurfaceKHR, + ) -> Result, } -pub struct NvShaderImageFootprintFn {} -unsafe impl Send for NvShaderImageFootprintFn {} -unsafe impl Sync for NvShaderImageFootprintFn {} -impl ::std::clone::Clone for NvShaderImageFootprintFn { +unsafe impl Send for ExtHeadlessSurfaceFn {} +unsafe impl Sync for ExtHeadlessSurfaceFn {} +impl ::std::clone::Clone for ExtHeadlessSurfaceFn { fn clone(&self) -> Self { - NvShaderImageFootprintFn {} + ExtHeadlessSurfaceFn { + create_headless_surface_ext: self.create_headless_surface_ext, + } } } -impl NvShaderImageFootprintFn { +impl ExtHeadlessSurfaceFn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - NvShaderImageFootprintFn {} + ExtHeadlessSurfaceFn { + create_headless_surface_ext: unsafe { + extern "system" fn create_headless_surface_ext( + _instance: Instance, + _p_create_info: *const HeadlessSurfaceCreateInfoEXT, + _p_allocator: *const AllocationCallbacks, + _p_surface: *mut SurfaceKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(create_headless_surface_ext) + )) + } + let raw_name = stringify!(vkCreateHeadlessSurfaceEXT); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + create_headless_surface_ext + } else { + ::std::mem::transmute(val) + } + }, + } + } + #[doc = ""] + pub unsafe fn create_headless_surface_ext( + &self, + instance: Instance, + p_create_info: *const HeadlessSurfaceCreateInfoEXT, + p_allocator: *const AllocationCallbacks, + p_surface: *mut SurfaceKHR, + ) -> Result { + (self.create_headless_surface_ext)(instance, p_create_info, p_allocator, p_surface) } } -#[doc = "Generated from \'VK_NV_shader_image_footprint\'"] +#[doc = "Generated from \'VK_EXT_headless_surface\'"] impl StructureType { - pub const PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV: Self = Self(1_000_204_000); + pub const HEADLESS_SURFACE_CREATE_INFO_EXT: Self = Self(1_000_256_000); } -impl NvScissorExclusiveFn { +impl KhrBufferDeviceAddressFn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_scissor_exclusive\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_buffer_device_address\0") .expect("Wrong extension string") } pub const SPEC_VERSION: u32 = 1u32; } #[allow(non_camel_case_types)] -pub type PFN_vkCmdSetExclusiveScissorNV = extern "system" fn( - command_buffer: CommandBuffer, - first_exclusive_scissor: u32, - exclusive_scissor_count: u32, - p_exclusive_scissors: *const Rect2D, -) -> c_void; -pub struct NvScissorExclusiveFn { - pub cmd_set_exclusive_scissor_nv: extern "system" fn( - command_buffer: CommandBuffer, - first_exclusive_scissor: u32, - exclusive_scissor_count: u32, - p_exclusive_scissors: *const Rect2D, - ) -> c_void, +pub type PFN_vkGetBufferOpaqueCaptureAddress = + extern "system" fn(device: Device, p_info: *const BufferDeviceAddressInfo) -> DeviceAddress; +#[allow(non_camel_case_types)] +pub type PFN_vkGetDeviceMemoryOpaqueCaptureAddress = + extern "system" fn(device: Device, p_info: *const BufferDeviceAddressInfo) -> u64; +pub struct KhrBufferDeviceAddressFn { + pub get_buffer_device_address_khr: + extern "system" fn(device: Device, p_info: *const BufferDeviceAddressInfo) -> DeviceAddress, + pub get_buffer_opaque_capture_address_khr: + extern "system" fn(device: Device, p_info: *const BufferDeviceAddressInfo) -> u64, + pub get_device_memory_opaque_capture_address_khr: extern "system" fn( + device: Device, + p_info: *const DeviceMemoryOpaqueCaptureAddressInfo, + ) -> u64, } -unsafe impl Send for NvScissorExclusiveFn {} -unsafe impl Sync for NvScissorExclusiveFn {} -impl ::std::clone::Clone for NvScissorExclusiveFn { +unsafe impl Send for KhrBufferDeviceAddressFn {} +unsafe impl Sync for KhrBufferDeviceAddressFn {} +impl ::std::clone::Clone for KhrBufferDeviceAddressFn { fn clone(&self) -> Self { - NvScissorExclusiveFn { - cmd_set_exclusive_scissor_nv: self.cmd_set_exclusive_scissor_nv, + KhrBufferDeviceAddressFn { + get_buffer_device_address_khr: self.get_buffer_device_address_khr, + get_buffer_opaque_capture_address_khr: self.get_buffer_opaque_capture_address_khr, + get_device_memory_opaque_capture_address_khr: self + .get_device_memory_opaque_capture_address_khr, } } } -impl NvScissorExclusiveFn { +impl KhrBufferDeviceAddressFn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - NvScissorExclusiveFn { - cmd_set_exclusive_scissor_nv: unsafe { - extern "system" fn cmd_set_exclusive_scissor_nv( - _command_buffer: CommandBuffer, - _first_exclusive_scissor: u32, - _exclusive_scissor_count: u32, - _p_exclusive_scissors: *const Rect2D, - ) -> c_void { + KhrBufferDeviceAddressFn { + get_buffer_device_address_khr: unsafe { + extern "system" fn get_buffer_device_address_khr( + _device: Device, + _p_info: *const BufferDeviceAddressInfo, + ) -> DeviceAddress { panic!(concat!( "Unable to load ", - stringify!(cmd_set_exclusive_scissor_nv) + stringify!(get_buffer_device_address_khr) )) } - let raw_name = stringify!(vkCmdSetExclusiveScissorNV); + let raw_name = stringify!(vkGetBufferDeviceAddressKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - cmd_set_exclusive_scissor_nv + get_buffer_device_address_khr + } else { + ::std::mem::transmute(val) + } + }, + get_buffer_opaque_capture_address_khr: unsafe { + extern "system" fn get_buffer_opaque_capture_address_khr( + _device: Device, + _p_info: *const BufferDeviceAddressInfo, + ) -> u64 { + panic!(concat!( + "Unable to load ", + stringify!(get_buffer_opaque_capture_address_khr) + )) + } + let raw_name = stringify!(vkGetBufferOpaqueCaptureAddressKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + get_buffer_opaque_capture_address_khr + } else { + ::std::mem::transmute(val) + } + }, + get_device_memory_opaque_capture_address_khr: unsafe { + extern "system" fn get_device_memory_opaque_capture_address_khr( + _device: Device, + _p_info: *const DeviceMemoryOpaqueCaptureAddressInfo, + ) -> u64 { + panic!(concat!( + "Unable to load ", + stringify!(get_device_memory_opaque_capture_address_khr) + )) + } + let raw_name = stringify!(vkGetDeviceMemoryOpaqueCaptureAddressKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + get_device_memory_opaque_capture_address_khr } else { ::std::mem::transmute(val) } }, } } - #[doc = ""] - pub unsafe fn cmd_set_exclusive_scissor_nv( + #[doc = ""] + pub unsafe fn get_buffer_device_address_khr( &self, - command_buffer: CommandBuffer, - first_exclusive_scissor: u32, - exclusive_scissor_count: u32, - p_exclusive_scissors: *const Rect2D, - ) -> c_void { - (self.cmd_set_exclusive_scissor_nv)( - command_buffer, - first_exclusive_scissor, - exclusive_scissor_count, - p_exclusive_scissors, - ) + device: Device, + p_info: *const BufferDeviceAddressInfo, + ) -> DeviceAddress { + (self.get_buffer_device_address_khr)(device, p_info) + } + #[doc = ""] + pub unsafe fn get_buffer_opaque_capture_address_khr( + &self, + device: Device, + p_info: *const BufferDeviceAddressInfo, + ) -> u64 { + (self.get_buffer_opaque_capture_address_khr)(device, p_info) + } + #[doc = ""] + pub unsafe fn get_device_memory_opaque_capture_address_khr( + &self, + device: Device, + p_info: *const DeviceMemoryOpaqueCaptureAddressInfo, + ) -> u64 { + (self.get_device_memory_opaque_capture_address_khr)(device, p_info) } } -#[doc = "Generated from \'VK_NV_scissor_exclusive\'"] +#[doc = "Generated from \'VK_KHR_buffer_device_address\'"] impl StructureType { - pub const PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV: Self = Self(1_000_205_000); + pub const PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_KHR: Self = + StructureType::PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES; } -#[doc = "Generated from \'VK_NV_scissor_exclusive\'"] -impl DynamicState { - pub const EXCLUSIVE_SCISSOR_NV: Self = Self(1_000_205_001); +#[doc = "Generated from \'VK_KHR_buffer_device_address\'"] +impl StructureType { + pub const BUFFER_DEVICE_ADDRESS_INFO_KHR: Self = StructureType::BUFFER_DEVICE_ADDRESS_INFO; } -#[doc = "Generated from \'VK_NV_scissor_exclusive\'"] +#[doc = "Generated from \'VK_KHR_buffer_device_address\'"] impl StructureType { - pub const PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV: Self = Self(1_000_205_002); + pub const BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO_KHR: Self = + StructureType::BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO; +} +#[doc = "Generated from \'VK_KHR_buffer_device_address\'"] +impl StructureType { + pub const MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO_KHR: Self = + StructureType::MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO; +} +#[doc = "Generated from \'VK_KHR_buffer_device_address\'"] +impl StructureType { + pub const DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO_KHR: Self = + StructureType::DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO; +} +#[doc = "Generated from \'VK_KHR_buffer_device_address\'"] +impl BufferUsageFlags { + pub const SHADER_DEVICE_ADDRESS_KHR: Self = BufferUsageFlags::SHADER_DEVICE_ADDRESS; +} +#[doc = "Generated from \'VK_KHR_buffer_device_address\'"] +impl BufferCreateFlags { + pub const DEVICE_ADDRESS_CAPTURE_REPLAY_KHR: Self = + BufferCreateFlags::DEVICE_ADDRESS_CAPTURE_REPLAY; +} +#[doc = "Generated from \'VK_KHR_buffer_device_address\'"] +impl MemoryAllocateFlags { + pub const DEVICE_ADDRESS_KHR: Self = MemoryAllocateFlags::DEVICE_ADDRESS; +} +#[doc = "Generated from \'VK_KHR_buffer_device_address\'"] +impl MemoryAllocateFlags { + pub const DEVICE_ADDRESS_CAPTURE_REPLAY_KHR: Self = + MemoryAllocateFlags::DEVICE_ADDRESS_CAPTURE_REPLAY; +} +#[doc = "Generated from \'VK_KHR_buffer_device_address\'"] +impl Result { + pub const ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS_KHR: Self = + Result::ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS; +} +impl ExtExtension259Fn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_extension_259\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 0u32; +} +pub struct ExtExtension259Fn {} +unsafe impl Send for ExtExtension259Fn {} +unsafe impl Sync for ExtExtension259Fn {} +impl ::std::clone::Clone for ExtExtension259Fn { + fn clone(&self) -> Self { + ExtExtension259Fn {} + } +} +impl ExtExtension259Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + ExtExtension259Fn {} + } } -impl NvDeviceDiagnosticCheckpointsFn { +impl ExtLineRasterizationFn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_device_diagnostic_checkpoints\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_line_rasterization\0") .expect("Wrong extension string") } - pub const SPEC_VERSION: u32 = 2u32; + pub const SPEC_VERSION: u32 = 1u32; } #[allow(non_camel_case_types)] -pub type PFN_vkCmdSetCheckpointNV = - extern "system" fn(command_buffer: CommandBuffer, p_checkpoint_marker: *const c_void) -> c_void; -#[allow(non_camel_case_types)] -pub type PFN_vkGetQueueCheckpointDataNV = extern "system" fn( - queue: Queue, - p_checkpoint_data_count: *mut u32, - p_checkpoint_data: *mut CheckpointDataNV, +pub type PFN_vkCmdSetLineStippleEXT = extern "system" fn( + command_buffer: CommandBuffer, + line_stipple_factor: u32, + line_stipple_pattern: u16, ) -> c_void; -pub struct NvDeviceDiagnosticCheckpointsFn { - pub cmd_set_checkpoint_nv: extern "system" fn( +pub struct ExtLineRasterizationFn { + pub cmd_set_line_stipple_ext: extern "system" fn( command_buffer: CommandBuffer, - p_checkpoint_marker: *const c_void, - ) -> c_void, - pub get_queue_checkpoint_data_nv: extern "system" fn( - queue: Queue, - p_checkpoint_data_count: *mut u32, - p_checkpoint_data: *mut CheckpointDataNV, + line_stipple_factor: u32, + line_stipple_pattern: u16, ) -> c_void, } -unsafe impl Send for NvDeviceDiagnosticCheckpointsFn {} -unsafe impl Sync for NvDeviceDiagnosticCheckpointsFn {} -impl ::std::clone::Clone for NvDeviceDiagnosticCheckpointsFn { +unsafe impl Send for ExtLineRasterizationFn {} +unsafe impl Sync for ExtLineRasterizationFn {} +impl ::std::clone::Clone for ExtLineRasterizationFn { fn clone(&self) -> Self { - NvDeviceDiagnosticCheckpointsFn { - cmd_set_checkpoint_nv: self.cmd_set_checkpoint_nv, - get_queue_checkpoint_data_nv: self.get_queue_checkpoint_data_nv, + ExtLineRasterizationFn { + cmd_set_line_stipple_ext: self.cmd_set_line_stipple_ext, } } } -impl NvDeviceDiagnosticCheckpointsFn { +impl ExtLineRasterizationFn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - NvDeviceDiagnosticCheckpointsFn { - cmd_set_checkpoint_nv: unsafe { - extern "system" fn cmd_set_checkpoint_nv( + ExtLineRasterizationFn { + cmd_set_line_stipple_ext: unsafe { + extern "system" fn cmd_set_line_stipple_ext( _command_buffer: CommandBuffer, - _p_checkpoint_marker: *const c_void, - ) -> c_void { - panic!(concat!( - "Unable to load ", - stringify!(cmd_set_checkpoint_nv) - )) - } - let raw_name = stringify!(vkCmdSetCheckpointNV); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - cmd_set_checkpoint_nv - } else { - ::std::mem::transmute(val) - } - }, - get_queue_checkpoint_data_nv: unsafe { - extern "system" fn get_queue_checkpoint_data_nv( - _queue: Queue, - _p_checkpoint_data_count: *mut u32, - _p_checkpoint_data: *mut CheckpointDataNV, + _line_stipple_factor: u32, + _line_stipple_pattern: u16, ) -> c_void { panic!(concat!( "Unable to load ", - stringify!(get_queue_checkpoint_data_nv) + stringify!(cmd_set_line_stipple_ext) )) } - let raw_name = stringify!(vkGetQueueCheckpointDataNV); + let raw_name = stringify!(vkCmdSetLineStippleEXT); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - get_queue_checkpoint_data_nv + cmd_set_line_stipple_ext } else { ::std::mem::transmute(val) } }, } } - #[doc = ""] - pub unsafe fn cmd_set_checkpoint_nv( + #[doc = ""] + pub unsafe fn cmd_set_line_stipple_ext( &self, command_buffer: CommandBuffer, - p_checkpoint_marker: *const c_void, - ) -> c_void { - (self.cmd_set_checkpoint_nv)(command_buffer, p_checkpoint_marker) - } - #[doc = ""] - pub unsafe fn get_queue_checkpoint_data_nv( - &self, - queue: Queue, - p_checkpoint_data_count: *mut u32, - p_checkpoint_data: *mut CheckpointDataNV, + line_stipple_factor: u32, + line_stipple_pattern: u16, ) -> c_void { - (self.get_queue_checkpoint_data_nv)(queue, p_checkpoint_data_count, p_checkpoint_data) + (self.cmd_set_line_stipple_ext)(command_buffer, line_stipple_factor, line_stipple_pattern) } } -#[doc = "Generated from \'VK_NV_device_diagnostic_checkpoints\'"] +#[doc = "Generated from \'VK_EXT_line_rasterization\'"] impl StructureType { - pub const CHECKPOINT_DATA_NV: Self = Self(1_000_206_000); + pub const PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT: Self = Self(1_000_259_000); } -#[doc = "Generated from \'VK_NV_device_diagnostic_checkpoints\'"] +#[doc = "Generated from \'VK_EXT_line_rasterization\'"] impl StructureType { - pub const QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV: Self = Self(1_000_206_001); + pub const PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT: Self = Self(1_000_259_001); } -impl KhrTimelineSemaphoreFn { +#[doc = "Generated from \'VK_EXT_line_rasterization\'"] +impl StructureType { + pub const PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT: Self = Self(1_000_259_002); +} +#[doc = "Generated from \'VK_EXT_line_rasterization\'"] +impl DynamicState { + pub const LINE_STIPPLE_EXT: Self = Self(1_000_259_000); +} +impl ExtShaderAtomicFloatFn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_timeline_semaphore\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_shader_atomic_float\0") .expect("Wrong extension string") } - pub const SPEC_VERSION: u32 = 2u32; + pub const SPEC_VERSION: u32 = 1u32; +} +pub struct ExtShaderAtomicFloatFn {} +unsafe impl Send for ExtShaderAtomicFloatFn {} +unsafe impl Sync for ExtShaderAtomicFloatFn {} +impl ::std::clone::Clone for ExtShaderAtomicFloatFn { + fn clone(&self) -> Self { + ExtShaderAtomicFloatFn {} + } +} +impl ExtShaderAtomicFloatFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + ExtShaderAtomicFloatFn {} + } +} +#[doc = "Generated from \'VK_EXT_shader_atomic_float\'"] +impl StructureType { + pub const PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT: Self = Self(1_000_260_000); +} +impl ExtHostQueryResetFn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_host_query_reset\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 1u32; } #[allow(non_camel_case_types)] -pub type PFN_vkGetSemaphoreCounterValue = - extern "system" fn(device: Device, semaphore: Semaphore, p_value: *mut u64) -> Result; -#[allow(non_camel_case_types)] -pub type PFN_vkWaitSemaphores = extern "system" fn( +pub type PFN_vkResetQueryPool = extern "system" fn( device: Device, - p_wait_info: *const SemaphoreWaitInfo, - timeout: u64, -) -> Result; -#[allow(non_camel_case_types)] -pub type PFN_vkSignalSemaphore = - extern "system" fn(device: Device, p_signal_info: *const SemaphoreSignalInfo) -> Result; -pub struct KhrTimelineSemaphoreFn { - pub get_semaphore_counter_value_khr: - extern "system" fn(device: Device, semaphore: Semaphore, p_value: *mut u64) -> Result, - pub wait_semaphores_khr: extern "system" fn( + query_pool: QueryPool, + first_query: u32, + query_count: u32, +) -> c_void; +pub struct ExtHostQueryResetFn { + pub reset_query_pool_ext: extern "system" fn( device: Device, - p_wait_info: *const SemaphoreWaitInfo, - timeout: u64, - ) -> Result, - pub signal_semaphore_khr: - extern "system" fn(device: Device, p_signal_info: *const SemaphoreSignalInfo) -> Result, + query_pool: QueryPool, + first_query: u32, + query_count: u32, + ) -> c_void, } -unsafe impl Send for KhrTimelineSemaphoreFn {} -unsafe impl Sync for KhrTimelineSemaphoreFn {} -impl ::std::clone::Clone for KhrTimelineSemaphoreFn { +unsafe impl Send for ExtHostQueryResetFn {} +unsafe impl Sync for ExtHostQueryResetFn {} +impl ::std::clone::Clone for ExtHostQueryResetFn { fn clone(&self) -> Self { - KhrTimelineSemaphoreFn { - get_semaphore_counter_value_khr: self.get_semaphore_counter_value_khr, - wait_semaphores_khr: self.wait_semaphores_khr, - signal_semaphore_khr: self.signal_semaphore_khr, + ExtHostQueryResetFn { + reset_query_pool_ext: self.reset_query_pool_ext, } } } -impl KhrTimelineSemaphoreFn { +impl ExtHostQueryResetFn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - KhrTimelineSemaphoreFn { - get_semaphore_counter_value_khr: unsafe { - extern "system" fn get_semaphore_counter_value_khr( - _device: Device, - _semaphore: Semaphore, - _p_value: *mut u64, - ) -> Result { - panic!(concat!( - "Unable to load ", - stringify!(get_semaphore_counter_value_khr) - )) - } - let raw_name = stringify!(vkGetSemaphoreCounterValueKHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - get_semaphore_counter_value_khr - } else { - ::std::mem::transmute(val) - } - }, - wait_semaphores_khr: unsafe { - extern "system" fn wait_semaphores_khr( - _device: Device, - _p_wait_info: *const SemaphoreWaitInfo, - _timeout: u64, - ) -> Result { - panic!(concat!("Unable to load ", stringify!(wait_semaphores_khr))) - } - let raw_name = stringify!(vkWaitSemaphoresKHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - wait_semaphores_khr - } else { - ::std::mem::transmute(val) - } - }, - signal_semaphore_khr: unsafe { - extern "system" fn signal_semaphore_khr( + ExtHostQueryResetFn { + reset_query_pool_ext: unsafe { + extern "system" fn reset_query_pool_ext( _device: Device, - _p_signal_info: *const SemaphoreSignalInfo, - ) -> Result { - panic!(concat!("Unable to load ", stringify!(signal_semaphore_khr))) + _query_pool: QueryPool, + _first_query: u32, + _query_count: u32, + ) -> c_void { + panic!(concat!("Unable to load ", stringify!(reset_query_pool_ext))) } - let raw_name = stringify!(vkSignalSemaphoreKHR); + let raw_name = stringify!(vkResetQueryPoolEXT); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - signal_semaphore_khr - } else { - ::std::mem::transmute(val) - } - }, - } - } - #[doc = ""] - pub unsafe fn get_semaphore_counter_value_khr( - &self, - device: Device, - semaphore: Semaphore, - p_value: *mut u64, - ) -> Result { - (self.get_semaphore_counter_value_khr)(device, semaphore, p_value) - } - #[doc = ""] - pub unsafe fn wait_semaphores_khr( - &self, - device: Device, - p_wait_info: *const SemaphoreWaitInfo, - timeout: u64, - ) -> Result { - (self.wait_semaphores_khr)(device, p_wait_info, timeout) + reset_query_pool_ext + } else { + ::std::mem::transmute(val) + } + }, + } } - #[doc = ""] - pub unsafe fn signal_semaphore_khr( + #[doc = ""] + pub unsafe fn reset_query_pool_ext( &self, device: Device, - p_signal_info: *const SemaphoreSignalInfo, - ) -> Result { - (self.signal_semaphore_khr)(device, p_signal_info) + query_pool: QueryPool, + first_query: u32, + query_count: u32, + ) -> c_void { + (self.reset_query_pool_ext)(device, query_pool, first_query, query_count) } } -#[doc = "Generated from \'VK_KHR_timeline_semaphore\'"] -impl StructureType { - pub const PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES_KHR: Self = - StructureType::PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES; -} -#[doc = "Generated from \'VK_KHR_timeline_semaphore\'"] -impl StructureType { - pub const PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES_KHR: Self = - StructureType::PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES; -} -#[doc = "Generated from \'VK_KHR_timeline_semaphore\'"] +#[doc = "Generated from \'VK_EXT_host_query_reset\'"] impl StructureType { - pub const SEMAPHORE_TYPE_CREATE_INFO_KHR: Self = StructureType::SEMAPHORE_TYPE_CREATE_INFO; + pub const PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES_EXT: Self = + StructureType::PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES; } -#[doc = "Generated from \'VK_KHR_timeline_semaphore\'"] -impl StructureType { - pub const TIMELINE_SEMAPHORE_SUBMIT_INFO_KHR: Self = - StructureType::TIMELINE_SEMAPHORE_SUBMIT_INFO; +impl GgpExtension263Fn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_GGP_extension_263\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 0u32; } -#[doc = "Generated from \'VK_KHR_timeline_semaphore\'"] -impl StructureType { - pub const SEMAPHORE_WAIT_INFO_KHR: Self = StructureType::SEMAPHORE_WAIT_INFO; +pub struct GgpExtension263Fn {} +unsafe impl Send for GgpExtension263Fn {} +unsafe impl Sync for GgpExtension263Fn {} +impl ::std::clone::Clone for GgpExtension263Fn { + fn clone(&self) -> Self { + GgpExtension263Fn {} + } } -#[doc = "Generated from \'VK_KHR_timeline_semaphore\'"] -impl StructureType { - pub const SEMAPHORE_SIGNAL_INFO_KHR: Self = StructureType::SEMAPHORE_SIGNAL_INFO; +impl GgpExtension263Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + GgpExtension263Fn {} + } } -#[doc = "Generated from \'VK_KHR_timeline_semaphore\'"] -impl SemaphoreType { - pub const BINARY_KHR: Self = SemaphoreType::BINARY; +impl BrcmExtension264Fn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_BRCM_extension_264\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 0u32; } -#[doc = "Generated from \'VK_KHR_timeline_semaphore\'"] -impl SemaphoreType { - pub const TIMELINE_KHR: Self = SemaphoreType::TIMELINE; +pub struct BrcmExtension264Fn {} +unsafe impl Send for BrcmExtension264Fn {} +unsafe impl Sync for BrcmExtension264Fn {} +impl ::std::clone::Clone for BrcmExtension264Fn { + fn clone(&self) -> Self { + BrcmExtension264Fn {} + } } -#[doc = "Generated from \'VK_KHR_timeline_semaphore\'"] -impl SemaphoreWaitFlags { - pub const ANY_KHR: Self = SemaphoreWaitFlags::ANY; +impl BrcmExtension264Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + BrcmExtension264Fn {} + } } -impl KhrExtension209Fn { +impl BrcmExtension265Fn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_extension_209\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_BRCM_extension_265\0") .expect("Wrong extension string") } pub const SPEC_VERSION: u32 = 0u32; } -pub struct KhrExtension209Fn {} -unsafe impl Send for KhrExtension209Fn {} -unsafe impl Sync for KhrExtension209Fn {} -impl ::std::clone::Clone for KhrExtension209Fn { +pub struct BrcmExtension265Fn {} +unsafe impl Send for BrcmExtension265Fn {} +unsafe impl Sync for BrcmExtension265Fn {} +impl ::std::clone::Clone for BrcmExtension265Fn { fn clone(&self) -> Self { - KhrExtension209Fn {} + BrcmExtension265Fn {} } } -impl KhrExtension209Fn { +impl BrcmExtension265Fn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - KhrExtension209Fn {} + BrcmExtension265Fn {} } } -impl IntelShaderIntegerFunctions2Fn { +impl ExtIndexTypeUint8Fn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_INTEL_shader_integer_functions2\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_index_type_uint8\0") .expect("Wrong extension string") } pub const SPEC_VERSION: u32 = 1u32; } -pub struct IntelShaderIntegerFunctions2Fn {} -unsafe impl Send for IntelShaderIntegerFunctions2Fn {} -unsafe impl Sync for IntelShaderIntegerFunctions2Fn {} -impl ::std::clone::Clone for IntelShaderIntegerFunctions2Fn { +pub struct ExtIndexTypeUint8Fn {} +unsafe impl Send for ExtIndexTypeUint8Fn {} +unsafe impl Sync for ExtIndexTypeUint8Fn {} +impl ::std::clone::Clone for ExtIndexTypeUint8Fn { fn clone(&self) -> Self { - IntelShaderIntegerFunctions2Fn {} + ExtIndexTypeUint8Fn {} } } -impl IntelShaderIntegerFunctions2Fn { +impl ExtIndexTypeUint8Fn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - IntelShaderIntegerFunctions2Fn {} + ExtIndexTypeUint8Fn {} } } -#[doc = "Generated from \'VK_INTEL_shader_integer_functions2\'"] +#[doc = "Generated from \'VK_EXT_index_type_uint8\'"] impl StructureType { - pub const PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL: Self = Self(1_000_209_000); + pub const PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT: Self = Self(1_000_265_000); } -impl IntelPerformanceQueryFn { +#[doc = "Generated from \'VK_EXT_index_type_uint8\'"] +impl IndexType { + pub const UINT8_EXT: Self = Self(1_000_265_000); +} +impl ExtExtension267Fn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_INTEL_performance_query\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_extension_267\0") .expect("Wrong extension string") } - pub const SPEC_VERSION: u32 = 2u32; + pub const SPEC_VERSION: u32 = 0u32; +} +pub struct ExtExtension267Fn {} +unsafe impl Send for ExtExtension267Fn {} +unsafe impl Sync for ExtExtension267Fn {} +impl ::std::clone::Clone for ExtExtension267Fn { + fn clone(&self) -> Self { + ExtExtension267Fn {} + } +} +impl ExtExtension267Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + ExtExtension267Fn {} + } +} +impl ExtExtendedDynamicStateFn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_extended_dynamic_state\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 1u32; } #[allow(non_camel_case_types)] -pub type PFN_vkInitializePerformanceApiINTEL = extern "system" fn( - device: Device, - p_initialize_info: *const InitializePerformanceApiInfoINTEL, -) -> Result; +pub type PFN_vkCmdSetCullModeEXT = + extern "system" fn(command_buffer: CommandBuffer, cull_mode: CullModeFlags) -> c_void; #[allow(non_camel_case_types)] -pub type PFN_vkUninitializePerformanceApiINTEL = extern "system" fn(device: Device) -> c_void; +pub type PFN_vkCmdSetFrontFaceEXT = + extern "system" fn(command_buffer: CommandBuffer, front_face: FrontFace) -> c_void; #[allow(non_camel_case_types)] -pub type PFN_vkCmdSetPerformanceMarkerINTEL = extern "system" fn( +pub type PFN_vkCmdSetPrimitiveTopologyEXT = extern "system" fn( command_buffer: CommandBuffer, - p_marker_info: *const PerformanceMarkerInfoINTEL, -) -> Result; + primitive_topology: PrimitiveTopology, +) -> c_void; #[allow(non_camel_case_types)] -pub type PFN_vkCmdSetPerformanceStreamMarkerINTEL = extern "system" fn( +pub type PFN_vkCmdSetViewportWithCountEXT = extern "system" fn( command_buffer: CommandBuffer, - p_marker_info: *const PerformanceStreamMarkerInfoINTEL, -) -> Result; + viewport_count: u32, + p_viewports: *const Viewport, +) -> c_void; #[allow(non_camel_case_types)] -pub type PFN_vkCmdSetPerformanceOverrideINTEL = extern "system" fn( +pub type PFN_vkCmdSetScissorWithCountEXT = extern "system" fn( command_buffer: CommandBuffer, - p_override_info: *const PerformanceOverrideInfoINTEL, -) -> Result; + scissor_count: u32, + p_scissors: *const Rect2D, +) -> c_void; #[allow(non_camel_case_types)] -pub type PFN_vkAcquirePerformanceConfigurationINTEL = extern "system" fn( - device: Device, - p_acquire_info: *const PerformanceConfigurationAcquireInfoINTEL, - p_configuration: *mut PerformanceConfigurationINTEL, -) -> Result; +pub type PFN_vkCmdBindVertexBuffers2EXT = extern "system" fn( + command_buffer: CommandBuffer, + first_binding: u32, + binding_count: u32, + p_buffers: *const Buffer, + p_offsets: *const DeviceSize, + p_sizes: *const DeviceSize, + p_strides: *const DeviceSize, +) -> c_void; #[allow(non_camel_case_types)] -pub type PFN_vkReleasePerformanceConfigurationINTEL = - extern "system" fn(device: Device, configuration: PerformanceConfigurationINTEL) -> Result; +pub type PFN_vkCmdSetDepthTestEnableEXT = + extern "system" fn(command_buffer: CommandBuffer, depth_test_enable: Bool32) -> c_void; #[allow(non_camel_case_types)] -pub type PFN_vkQueueSetPerformanceConfigurationINTEL = - extern "system" fn(queue: Queue, configuration: PerformanceConfigurationINTEL) -> Result; +pub type PFN_vkCmdSetDepthWriteEnableEXT = + extern "system" fn(command_buffer: CommandBuffer, depth_write_enable: Bool32) -> c_void; #[allow(non_camel_case_types)] -pub type PFN_vkGetPerformanceParameterINTEL = extern "system" fn( - device: Device, - parameter: PerformanceParameterTypeINTEL, - p_value: *mut PerformanceValueINTEL, -) -> Result; -pub struct IntelPerformanceQueryFn { - pub initialize_performance_api_intel: extern "system" fn( - device: Device, - p_initialize_info: *const InitializePerformanceApiInfoINTEL, - ) -> Result, - pub uninitialize_performance_api_intel: extern "system" fn(device: Device) -> c_void, - pub cmd_set_performance_marker_intel: extern "system" fn( - command_buffer: CommandBuffer, - p_marker_info: *const PerformanceMarkerInfoINTEL, - ) -> Result, - pub cmd_set_performance_stream_marker_intel: extern "system" fn( +pub type PFN_vkCmdSetDepthCompareOpEXT = + extern "system" fn(command_buffer: CommandBuffer, depth_compare_op: CompareOp) -> c_void; +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetDepthBoundsTestEnableEXT = + extern "system" fn(command_buffer: CommandBuffer, depth_bounds_test_enable: Bool32) -> c_void; +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetStencilTestEnableEXT = + extern "system" fn(command_buffer: CommandBuffer, stencil_test_enable: Bool32) -> c_void; +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetStencilOpEXT = extern "system" fn( + command_buffer: CommandBuffer, + face_mask: StencilFaceFlags, + fail_op: StencilOp, + pass_op: StencilOp, + depth_fail_op: StencilOp, + compare_op: CompareOp, +) -> c_void; +pub struct ExtExtendedDynamicStateFn { + pub cmd_set_cull_mode_ext: + extern "system" fn(command_buffer: CommandBuffer, cull_mode: CullModeFlags) -> c_void, + pub cmd_set_front_face_ext: + extern "system" fn(command_buffer: CommandBuffer, front_face: FrontFace) -> c_void, + pub cmd_set_primitive_topology_ext: extern "system" fn( command_buffer: CommandBuffer, - p_marker_info: *const PerformanceStreamMarkerInfoINTEL, - ) -> Result, - pub cmd_set_performance_override_intel: extern "system" fn( + primitive_topology: PrimitiveTopology, + ) -> c_void, + pub cmd_set_viewport_with_count_ext: extern "system" fn( command_buffer: CommandBuffer, - p_override_info: *const PerformanceOverrideInfoINTEL, - ) -> Result, - pub acquire_performance_configuration_intel: extern "system" fn( - device: Device, - p_acquire_info: *const PerformanceConfigurationAcquireInfoINTEL, - p_configuration: *mut PerformanceConfigurationINTEL, - ) -> Result, - pub release_performance_configuration_intel: - extern "system" fn(device: Device, configuration: PerformanceConfigurationINTEL) -> Result, - pub queue_set_performance_configuration_intel: - extern "system" fn(queue: Queue, configuration: PerformanceConfigurationINTEL) -> Result, - pub get_performance_parameter_intel: extern "system" fn( - device: Device, - parameter: PerformanceParameterTypeINTEL, - p_value: *mut PerformanceValueINTEL, - ) -> Result, -} -unsafe impl Send for IntelPerformanceQueryFn {} -unsafe impl Sync for IntelPerformanceQueryFn {} -impl ::std::clone::Clone for IntelPerformanceQueryFn { - fn clone(&self) -> Self { - IntelPerformanceQueryFn { - initialize_performance_api_intel: self.initialize_performance_api_intel, - uninitialize_performance_api_intel: self.uninitialize_performance_api_intel, - cmd_set_performance_marker_intel: self.cmd_set_performance_marker_intel, - cmd_set_performance_stream_marker_intel: self.cmd_set_performance_stream_marker_intel, - cmd_set_performance_override_intel: self.cmd_set_performance_override_intel, - acquire_performance_configuration_intel: self.acquire_performance_configuration_intel, - release_performance_configuration_intel: self.release_performance_configuration_intel, - queue_set_performance_configuration_intel: self - .queue_set_performance_configuration_intel, - get_performance_parameter_intel: self.get_performance_parameter_intel, + viewport_count: u32, + p_viewports: *const Viewport, + ) -> c_void, + pub cmd_set_scissor_with_count_ext: extern "system" fn( + command_buffer: CommandBuffer, + scissor_count: u32, + p_scissors: *const Rect2D, + ) -> c_void, + pub cmd_bind_vertex_buffers2_ext: extern "system" fn( + command_buffer: CommandBuffer, + first_binding: u32, + binding_count: u32, + p_buffers: *const Buffer, + p_offsets: *const DeviceSize, + p_sizes: *const DeviceSize, + p_strides: *const DeviceSize, + ) -> c_void, + pub cmd_set_depth_test_enable_ext: + extern "system" fn(command_buffer: CommandBuffer, depth_test_enable: Bool32) -> c_void, + pub cmd_set_depth_write_enable_ext: + extern "system" fn(command_buffer: CommandBuffer, depth_write_enable: Bool32) -> c_void, + pub cmd_set_depth_compare_op_ext: + extern "system" fn(command_buffer: CommandBuffer, depth_compare_op: CompareOp) -> c_void, + pub cmd_set_depth_bounds_test_enable_ext: extern "system" fn( + command_buffer: CommandBuffer, + depth_bounds_test_enable: Bool32, + ) -> c_void, + pub cmd_set_stencil_test_enable_ext: + extern "system" fn(command_buffer: CommandBuffer, stencil_test_enable: Bool32) -> c_void, + pub cmd_set_stencil_op_ext: extern "system" fn( + command_buffer: CommandBuffer, + face_mask: StencilFaceFlags, + fail_op: StencilOp, + pass_op: StencilOp, + depth_fail_op: StencilOp, + compare_op: CompareOp, + ) -> c_void, +} +unsafe impl Send for ExtExtendedDynamicStateFn {} +unsafe impl Sync for ExtExtendedDynamicStateFn {} +impl ::std::clone::Clone for ExtExtendedDynamicStateFn { + fn clone(&self) -> Self { + ExtExtendedDynamicStateFn { + cmd_set_cull_mode_ext: self.cmd_set_cull_mode_ext, + cmd_set_front_face_ext: self.cmd_set_front_face_ext, + cmd_set_primitive_topology_ext: self.cmd_set_primitive_topology_ext, + cmd_set_viewport_with_count_ext: self.cmd_set_viewport_with_count_ext, + cmd_set_scissor_with_count_ext: self.cmd_set_scissor_with_count_ext, + cmd_bind_vertex_buffers2_ext: self.cmd_bind_vertex_buffers2_ext, + cmd_set_depth_test_enable_ext: self.cmd_set_depth_test_enable_ext, + cmd_set_depth_write_enable_ext: self.cmd_set_depth_write_enable_ext, + cmd_set_depth_compare_op_ext: self.cmd_set_depth_compare_op_ext, + cmd_set_depth_bounds_test_enable_ext: self.cmd_set_depth_bounds_test_enable_ext, + cmd_set_stencil_test_enable_ext: self.cmd_set_stencil_test_enable_ext, + cmd_set_stencil_op_ext: self.cmd_set_stencil_op_ext, } } } -impl IntelPerformanceQueryFn { +impl ExtExtendedDynamicStateFn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - IntelPerformanceQueryFn { - initialize_performance_api_intel: unsafe { - extern "system" fn initialize_performance_api_intel( - _device: Device, - _p_initialize_info: *const InitializePerformanceApiInfoINTEL, - ) -> Result { + ExtExtendedDynamicStateFn { + cmd_set_cull_mode_ext: unsafe { + extern "system" fn cmd_set_cull_mode_ext( + _command_buffer: CommandBuffer, + _cull_mode: CullModeFlags, + ) -> c_void { panic!(concat!( "Unable to load ", - stringify!(initialize_performance_api_intel) + stringify!(cmd_set_cull_mode_ext) )) } - let raw_name = stringify!(vkInitializePerformanceApiINTEL); + let raw_name = stringify!(vkCmdSetCullModeEXT); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - initialize_performance_api_intel + cmd_set_cull_mode_ext } else { ::std::mem::transmute(val) } }, - uninitialize_performance_api_intel: unsafe { - extern "system" fn uninitialize_performance_api_intel(_device: Device) -> c_void { + cmd_set_front_face_ext: unsafe { + extern "system" fn cmd_set_front_face_ext( + _command_buffer: CommandBuffer, + _front_face: FrontFace, + ) -> c_void { panic!(concat!( "Unable to load ", - stringify!(uninitialize_performance_api_intel) + stringify!(cmd_set_front_face_ext) )) } - let raw_name = stringify!(vkUninitializePerformanceApiINTEL); + let raw_name = stringify!(vkCmdSetFrontFaceEXT); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - uninitialize_performance_api_intel + cmd_set_front_face_ext } else { ::std::mem::transmute(val) } }, - cmd_set_performance_marker_intel: unsafe { - extern "system" fn cmd_set_performance_marker_intel( + cmd_set_primitive_topology_ext: unsafe { + extern "system" fn cmd_set_primitive_topology_ext( _command_buffer: CommandBuffer, - _p_marker_info: *const PerformanceMarkerInfoINTEL, - ) -> Result { + _primitive_topology: PrimitiveTopology, + ) -> c_void { panic!(concat!( "Unable to load ", - stringify!(cmd_set_performance_marker_intel) + stringify!(cmd_set_primitive_topology_ext) )) } - let raw_name = stringify!(vkCmdSetPerformanceMarkerINTEL); + let raw_name = stringify!(vkCmdSetPrimitiveTopologyEXT); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - cmd_set_performance_marker_intel + cmd_set_primitive_topology_ext } else { ::std::mem::transmute(val) } }, - cmd_set_performance_stream_marker_intel: unsafe { - extern "system" fn cmd_set_performance_stream_marker_intel( + cmd_set_viewport_with_count_ext: unsafe { + extern "system" fn cmd_set_viewport_with_count_ext( _command_buffer: CommandBuffer, - _p_marker_info: *const PerformanceStreamMarkerInfoINTEL, - ) -> Result { + _viewport_count: u32, + _p_viewports: *const Viewport, + ) -> c_void { panic!(concat!( "Unable to load ", - stringify!(cmd_set_performance_stream_marker_intel) + stringify!(cmd_set_viewport_with_count_ext) )) } - let raw_name = stringify!(vkCmdSetPerformanceStreamMarkerINTEL); + let raw_name = stringify!(vkCmdSetViewportWithCountEXT); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - cmd_set_performance_stream_marker_intel + cmd_set_viewport_with_count_ext } else { ::std::mem::transmute(val) } }, - cmd_set_performance_override_intel: unsafe { - extern "system" fn cmd_set_performance_override_intel( + cmd_set_scissor_with_count_ext: unsafe { + extern "system" fn cmd_set_scissor_with_count_ext( _command_buffer: CommandBuffer, - _p_override_info: *const PerformanceOverrideInfoINTEL, - ) -> Result { + _scissor_count: u32, + _p_scissors: *const Rect2D, + ) -> c_void { panic!(concat!( "Unable to load ", - stringify!(cmd_set_performance_override_intel) + stringify!(cmd_set_scissor_with_count_ext) )) } - let raw_name = stringify!(vkCmdSetPerformanceOverrideINTEL); + let raw_name = stringify!(vkCmdSetScissorWithCountEXT); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - cmd_set_performance_override_intel + cmd_set_scissor_with_count_ext } else { ::std::mem::transmute(val) } }, - acquire_performance_configuration_intel: unsafe { - extern "system" fn acquire_performance_configuration_intel( - _device: Device, - _p_acquire_info: *const PerformanceConfigurationAcquireInfoINTEL, - _p_configuration: *mut PerformanceConfigurationINTEL, - ) -> Result { + cmd_bind_vertex_buffers2_ext: 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, + ) -> c_void { panic!(concat!( "Unable to load ", - stringify!(acquire_performance_configuration_intel) + stringify!(cmd_bind_vertex_buffers2_ext) )) } - let raw_name = stringify!(vkAcquirePerformanceConfigurationINTEL); + let raw_name = stringify!(vkCmdBindVertexBuffers2EXT); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - acquire_performance_configuration_intel + cmd_bind_vertex_buffers2_ext } else { ::std::mem::transmute(val) } }, - release_performance_configuration_intel: unsafe { - extern "system" fn release_performance_configuration_intel( - _device: Device, - _configuration: PerformanceConfigurationINTEL, - ) -> Result { + cmd_set_depth_test_enable_ext: unsafe { + extern "system" fn cmd_set_depth_test_enable_ext( + _command_buffer: CommandBuffer, + _depth_test_enable: Bool32, + ) -> c_void { panic!(concat!( "Unable to load ", - stringify!(release_performance_configuration_intel) + stringify!(cmd_set_depth_test_enable_ext) )) } - let raw_name = stringify!(vkReleasePerformanceConfigurationINTEL); + let raw_name = stringify!(vkCmdSetDepthTestEnableEXT); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - release_performance_configuration_intel + cmd_set_depth_test_enable_ext } else { ::std::mem::transmute(val) } }, - queue_set_performance_configuration_intel: unsafe { - extern "system" fn queue_set_performance_configuration_intel( - _queue: Queue, - _configuration: PerformanceConfigurationINTEL, - ) -> Result { + cmd_set_depth_write_enable_ext: unsafe { + extern "system" fn cmd_set_depth_write_enable_ext( + _command_buffer: CommandBuffer, + _depth_write_enable: Bool32, + ) -> c_void { panic!(concat!( "Unable to load ", - stringify!(queue_set_performance_configuration_intel) + stringify!(cmd_set_depth_write_enable_ext) )) } - let raw_name = stringify!(vkQueueSetPerformanceConfigurationINTEL); + let raw_name = stringify!(vkCmdSetDepthWriteEnableEXT); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - queue_set_performance_configuration_intel + cmd_set_depth_write_enable_ext } else { ::std::mem::transmute(val) } }, - get_performance_parameter_intel: unsafe { - extern "system" fn get_performance_parameter_intel( - _device: Device, - _parameter: PerformanceParameterTypeINTEL, - _p_value: *mut PerformanceValueINTEL, - ) -> Result { + cmd_set_depth_compare_op_ext: unsafe { + extern "system" fn cmd_set_depth_compare_op_ext( + _command_buffer: CommandBuffer, + _depth_compare_op: CompareOp, + ) -> c_void { panic!(concat!( "Unable to load ", - stringify!(get_performance_parameter_intel) + stringify!(cmd_set_depth_compare_op_ext) )) } - let raw_name = stringify!(vkGetPerformanceParameterINTEL); + let raw_name = stringify!(vkCmdSetDepthCompareOpEXT); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - get_performance_parameter_intel + cmd_set_depth_compare_op_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_depth_bounds_test_enable_ext: unsafe { + extern "system" fn cmd_set_depth_bounds_test_enable_ext( + _command_buffer: CommandBuffer, + _depth_bounds_test_enable: Bool32, + ) -> c_void { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_depth_bounds_test_enable_ext) + )) + } + let raw_name = stringify!(vkCmdSetDepthBoundsTestEnableEXT); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + cmd_set_depth_bounds_test_enable_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_stencil_test_enable_ext: unsafe { + extern "system" fn cmd_set_stencil_test_enable_ext( + _command_buffer: CommandBuffer, + _stencil_test_enable: Bool32, + ) -> c_void { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_stencil_test_enable_ext) + )) + } + let raw_name = stringify!(vkCmdSetStencilTestEnableEXT); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + cmd_set_stencil_test_enable_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_stencil_op_ext: unsafe { + 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, + ) -> c_void { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_stencil_op_ext) + )) + } + let raw_name = stringify!(vkCmdSetStencilOpEXT); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + cmd_set_stencil_op_ext } else { ::std::mem::transmute(val) } }, } } - #[doc = ""] - pub unsafe fn initialize_performance_api_intel( + #[doc = ""] + pub unsafe fn cmd_set_cull_mode_ext( &self, - device: Device, - p_initialize_info: *const InitializePerformanceApiInfoINTEL, - ) -> Result { - (self.initialize_performance_api_intel)(device, p_initialize_info) + command_buffer: CommandBuffer, + cull_mode: CullModeFlags, + ) -> c_void { + (self.cmd_set_cull_mode_ext)(command_buffer, cull_mode) } - #[doc = ""] - pub unsafe fn uninitialize_performance_api_intel(&self, device: Device) -> c_void { - (self.uninitialize_performance_api_intel)(device) + #[doc = ""] + pub unsafe fn cmd_set_front_face_ext( + &self, + command_buffer: CommandBuffer, + front_face: FrontFace, + ) -> c_void { + (self.cmd_set_front_face_ext)(command_buffer, front_face) } - #[doc = ""] - pub unsafe fn cmd_set_performance_marker_intel( + #[doc = ""] + pub unsafe fn cmd_set_primitive_topology_ext( &self, command_buffer: CommandBuffer, - p_marker_info: *const PerformanceMarkerInfoINTEL, - ) -> Result { - (self.cmd_set_performance_marker_intel)(command_buffer, p_marker_info) + primitive_topology: PrimitiveTopology, + ) -> c_void { + (self.cmd_set_primitive_topology_ext)(command_buffer, primitive_topology) } - #[doc = ""] - pub unsafe fn cmd_set_performance_stream_marker_intel( + #[doc = ""] + pub unsafe fn cmd_set_viewport_with_count_ext( &self, command_buffer: CommandBuffer, - p_marker_info: *const PerformanceStreamMarkerInfoINTEL, - ) -> Result { - (self.cmd_set_performance_stream_marker_intel)(command_buffer, p_marker_info) + viewport_count: u32, + p_viewports: *const Viewport, + ) -> c_void { + (self.cmd_set_viewport_with_count_ext)(command_buffer, viewport_count, p_viewports) } - #[doc = ""] - pub unsafe fn cmd_set_performance_override_intel( + #[doc = ""] + pub unsafe fn cmd_set_scissor_with_count_ext( &self, command_buffer: CommandBuffer, - p_override_info: *const PerformanceOverrideInfoINTEL, - ) -> Result { - (self.cmd_set_performance_override_intel)(command_buffer, p_override_info) + scissor_count: u32, + p_scissors: *const Rect2D, + ) -> c_void { + (self.cmd_set_scissor_with_count_ext)(command_buffer, scissor_count, p_scissors) } - #[doc = ""] - pub unsafe fn acquire_performance_configuration_intel( + #[doc = ""] + pub unsafe fn cmd_bind_vertex_buffers2_ext( &self, - device: Device, - p_acquire_info: *const PerformanceConfigurationAcquireInfoINTEL, - p_configuration: *mut PerformanceConfigurationINTEL, - ) -> Result { - (self.acquire_performance_configuration_intel)(device, p_acquire_info, p_configuration) + 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, + ) -> c_void { + (self.cmd_bind_vertex_buffers2_ext)( + command_buffer, + first_binding, + binding_count, + p_buffers, + p_offsets, + p_sizes, + p_strides, + ) } - #[doc = ""] - pub unsafe fn release_performance_configuration_intel( + #[doc = ""] + pub unsafe fn cmd_set_depth_test_enable_ext( &self, - device: Device, - configuration: PerformanceConfigurationINTEL, - ) -> Result { - (self.release_performance_configuration_intel)(device, configuration) + command_buffer: CommandBuffer, + depth_test_enable: Bool32, + ) -> c_void { + (self.cmd_set_depth_test_enable_ext)(command_buffer, depth_test_enable) } - #[doc = ""] - pub unsafe fn queue_set_performance_configuration_intel( + #[doc = ""] + pub unsafe fn cmd_set_depth_write_enable_ext( &self, - queue: Queue, - configuration: PerformanceConfigurationINTEL, - ) -> Result { - (self.queue_set_performance_configuration_intel)(queue, configuration) + command_buffer: CommandBuffer, + depth_write_enable: Bool32, + ) -> c_void { + (self.cmd_set_depth_write_enable_ext)(command_buffer, depth_write_enable) } - #[doc = ""] - pub unsafe fn get_performance_parameter_intel( + #[doc = ""] + pub unsafe fn cmd_set_depth_compare_op_ext( &self, - device: Device, - parameter: PerformanceParameterTypeINTEL, - p_value: *mut PerformanceValueINTEL, - ) -> Result { - (self.get_performance_parameter_intel)(device, parameter, p_value) + command_buffer: CommandBuffer, + depth_compare_op: CompareOp, + ) -> c_void { + (self.cmd_set_depth_compare_op_ext)(command_buffer, depth_compare_op) + } + #[doc = ""] + pub unsafe fn cmd_set_depth_bounds_test_enable_ext( + &self, + command_buffer: CommandBuffer, + depth_bounds_test_enable: Bool32, + ) -> c_void { + (self.cmd_set_depth_bounds_test_enable_ext)(command_buffer, depth_bounds_test_enable) + } + #[doc = ""] + pub unsafe fn cmd_set_stencil_test_enable_ext( + &self, + command_buffer: CommandBuffer, + stencil_test_enable: Bool32, + ) -> c_void { + (self.cmd_set_stencil_test_enable_ext)(command_buffer, stencil_test_enable) + } + #[doc = ""] + pub unsafe fn cmd_set_stencil_op_ext( + &self, + command_buffer: CommandBuffer, + face_mask: StencilFaceFlags, + fail_op: StencilOp, + pass_op: StencilOp, + depth_fail_op: StencilOp, + compare_op: CompareOp, + ) -> c_void { + (self.cmd_set_stencil_op_ext)( + command_buffer, + face_mask, + fail_op, + pass_op, + depth_fail_op, + compare_op, + ) } } -#[doc = "Generated from \'VK_INTEL_performance_query\'"] -impl StructureType { - pub const QUERY_POOL_CREATE_INFO_INTEL: Self = Self(1_000_210_000); -} -#[doc = "Generated from \'VK_INTEL_performance_query\'"] -impl StructureType { - pub const INITIALIZE_PERFORMANCE_API_INFO_INTEL: Self = Self(1_000_210_001); -} -#[doc = "Generated from \'VK_INTEL_performance_query\'"] -impl StructureType { - pub const PERFORMANCE_MARKER_INFO_INTEL: Self = Self(1_000_210_002); -} -#[doc = "Generated from \'VK_INTEL_performance_query\'"] -impl StructureType { - pub const PERFORMANCE_STREAM_MARKER_INFO_INTEL: Self = Self(1_000_210_003); -} -#[doc = "Generated from \'VK_INTEL_performance_query\'"] -impl StructureType { - pub const PERFORMANCE_OVERRIDE_INFO_INTEL: Self = Self(1_000_210_004); -} -#[doc = "Generated from \'VK_INTEL_performance_query\'"] +#[doc = "Generated from \'VK_EXT_extended_dynamic_state\'"] impl StructureType { - pub const PERFORMANCE_CONFIGURATION_ACQUIRE_INFO_INTEL: Self = Self(1_000_210_005); + pub const PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT: Self = Self(1_000_267_000); } -#[doc = "Generated from \'VK_INTEL_performance_query\'"] -impl QueryType { - pub const PERFORMANCE_QUERY_INTEL: Self = Self(1_000_210_000); +#[doc = "Generated from \'VK_EXT_extended_dynamic_state\'"] +impl DynamicState { + pub const CULL_MODE_EXT: Self = Self(1_000_267_000); } -#[doc = "Generated from \'VK_INTEL_performance_query\'"] -impl ObjectType { - pub const PERFORMANCE_CONFIGURATION_INTEL: Self = Self(1_000_210_000); +#[doc = "Generated from \'VK_EXT_extended_dynamic_state\'"] +impl DynamicState { + pub const FRONT_FACE_EXT: Self = Self(1_000_267_001); } -impl KhrVulkanMemoryModelFn { - pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_vulkan_memory_model\0") - .expect("Wrong extension string") - } - pub const SPEC_VERSION: u32 = 3u32; +#[doc = "Generated from \'VK_EXT_extended_dynamic_state\'"] +impl DynamicState { + pub const PRIMITIVE_TOPOLOGY_EXT: Self = Self(1_000_267_002); } -pub struct KhrVulkanMemoryModelFn {} -unsafe impl Send for KhrVulkanMemoryModelFn {} -unsafe impl Sync for KhrVulkanMemoryModelFn {} -impl ::std::clone::Clone for KhrVulkanMemoryModelFn { - fn clone(&self) -> Self { - KhrVulkanMemoryModelFn {} - } +#[doc = "Generated from \'VK_EXT_extended_dynamic_state\'"] +impl DynamicState { + pub const VIEWPORT_WITH_COUNT_EXT: Self = Self(1_000_267_003); } -impl KhrVulkanMemoryModelFn { - pub fn load(mut _f: F) -> Self - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - KhrVulkanMemoryModelFn {} - } +#[doc = "Generated from \'VK_EXT_extended_dynamic_state\'"] +impl DynamicState { + pub const SCISSOR_WITH_COUNT_EXT: Self = Self(1_000_267_004); } -#[doc = "Generated from \'VK_KHR_vulkan_memory_model\'"] -impl StructureType { - pub const PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES_KHR: Self = - StructureType::PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES; +#[doc = "Generated from \'VK_EXT_extended_dynamic_state\'"] +impl DynamicState { + pub const VERTEX_INPUT_BINDING_STRIDE_EXT: Self = Self(1_000_267_005); } -impl ExtPciBusInfoFn { - pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_pci_bus_info\0") - .expect("Wrong extension string") - } - pub const SPEC_VERSION: u32 = 2u32; +#[doc = "Generated from \'VK_EXT_extended_dynamic_state\'"] +impl DynamicState { + pub const DEPTH_TEST_ENABLE_EXT: Self = Self(1_000_267_006); } -pub struct ExtPciBusInfoFn {} -unsafe impl Send for ExtPciBusInfoFn {} -unsafe impl Sync for ExtPciBusInfoFn {} -impl ::std::clone::Clone for ExtPciBusInfoFn { - fn clone(&self) -> Self { - ExtPciBusInfoFn {} - } +#[doc = "Generated from \'VK_EXT_extended_dynamic_state\'"] +impl DynamicState { + pub const DEPTH_WRITE_ENABLE_EXT: Self = Self(1_000_267_007); } -impl ExtPciBusInfoFn { - pub fn load(mut _f: F) -> Self - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - ExtPciBusInfoFn {} - } +#[doc = "Generated from \'VK_EXT_extended_dynamic_state\'"] +impl DynamicState { + pub const DEPTH_COMPARE_OP_EXT: Self = Self(1_000_267_008); } -#[doc = "Generated from \'VK_EXT_pci_bus_info\'"] -impl StructureType { - pub const PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT: Self = Self(1_000_212_000); +#[doc = "Generated from \'VK_EXT_extended_dynamic_state\'"] +impl DynamicState { + pub const DEPTH_BOUNDS_TEST_ENABLE_EXT: Self = Self(1_000_267_009); } -impl AmdDisplayNativeHdrFn { +#[doc = "Generated from \'VK_EXT_extended_dynamic_state\'"] +impl DynamicState { + pub const STENCIL_TEST_ENABLE_EXT: Self = Self(1_000_267_010); +} +#[doc = "Generated from \'VK_EXT_extended_dynamic_state\'"] +impl DynamicState { + pub const STENCIL_OP_EXT: Self = Self(1_000_267_011); +} +impl KhrDeferredHostOperationsFn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_AMD_display_native_hdr\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_deferred_host_operations\0") .expect("Wrong extension string") } - pub const SPEC_VERSION: u32 = 1u32; + pub const SPEC_VERSION: u32 = 4u32; } #[allow(non_camel_case_types)] -pub type PFN_vkSetLocalDimmingAMD = extern "system" fn( +pub type PFN_vkCreateDeferredOperationKHR = extern "system" fn( device: Device, - swap_chain: SwapchainKHR, - local_dimming_enable: Bool32, + p_allocator: *const AllocationCallbacks, + p_deferred_operation: *mut DeferredOperationKHR, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkDestroyDeferredOperationKHR = extern "system" fn( + device: Device, + operation: DeferredOperationKHR, + p_allocator: *const AllocationCallbacks, ) -> c_void; -pub struct AmdDisplayNativeHdrFn { - pub set_local_dimming_amd: extern "system" fn( +#[allow(non_camel_case_types)] +pub type PFN_vkGetDeferredOperationMaxConcurrencyKHR = + extern "system" fn(device: Device, operation: DeferredOperationKHR) -> u32; +#[allow(non_camel_case_types)] +pub type PFN_vkGetDeferredOperationResultKHR = + extern "system" fn(device: Device, operation: DeferredOperationKHR) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkDeferredOperationJoinKHR = + extern "system" fn(device: Device, operation: DeferredOperationKHR) -> Result; +pub struct KhrDeferredHostOperationsFn { + pub create_deferred_operation_khr: extern "system" fn( device: Device, - swap_chain: SwapchainKHR, - local_dimming_enable: Bool32, + p_allocator: *const AllocationCallbacks, + p_deferred_operation: *mut DeferredOperationKHR, + ) -> Result, + pub destroy_deferred_operation_khr: extern "system" fn( + device: Device, + operation: DeferredOperationKHR, + p_allocator: *const AllocationCallbacks, ) -> c_void, + pub get_deferred_operation_max_concurrency_khr: + extern "system" fn(device: Device, operation: DeferredOperationKHR) -> u32, + pub get_deferred_operation_result_khr: + extern "system" fn(device: Device, operation: DeferredOperationKHR) -> Result, + pub deferred_operation_join_khr: + extern "system" fn(device: Device, operation: DeferredOperationKHR) -> Result, } -unsafe impl Send for AmdDisplayNativeHdrFn {} -unsafe impl Sync for AmdDisplayNativeHdrFn {} -impl ::std::clone::Clone for AmdDisplayNativeHdrFn { +unsafe impl Send for KhrDeferredHostOperationsFn {} +unsafe impl Sync for KhrDeferredHostOperationsFn {} +impl ::std::clone::Clone for KhrDeferredHostOperationsFn { fn clone(&self) -> Self { - AmdDisplayNativeHdrFn { - set_local_dimming_amd: self.set_local_dimming_amd, + KhrDeferredHostOperationsFn { + create_deferred_operation_khr: self.create_deferred_operation_khr, + destroy_deferred_operation_khr: self.destroy_deferred_operation_khr, + get_deferred_operation_max_concurrency_khr: self + .get_deferred_operation_max_concurrency_khr, + get_deferred_operation_result_khr: self.get_deferred_operation_result_khr, + deferred_operation_join_khr: self.deferred_operation_join_khr, } } } -impl AmdDisplayNativeHdrFn { +impl KhrDeferredHostOperationsFn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - AmdDisplayNativeHdrFn { - set_local_dimming_amd: unsafe { - extern "system" fn set_local_dimming_amd( + KhrDeferredHostOperationsFn { + create_deferred_operation_khr: unsafe { + extern "system" fn create_deferred_operation_khr( _device: Device, - _swap_chain: SwapchainKHR, - _local_dimming_enable: Bool32, - ) -> c_void { + _p_allocator: *const AllocationCallbacks, + _p_deferred_operation: *mut DeferredOperationKHR, + ) -> Result { panic!(concat!( "Unable to load ", - stringify!(set_local_dimming_amd) + stringify!(create_deferred_operation_khr) )) } - let raw_name = stringify!(vkSetLocalDimmingAMD); + let raw_name = stringify!(vkCreateDeferredOperationKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - set_local_dimming_amd + create_deferred_operation_khr } else { ::std::mem::transmute(val) } }, - } - } - #[doc = ""] - pub unsafe fn set_local_dimming_amd( - &self, - device: Device, - swap_chain: SwapchainKHR, - local_dimming_enable: Bool32, - ) -> c_void { - (self.set_local_dimming_amd)(device, swap_chain, local_dimming_enable) - } -} -#[doc = "Generated from \'VK_AMD_display_native_hdr\'"] -impl StructureType { - pub const DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD: Self = Self(1_000_213_000); -} -#[doc = "Generated from \'VK_AMD_display_native_hdr\'"] -impl StructureType { - pub const SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD: Self = Self(1_000_213_001); -} -#[doc = "Generated from \'VK_AMD_display_native_hdr\'"] -impl ColorSpaceKHR { - pub const DISPLAY_NATIVE_AMD: Self = Self(1_000_213_000); -} -impl FuchsiaImagepipeSurfaceFn { - pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_FUCHSIA_imagepipe_surface\0") - .expect("Wrong extension string") - } - pub const SPEC_VERSION: u32 = 1u32; -} -#[allow(non_camel_case_types)] -pub type PFN_vkCreateImagePipeSurfaceFUCHSIA = extern "system" fn( - instance: Instance, - p_create_info: *const ImagePipeSurfaceCreateInfoFUCHSIA, - p_allocator: *const AllocationCallbacks, - p_surface: *mut SurfaceKHR, -) -> Result; -pub struct FuchsiaImagepipeSurfaceFn { - pub create_image_pipe_surface_fuchsia: extern "system" fn( - instance: Instance, - p_create_info: *const ImagePipeSurfaceCreateInfoFUCHSIA, - p_allocator: *const AllocationCallbacks, - p_surface: *mut SurfaceKHR, - ) -> Result, -} -unsafe impl Send for FuchsiaImagepipeSurfaceFn {} -unsafe impl Sync for FuchsiaImagepipeSurfaceFn {} -impl ::std::clone::Clone for FuchsiaImagepipeSurfaceFn { - fn clone(&self) -> Self { - FuchsiaImagepipeSurfaceFn { - create_image_pipe_surface_fuchsia: self.create_image_pipe_surface_fuchsia, - } - } -} -impl FuchsiaImagepipeSurfaceFn { - pub fn load(mut _f: F) -> Self - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - FuchsiaImagepipeSurfaceFn { - create_image_pipe_surface_fuchsia: unsafe { - extern "system" fn create_image_pipe_surface_fuchsia( - _instance: Instance, - _p_create_info: *const ImagePipeSurfaceCreateInfoFUCHSIA, + destroy_deferred_operation_khr: unsafe { + extern "system" fn destroy_deferred_operation_khr( + _device: Device, + _operation: DeferredOperationKHR, _p_allocator: *const AllocationCallbacks, - _p_surface: *mut SurfaceKHR, + ) -> c_void { + panic!(concat!( + "Unable to load ", + stringify!(destroy_deferred_operation_khr) + )) + } + let raw_name = stringify!(vkDestroyDeferredOperationKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + destroy_deferred_operation_khr + } else { + ::std::mem::transmute(val) + } + }, + get_deferred_operation_max_concurrency_khr: unsafe { + extern "system" fn get_deferred_operation_max_concurrency_khr( + _device: Device, + _operation: DeferredOperationKHR, + ) -> u32 { + panic!(concat!( + "Unable to load ", + stringify!(get_deferred_operation_max_concurrency_khr) + )) + } + let raw_name = stringify!(vkGetDeferredOperationMaxConcurrencyKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + get_deferred_operation_max_concurrency_khr + } else { + ::std::mem::transmute(val) + } + }, + get_deferred_operation_result_khr: unsafe { + extern "system" fn get_deferred_operation_result_khr( + _device: Device, + _operation: DeferredOperationKHR, ) -> Result { panic!(concat!( "Unable to load ", - stringify!(create_image_pipe_surface_fuchsia) + stringify!(get_deferred_operation_result_khr) )) } - let raw_name = stringify!(vkCreateImagePipeSurfaceFUCHSIA); + let raw_name = stringify!(vkGetDeferredOperationResultKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - create_image_pipe_surface_fuchsia + get_deferred_operation_result_khr } else { ::std::mem::transmute(val) } }, - } - } - #[doc = ""] - pub unsafe fn create_image_pipe_surface_fuchsia( - &self, - instance: Instance, - p_create_info: *const ImagePipeSurfaceCreateInfoFUCHSIA, - p_allocator: *const AllocationCallbacks, - p_surface: *mut SurfaceKHR, - ) -> Result { - (self.create_image_pipe_surface_fuchsia)(instance, p_create_info, p_allocator, p_surface) - } -} -#[doc = "Generated from \'VK_FUCHSIA_imagepipe_surface\'"] -impl StructureType { - pub const IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA: Self = Self(1_000_214_000); -} -impl GoogleExtension216Fn { - pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_GOOGLE_extension_216\0") - .expect("Wrong extension string") - } - pub const SPEC_VERSION: u32 = 0u32; -} -pub struct GoogleExtension216Fn {} -unsafe impl Send for GoogleExtension216Fn {} -unsafe impl Sync for GoogleExtension216Fn {} -impl ::std::clone::Clone for GoogleExtension216Fn { - fn clone(&self) -> Self { - GoogleExtension216Fn {} - } -} -impl GoogleExtension216Fn { - pub fn load(mut _f: F) -> Self - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - GoogleExtension216Fn {} - } -} -impl GoogleExtension217Fn { - pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_GOOGLE_extension_217\0") - .expect("Wrong extension string") - } - pub const SPEC_VERSION: u32 = 0u32; -} -pub struct GoogleExtension217Fn {} -unsafe impl Send for GoogleExtension217Fn {} -unsafe impl Sync for GoogleExtension217Fn {} -impl ::std::clone::Clone for GoogleExtension217Fn { - fn clone(&self) -> Self { - GoogleExtension217Fn {} - } -} -impl GoogleExtension217Fn { - pub fn load(mut _f: F) -> Self - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - GoogleExtension217Fn {} - } -} -impl ExtMetalSurfaceFn { - pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_metal_surface\0") - .expect("Wrong extension string") - } - pub const SPEC_VERSION: u32 = 1u32; -} -#[allow(non_camel_case_types)] -pub type PFN_vkCreateMetalSurfaceEXT = extern "system" fn( - instance: Instance, - p_create_info: *const MetalSurfaceCreateInfoEXT, - p_allocator: *const AllocationCallbacks, - p_surface: *mut SurfaceKHR, -) -> Result; -pub struct ExtMetalSurfaceFn { - pub create_metal_surface_ext: extern "system" fn( - instance: Instance, - p_create_info: *const MetalSurfaceCreateInfoEXT, - p_allocator: *const AllocationCallbacks, - p_surface: *mut SurfaceKHR, - ) -> Result, -} -unsafe impl Send for ExtMetalSurfaceFn {} -unsafe impl Sync for ExtMetalSurfaceFn {} -impl ::std::clone::Clone for ExtMetalSurfaceFn { - fn clone(&self) -> Self { - ExtMetalSurfaceFn { - create_metal_surface_ext: self.create_metal_surface_ext, - } - } -} -impl ExtMetalSurfaceFn { - pub fn load(mut _f: F) -> Self - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - ExtMetalSurfaceFn { - create_metal_surface_ext: unsafe { - extern "system" fn create_metal_surface_ext( - _instance: Instance, - _p_create_info: *const MetalSurfaceCreateInfoEXT, - _p_allocator: *const AllocationCallbacks, - _p_surface: *mut SurfaceKHR, + deferred_operation_join_khr: unsafe { + extern "system" fn deferred_operation_join_khr( + _device: Device, + _operation: DeferredOperationKHR, ) -> Result { panic!(concat!( "Unable to load ", - stringify!(create_metal_surface_ext) + stringify!(deferred_operation_join_khr) )) } - let raw_name = stringify!(vkCreateMetalSurfaceEXT); + let raw_name = stringify!(vkDeferredOperationJoinKHR); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - create_metal_surface_ext + deferred_operation_join_khr } else { ::std::mem::transmute(val) } }, } } - #[doc = ""] - pub unsafe fn create_metal_surface_ext( + #[doc = ""] + pub unsafe fn create_deferred_operation_khr( &self, - instance: Instance, - p_create_info: *const MetalSurfaceCreateInfoEXT, + device: Device, p_allocator: *const AllocationCallbacks, - p_surface: *mut SurfaceKHR, + p_deferred_operation: *mut DeferredOperationKHR, ) -> Result { - (self.create_metal_surface_ext)(instance, p_create_info, p_allocator, p_surface) - } -} -#[doc = "Generated from \'VK_EXT_metal_surface\'"] -impl StructureType { - pub const METAL_SURFACE_CREATE_INFO_EXT: Self = Self(1_000_217_000); -} -impl ExtFragmentDensityMapFn { - pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_fragment_density_map\0") - .expect("Wrong extension string") - } - pub const SPEC_VERSION: u32 = 1u32; -} -pub struct ExtFragmentDensityMapFn {} -unsafe impl Send for ExtFragmentDensityMapFn {} -unsafe impl Sync for ExtFragmentDensityMapFn {} -impl ::std::clone::Clone for ExtFragmentDensityMapFn { - fn clone(&self) -> Self { - ExtFragmentDensityMapFn {} - } -} -impl ExtFragmentDensityMapFn { - pub fn load(mut _f: F) -> Self - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - ExtFragmentDensityMapFn {} - } -} -#[doc = "Generated from \'VK_EXT_fragment_density_map\'"] -impl StructureType { - pub const PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT: Self = Self(1_000_218_000); -} -#[doc = "Generated from \'VK_EXT_fragment_density_map\'"] -impl StructureType { - pub const PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT: Self = Self(1_000_218_001); -} -#[doc = "Generated from \'VK_EXT_fragment_density_map\'"] -impl StructureType { - pub const RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT: Self = Self(1_000_218_002); -} -#[doc = "Generated from \'VK_EXT_fragment_density_map\'"] -impl ImageCreateFlags { - pub const SUBSAMPLED_EXT: Self = Self(0b100_0000_0000_0000); -} -#[doc = "Generated from \'VK_EXT_fragment_density_map\'"] -impl ImageLayout { - pub const FRAGMENT_DENSITY_MAP_OPTIMAL_EXT: Self = Self(1_000_218_000); -} -#[doc = "Generated from \'VK_EXT_fragment_density_map\'"] -impl AccessFlags { - pub const FRAGMENT_DENSITY_MAP_READ_EXT: Self = Self(0b1_0000_0000_0000_0000_0000_0000); -} -#[doc = "Generated from \'VK_EXT_fragment_density_map\'"] -impl FormatFeatureFlags { - pub const FRAGMENT_DENSITY_MAP_EXT: Self = Self(0b1_0000_0000_0000_0000_0000_0000); -} -#[doc = "Generated from \'VK_EXT_fragment_density_map\'"] -impl ImageUsageFlags { - pub const FRAGMENT_DENSITY_MAP_EXT: Self = Self(0b10_0000_0000); -} -#[doc = "Generated from \'VK_EXT_fragment_density_map\'"] -impl ImageViewCreateFlags { - pub const FRAGMENT_DENSITY_MAP_DYNAMIC_EXT: Self = Self(0b1); -} -#[doc = "Generated from \'VK_EXT_fragment_density_map\'"] -impl PipelineStageFlags { - pub const FRAGMENT_DENSITY_PROCESS_EXT: Self = Self(0b1000_0000_0000_0000_0000_0000); -} -#[doc = "Generated from \'VK_EXT_fragment_density_map\'"] -impl SamplerCreateFlags { - pub const SUBSAMPLED_EXT: Self = Self(0b1); -} -#[doc = "Generated from \'VK_EXT_fragment_density_map\'"] -impl SamplerCreateFlags { - pub const SUBSAMPLED_COARSE_RECONSTRUCTION_EXT: Self = Self(0b10); -} -impl ExtExtension220Fn { - pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_extension_220\0") - .expect("Wrong extension string") - } - pub const SPEC_VERSION: u32 = 0u32; -} -pub struct ExtExtension220Fn {} -unsafe impl Send for ExtExtension220Fn {} -unsafe impl Sync for ExtExtension220Fn {} -impl ::std::clone::Clone for ExtExtension220Fn { - fn clone(&self) -> Self { - ExtExtension220Fn {} - } -} -impl ExtExtension220Fn { - pub fn load(mut _f: F) -> Self - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - ExtExtension220Fn {} - } -} -impl KhrExtension221Fn { - pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_extension_221\0") - .expect("Wrong extension string") - } - pub const SPEC_VERSION: u32 = 0u32; -} -pub struct KhrExtension221Fn {} -unsafe impl Send for KhrExtension221Fn {} -unsafe impl Sync for KhrExtension221Fn {} -impl ::std::clone::Clone for KhrExtension221Fn { - fn clone(&self) -> Self { - KhrExtension221Fn {} - } -} -impl KhrExtension221Fn { - pub fn load(mut _f: F) -> Self - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - KhrExtension221Fn {} - } -} -#[doc = "Generated from \'VK_KHR_extension_221\'"] -impl RenderPassCreateFlags { - pub const RESERVED_0_KHR: Self = Self(0b1); -} -impl ExtScalarBlockLayoutFn { - pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_scalar_block_layout\0") - .expect("Wrong extension string") + (self.create_deferred_operation_khr)(device, p_allocator, p_deferred_operation) } - pub const SPEC_VERSION: u32 = 1u32; -} -pub struct ExtScalarBlockLayoutFn {} -unsafe impl Send for ExtScalarBlockLayoutFn {} -unsafe impl Sync for ExtScalarBlockLayoutFn {} -impl ::std::clone::Clone for ExtScalarBlockLayoutFn { - fn clone(&self) -> Self { - ExtScalarBlockLayoutFn {} + #[doc = ""] + pub unsafe fn destroy_deferred_operation_khr( + &self, + device: Device, + operation: DeferredOperationKHR, + p_allocator: *const AllocationCallbacks, + ) -> c_void { + (self.destroy_deferred_operation_khr)(device, operation, p_allocator) } -} -impl ExtScalarBlockLayoutFn { - pub fn load(mut _f: F) -> Self - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - ExtScalarBlockLayoutFn {} + #[doc = ""] + pub unsafe fn get_deferred_operation_max_concurrency_khr( + &self, + device: Device, + operation: DeferredOperationKHR, + ) -> u32 { + (self.get_deferred_operation_max_concurrency_khr)(device, operation) } -} -#[doc = "Generated from \'VK_EXT_scalar_block_layout\'"] -impl StructureType { - pub const PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES_EXT: Self = - StructureType::PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES; -} -impl ExtExtension223Fn { - pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_extension_223\0") - .expect("Wrong extension string") + #[doc = ""] + pub unsafe fn get_deferred_operation_result_khr( + &self, + device: Device, + operation: DeferredOperationKHR, + ) -> Result { + (self.get_deferred_operation_result_khr)(device, operation) } - pub const SPEC_VERSION: u32 = 0u32; -} -pub struct ExtExtension223Fn {} -unsafe impl Send for ExtExtension223Fn {} -unsafe impl Sync for ExtExtension223Fn {} -impl ::std::clone::Clone for ExtExtension223Fn { - fn clone(&self) -> Self { - ExtExtension223Fn {} + #[doc = ""] + pub unsafe fn deferred_operation_join_khr( + &self, + device: Device, + operation: DeferredOperationKHR, + ) -> Result { + (self.deferred_operation_join_khr)(device, operation) } } -impl ExtExtension223Fn { - pub fn load(mut _f: F) -> Self - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - ExtExtension223Fn {} - } +#[doc = "Generated from \'VK_KHR_deferred_host_operations\'"] +impl ObjectType { + pub const DEFERRED_OPERATION_KHR: Self = Self(1_000_268_000); } -impl GoogleHlslFunctionality1Fn { - pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_GOOGLE_hlsl_functionality1\0") - .expect("Wrong extension string") - } - pub const SPEC_VERSION: u32 = 1u32; +#[doc = "Generated from \'VK_KHR_deferred_host_operations\'"] +impl Result { + pub const THREAD_IDLE_KHR: Self = Self(1_000_268_000); } -pub struct GoogleHlslFunctionality1Fn {} -unsafe impl Send for GoogleHlslFunctionality1Fn {} -unsafe impl Sync for GoogleHlslFunctionality1Fn {} -impl ::std::clone::Clone for GoogleHlslFunctionality1Fn { - fn clone(&self) -> Self { - GoogleHlslFunctionality1Fn {} - } +#[doc = "Generated from \'VK_KHR_deferred_host_operations\'"] +impl Result { + pub const THREAD_DONE_KHR: Self = Self(1_000_268_001); } -impl GoogleHlslFunctionality1Fn { - pub fn load(mut _f: F) -> Self - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - GoogleHlslFunctionality1Fn {} - } +#[doc = "Generated from \'VK_KHR_deferred_host_operations\'"] +impl Result { + pub const OPERATION_DEFERRED_KHR: Self = Self(1_000_268_002); } -impl GoogleDecorateStringFn { +#[doc = "Generated from \'VK_KHR_deferred_host_operations\'"] +impl Result { + pub const OPERATION_NOT_DEFERRED_KHR: Self = Self(1_000_268_003); +} +impl KhrPipelineExecutablePropertiesFn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_GOOGLE_decorate_string\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_pipeline_executable_properties\0") .expect("Wrong extension string") } pub const SPEC_VERSION: u32 = 1u32; } -pub struct GoogleDecorateStringFn {} -unsafe impl Send for GoogleDecorateStringFn {} -unsafe impl Sync for GoogleDecorateStringFn {} -impl ::std::clone::Clone for GoogleDecorateStringFn { +#[allow(non_camel_case_types)] +pub type PFN_vkGetPipelineExecutablePropertiesKHR = extern "system" fn( + device: Device, + p_pipeline_info: *const PipelineInfoKHR, + p_executable_count: *mut u32, + p_properties: *mut PipelineExecutablePropertiesKHR, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetPipelineExecutableStatisticsKHR = extern "system" fn( + device: Device, + p_executable_info: *const PipelineExecutableInfoKHR, + p_statistic_count: *mut u32, + p_statistics: *mut PipelineExecutableStatisticKHR, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetPipelineExecutableInternalRepresentationsKHR = extern "system" fn( + device: Device, + p_executable_info: *const PipelineExecutableInfoKHR, + p_internal_representation_count: *mut u32, + p_internal_representations: *mut PipelineExecutableInternalRepresentationKHR, +) -> Result; +pub struct KhrPipelineExecutablePropertiesFn { + pub get_pipeline_executable_properties_khr: extern "system" fn( + device: Device, + p_pipeline_info: *const PipelineInfoKHR, + p_executable_count: *mut u32, + p_properties: *mut PipelineExecutablePropertiesKHR, + ) -> Result, + pub get_pipeline_executable_statistics_khr: extern "system" fn( + device: Device, + p_executable_info: *const PipelineExecutableInfoKHR, + p_statistic_count: *mut u32, + p_statistics: *mut PipelineExecutableStatisticKHR, + ) -> Result, + pub get_pipeline_executable_internal_representations_khr: extern "system" fn( + device: Device, + p_executable_info: *const PipelineExecutableInfoKHR, + p_internal_representation_count: *mut u32, + p_internal_representations: *mut PipelineExecutableInternalRepresentationKHR, + ) -> Result, +} +unsafe impl Send for KhrPipelineExecutablePropertiesFn {} +unsafe impl Sync for KhrPipelineExecutablePropertiesFn {} +impl ::std::clone::Clone for KhrPipelineExecutablePropertiesFn { fn clone(&self) -> Self { - GoogleDecorateStringFn {} + KhrPipelineExecutablePropertiesFn { + get_pipeline_executable_properties_khr: self.get_pipeline_executable_properties_khr, + get_pipeline_executable_statistics_khr: self.get_pipeline_executable_statistics_khr, + get_pipeline_executable_internal_representations_khr: self + .get_pipeline_executable_internal_representations_khr, + } } } -impl GoogleDecorateStringFn { +impl KhrPipelineExecutablePropertiesFn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - GoogleDecorateStringFn {} - } -} -impl ExtSubgroupSizeControlFn { - pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_subgroup_size_control\0") - .expect("Wrong extension string") + KhrPipelineExecutablePropertiesFn { + get_pipeline_executable_properties_khr: unsafe { + extern "system" fn get_pipeline_executable_properties_khr( + _device: Device, + _p_pipeline_info: *const PipelineInfoKHR, + _p_executable_count: *mut u32, + _p_properties: *mut PipelineExecutablePropertiesKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_pipeline_executable_properties_khr) + )) + } + let raw_name = stringify!(vkGetPipelineExecutablePropertiesKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + get_pipeline_executable_properties_khr + } else { + ::std::mem::transmute(val) + } + }, + get_pipeline_executable_statistics_khr: unsafe { + extern "system" fn get_pipeline_executable_statistics_khr( + _device: Device, + _p_executable_info: *const PipelineExecutableInfoKHR, + _p_statistic_count: *mut u32, + _p_statistics: *mut PipelineExecutableStatisticKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_pipeline_executable_statistics_khr) + )) + } + let raw_name = stringify!(vkGetPipelineExecutableStatisticsKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + get_pipeline_executable_statistics_khr + } else { + ::std::mem::transmute(val) + } + }, + get_pipeline_executable_internal_representations_khr: unsafe { + extern "system" fn get_pipeline_executable_internal_representations_khr( + _device: Device, + _p_executable_info: *const PipelineExecutableInfoKHR, + _p_internal_representation_count: *mut u32, + _p_internal_representations: *mut PipelineExecutableInternalRepresentationKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_pipeline_executable_internal_representations_khr) + )) + } + let raw_name = stringify!(vkGetPipelineExecutableInternalRepresentationsKHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + get_pipeline_executable_internal_representations_khr + } else { + ::std::mem::transmute(val) + } + }, + } } - pub const SPEC_VERSION: u32 = 2u32; -} -pub struct ExtSubgroupSizeControlFn {} -unsafe impl Send for ExtSubgroupSizeControlFn {} -unsafe impl Sync for ExtSubgroupSizeControlFn {} -impl ::std::clone::Clone for ExtSubgroupSizeControlFn { - fn clone(&self) -> Self { - ExtSubgroupSizeControlFn {} + #[doc = ""] + pub unsafe fn get_pipeline_executable_properties_khr( + &self, + device: Device, + p_pipeline_info: *const PipelineInfoKHR, + p_executable_count: *mut u32, + p_properties: *mut PipelineExecutablePropertiesKHR, + ) -> Result { + (self.get_pipeline_executable_properties_khr)( + device, + p_pipeline_info, + p_executable_count, + p_properties, + ) } -} -impl ExtSubgroupSizeControlFn { - pub fn load(mut _f: F) -> Self - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - ExtSubgroupSizeControlFn {} + #[doc = ""] + pub unsafe fn get_pipeline_executable_statistics_khr( + &self, + device: Device, + p_executable_info: *const PipelineExecutableInfoKHR, + p_statistic_count: *mut u32, + p_statistics: *mut PipelineExecutableStatisticKHR, + ) -> Result { + (self.get_pipeline_executable_statistics_khr)( + device, + p_executable_info, + p_statistic_count, + p_statistics, + ) + } + #[doc = ""] + pub unsafe fn get_pipeline_executable_internal_representations_khr( + &self, + device: Device, + p_executable_info: *const PipelineExecutableInfoKHR, + p_internal_representation_count: *mut u32, + p_internal_representations: *mut PipelineExecutableInternalRepresentationKHR, + ) -> Result { + (self.get_pipeline_executable_internal_representations_khr)( + device, + p_executable_info, + p_internal_representation_count, + p_internal_representations, + ) } } -#[doc = "Generated from \'VK_EXT_subgroup_size_control\'"] +#[doc = "Generated from \'VK_KHR_pipeline_executable_properties\'"] impl StructureType { - pub const PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT: Self = Self(1_000_225_000); + pub const PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR: Self = + Self(1_000_269_000); } -#[doc = "Generated from \'VK_EXT_subgroup_size_control\'"] +#[doc = "Generated from \'VK_KHR_pipeline_executable_properties\'"] impl StructureType { - pub const PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT: Self = - Self(1_000_225_001); + pub const PIPELINE_INFO_KHR: Self = Self(1_000_269_001); } -#[doc = "Generated from \'VK_EXT_subgroup_size_control\'"] +#[doc = "Generated from \'VK_KHR_pipeline_executable_properties\'"] impl StructureType { - pub const PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT: Self = Self(1_000_225_002); -} -#[doc = "Generated from \'VK_EXT_subgroup_size_control\'"] -impl PipelineShaderStageCreateFlags { - pub const ALLOW_VARYING_SUBGROUP_SIZE_EXT: Self = Self(0b1); -} -#[doc = "Generated from \'VK_EXT_subgroup_size_control\'"] -impl PipelineShaderStageCreateFlags { - pub const REQUIRE_FULL_SUBGROUPS_EXT: Self = Self(0b10); -} -impl AmdExtension227Fn { - pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_AMD_extension_227\0") - .expect("Wrong extension string") - } - pub const SPEC_VERSION: u32 = 0u32; -} -pub struct AmdExtension227Fn {} -unsafe impl Send for AmdExtension227Fn {} -unsafe impl Sync for AmdExtension227Fn {} -impl ::std::clone::Clone for AmdExtension227Fn { - fn clone(&self) -> Self { - AmdExtension227Fn {} - } + pub const PIPELINE_EXECUTABLE_PROPERTIES_KHR: Self = Self(1_000_269_002); } -impl AmdExtension227Fn { - pub fn load(mut _f: F) -> Self - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - AmdExtension227Fn {} - } +#[doc = "Generated from \'VK_KHR_pipeline_executable_properties\'"] +impl StructureType { + pub const PIPELINE_EXECUTABLE_INFO_KHR: Self = Self(1_000_269_003); } -impl AmdShaderCoreProperties2Fn { - pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_AMD_shader_core_properties2\0") - .expect("Wrong extension string") - } - pub const SPEC_VERSION: u32 = 1u32; +#[doc = "Generated from \'VK_KHR_pipeline_executable_properties\'"] +impl StructureType { + pub const PIPELINE_EXECUTABLE_STATISTIC_KHR: Self = Self(1_000_269_004); } -pub struct AmdShaderCoreProperties2Fn {} -unsafe impl Send for AmdShaderCoreProperties2Fn {} -unsafe impl Sync for AmdShaderCoreProperties2Fn {} -impl ::std::clone::Clone for AmdShaderCoreProperties2Fn { - fn clone(&self) -> Self { - AmdShaderCoreProperties2Fn {} - } +#[doc = "Generated from \'VK_KHR_pipeline_executable_properties\'"] +impl StructureType { + pub const PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR: Self = Self(1_000_269_005); } -impl AmdShaderCoreProperties2Fn { - pub fn load(mut _f: F) -> Self - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - AmdShaderCoreProperties2Fn {} - } +#[doc = "Generated from \'VK_KHR_pipeline_executable_properties\'"] +impl PipelineCreateFlags { + pub const CAPTURE_STATISTICS_KHR: Self = Self(0b100_0000); } -#[doc = "Generated from \'VK_AMD_shader_core_properties2\'"] -impl StructureType { - pub const PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD: Self = Self(1_000_227_000); +#[doc = "Generated from \'VK_KHR_pipeline_executable_properties\'"] +impl PipelineCreateFlags { + pub const CAPTURE_INTERNAL_REPRESENTATIONS_KHR: Self = Self(0b1000_0000); } -impl AmdExtension229Fn { +impl IntelExtension271Fn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_AMD_extension_229\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_INTEL_extension_271\0") .expect("Wrong extension string") } pub const SPEC_VERSION: u32 = 0u32; } -pub struct AmdExtension229Fn {} -unsafe impl Send for AmdExtension229Fn {} -unsafe impl Sync for AmdExtension229Fn {} -impl ::std::clone::Clone for AmdExtension229Fn { +pub struct IntelExtension271Fn {} +unsafe impl Send for IntelExtension271Fn {} +unsafe impl Sync for IntelExtension271Fn {} +impl ::std::clone::Clone for IntelExtension271Fn { fn clone(&self) -> Self { - AmdExtension229Fn {} + IntelExtension271Fn {} } } -impl AmdExtension229Fn { +impl IntelExtension271Fn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - AmdExtension229Fn {} + IntelExtension271Fn {} } } -impl AmdDeviceCoherentMemoryFn { +impl IntelExtension272Fn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_AMD_device_coherent_memory\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_INTEL_extension_272\0") .expect("Wrong extension string") } - pub const SPEC_VERSION: u32 = 1u32; + pub const SPEC_VERSION: u32 = 0u32; } -pub struct AmdDeviceCoherentMemoryFn {} -unsafe impl Send for AmdDeviceCoherentMemoryFn {} -unsafe impl Sync for AmdDeviceCoherentMemoryFn {} -impl ::std::clone::Clone for AmdDeviceCoherentMemoryFn { +pub struct IntelExtension272Fn {} +unsafe impl Send for IntelExtension272Fn {} +unsafe impl Sync for IntelExtension272Fn {} +impl ::std::clone::Clone for IntelExtension272Fn { fn clone(&self) -> Self { - AmdDeviceCoherentMemoryFn {} + IntelExtension272Fn {} } } -impl AmdDeviceCoherentMemoryFn { +impl IntelExtension272Fn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - AmdDeviceCoherentMemoryFn {} + IntelExtension272Fn {} } } -#[doc = "Generated from \'VK_AMD_device_coherent_memory\'"] -impl MemoryPropertyFlags { - pub const DEVICE_COHERENT_AMD: Self = Self(0b100_0000); -} -#[doc = "Generated from \'VK_AMD_device_coherent_memory\'"] -impl MemoryPropertyFlags { - pub const DEVICE_UNCACHED_AMD: Self = Self(0b1000_0000); -} -#[doc = "Generated from \'VK_AMD_device_coherent_memory\'"] -impl StructureType { - pub const PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD: Self = Self(1_000_229_000); -} -impl AmdExtension231Fn { +impl IntelExtension273Fn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_AMD_extension_231\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_INTEL_extension_273\0") .expect("Wrong extension string") } pub const SPEC_VERSION: u32 = 0u32; } -pub struct AmdExtension231Fn {} -unsafe impl Send for AmdExtension231Fn {} -unsafe impl Sync for AmdExtension231Fn {} -impl ::std::clone::Clone for AmdExtension231Fn { +pub struct IntelExtension273Fn {} +unsafe impl Send for IntelExtension273Fn {} +unsafe impl Sync for IntelExtension273Fn {} +impl ::std::clone::Clone for IntelExtension273Fn { fn clone(&self) -> Self { - AmdExtension231Fn {} + IntelExtension273Fn {} } } -impl AmdExtension231Fn { +impl IntelExtension273Fn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - AmdExtension231Fn {} + IntelExtension273Fn {} } } -impl AmdExtension232Fn { +impl IntelExtension274Fn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_AMD_extension_232\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_INTEL_extension_274\0") .expect("Wrong extension string") } pub const SPEC_VERSION: u32 = 0u32; } -pub struct AmdExtension232Fn {} -unsafe impl Send for AmdExtension232Fn {} -unsafe impl Sync for AmdExtension232Fn {} -impl ::std::clone::Clone for AmdExtension232Fn { +pub struct IntelExtension274Fn {} +unsafe impl Send for IntelExtension274Fn {} +unsafe impl Sync for IntelExtension274Fn {} +impl ::std::clone::Clone for IntelExtension274Fn { fn clone(&self) -> Self { - AmdExtension232Fn {} + IntelExtension274Fn {} } } -impl AmdExtension232Fn { +impl IntelExtension274Fn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - AmdExtension232Fn {} + IntelExtension274Fn {} } } -impl AmdExtension233Fn { +impl KhrExtension275Fn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_AMD_extension_233\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_extension_275\0") .expect("Wrong extension string") } pub const SPEC_VERSION: u32 = 0u32; } -pub struct AmdExtension233Fn {} -unsafe impl Send for AmdExtension233Fn {} -unsafe impl Sync for AmdExtension233Fn {} -impl ::std::clone::Clone for AmdExtension233Fn { +pub struct KhrExtension275Fn {} +unsafe impl Send for KhrExtension275Fn {} +unsafe impl Sync for KhrExtension275Fn {} +impl ::std::clone::Clone for KhrExtension275Fn { fn clone(&self) -> Self { - AmdExtension233Fn {} + KhrExtension275Fn {} } } -impl AmdExtension233Fn { +impl KhrExtension275Fn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - AmdExtension233Fn {} + KhrExtension275Fn {} } } -impl AmdExtension234Fn { +impl KhrExtension276Fn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_AMD_extension_234\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_extension_276\0") .expect("Wrong extension string") } pub const SPEC_VERSION: u32 = 0u32; } -pub struct AmdExtension234Fn {} -unsafe impl Send for AmdExtension234Fn {} -unsafe impl Sync for AmdExtension234Fn {} -impl ::std::clone::Clone for AmdExtension234Fn { +pub struct KhrExtension276Fn {} +unsafe impl Send for KhrExtension276Fn {} +unsafe impl Sync for KhrExtension276Fn {} +impl ::std::clone::Clone for KhrExtension276Fn { fn clone(&self) -> Self { - AmdExtension234Fn {} + KhrExtension276Fn {} } } -impl AmdExtension234Fn { +impl KhrExtension276Fn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - AmdExtension234Fn {} + KhrExtension276Fn {} } } -impl AmdExtension235Fn { +impl ExtShaderDemoteToHelperInvocationFn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_AMD_extension_235\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_shader_demote_to_helper_invocation\0") .expect("Wrong extension string") } - pub const SPEC_VERSION: u32 = 0u32; + pub const SPEC_VERSION: u32 = 1u32; } -pub struct AmdExtension235Fn {} -unsafe impl Send for AmdExtension235Fn {} -unsafe impl Sync for AmdExtension235Fn {} -impl ::std::clone::Clone for AmdExtension235Fn { +pub struct ExtShaderDemoteToHelperInvocationFn {} +unsafe impl Send for ExtShaderDemoteToHelperInvocationFn {} +unsafe impl Sync for ExtShaderDemoteToHelperInvocationFn {} +impl ::std::clone::Clone for ExtShaderDemoteToHelperInvocationFn { fn clone(&self) -> Self { - AmdExtension235Fn {} + ExtShaderDemoteToHelperInvocationFn {} } } -impl AmdExtension235Fn { +impl ExtShaderDemoteToHelperInvocationFn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - AmdExtension235Fn {} + ExtShaderDemoteToHelperInvocationFn {} } } -impl AmdExtension236Fn { +#[doc = "Generated from \'VK_EXT_shader_demote_to_helper_invocation\'"] +impl StructureType { + pub const PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT: Self = + Self(1_000_276_000); +} +impl NvDeviceGeneratedCommandsFn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_AMD_extension_236\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_device_generated_commands\0") .expect("Wrong extension string") } - pub const SPEC_VERSION: u32 = 0u32; + pub const SPEC_VERSION: u32 = 3u32; } -pub struct AmdExtension236Fn {} -unsafe impl Send for AmdExtension236Fn {} -unsafe impl Sync for AmdExtension236Fn {} -impl ::std::clone::Clone for AmdExtension236Fn { +#[allow(non_camel_case_types)] +pub type PFN_vkGetGeneratedCommandsMemoryRequirementsNV = extern "system" fn( + device: Device, + p_info: *const GeneratedCommandsMemoryRequirementsInfoNV, + p_memory_requirements: *mut MemoryRequirements2, +) -> c_void; +#[allow(non_camel_case_types)] +pub type PFN_vkCmdPreprocessGeneratedCommandsNV = extern "system" fn( + command_buffer: CommandBuffer, + p_generated_commands_info: *const GeneratedCommandsInfoNV, +) -> c_void; +#[allow(non_camel_case_types)] +pub type PFN_vkCmdExecuteGeneratedCommandsNV = extern "system" fn( + command_buffer: CommandBuffer, + is_preprocessed: Bool32, + p_generated_commands_info: *const GeneratedCommandsInfoNV, +) -> c_void; +#[allow(non_camel_case_types)] +pub type PFN_vkCmdBindPipelineShaderGroupNV = extern "system" fn( + command_buffer: CommandBuffer, + pipeline_bind_point: PipelineBindPoint, + pipeline: Pipeline, + group_index: u32, +) -> c_void; +#[allow(non_camel_case_types)] +pub type PFN_vkCreateIndirectCommandsLayoutNV = extern "system" fn( + device: Device, + p_create_info: *const IndirectCommandsLayoutCreateInfoNV, + p_allocator: *const AllocationCallbacks, + p_indirect_commands_layout: *mut IndirectCommandsLayoutNV, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkDestroyIndirectCommandsLayoutNV = extern "system" fn( + device: Device, + indirect_commands_layout: IndirectCommandsLayoutNV, + p_allocator: *const AllocationCallbacks, +) -> c_void; +pub struct NvDeviceGeneratedCommandsFn { + pub get_generated_commands_memory_requirements_nv: extern "system" fn( + device: Device, + p_info: *const GeneratedCommandsMemoryRequirementsInfoNV, + p_memory_requirements: *mut MemoryRequirements2, + ) -> c_void, + pub cmd_preprocess_generated_commands_nv: extern "system" fn( + command_buffer: CommandBuffer, + p_generated_commands_info: *const GeneratedCommandsInfoNV, + ) -> c_void, + pub cmd_execute_generated_commands_nv: extern "system" fn( + command_buffer: CommandBuffer, + is_preprocessed: Bool32, + p_generated_commands_info: *const GeneratedCommandsInfoNV, + ) -> c_void, + pub cmd_bind_pipeline_shader_group_nv: extern "system" fn( + command_buffer: CommandBuffer, + pipeline_bind_point: PipelineBindPoint, + pipeline: Pipeline, + group_index: u32, + ) -> c_void, + pub create_indirect_commands_layout_nv: extern "system" fn( + device: Device, + p_create_info: *const IndirectCommandsLayoutCreateInfoNV, + p_allocator: *const AllocationCallbacks, + p_indirect_commands_layout: *mut IndirectCommandsLayoutNV, + ) -> Result, + pub destroy_indirect_commands_layout_nv: extern "system" fn( + device: Device, + indirect_commands_layout: IndirectCommandsLayoutNV, + p_allocator: *const AllocationCallbacks, + ) -> c_void, +} +unsafe impl Send for NvDeviceGeneratedCommandsFn {} +unsafe impl Sync for NvDeviceGeneratedCommandsFn {} +impl ::std::clone::Clone for NvDeviceGeneratedCommandsFn { fn clone(&self) -> Self { - AmdExtension236Fn {} + NvDeviceGeneratedCommandsFn { + get_generated_commands_memory_requirements_nv: self + .get_generated_commands_memory_requirements_nv, + cmd_preprocess_generated_commands_nv: self.cmd_preprocess_generated_commands_nv, + cmd_execute_generated_commands_nv: self.cmd_execute_generated_commands_nv, + cmd_bind_pipeline_shader_group_nv: self.cmd_bind_pipeline_shader_group_nv, + create_indirect_commands_layout_nv: self.create_indirect_commands_layout_nv, + destroy_indirect_commands_layout_nv: self.destroy_indirect_commands_layout_nv, + } } } -impl AmdExtension236Fn { +impl NvDeviceGeneratedCommandsFn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - AmdExtension236Fn {} + NvDeviceGeneratedCommandsFn { + get_generated_commands_memory_requirements_nv: unsafe { + extern "system" fn get_generated_commands_memory_requirements_nv( + _device: Device, + _p_info: *const GeneratedCommandsMemoryRequirementsInfoNV, + _p_memory_requirements: *mut MemoryRequirements2, + ) -> c_void { + panic!(concat!( + "Unable to load ", + stringify!(get_generated_commands_memory_requirements_nv) + )) + } + let raw_name = stringify!(vkGetGeneratedCommandsMemoryRequirementsNV); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + get_generated_commands_memory_requirements_nv + } else { + ::std::mem::transmute(val) + } + }, + cmd_preprocess_generated_commands_nv: unsafe { + extern "system" fn cmd_preprocess_generated_commands_nv( + _command_buffer: CommandBuffer, + _p_generated_commands_info: *const GeneratedCommandsInfoNV, + ) -> c_void { + panic!(concat!( + "Unable to load ", + stringify!(cmd_preprocess_generated_commands_nv) + )) + } + let raw_name = stringify!(vkCmdPreprocessGeneratedCommandsNV); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + cmd_preprocess_generated_commands_nv + } else { + ::std::mem::transmute(val) + } + }, + cmd_execute_generated_commands_nv: unsafe { + extern "system" fn cmd_execute_generated_commands_nv( + _command_buffer: CommandBuffer, + _is_preprocessed: Bool32, + _p_generated_commands_info: *const GeneratedCommandsInfoNV, + ) -> c_void { + panic!(concat!( + "Unable to load ", + stringify!(cmd_execute_generated_commands_nv) + )) + } + let raw_name = stringify!(vkCmdExecuteGeneratedCommandsNV); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + cmd_execute_generated_commands_nv + } else { + ::std::mem::transmute(val) + } + }, + cmd_bind_pipeline_shader_group_nv: unsafe { + extern "system" fn cmd_bind_pipeline_shader_group_nv( + _command_buffer: CommandBuffer, + _pipeline_bind_point: PipelineBindPoint, + _pipeline: Pipeline, + _group_index: u32, + ) -> c_void { + panic!(concat!( + "Unable to load ", + stringify!(cmd_bind_pipeline_shader_group_nv) + )) + } + let raw_name = stringify!(vkCmdBindPipelineShaderGroupNV); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + cmd_bind_pipeline_shader_group_nv + } else { + ::std::mem::transmute(val) + } + }, + create_indirect_commands_layout_nv: unsafe { + extern "system" fn create_indirect_commands_layout_nv( + _device: Device, + _p_create_info: *const IndirectCommandsLayoutCreateInfoNV, + _p_allocator: *const AllocationCallbacks, + _p_indirect_commands_layout: *mut IndirectCommandsLayoutNV, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(create_indirect_commands_layout_nv) + )) + } + let raw_name = stringify!(vkCreateIndirectCommandsLayoutNV); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + create_indirect_commands_layout_nv + } else { + ::std::mem::transmute(val) + } + }, + destroy_indirect_commands_layout_nv: unsafe { + extern "system" fn destroy_indirect_commands_layout_nv( + _device: Device, + _indirect_commands_layout: IndirectCommandsLayoutNV, + _p_allocator: *const AllocationCallbacks, + ) -> c_void { + panic!(concat!( + "Unable to load ", + stringify!(destroy_indirect_commands_layout_nv) + )) + } + let raw_name = stringify!(vkDestroyIndirectCommandsLayoutNV); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + destroy_indirect_commands_layout_nv + } else { + ::std::mem::transmute(val) + } + }, + } } -} -impl KhrSpirv14Fn { - pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_spirv_1_4\0") - .expect("Wrong extension string") + #[doc = ""] + pub unsafe fn get_generated_commands_memory_requirements_nv( + &self, + device: Device, + p_info: *const GeneratedCommandsMemoryRequirementsInfoNV, + p_memory_requirements: *mut MemoryRequirements2, + ) -> c_void { + (self.get_generated_commands_memory_requirements_nv)(device, p_info, p_memory_requirements) } - pub const SPEC_VERSION: u32 = 1u32; -} -pub struct KhrSpirv14Fn {} -unsafe impl Send for KhrSpirv14Fn {} -unsafe impl Sync for KhrSpirv14Fn {} -impl ::std::clone::Clone for KhrSpirv14Fn { - fn clone(&self) -> Self { - KhrSpirv14Fn {} + #[doc = ""] + pub unsafe fn cmd_preprocess_generated_commands_nv( + &self, + command_buffer: CommandBuffer, + p_generated_commands_info: *const GeneratedCommandsInfoNV, + ) -> c_void { + (self.cmd_preprocess_generated_commands_nv)(command_buffer, p_generated_commands_info) + } + #[doc = ""] + pub unsafe fn cmd_execute_generated_commands_nv( + &self, + command_buffer: CommandBuffer, + is_preprocessed: Bool32, + p_generated_commands_info: *const GeneratedCommandsInfoNV, + ) -> c_void { + (self.cmd_execute_generated_commands_nv)( + command_buffer, + is_preprocessed, + p_generated_commands_info, + ) } -} -impl KhrSpirv14Fn { - pub fn load(mut _f: F) -> Self - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - KhrSpirv14Fn {} + #[doc = ""] + pub unsafe fn cmd_bind_pipeline_shader_group_nv( + &self, + command_buffer: CommandBuffer, + pipeline_bind_point: PipelineBindPoint, + pipeline: Pipeline, + group_index: u32, + ) -> c_void { + (self.cmd_bind_pipeline_shader_group_nv)( + command_buffer, + pipeline_bind_point, + pipeline, + group_index, + ) } -} -impl ExtMemoryBudgetFn { - pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_memory_budget\0") - .expect("Wrong extension string") + #[doc = ""] + pub unsafe fn create_indirect_commands_layout_nv( + &self, + device: Device, + p_create_info: *const IndirectCommandsLayoutCreateInfoNV, + p_allocator: *const AllocationCallbacks, + p_indirect_commands_layout: *mut IndirectCommandsLayoutNV, + ) -> Result { + (self.create_indirect_commands_layout_nv)( + device, + p_create_info, + p_allocator, + p_indirect_commands_layout, + ) } - pub const SPEC_VERSION: u32 = 1u32; -} -pub struct ExtMemoryBudgetFn {} -unsafe impl Send for ExtMemoryBudgetFn {} -unsafe impl Sync for ExtMemoryBudgetFn {} -impl ::std::clone::Clone for ExtMemoryBudgetFn { - fn clone(&self) -> Self { - ExtMemoryBudgetFn {} + #[doc = ""] + pub unsafe fn destroy_indirect_commands_layout_nv( + &self, + device: Device, + indirect_commands_layout: IndirectCommandsLayoutNV, + p_allocator: *const AllocationCallbacks, + ) -> c_void { + (self.destroy_indirect_commands_layout_nv)(device, indirect_commands_layout, p_allocator) } } -impl ExtMemoryBudgetFn { - pub fn load(mut _f: F) -> Self - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - ExtMemoryBudgetFn {} - } +#[doc = "Generated from \'VK_NV_device_generated_commands\'"] +impl StructureType { + pub const PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV: Self = Self(1_000_277_000); } -#[doc = "Generated from \'VK_EXT_memory_budget\'"] +#[doc = "Generated from \'VK_NV_device_generated_commands\'"] impl StructureType { - pub const PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT: Self = Self(1_000_237_000); + pub const GRAPHICS_SHADER_GROUP_CREATE_INFO_NV: Self = Self(1_000_277_001); } -impl ExtMemoryPriorityFn { - pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_memory_priority\0") - .expect("Wrong extension string") - } - pub const SPEC_VERSION: u32 = 1u32; +#[doc = "Generated from \'VK_NV_device_generated_commands\'"] +impl StructureType { + pub const GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV: Self = Self(1_000_277_002); } -pub struct ExtMemoryPriorityFn {} -unsafe impl Send for ExtMemoryPriorityFn {} -unsafe impl Sync for ExtMemoryPriorityFn {} -impl ::std::clone::Clone for ExtMemoryPriorityFn { - fn clone(&self) -> Self { - ExtMemoryPriorityFn {} - } +#[doc = "Generated from \'VK_NV_device_generated_commands\'"] +impl StructureType { + pub const INDIRECT_COMMANDS_LAYOUT_TOKEN_NV: Self = Self(1_000_277_003); } -impl ExtMemoryPriorityFn { - pub fn load(mut _f: F) -> Self - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - ExtMemoryPriorityFn {} - } +#[doc = "Generated from \'VK_NV_device_generated_commands\'"] +impl StructureType { + pub const INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NV: Self = Self(1_000_277_004); } -#[doc = "Generated from \'VK_EXT_memory_priority\'"] +#[doc = "Generated from \'VK_NV_device_generated_commands\'"] impl StructureType { - pub const PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT: Self = Self(1_000_238_000); + pub const GENERATED_COMMANDS_INFO_NV: Self = Self(1_000_277_005); } -#[doc = "Generated from \'VK_EXT_memory_priority\'"] +#[doc = "Generated from \'VK_NV_device_generated_commands\'"] impl StructureType { - pub const MEMORY_PRIORITY_ALLOCATE_INFO_EXT: Self = Self(1_000_238_001); + pub const GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_NV: Self = Self(1_000_277_006); } -impl KhrSurfaceProtectedCapabilitiesFn { - pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_surface_protected_capabilities\0") - .expect("Wrong extension string") - } - pub const SPEC_VERSION: u32 = 1u32; +#[doc = "Generated from \'VK_NV_device_generated_commands\'"] +impl StructureType { + pub const PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV: Self = Self(1_000_277_007); } -pub struct KhrSurfaceProtectedCapabilitiesFn {} -unsafe impl Send for KhrSurfaceProtectedCapabilitiesFn {} -unsafe impl Sync for KhrSurfaceProtectedCapabilitiesFn {} -impl ::std::clone::Clone for KhrSurfaceProtectedCapabilitiesFn { - fn clone(&self) -> Self { - KhrSurfaceProtectedCapabilitiesFn {} - } +#[doc = "Generated from \'VK_NV_device_generated_commands\'"] +impl PipelineCreateFlags { + pub const INDIRECT_BINDABLE_NV: Self = Self(0b100_0000_0000_0000_0000); } -impl KhrSurfaceProtectedCapabilitiesFn { - pub fn load(mut _f: F) -> Self - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - KhrSurfaceProtectedCapabilitiesFn {} - } +#[doc = "Generated from \'VK_NV_device_generated_commands\'"] +impl PipelineStageFlags { + pub const COMMAND_PREPROCESS_NV: Self = Self(0b10_0000_0000_0000_0000); } -#[doc = "Generated from \'VK_KHR_surface_protected_capabilities\'"] -impl StructureType { - pub const SURFACE_PROTECTED_CAPABILITIES_KHR: Self = Self(1_000_239_000); +#[doc = "Generated from \'VK_NV_device_generated_commands\'"] +impl AccessFlags { + pub const COMMAND_PREPROCESS_READ_NV: Self = Self(0b10_0000_0000_0000_0000); } -impl NvDedicatedAllocationImageAliasingFn { +#[doc = "Generated from \'VK_NV_device_generated_commands\'"] +impl AccessFlags { + pub const COMMAND_PREPROCESS_WRITE_NV: Self = Self(0b100_0000_0000_0000_0000); +} +#[doc = "Generated from \'VK_NV_device_generated_commands\'"] +impl ObjectType { + pub const INDIRECT_COMMANDS_LAYOUT_NV: Self = Self(1_000_277_000); +} +impl NvExtension279Fn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_dedicated_allocation_image_aliasing\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_extension_279\0") .expect("Wrong extension string") } - pub const SPEC_VERSION: u32 = 1u32; + pub const SPEC_VERSION: u32 = 0u32; } -pub struct NvDedicatedAllocationImageAliasingFn {} -unsafe impl Send for NvDedicatedAllocationImageAliasingFn {} -unsafe impl Sync for NvDedicatedAllocationImageAliasingFn {} -impl ::std::clone::Clone for NvDedicatedAllocationImageAliasingFn { +pub struct NvExtension279Fn {} +unsafe impl Send for NvExtension279Fn {} +unsafe impl Sync for NvExtension279Fn {} +impl ::std::clone::Clone for NvExtension279Fn { fn clone(&self) -> Self { - NvDedicatedAllocationImageAliasingFn {} + NvExtension279Fn {} } } -impl NvDedicatedAllocationImageAliasingFn { +impl NvExtension279Fn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - NvDedicatedAllocationImageAliasingFn {} + NvExtension279Fn {} } } -#[doc = "Generated from \'VK_NV_dedicated_allocation_image_aliasing\'"] -impl StructureType { - pub const PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV: Self = - Self(1_000_240_000); -} -impl KhrSeparateDepthStencilLayoutsFn { +impl KhrExtension280Fn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_separate_depth_stencil_layouts\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_extension_280\0") .expect("Wrong extension string") } - pub const SPEC_VERSION: u32 = 1u32; + pub const SPEC_VERSION: u32 = 0u32; } -pub struct KhrSeparateDepthStencilLayoutsFn {} -unsafe impl Send for KhrSeparateDepthStencilLayoutsFn {} -unsafe impl Sync for KhrSeparateDepthStencilLayoutsFn {} -impl ::std::clone::Clone for KhrSeparateDepthStencilLayoutsFn { +pub struct KhrExtension280Fn {} +unsafe impl Send for KhrExtension280Fn {} +unsafe impl Sync for KhrExtension280Fn {} +impl ::std::clone::Clone for KhrExtension280Fn { fn clone(&self) -> Self { - KhrSeparateDepthStencilLayoutsFn {} + KhrExtension280Fn {} } } -impl KhrSeparateDepthStencilLayoutsFn { +impl KhrExtension280Fn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - KhrSeparateDepthStencilLayoutsFn {} + KhrExtension280Fn {} } } -#[doc = "Generated from \'VK_KHR_separate_depth_stencil_layouts\'"] -impl StructureType { - pub const PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES_KHR: Self = - StructureType::PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES; -} -#[doc = "Generated from \'VK_KHR_separate_depth_stencil_layouts\'"] -impl StructureType { - pub const ATTACHMENT_REFERENCE_STENCIL_LAYOUT_KHR: Self = - StructureType::ATTACHMENT_REFERENCE_STENCIL_LAYOUT; -} -#[doc = "Generated from \'VK_KHR_separate_depth_stencil_layouts\'"] -impl StructureType { - pub const ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT_KHR: Self = - StructureType::ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT; -} -#[doc = "Generated from \'VK_KHR_separate_depth_stencil_layouts\'"] -impl ImageLayout { - pub const DEPTH_ATTACHMENT_OPTIMAL_KHR: Self = ImageLayout::DEPTH_ATTACHMENT_OPTIMAL; -} -#[doc = "Generated from \'VK_KHR_separate_depth_stencil_layouts\'"] -impl ImageLayout { - pub const DEPTH_READ_ONLY_OPTIMAL_KHR: Self = ImageLayout::DEPTH_READ_ONLY_OPTIMAL; -} -#[doc = "Generated from \'VK_KHR_separate_depth_stencil_layouts\'"] -impl ImageLayout { - pub const STENCIL_ATTACHMENT_OPTIMAL_KHR: Self = ImageLayout::STENCIL_ATTACHMENT_OPTIMAL; -} -#[doc = "Generated from \'VK_KHR_separate_depth_stencil_layouts\'"] -impl ImageLayout { - pub const STENCIL_READ_ONLY_OPTIMAL_KHR: Self = ImageLayout::STENCIL_READ_ONLY_OPTIMAL; -} -impl IntelExtension243Fn { +impl ArmExtension281Fn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_INTEL_extension_243\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_ARM_extension_281\0") .expect("Wrong extension string") } pub const SPEC_VERSION: u32 = 0u32; } -pub struct IntelExtension243Fn {} -unsafe impl Send for IntelExtension243Fn {} -unsafe impl Sync for IntelExtension243Fn {} -impl ::std::clone::Clone for IntelExtension243Fn { +pub struct ArmExtension281Fn {} +unsafe impl Send for ArmExtension281Fn {} +unsafe impl Sync for ArmExtension281Fn {} +impl ::std::clone::Clone for ArmExtension281Fn { fn clone(&self) -> Self { - IntelExtension243Fn {} + ArmExtension281Fn {} } } -impl IntelExtension243Fn { +impl ArmExtension281Fn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - IntelExtension243Fn {} + ArmExtension281Fn {} } } -impl MesaExtension244Fn { +impl ExtTexelBufferAlignmentFn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_MESA_extension_244\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_texel_buffer_alignment\0") .expect("Wrong extension string") } - pub const SPEC_VERSION: u32 = 0u32; + pub const SPEC_VERSION: u32 = 1u32; } -pub struct MesaExtension244Fn {} -unsafe impl Send for MesaExtension244Fn {} -unsafe impl Sync for MesaExtension244Fn {} -impl ::std::clone::Clone for MesaExtension244Fn { +pub struct ExtTexelBufferAlignmentFn {} +unsafe impl Send for ExtTexelBufferAlignmentFn {} +unsafe impl Sync for ExtTexelBufferAlignmentFn {} +impl ::std::clone::Clone for ExtTexelBufferAlignmentFn { fn clone(&self) -> Self { - MesaExtension244Fn {} + ExtTexelBufferAlignmentFn {} } } -impl MesaExtension244Fn { +impl ExtTexelBufferAlignmentFn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - MesaExtension244Fn {} + ExtTexelBufferAlignmentFn {} } } -impl ExtBufferDeviceAddressFn { +#[doc = "Generated from \'VK_EXT_texel_buffer_alignment\'"] +impl StructureType { + pub const PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT: Self = Self(1_000_281_000); +} +#[doc = "Generated from \'VK_EXT_texel_buffer_alignment\'"] +impl StructureType { + pub const PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT: Self = Self(1_000_281_001); +} +impl QcomRenderPassTransformFn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_buffer_device_address\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_QCOM_render_pass_transform\0") .expect("Wrong extension string") } - pub const SPEC_VERSION: u32 = 2u32; -} -#[allow(non_camel_case_types)] -pub type PFN_vkGetBufferDeviceAddress = - extern "system" fn(device: Device, p_info: *const BufferDeviceAddressInfo) -> DeviceAddress; -pub struct ExtBufferDeviceAddressFn { - pub get_buffer_device_address_ext: - extern "system" fn(device: Device, p_info: *const BufferDeviceAddressInfo) -> DeviceAddress, + pub const SPEC_VERSION: u32 = 1u32; } -unsafe impl Send for ExtBufferDeviceAddressFn {} -unsafe impl Sync for ExtBufferDeviceAddressFn {} -impl ::std::clone::Clone for ExtBufferDeviceAddressFn { +pub struct QcomRenderPassTransformFn {} +unsafe impl Send for QcomRenderPassTransformFn {} +unsafe impl Sync for QcomRenderPassTransformFn {} +impl ::std::clone::Clone for QcomRenderPassTransformFn { fn clone(&self) -> Self { - ExtBufferDeviceAddressFn { - get_buffer_device_address_ext: self.get_buffer_device_address_ext, - } + QcomRenderPassTransformFn {} } } -impl ExtBufferDeviceAddressFn { +impl QcomRenderPassTransformFn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - ExtBufferDeviceAddressFn { - get_buffer_device_address_ext: unsafe { - extern "system" fn get_buffer_device_address_ext( - _device: Device, - _p_info: *const BufferDeviceAddressInfo, - ) -> DeviceAddress { - panic!(concat!( - "Unable to load ", - stringify!(get_buffer_device_address_ext) - )) - } - let raw_name = stringify!(vkGetBufferDeviceAddressEXT); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - get_buffer_device_address_ext - } else { - ::std::mem::transmute(val) - } - }, - } - } - #[doc = ""] - pub unsafe fn get_buffer_device_address_ext( - &self, - device: Device, - p_info: *const BufferDeviceAddressInfo, - ) -> DeviceAddress { - (self.get_buffer_device_address_ext)(device, p_info) + QcomRenderPassTransformFn {} } } -#[doc = "Generated from \'VK_EXT_buffer_device_address\'"] -impl StructureType { - pub const PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT: Self = Self(1_000_244_000); -} -#[doc = "Generated from \'VK_EXT_buffer_device_address\'"] -impl StructureType { - pub const PHYSICAL_DEVICE_BUFFER_ADDRESS_FEATURES_EXT: Self = - StructureType::PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT; -} -#[doc = "Generated from \'VK_EXT_buffer_device_address\'"] +#[doc = "Generated from \'VK_QCOM_render_pass_transform\'"] impl StructureType { - pub const BUFFER_DEVICE_ADDRESS_INFO_EXT: Self = StructureType::BUFFER_DEVICE_ADDRESS_INFO; + pub const COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM: Self = + Self(1_000_282_000); } -#[doc = "Generated from \'VK_EXT_buffer_device_address\'"] +#[doc = "Generated from \'VK_QCOM_render_pass_transform\'"] impl StructureType { - pub const BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT: Self = Self(1_000_244_002); -} -#[doc = "Generated from \'VK_EXT_buffer_device_address\'"] -impl BufferUsageFlags { - pub const SHADER_DEVICE_ADDRESS_EXT: Self = BufferUsageFlags::SHADER_DEVICE_ADDRESS; -} -#[doc = "Generated from \'VK_EXT_buffer_device_address\'"] -impl BufferCreateFlags { - pub const DEVICE_ADDRESS_CAPTURE_REPLAY_EXT: Self = - BufferCreateFlags::DEVICE_ADDRESS_CAPTURE_REPLAY; + pub const RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM: Self = Self(1_000_282_001); } -#[doc = "Generated from \'VK_EXT_buffer_device_address\'"] -impl Result { - pub const ERROR_INVALID_DEVICE_ADDRESS_EXT: Self = Result::ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS; +#[doc = "Generated from \'VK_QCOM_render_pass_transform\'"] +impl RenderPassCreateFlags { + pub const TRANSFORM_QCOM: Self = Self(0b10); } -impl ExtToolingInfoFn { +impl ExtExtension284Fn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_tooling_info\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_extension_284\0") .expect("Wrong extension string") } - pub const SPEC_VERSION: u32 = 1u32; -} -#[allow(non_camel_case_types)] -pub type PFN_vkGetPhysicalDeviceToolPropertiesEXT = extern "system" fn( - physical_device: PhysicalDevice, - p_tool_count: *mut u32, - p_tool_properties: *mut PhysicalDeviceToolPropertiesEXT, -) -> Result; -pub struct ExtToolingInfoFn { - pub get_physical_device_tool_properties_ext: extern "system" fn( - physical_device: PhysicalDevice, - p_tool_count: *mut u32, - p_tool_properties: *mut PhysicalDeviceToolPropertiesEXT, - ) -> Result, + pub const SPEC_VERSION: u32 = 0u32; } -unsafe impl Send for ExtToolingInfoFn {} -unsafe impl Sync for ExtToolingInfoFn {} -impl ::std::clone::Clone for ExtToolingInfoFn { +pub struct ExtExtension284Fn {} +unsafe impl Send for ExtExtension284Fn {} +unsafe impl Sync for ExtExtension284Fn {} +impl ::std::clone::Clone for ExtExtension284Fn { fn clone(&self) -> Self { - ExtToolingInfoFn { - get_physical_device_tool_properties_ext: self.get_physical_device_tool_properties_ext, - } + ExtExtension284Fn {} } } -impl ExtToolingInfoFn { +impl ExtExtension284Fn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - ExtToolingInfoFn { - get_physical_device_tool_properties_ext: unsafe { - extern "system" fn get_physical_device_tool_properties_ext( - _physical_device: PhysicalDevice, - _p_tool_count: *mut u32, - _p_tool_properties: *mut PhysicalDeviceToolPropertiesEXT, - ) -> Result { - panic!(concat!( - "Unable to load ", - stringify!(get_physical_device_tool_properties_ext) - )) - } - let raw_name = stringify!(vkGetPhysicalDeviceToolPropertiesEXT); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - get_physical_device_tool_properties_ext - } else { - ::std::mem::transmute(val) - } - }, - } - } - #[doc = ""] - pub unsafe fn get_physical_device_tool_properties_ext( - &self, - physical_device: PhysicalDevice, - p_tool_count: *mut u32, - p_tool_properties: *mut PhysicalDeviceToolPropertiesEXT, - ) -> Result { - (self.get_physical_device_tool_properties_ext)( - physical_device, - p_tool_count, - p_tool_properties, - ) + ExtExtension284Fn {} } } -#[doc = "Generated from \'VK_EXT_tooling_info\'"] -impl StructureType { - pub const PHYSICAL_DEVICE_TOOL_PROPERTIES_EXT: Self = Self(1_000_245_000); -} -#[doc = "Generated from \'VK_EXT_tooling_info\'"] -impl ToolPurposeFlagsEXT { - pub const DEBUG_REPORTING: Self = Self(0b10_0000); -} -#[doc = "Generated from \'VK_EXT_tooling_info\'"] -impl ToolPurposeFlagsEXT { - pub const DEBUG_MARKERS: Self = Self(0b100_0000); -} -impl ExtSeparateStencilUsageFn { +impl ExtDeviceMemoryReportFn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_separate_stencil_usage\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_device_memory_report\0") .expect("Wrong extension string") } pub const SPEC_VERSION: u32 = 1u32; } -pub struct ExtSeparateStencilUsageFn {} -unsafe impl Send for ExtSeparateStencilUsageFn {} -unsafe impl Sync for ExtSeparateStencilUsageFn {} -impl ::std::clone::Clone for ExtSeparateStencilUsageFn { +pub struct ExtDeviceMemoryReportFn {} +unsafe impl Send for ExtDeviceMemoryReportFn {} +unsafe impl Sync for ExtDeviceMemoryReportFn {} +impl ::std::clone::Clone for ExtDeviceMemoryReportFn { fn clone(&self) -> Self { - ExtSeparateStencilUsageFn {} + ExtDeviceMemoryReportFn {} } } -impl ExtSeparateStencilUsageFn { +impl ExtDeviceMemoryReportFn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - ExtSeparateStencilUsageFn {} + ExtDeviceMemoryReportFn {} } } -#[doc = "Generated from \'VK_EXT_separate_stencil_usage\'"] +#[doc = "Generated from \'VK_EXT_device_memory_report\'"] impl StructureType { - pub const IMAGE_STENCIL_USAGE_CREATE_INFO_EXT: Self = - StructureType::IMAGE_STENCIL_USAGE_CREATE_INFO; + pub const PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT: Self = Self(1_000_284_000); } -impl ExtValidationFeaturesFn { +#[doc = "Generated from \'VK_EXT_device_memory_report\'"] +impl StructureType { + pub const DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT: Self = Self(1_000_284_001); +} +#[doc = "Generated from \'VK_EXT_device_memory_report\'"] +impl StructureType { + pub const DEVICE_MEMORY_REPORT_CALLBACK_DATA_EXT: Self = Self(1_000_284_002); +} +impl ExtExtension286Fn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_validation_features\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_extension_286\0") .expect("Wrong extension string") } - pub const SPEC_VERSION: u32 = 3u32; + pub const SPEC_VERSION: u32 = 0u32; } -pub struct ExtValidationFeaturesFn {} -unsafe impl Send for ExtValidationFeaturesFn {} -unsafe impl Sync for ExtValidationFeaturesFn {} -impl ::std::clone::Clone for ExtValidationFeaturesFn { +pub struct ExtExtension286Fn {} +unsafe impl Send for ExtExtension286Fn {} +unsafe impl Sync for ExtExtension286Fn {} +impl ::std::clone::Clone for ExtExtension286Fn { fn clone(&self) -> Self { - ExtValidationFeaturesFn {} + ExtExtension286Fn {} } } -impl ExtValidationFeaturesFn { +impl ExtExtension286Fn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - ExtValidationFeaturesFn {} + ExtExtension286Fn {} } } -#[doc = "Generated from \'VK_EXT_validation_features\'"] -impl StructureType { - pub const VALIDATION_FEATURES_EXT: Self = Self(1_000_247_000); -} -impl KhrExtension249Fn { +impl ExtRobustness2Fn { 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_EXT_robustness2\0") .expect("Wrong extension string") } - pub const SPEC_VERSION: u32 = 0u32; + pub const SPEC_VERSION: u32 = 1u32; } -pub struct KhrExtension249Fn {} -unsafe impl Send for KhrExtension249Fn {} -unsafe impl Sync for KhrExtension249Fn {} -impl ::std::clone::Clone for KhrExtension249Fn { +pub struct ExtRobustness2Fn {} +unsafe impl Send for ExtRobustness2Fn {} +unsafe impl Sync for ExtRobustness2Fn {} +impl ::std::clone::Clone for ExtRobustness2Fn { fn clone(&self) -> Self { - KhrExtension249Fn {} + ExtRobustness2Fn {} } } -impl KhrExtension249Fn { +impl ExtRobustness2Fn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - KhrExtension249Fn {} + ExtRobustness2Fn {} } } -impl NvCooperativeMatrixFn { +#[doc = "Generated from \'VK_EXT_robustness2\'"] +impl StructureType { + pub const PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT: Self = Self(1_000_286_000); +} +#[doc = "Generated from \'VK_EXT_robustness2\'"] +impl StructureType { + pub const PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT: Self = Self(1_000_286_001); +} +impl ExtCustomBorderColorFn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_cooperative_matrix\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_custom_border_color\0") .expect("Wrong extension string") } - pub const SPEC_VERSION: u32 = 1u32; -} -#[allow(non_camel_case_types)] -pub type PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV = extern "system" fn( - physical_device: PhysicalDevice, - p_property_count: *mut u32, - p_properties: *mut CooperativeMatrixPropertiesNV, -) -> Result; -pub struct NvCooperativeMatrixFn { - pub get_physical_device_cooperative_matrix_properties_nv: extern "system" fn( - physical_device: PhysicalDevice, - p_property_count: *mut u32, - p_properties: *mut CooperativeMatrixPropertiesNV, - ) -> Result, + pub const SPEC_VERSION: u32 = 12u32; } -unsafe impl Send for NvCooperativeMatrixFn {} -unsafe impl Sync for NvCooperativeMatrixFn {} -impl ::std::clone::Clone for NvCooperativeMatrixFn { +pub struct ExtCustomBorderColorFn {} +unsafe impl Send for ExtCustomBorderColorFn {} +unsafe impl Sync for ExtCustomBorderColorFn {} +impl ::std::clone::Clone for ExtCustomBorderColorFn { fn clone(&self) -> Self { - NvCooperativeMatrixFn { - get_physical_device_cooperative_matrix_properties_nv: self - .get_physical_device_cooperative_matrix_properties_nv, - } + ExtCustomBorderColorFn {} } } -impl NvCooperativeMatrixFn { +impl ExtCustomBorderColorFn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - NvCooperativeMatrixFn { - get_physical_device_cooperative_matrix_properties_nv: unsafe { - extern "system" fn get_physical_device_cooperative_matrix_properties_nv( - _physical_device: PhysicalDevice, - _p_property_count: *mut u32, - _p_properties: *mut CooperativeMatrixPropertiesNV, - ) -> Result { - panic!(concat!( - "Unable to load ", - stringify!(get_physical_device_cooperative_matrix_properties_nv) - )) - } - let raw_name = stringify!(vkGetPhysicalDeviceCooperativeMatrixPropertiesNV); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - get_physical_device_cooperative_matrix_properties_nv - } else { - ::std::mem::transmute(val) - } - }, - } - } - #[doc = ""] - pub unsafe fn get_physical_device_cooperative_matrix_properties_nv( - &self, - physical_device: PhysicalDevice, - p_property_count: *mut u32, - p_properties: *mut CooperativeMatrixPropertiesNV, - ) -> Result { - (self.get_physical_device_cooperative_matrix_properties_nv)( - physical_device, - p_property_count, - p_properties, - ) + ExtCustomBorderColorFn {} } } -#[doc = "Generated from \'VK_NV_cooperative_matrix\'"] +#[doc = "Generated from \'VK_EXT_custom_border_color\'"] impl StructureType { - pub const PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV: Self = Self(1_000_249_000); + pub const SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT: Self = Self(1_000_287_000); } -#[doc = "Generated from \'VK_NV_cooperative_matrix\'"] +#[doc = "Generated from \'VK_EXT_custom_border_color\'"] impl StructureType { - pub const COOPERATIVE_MATRIX_PROPERTIES_NV: Self = Self(1_000_249_001); + pub const PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT: Self = Self(1_000_287_001); } -#[doc = "Generated from \'VK_NV_cooperative_matrix\'"] +#[doc = "Generated from \'VK_EXT_custom_border_color\'"] impl StructureType { - pub const PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV: Self = Self(1_000_249_002); + pub const PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT: Self = Self(1_000_287_002); } -impl NvCoverageReductionModeFn { +#[doc = "Generated from \'VK_EXT_custom_border_color\'"] +impl BorderColor { + pub const FLOAT_CUSTOM_EXT: Self = Self(1_000_287_003); +} +#[doc = "Generated from \'VK_EXT_custom_border_color\'"] +impl BorderColor { + pub const INT_CUSTOM_EXT: Self = Self(1_000_287_004); +} +impl ExtExtension289Fn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_coverage_reduction_mode\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_extension_289\0") .expect("Wrong extension string") } - pub const SPEC_VERSION: u32 = 1u32; -} -#[allow(non_camel_case_types)] -pub type PFN_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV = - extern "system" fn( - physical_device: PhysicalDevice, - p_combination_count: *mut u32, - p_combinations: *mut FramebufferMixedSamplesCombinationNV, - ) -> Result; -pub struct NvCoverageReductionModeFn { - pub get_physical_device_supported_framebuffer_mixed_samples_combinations_nv: - extern "system" fn( - physical_device: PhysicalDevice, - p_combination_count: *mut u32, - p_combinations: *mut FramebufferMixedSamplesCombinationNV, - ) -> Result, + pub const SPEC_VERSION: u32 = 0u32; } -unsafe impl Send for NvCoverageReductionModeFn {} -unsafe impl Sync for NvCoverageReductionModeFn {} -impl ::std::clone::Clone for NvCoverageReductionModeFn { +pub struct ExtExtension289Fn {} +unsafe impl Send for ExtExtension289Fn {} +unsafe impl Sync for ExtExtension289Fn {} +impl ::std::clone::Clone for ExtExtension289Fn { fn clone(&self) -> Self { - NvCoverageReductionModeFn { - get_physical_device_supported_framebuffer_mixed_samples_combinations_nv: self - .get_physical_device_supported_framebuffer_mixed_samples_combinations_nv, - } + ExtExtension289Fn {} } } -impl NvCoverageReductionModeFn { +impl ExtExtension289Fn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - NvCoverageReductionModeFn { - get_physical_device_supported_framebuffer_mixed_samples_combinations_nv: unsafe { - extern "system" fn get_physical_device_supported_framebuffer_mixed_samples_combinations_nv( - _physical_device: PhysicalDevice, - _p_combination_count: *mut u32, - _p_combinations: *mut FramebufferMixedSamplesCombinationNV, - ) -> Result { - panic!(concat!( - "Unable to load ", - stringify!( - get_physical_device_supported_framebuffer_mixed_samples_combinations_nv - ) - )) - } - let raw_name = - stringify!(vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - get_physical_device_supported_framebuffer_mixed_samples_combinations_nv - } else { - ::std::mem::transmute(val) - } - }, - } - } - #[doc = ""] - pub unsafe fn get_physical_device_supported_framebuffer_mixed_samples_combinations_nv( - &self, - physical_device: PhysicalDevice, - p_combination_count: *mut u32, - p_combinations: *mut FramebufferMixedSamplesCombinationNV, - ) -> Result { - (self.get_physical_device_supported_framebuffer_mixed_samples_combinations_nv)( - physical_device, - p_combination_count, - p_combinations, - ) + ExtExtension289Fn {} } } -#[doc = "Generated from \'VK_NV_coverage_reduction_mode\'"] -impl StructureType { - pub const PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV: Self = Self(1_000_250_000); +#[doc = "Generated from \'VK_EXT_extension_289\'"] +impl Format { + pub const ASTC_3X3X3_UNORM_BLOCK_EXT: Self = Self(1_000_288_000); } -#[doc = "Generated from \'VK_NV_coverage_reduction_mode\'"] -impl StructureType { - pub const PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV: Self = Self(1_000_250_001); +#[doc = "Generated from \'VK_EXT_extension_289\'"] +impl Format { + pub const ASTC_3X3X3_SRGB_BLOCK_EXT: Self = Self(1_000_288_001); } -#[doc = "Generated from \'VK_NV_coverage_reduction_mode\'"] -impl StructureType { - pub const FRAMEBUFFER_MIXED_SAMPLES_COMBINATION_NV: Self = Self(1_000_250_002); +#[doc = "Generated from \'VK_EXT_extension_289\'"] +impl Format { + pub const ASTC_3X3X3_SFLOAT_BLOCK_EXT: Self = Self(1_000_288_002); } -impl ExtFragmentShaderInterlockFn { +#[doc = "Generated from \'VK_EXT_extension_289\'"] +impl Format { + pub const ASTC_4X3X3_UNORM_BLOCK_EXT: Self = Self(1_000_288_003); +} +#[doc = "Generated from \'VK_EXT_extension_289\'"] +impl Format { + pub const ASTC_4X3X3_SRGB_BLOCK_EXT: Self = Self(1_000_288_004); +} +#[doc = "Generated from \'VK_EXT_extension_289\'"] +impl Format { + pub const ASTC_4X3X3_SFLOAT_BLOCK_EXT: Self = Self(1_000_288_005); +} +#[doc = "Generated from \'VK_EXT_extension_289\'"] +impl Format { + pub const ASTC_4X4X3_UNORM_BLOCK_EXT: Self = Self(1_000_288_006); +} +#[doc = "Generated from \'VK_EXT_extension_289\'"] +impl Format { + pub const ASTC_4X4X3_SRGB_BLOCK_EXT: Self = Self(1_000_288_007); +} +#[doc = "Generated from \'VK_EXT_extension_289\'"] +impl Format { + pub const ASTC_4X4X3_SFLOAT_BLOCK_EXT: Self = Self(1_000_288_008); +} +#[doc = "Generated from \'VK_EXT_extension_289\'"] +impl Format { + pub const ASTC_4X4X4_UNORM_BLOCK_EXT: Self = Self(1_000_288_009); +} +#[doc = "Generated from \'VK_EXT_extension_289\'"] +impl Format { + pub const ASTC_4X4X4_SRGB_BLOCK_EXT: Self = Self(1_000_288_010); +} +#[doc = "Generated from \'VK_EXT_extension_289\'"] +impl Format { + pub const ASTC_4X4X4_SFLOAT_BLOCK_EXT: Self = Self(1_000_288_011); +} +#[doc = "Generated from \'VK_EXT_extension_289\'"] +impl Format { + pub const ASTC_5X4X4_UNORM_BLOCK_EXT: Self = Self(1_000_288_012); +} +#[doc = "Generated from \'VK_EXT_extension_289\'"] +impl Format { + pub const ASTC_5X4X4_SRGB_BLOCK_EXT: Self = Self(1_000_288_013); +} +#[doc = "Generated from \'VK_EXT_extension_289\'"] +impl Format { + pub const ASTC_5X4X4_SFLOAT_BLOCK_EXT: Self = Self(1_000_288_014); +} +#[doc = "Generated from \'VK_EXT_extension_289\'"] +impl Format { + pub const ASTC_5X5X4_UNORM_BLOCK_EXT: Self = Self(1_000_288_015); +} +#[doc = "Generated from \'VK_EXT_extension_289\'"] +impl Format { + pub const ASTC_5X5X4_SRGB_BLOCK_EXT: Self = Self(1_000_288_016); +} +#[doc = "Generated from \'VK_EXT_extension_289\'"] +impl Format { + pub const ASTC_5X5X4_SFLOAT_BLOCK_EXT: Self = Self(1_000_288_017); +} +#[doc = "Generated from \'VK_EXT_extension_289\'"] +impl Format { + pub const ASTC_5X5X5_UNORM_BLOCK_EXT: Self = Self(1_000_288_018); +} +#[doc = "Generated from \'VK_EXT_extension_289\'"] +impl Format { + pub const ASTC_5X5X5_SRGB_BLOCK_EXT: Self = Self(1_000_288_019); +} +#[doc = "Generated from \'VK_EXT_extension_289\'"] +impl Format { + pub const ASTC_5X5X5_SFLOAT_BLOCK_EXT: Self = Self(1_000_288_020); +} +#[doc = "Generated from \'VK_EXT_extension_289\'"] +impl Format { + pub const ASTC_6X5X5_UNORM_BLOCK_EXT: Self = Self(1_000_288_021); +} +#[doc = "Generated from \'VK_EXT_extension_289\'"] +impl Format { + pub const ASTC_6X5X5_SRGB_BLOCK_EXT: Self = Self(1_000_288_022); +} +#[doc = "Generated from \'VK_EXT_extension_289\'"] +impl Format { + pub const ASTC_6X5X5_SFLOAT_BLOCK_EXT: Self = Self(1_000_288_023); +} +#[doc = "Generated from \'VK_EXT_extension_289\'"] +impl Format { + pub const ASTC_6X6X5_UNORM_BLOCK_EXT: Self = Self(1_000_288_024); +} +#[doc = "Generated from \'VK_EXT_extension_289\'"] +impl Format { + pub const ASTC_6X6X5_SRGB_BLOCK_EXT: Self = Self(1_000_288_025); +} +#[doc = "Generated from \'VK_EXT_extension_289\'"] +impl Format { + pub const ASTC_6X6X5_SFLOAT_BLOCK_EXT: Self = Self(1_000_288_026); +} +#[doc = "Generated from \'VK_EXT_extension_289\'"] +impl Format { + pub const ASTC_6X6X6_UNORM_BLOCK_EXT: Self = Self(1_000_288_027); +} +#[doc = "Generated from \'VK_EXT_extension_289\'"] +impl Format { + pub const ASTC_6X6X6_SRGB_BLOCK_EXT: Self = Self(1_000_288_028); +} +#[doc = "Generated from \'VK_EXT_extension_289\'"] +impl Format { + pub const ASTC_6X6X6_SFLOAT_BLOCK_EXT: Self = Self(1_000_288_029); +} +impl GoogleUserTypeFn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_fragment_shader_interlock\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_GOOGLE_user_type\0") .expect("Wrong extension string") } pub const SPEC_VERSION: u32 = 1u32; } -pub struct ExtFragmentShaderInterlockFn {} -unsafe impl Send for ExtFragmentShaderInterlockFn {} -unsafe impl Sync for ExtFragmentShaderInterlockFn {} -impl ::std::clone::Clone for ExtFragmentShaderInterlockFn { +pub struct GoogleUserTypeFn {} +unsafe impl Send for GoogleUserTypeFn {} +unsafe impl Sync for GoogleUserTypeFn {} +impl ::std::clone::Clone for GoogleUserTypeFn { fn clone(&self) -> Self { - ExtFragmentShaderInterlockFn {} + GoogleUserTypeFn {} } } -impl ExtFragmentShaderInterlockFn { +impl GoogleUserTypeFn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - ExtFragmentShaderInterlockFn {} + GoogleUserTypeFn {} } } -#[doc = "Generated from \'VK_EXT_fragment_shader_interlock\'"] -impl StructureType { - pub const PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT: Self = Self(1_000_251_000); -} -impl ExtYcbcrImageArraysFn { +impl KhrPipelineLibraryFn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_ycbcr_image_arrays\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_pipeline_library\0") .expect("Wrong extension string") } pub const SPEC_VERSION: u32 = 1u32; } -pub struct ExtYcbcrImageArraysFn {} -unsafe impl Send for ExtYcbcrImageArraysFn {} -unsafe impl Sync for ExtYcbcrImageArraysFn {} -impl ::std::clone::Clone for ExtYcbcrImageArraysFn { +pub struct KhrPipelineLibraryFn {} +unsafe impl Send for KhrPipelineLibraryFn {} +unsafe impl Sync for KhrPipelineLibraryFn {} +impl ::std::clone::Clone for KhrPipelineLibraryFn { fn clone(&self) -> Self { - ExtYcbcrImageArraysFn {} + KhrPipelineLibraryFn {} } } -impl ExtYcbcrImageArraysFn { +impl KhrPipelineLibraryFn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - ExtYcbcrImageArraysFn {} + KhrPipelineLibraryFn {} } } -#[doc = "Generated from \'VK_EXT_ycbcr_image_arrays\'"] +#[doc = "Generated from \'VK_KHR_pipeline_library\'"] +impl PipelineCreateFlags { + pub const LIBRARY_KHR: Self = Self(0b1000_0000_0000); +} +#[doc = "Generated from \'VK_KHR_pipeline_library\'"] impl StructureType { - pub const PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT: Self = Self(1_000_252_000); + pub const PIPELINE_LIBRARY_CREATE_INFO_KHR: Self = Self(1_000_290_000); } -impl KhrUniformBufferStandardLayoutFn { +impl NvExtension292Fn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_uniform_buffer_standard_layout\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_extension_292\0") .expect("Wrong extension string") } - pub const SPEC_VERSION: u32 = 1u32; + pub const SPEC_VERSION: u32 = 0u32; } -pub struct KhrUniformBufferStandardLayoutFn {} -unsafe impl Send for KhrUniformBufferStandardLayoutFn {} -unsafe impl Sync for KhrUniformBufferStandardLayoutFn {} -impl ::std::clone::Clone for KhrUniformBufferStandardLayoutFn { +pub struct NvExtension292Fn {} +unsafe impl Send for NvExtension292Fn {} +unsafe impl Sync for NvExtension292Fn {} +impl ::std::clone::Clone for NvExtension292Fn { fn clone(&self) -> Self { - KhrUniformBufferStandardLayoutFn {} + NvExtension292Fn {} } } -impl KhrUniformBufferStandardLayoutFn { +impl NvExtension292Fn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - KhrUniformBufferStandardLayoutFn {} + NvExtension292Fn {} } } -#[doc = "Generated from \'VK_KHR_uniform_buffer_standard_layout\'"] -impl StructureType { - pub const PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES_KHR: Self = - StructureType::PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES; -} -impl ExtExtension255Fn { +impl NvExtension293Fn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_extension_255\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_extension_293\0") .expect("Wrong extension string") } pub const SPEC_VERSION: u32 = 0u32; } -pub struct ExtExtension255Fn {} -unsafe impl Send for ExtExtension255Fn {} -unsafe impl Sync for ExtExtension255Fn {} -impl ::std::clone::Clone for ExtExtension255Fn { +pub struct NvExtension293Fn {} +unsafe impl Send for NvExtension293Fn {} +unsafe impl Sync for NvExtension293Fn {} +impl ::std::clone::Clone for NvExtension293Fn { fn clone(&self) -> Self { - ExtExtension255Fn {} + NvExtension293Fn {} } } -impl ExtExtension255Fn { +impl NvExtension293Fn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - ExtExtension255Fn {} + NvExtension293Fn {} } } -impl ExtFullScreenExclusiveFn { +impl KhrShaderNonSemanticInfoFn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_full_screen_exclusive\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_shader_non_semantic_info\0") .expect("Wrong extension string") } - pub const SPEC_VERSION: u32 = 4u32; -} -#[allow(non_camel_case_types)] -pub type PFN_vkGetPhysicalDeviceSurfacePresentModes2EXT = extern "system" fn( - physical_device: PhysicalDevice, - p_surface_info: *const PhysicalDeviceSurfaceInfo2KHR, - p_present_mode_count: *mut u32, - p_present_modes: *mut PresentModeKHR, -) -> Result; -#[allow(non_camel_case_types)] -pub type PFN_vkAcquireFullScreenExclusiveModeEXT = - extern "system" fn(device: Device, swapchain: SwapchainKHR) -> Result; -#[allow(non_camel_case_types)] -pub type PFN_vkReleaseFullScreenExclusiveModeEXT = - extern "system" fn(device: Device, swapchain: SwapchainKHR) -> Result; -#[allow(non_camel_case_types)] -pub type PFN_vkGetDeviceGroupSurfacePresentModes2EXT = extern "system" fn( - device: Device, - p_surface_info: *const PhysicalDeviceSurfaceInfo2KHR, - p_modes: *mut DeviceGroupPresentModeFlagsKHR, -) -> Result; -pub struct ExtFullScreenExclusiveFn { - pub get_physical_device_surface_present_modes2_ext: extern "system" fn( - physical_device: PhysicalDevice, - p_surface_info: *const PhysicalDeviceSurfaceInfo2KHR, - p_present_mode_count: *mut u32, - p_present_modes: *mut PresentModeKHR, - ) -> Result, - pub acquire_full_screen_exclusive_mode_ext: - extern "system" fn(device: Device, swapchain: SwapchainKHR) -> Result, - pub release_full_screen_exclusive_mode_ext: - extern "system" fn(device: Device, swapchain: SwapchainKHR) -> Result, - pub get_device_group_surface_present_modes2_ext: extern "system" fn( - device: Device, - p_surface_info: *const PhysicalDeviceSurfaceInfo2KHR, - p_modes: *mut DeviceGroupPresentModeFlagsKHR, - ) -> Result, + pub const SPEC_VERSION: u32 = 1u32; } -unsafe impl Send for ExtFullScreenExclusiveFn {} -unsafe impl Sync for ExtFullScreenExclusiveFn {} -impl ::std::clone::Clone for ExtFullScreenExclusiveFn { +pub struct KhrShaderNonSemanticInfoFn {} +unsafe impl Send for KhrShaderNonSemanticInfoFn {} +unsafe impl Sync for KhrShaderNonSemanticInfoFn {} +impl ::std::clone::Clone for KhrShaderNonSemanticInfoFn { fn clone(&self) -> Self { - ExtFullScreenExclusiveFn { - get_physical_device_surface_present_modes2_ext: self - .get_physical_device_surface_present_modes2_ext, - acquire_full_screen_exclusive_mode_ext: self.acquire_full_screen_exclusive_mode_ext, - release_full_screen_exclusive_mode_ext: self.release_full_screen_exclusive_mode_ext, - get_device_group_surface_present_modes2_ext: self - .get_device_group_surface_present_modes2_ext, - } + KhrShaderNonSemanticInfoFn {} } } -impl ExtFullScreenExclusiveFn { +impl KhrShaderNonSemanticInfoFn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - ExtFullScreenExclusiveFn { - get_physical_device_surface_present_modes2_ext: 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 raw_name = stringify!(vkGetPhysicalDeviceSurfacePresentModes2EXT); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - get_physical_device_surface_present_modes2_ext - } else { - ::std::mem::transmute(val) - } - }, - acquire_full_screen_exclusive_mode_ext: unsafe { - extern "system" fn acquire_full_screen_exclusive_mode_ext( - _device: Device, - _swapchain: SwapchainKHR, - ) -> Result { - panic!(concat!( - "Unable to load ", - stringify!(acquire_full_screen_exclusive_mode_ext) - )) - } - let raw_name = stringify!(vkAcquireFullScreenExclusiveModeEXT); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - acquire_full_screen_exclusive_mode_ext - } else { - ::std::mem::transmute(val) - } - }, - release_full_screen_exclusive_mode_ext: unsafe { - extern "system" fn release_full_screen_exclusive_mode_ext( - _device: Device, - _swapchain: SwapchainKHR, - ) -> Result { - panic!(concat!( - "Unable to load ", - stringify!(release_full_screen_exclusive_mode_ext) - )) - } - let raw_name = stringify!(vkReleaseFullScreenExclusiveModeEXT); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - release_full_screen_exclusive_mode_ext - } else { - ::std::mem::transmute(val) - } - }, - get_device_group_surface_present_modes2_ext: unsafe { - extern "system" fn get_device_group_surface_present_modes2_ext( - _device: Device, - _p_surface_info: *const PhysicalDeviceSurfaceInfo2KHR, - _p_modes: *mut DeviceGroupPresentModeFlagsKHR, - ) -> Result { - panic!(concat!( - "Unable to load ", - stringify!(get_device_group_surface_present_modes2_ext) - )) - } - let raw_name = stringify!(vkGetDeviceGroupSurfacePresentModes2EXT); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - get_device_group_surface_present_modes2_ext - } else { - ::std::mem::transmute(val) - } - }, - } - } - #[doc = ""] - pub unsafe fn get_physical_device_surface_present_modes2_ext( - &self, - physical_device: PhysicalDevice, - p_surface_info: *const PhysicalDeviceSurfaceInfo2KHR, - p_present_mode_count: *mut u32, - p_present_modes: *mut PresentModeKHR, - ) -> Result { - (self.get_physical_device_surface_present_modes2_ext)( - physical_device, - p_surface_info, - p_present_mode_count, - p_present_modes, - ) - } - #[doc = ""] - pub unsafe fn acquire_full_screen_exclusive_mode_ext( - &self, - device: Device, - swapchain: SwapchainKHR, - ) -> Result { - (self.acquire_full_screen_exclusive_mode_ext)(device, swapchain) - } - #[doc = ""] - pub unsafe fn release_full_screen_exclusive_mode_ext( - &self, - device: Device, - swapchain: SwapchainKHR, - ) -> Result { - (self.release_full_screen_exclusive_mode_ext)(device, swapchain) - } - #[doc = ""] - pub unsafe fn get_device_group_surface_present_modes2_ext( - &self, - device: Device, - p_surface_info: *const PhysicalDeviceSurfaceInfo2KHR, - p_modes: *mut DeviceGroupPresentModeFlagsKHR, - ) -> Result { - (self.get_device_group_surface_present_modes2_ext)(device, p_surface_info, p_modes) + KhrShaderNonSemanticInfoFn {} } } -#[doc = "Generated from \'VK_EXT_full_screen_exclusive\'"] -impl StructureType { - pub const SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT: Self = Self(1_000_255_000); -} -#[doc = "Generated from \'VK_EXT_full_screen_exclusive\'"] -impl StructureType { - pub const SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT: Self = Self(1_000_255_002); -} -#[doc = "Generated from \'VK_EXT_full_screen_exclusive\'"] -impl Result { - pub const ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT: Self = Self(-1_000_255_000); -} -#[doc = "Generated from \'VK_EXT_full_screen_exclusive\'"] -impl StructureType { - pub const SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT: Self = Self(1_000_255_001); -} -impl ExtHeadlessSurfaceFn { +impl KhrExtension295Fn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_headless_surface\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_extension_295\0") .expect("Wrong extension string") } - pub const SPEC_VERSION: u32 = 1u32; -} -#[allow(non_camel_case_types)] -pub type PFN_vkCreateHeadlessSurfaceEXT = extern "system" fn( - instance: Instance, - p_create_info: *const HeadlessSurfaceCreateInfoEXT, - p_allocator: *const AllocationCallbacks, - p_surface: *mut SurfaceKHR, -) -> Result; -pub struct ExtHeadlessSurfaceFn { - pub create_headless_surface_ext: extern "system" fn( - instance: Instance, - p_create_info: *const HeadlessSurfaceCreateInfoEXT, - p_allocator: *const AllocationCallbacks, - p_surface: *mut SurfaceKHR, - ) -> Result, + pub const SPEC_VERSION: u32 = 0u32; } -unsafe impl Send for ExtHeadlessSurfaceFn {} -unsafe impl Sync for ExtHeadlessSurfaceFn {} -impl ::std::clone::Clone for ExtHeadlessSurfaceFn { +pub struct KhrExtension295Fn {} +unsafe impl Send for KhrExtension295Fn {} +unsafe impl Sync for KhrExtension295Fn {} +impl ::std::clone::Clone for KhrExtension295Fn { fn clone(&self) -> Self { - ExtHeadlessSurfaceFn { - create_headless_surface_ext: self.create_headless_surface_ext, - } + KhrExtension295Fn {} } } -impl ExtHeadlessSurfaceFn { +impl KhrExtension295Fn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - ExtHeadlessSurfaceFn { - create_headless_surface_ext: unsafe { - extern "system" fn create_headless_surface_ext( - _instance: Instance, - _p_create_info: *const HeadlessSurfaceCreateInfoEXT, - _p_allocator: *const AllocationCallbacks, - _p_surface: *mut SurfaceKHR, - ) -> Result { - panic!(concat!( - "Unable to load ", - stringify!(create_headless_surface_ext) - )) - } - let raw_name = stringify!(vkCreateHeadlessSurfaceEXT); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - create_headless_surface_ext - } else { - ::std::mem::transmute(val) - } - }, - } - } - #[doc = ""] - pub unsafe fn create_headless_surface_ext( - &self, - instance: Instance, - p_create_info: *const HeadlessSurfaceCreateInfoEXT, - p_allocator: *const AllocationCallbacks, - p_surface: *mut SurfaceKHR, - ) -> Result { - (self.create_headless_surface_ext)(instance, p_create_info, p_allocator, p_surface) + KhrExtension295Fn {} } } -#[doc = "Generated from \'VK_EXT_headless_surface\'"] -impl StructureType { - pub const HEADLESS_SURFACE_CREATE_INFO_EXT: Self = Self(1_000_256_000); -} -impl KhrBufferDeviceAddressFn { +impl ExtPrivateDataFn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_buffer_device_address\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_private_data\0") .expect("Wrong extension string") } pub const SPEC_VERSION: u32 = 1u32; } #[allow(non_camel_case_types)] -pub type PFN_vkGetBufferOpaqueCaptureAddress = - extern "system" fn(device: Device, p_info: *const BufferDeviceAddressInfo) -> DeviceAddress; +pub type PFN_vkCreatePrivateDataSlotEXT = extern "system" fn( + device: Device, + p_create_info: *const PrivateDataSlotCreateInfoEXT, + p_allocator: *const AllocationCallbacks, + p_private_data_slot: *mut PrivateDataSlotEXT, +) -> Result; #[allow(non_camel_case_types)] -pub type PFN_vkGetDeviceMemoryOpaqueCaptureAddress = - extern "system" fn(device: Device, p_info: *const BufferDeviceAddressInfo) -> u64; -pub struct KhrBufferDeviceAddressFn { - pub get_buffer_device_address_khr: - extern "system" fn(device: Device, p_info: *const BufferDeviceAddressInfo) -> DeviceAddress, - pub get_buffer_opaque_capture_address_khr: - extern "system" fn(device: Device, p_info: *const BufferDeviceAddressInfo) -> u64, - pub get_device_memory_opaque_capture_address_khr: extern "system" fn( +pub type PFN_vkDestroyPrivateDataSlotEXT = extern "system" fn( + device: Device, + private_data_slot: PrivateDataSlotEXT, + p_allocator: *const AllocationCallbacks, +) -> c_void; +#[allow(non_camel_case_types)] +pub type PFN_vkSetPrivateDataEXT = extern "system" fn( + device: Device, + object_type: ObjectType, + object_handle: u64, + private_data_slot: PrivateDataSlotEXT, + data: u64, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetPrivateDataEXT = extern "system" fn( + device: Device, + object_type: ObjectType, + object_handle: u64, + private_data_slot: PrivateDataSlotEXT, + p_data: *mut u64, +) -> c_void; +pub struct ExtPrivateDataFn { + pub create_private_data_slot_ext: extern "system" fn( device: Device, - p_info: *const DeviceMemoryOpaqueCaptureAddressInfo, - ) -> u64, + p_create_info: *const PrivateDataSlotCreateInfoEXT, + p_allocator: *const AllocationCallbacks, + p_private_data_slot: *mut PrivateDataSlotEXT, + ) -> Result, + pub destroy_private_data_slot_ext: extern "system" fn( + device: Device, + private_data_slot: PrivateDataSlotEXT, + p_allocator: *const AllocationCallbacks, + ) -> c_void, + pub set_private_data_ext: extern "system" fn( + device: Device, + object_type: ObjectType, + object_handle: u64, + private_data_slot: PrivateDataSlotEXT, + data: u64, + ) -> Result, + pub get_private_data_ext: extern "system" fn( + device: Device, + object_type: ObjectType, + object_handle: u64, + private_data_slot: PrivateDataSlotEXT, + p_data: *mut u64, + ) -> c_void, } -unsafe impl Send for KhrBufferDeviceAddressFn {} -unsafe impl Sync for KhrBufferDeviceAddressFn {} -impl ::std::clone::Clone for KhrBufferDeviceAddressFn { +unsafe impl Send for ExtPrivateDataFn {} +unsafe impl Sync for ExtPrivateDataFn {} +impl ::std::clone::Clone for ExtPrivateDataFn { fn clone(&self) -> Self { - KhrBufferDeviceAddressFn { - get_buffer_device_address_khr: self.get_buffer_device_address_khr, - get_buffer_opaque_capture_address_khr: self.get_buffer_opaque_capture_address_khr, - get_device_memory_opaque_capture_address_khr: self - .get_device_memory_opaque_capture_address_khr, + ExtPrivateDataFn { + create_private_data_slot_ext: self.create_private_data_slot_ext, + destroy_private_data_slot_ext: self.destroy_private_data_slot_ext, + set_private_data_ext: self.set_private_data_ext, + get_private_data_ext: self.get_private_data_ext, } } } -impl KhrBufferDeviceAddressFn { +impl ExtPrivateDataFn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - KhrBufferDeviceAddressFn { - get_buffer_device_address_khr: unsafe { - extern "system" fn get_buffer_device_address_khr( + ExtPrivateDataFn { + create_private_data_slot_ext: unsafe { + extern "system" fn create_private_data_slot_ext( _device: Device, - _p_info: *const BufferDeviceAddressInfo, - ) -> DeviceAddress { + _p_create_info: *const PrivateDataSlotCreateInfoEXT, + _p_allocator: *const AllocationCallbacks, + _p_private_data_slot: *mut PrivateDataSlotEXT, + ) -> Result { panic!(concat!( "Unable to load ", - stringify!(get_buffer_device_address_khr) + stringify!(create_private_data_slot_ext) )) } - let raw_name = stringify!(vkGetBufferDeviceAddressKHR); + let raw_name = stringify!(vkCreatePrivateDataSlotEXT); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - get_buffer_device_address_khr + create_private_data_slot_ext } else { ::std::mem::transmute(val) } }, - get_buffer_opaque_capture_address_khr: unsafe { - extern "system" fn get_buffer_opaque_capture_address_khr( + destroy_private_data_slot_ext: unsafe { + extern "system" fn destroy_private_data_slot_ext( _device: Device, - _p_info: *const BufferDeviceAddressInfo, - ) -> u64 { + _private_data_slot: PrivateDataSlotEXT, + _p_allocator: *const AllocationCallbacks, + ) -> c_void { panic!(concat!( "Unable to load ", - stringify!(get_buffer_opaque_capture_address_khr) + stringify!(destroy_private_data_slot_ext) )) } - let raw_name = stringify!(vkGetBufferOpaqueCaptureAddressKHR); + let raw_name = stringify!(vkDestroyPrivateDataSlotEXT); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - get_buffer_opaque_capture_address_khr + destroy_private_data_slot_ext } else { ::std::mem::transmute(val) } }, - get_device_memory_opaque_capture_address_khr: unsafe { - extern "system" fn get_device_memory_opaque_capture_address_khr( + set_private_data_ext: unsafe { + extern "system" fn set_private_data_ext( _device: Device, - _p_info: *const DeviceMemoryOpaqueCaptureAddressInfo, - ) -> u64 { - panic!(concat!( - "Unable to load ", - stringify!(get_device_memory_opaque_capture_address_khr) - )) + _object_type: ObjectType, + _object_handle: u64, + _private_data_slot: PrivateDataSlotEXT, + _data: u64, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(set_private_data_ext))) } - let raw_name = stringify!(vkGetDeviceMemoryOpaqueCaptureAddressKHR); + let raw_name = stringify!(vkSetPrivateDataEXT); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - get_device_memory_opaque_capture_address_khr + set_private_data_ext + } else { + ::std::mem::transmute(val) + } + }, + get_private_data_ext: unsafe { + extern "system" fn get_private_data_ext( + _device: Device, + _object_type: ObjectType, + _object_handle: u64, + _private_data_slot: PrivateDataSlotEXT, + _p_data: *mut u64, + ) -> c_void { + panic!(concat!("Unable to load ", stringify!(get_private_data_ext))) + } + let raw_name = stringify!(vkGetPrivateDataEXT); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + get_private_data_ext } else { ::std::mem::transmute(val) } }, } } - #[doc = ""] - pub unsafe fn get_buffer_device_address_khr( + #[doc = ""] + pub unsafe fn create_private_data_slot_ext( &self, device: Device, - p_info: *const BufferDeviceAddressInfo, - ) -> DeviceAddress { - (self.get_buffer_device_address_khr)(device, p_info) + p_create_info: *const PrivateDataSlotCreateInfoEXT, + p_allocator: *const AllocationCallbacks, + p_private_data_slot: *mut PrivateDataSlotEXT, + ) -> Result { + (self.create_private_data_slot_ext)(device, p_create_info, p_allocator, p_private_data_slot) } - #[doc = ""] - pub unsafe fn get_buffer_opaque_capture_address_khr( + #[doc = ""] + pub unsafe fn destroy_private_data_slot_ext( &self, device: Device, - p_info: *const BufferDeviceAddressInfo, - ) -> u64 { - (self.get_buffer_opaque_capture_address_khr)(device, p_info) + private_data_slot: PrivateDataSlotEXT, + p_allocator: *const AllocationCallbacks, + ) -> c_void { + (self.destroy_private_data_slot_ext)(device, private_data_slot, p_allocator) } - #[doc = ""] - pub unsafe fn get_device_memory_opaque_capture_address_khr( + #[doc = ""] + pub unsafe fn set_private_data_ext( &self, device: Device, - p_info: *const DeviceMemoryOpaqueCaptureAddressInfo, - ) -> u64 { - (self.get_device_memory_opaque_capture_address_khr)(device, p_info) + object_type: ObjectType, + object_handle: u64, + private_data_slot: PrivateDataSlotEXT, + data: u64, + ) -> Result { + (self.set_private_data_ext)(device, object_type, object_handle, private_data_slot, data) + } + #[doc = ""] + pub unsafe fn get_private_data_ext( + &self, + device: Device, + object_type: ObjectType, + object_handle: u64, + private_data_slot: PrivateDataSlotEXT, + p_data: *mut u64, + ) -> c_void { + (self.get_private_data_ext)( + device, + object_type, + object_handle, + private_data_slot, + p_data, + ) } } -#[doc = "Generated from \'VK_KHR_buffer_device_address\'"] +#[doc = "Generated from \'VK_EXT_private_data\'"] impl StructureType { - pub const PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_KHR: Self = - StructureType::PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES; + pub const PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES_EXT: Self = Self(1_000_295_000); } -#[doc = "Generated from \'VK_KHR_buffer_device_address\'"] +#[doc = "Generated from \'VK_EXT_private_data\'"] impl StructureType { - pub const BUFFER_DEVICE_ADDRESS_INFO_KHR: Self = StructureType::BUFFER_DEVICE_ADDRESS_INFO; + pub const DEVICE_PRIVATE_DATA_CREATE_INFO_EXT: Self = Self(1_000_295_001); } -#[doc = "Generated from \'VK_KHR_buffer_device_address\'"] +#[doc = "Generated from \'VK_EXT_private_data\'"] impl StructureType { - pub const BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO_KHR: Self = - StructureType::BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO; + pub const PRIVATE_DATA_SLOT_CREATE_INFO_EXT: Self = Self(1_000_295_002); } -#[doc = "Generated from \'VK_KHR_buffer_device_address\'"] -impl StructureType { - pub const MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO_KHR: Self = - StructureType::MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO; +#[doc = "Generated from \'VK_EXT_private_data\'"] +impl ObjectType { + pub const PRIVATE_DATA_SLOT_EXT: Self = Self(1_000_295_000); } -#[doc = "Generated from \'VK_KHR_buffer_device_address\'"] +impl KhrExtension297Fn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_extension_297\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 0u32; +} +pub struct KhrExtension297Fn {} +unsafe impl Send for KhrExtension297Fn {} +unsafe impl Sync for KhrExtension297Fn {} +impl ::std::clone::Clone for KhrExtension297Fn { + fn clone(&self) -> Self { + KhrExtension297Fn {} + } +} +impl KhrExtension297Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + KhrExtension297Fn {} + } +} +#[doc = "Generated from \'VK_KHR_extension_297\'"] +impl PipelineShaderStageCreateFlags { + pub const RESERVED_3_KHR: Self = Self(0b1000); +} +impl ExtPipelineCreationCacheControlFn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_pipeline_creation_cache_control\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 3u32; +} +pub struct ExtPipelineCreationCacheControlFn {} +unsafe impl Send for ExtPipelineCreationCacheControlFn {} +unsafe impl Sync for ExtPipelineCreationCacheControlFn {} +impl ::std::clone::Clone for ExtPipelineCreationCacheControlFn { + fn clone(&self) -> Self { + ExtPipelineCreationCacheControlFn {} + } +} +impl ExtPipelineCreationCacheControlFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + ExtPipelineCreationCacheControlFn {} + } +} +#[doc = "Generated from \'VK_EXT_pipeline_creation_cache_control\'"] impl StructureType { - pub const DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO_KHR: Self = - StructureType::DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO; + pub const PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES_EXT: Self = + Self(1_000_297_000); } -#[doc = "Generated from \'VK_KHR_buffer_device_address\'"] -impl BufferUsageFlags { - pub const SHADER_DEVICE_ADDRESS_KHR: Self = BufferUsageFlags::SHADER_DEVICE_ADDRESS; +#[doc = "Generated from \'VK_EXT_pipeline_creation_cache_control\'"] +impl PipelineCreateFlags { + pub const FAIL_ON_PIPELINE_COMPILE_REQUIRED_EXT: Self = Self(0b1_0000_0000); } -#[doc = "Generated from \'VK_KHR_buffer_device_address\'"] -impl BufferCreateFlags { - pub const DEVICE_ADDRESS_CAPTURE_REPLAY_KHR: Self = - BufferCreateFlags::DEVICE_ADDRESS_CAPTURE_REPLAY; +#[doc = "Generated from \'VK_EXT_pipeline_creation_cache_control\'"] +impl PipelineCreateFlags { + pub const EARLY_RETURN_ON_FAILURE_EXT: Self = Self(0b10_0000_0000); } -#[doc = "Generated from \'VK_KHR_buffer_device_address\'"] -impl MemoryAllocateFlags { - pub const DEVICE_ADDRESS_KHR: Self = MemoryAllocateFlags::DEVICE_ADDRESS; +#[doc = "Generated from \'VK_EXT_pipeline_creation_cache_control\'"] +impl Result { + pub const PIPELINE_COMPILE_REQUIRED_EXT: Self = Self(1_000_297_000); } -#[doc = "Generated from \'VK_KHR_buffer_device_address\'"] -impl MemoryAllocateFlags { - pub const DEVICE_ADDRESS_CAPTURE_REPLAY_KHR: Self = - MemoryAllocateFlags::DEVICE_ADDRESS_CAPTURE_REPLAY; +#[doc = "Generated from \'VK_EXT_pipeline_creation_cache_control\'"] +impl Result { + pub const ERROR_PIPELINE_COMPILE_REQUIRED_EXT: Self = Result::PIPELINE_COMPILE_REQUIRED_EXT; +} +#[doc = "Generated from \'VK_EXT_pipeline_creation_cache_control\'"] +impl PipelineCacheCreateFlags { + pub const EXTERNALLY_SYNCHRONIZED_EXT: Self = Self(0b1); +} +impl KhrExtension299Fn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_extension_299\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 0u32; } -#[doc = "Generated from \'VK_KHR_buffer_device_address\'"] -impl Result { - pub const ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS_KHR: Self = - Result::ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS; +pub struct KhrExtension299Fn {} +unsafe impl Send for KhrExtension299Fn {} +unsafe impl Sync for KhrExtension299Fn {} +impl ::std::clone::Clone for KhrExtension299Fn { + fn clone(&self) -> Self { + KhrExtension299Fn {} + } } -impl ExtExtension259Fn { +impl KhrExtension299Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + KhrExtension299Fn {} + } +} +impl KhrExtension300Fn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_extension_259\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_extension_300\0") .expect("Wrong extension string") } pub const SPEC_VERSION: u32 = 0u32; } -pub struct ExtExtension259Fn {} -unsafe impl Send for ExtExtension259Fn {} -unsafe impl Sync for ExtExtension259Fn {} -impl ::std::clone::Clone for ExtExtension259Fn { +pub struct KhrExtension300Fn {} +unsafe impl Send for KhrExtension300Fn {} +unsafe impl Sync for KhrExtension300Fn {} +impl ::std::clone::Clone for KhrExtension300Fn { fn clone(&self) -> Self { - ExtExtension259Fn {} + KhrExtension300Fn {} } } -impl ExtExtension259Fn { +impl KhrExtension300Fn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - ExtExtension259Fn {} + KhrExtension300Fn {} } } -impl ExtLineRasterizationFn { +impl NvDeviceDiagnosticsConfigFn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_line_rasterization\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_device_diagnostics_config\0") .expect("Wrong extension string") } pub const SPEC_VERSION: u32 = 1u32; } -#[allow(non_camel_case_types)] -pub type PFN_vkCmdSetLineStippleEXT = extern "system" fn( - command_buffer: CommandBuffer, - line_stipple_factor: u32, - line_stipple_pattern: u16, -) -> c_void; -pub struct ExtLineRasterizationFn { - pub cmd_set_line_stipple_ext: extern "system" fn( - command_buffer: CommandBuffer, - line_stipple_factor: u32, - line_stipple_pattern: u16, - ) -> c_void, -} -unsafe impl Send for ExtLineRasterizationFn {} -unsafe impl Sync for ExtLineRasterizationFn {} -impl ::std::clone::Clone for ExtLineRasterizationFn { +pub struct NvDeviceDiagnosticsConfigFn {} +unsafe impl Send for NvDeviceDiagnosticsConfigFn {} +unsafe impl Sync for NvDeviceDiagnosticsConfigFn {} +impl ::std::clone::Clone for NvDeviceDiagnosticsConfigFn { fn clone(&self) -> Self { - ExtLineRasterizationFn { - cmd_set_line_stipple_ext: self.cmd_set_line_stipple_ext, - } + NvDeviceDiagnosticsConfigFn {} } } -impl ExtLineRasterizationFn { +impl NvDeviceDiagnosticsConfigFn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - ExtLineRasterizationFn { - cmd_set_line_stipple_ext: unsafe { - extern "system" fn cmd_set_line_stipple_ext( - _command_buffer: CommandBuffer, - _line_stipple_factor: u32, - _line_stipple_pattern: u16, - ) -> c_void { - panic!(concat!( - "Unable to load ", - stringify!(cmd_set_line_stipple_ext) - )) - } - let raw_name = stringify!(vkCmdSetLineStippleEXT); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - cmd_set_line_stipple_ext - } else { - ::std::mem::transmute(val) - } - }, - } - } - #[doc = ""] - pub unsafe fn cmd_set_line_stipple_ext( - &self, - command_buffer: CommandBuffer, - line_stipple_factor: u32, - line_stipple_pattern: u16, - ) -> c_void { - (self.cmd_set_line_stipple_ext)(command_buffer, line_stipple_factor, line_stipple_pattern) + NvDeviceDiagnosticsConfigFn {} } } -#[doc = "Generated from \'VK_EXT_line_rasterization\'"] -impl StructureType { - pub const PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT: Self = Self(1_000_259_000); -} -#[doc = "Generated from \'VK_EXT_line_rasterization\'"] +#[doc = "Generated from \'VK_NV_device_diagnostics_config\'"] impl StructureType { - pub const PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT: Self = Self(1_000_259_001); + pub const PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV: Self = Self(1_000_300_000); } -#[doc = "Generated from \'VK_EXT_line_rasterization\'"] +#[doc = "Generated from \'VK_NV_device_diagnostics_config\'"] impl StructureType { - pub const PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT: Self = Self(1_000_259_002); -} -#[doc = "Generated from \'VK_EXT_line_rasterization\'"] -impl DynamicState { - pub const LINE_STIPPLE_EXT: Self = Self(1_000_259_000); + pub const DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV: Self = Self(1_000_300_001); } -impl NvExtension261Fn { +impl QcomRenderPassStoreOpsFn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_extension_261\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_QCOM_render_pass_store_ops\0") .expect("Wrong extension string") } - pub const SPEC_VERSION: u32 = 0u32; + pub const SPEC_VERSION: u32 = 2u32; } -pub struct NvExtension261Fn {} -unsafe impl Send for NvExtension261Fn {} -unsafe impl Sync for NvExtension261Fn {} -impl ::std::clone::Clone for NvExtension261Fn { +pub struct QcomRenderPassStoreOpsFn {} +unsafe impl Send for QcomRenderPassStoreOpsFn {} +unsafe impl Sync for QcomRenderPassStoreOpsFn {} +impl ::std::clone::Clone for QcomRenderPassStoreOpsFn { fn clone(&self) -> Self { - NvExtension261Fn {} + QcomRenderPassStoreOpsFn {} } } -impl NvExtension261Fn { +impl QcomRenderPassStoreOpsFn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - NvExtension261Fn {} + QcomRenderPassStoreOpsFn {} } } -impl ExtHostQueryResetFn { +#[doc = "Generated from \'VK_QCOM_render_pass_store_ops\'"] +impl AttachmentStoreOp { + pub const NONE_QCOM: Self = Self(1_000_301_000); +} +impl QcomExtension303Fn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_host_query_reset\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_QCOM_extension_303\0") .expect("Wrong extension string") } - pub const SPEC_VERSION: u32 = 1u32; -} -#[allow(non_camel_case_types)] -pub type PFN_vkResetQueryPool = extern "system" fn( - device: Device, - query_pool: QueryPool, - first_query: u32, - query_count: u32, -) -> c_void; -pub struct ExtHostQueryResetFn { - pub reset_query_pool_ext: extern "system" fn( - device: Device, - query_pool: QueryPool, - first_query: u32, - query_count: u32, - ) -> c_void, + pub const SPEC_VERSION: u32 = 0u32; } -unsafe impl Send for ExtHostQueryResetFn {} -unsafe impl Sync for ExtHostQueryResetFn {} -impl ::std::clone::Clone for ExtHostQueryResetFn { +pub struct QcomExtension303Fn {} +unsafe impl Send for QcomExtension303Fn {} +unsafe impl Sync for QcomExtension303Fn {} +impl ::std::clone::Clone for QcomExtension303Fn { fn clone(&self) -> Self { - ExtHostQueryResetFn { - reset_query_pool_ext: self.reset_query_pool_ext, - } + QcomExtension303Fn {} } } -impl ExtHostQueryResetFn { +impl QcomExtension303Fn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - ExtHostQueryResetFn { - reset_query_pool_ext: unsafe { - extern "system" fn reset_query_pool_ext( - _device: Device, - _query_pool: QueryPool, - _first_query: u32, - _query_count: u32, - ) -> c_void { - panic!(concat!("Unable to load ", stringify!(reset_query_pool_ext))) - } - let raw_name = stringify!(vkResetQueryPoolEXT); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - reset_query_pool_ext - } else { - ::std::mem::transmute(val) - } - }, - } - } - #[doc = ""] - pub unsafe fn reset_query_pool_ext( - &self, - device: Device, - query_pool: QueryPool, - first_query: u32, - query_count: u32, - ) -> c_void { - (self.reset_query_pool_ext)(device, query_pool, first_query, query_count) + QcomExtension303Fn {} } } -#[doc = "Generated from \'VK_EXT_host_query_reset\'"] -impl StructureType { - pub const PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES_EXT: Self = - StructureType::PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES; -} -impl GgpExtension263Fn { +impl QcomExtension304Fn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_GGP_extension_263\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_QCOM_extension_304\0") .expect("Wrong extension string") } pub const SPEC_VERSION: u32 = 0u32; } -pub struct GgpExtension263Fn {} -unsafe impl Send for GgpExtension263Fn {} -unsafe impl Sync for GgpExtension263Fn {} -impl ::std::clone::Clone for GgpExtension263Fn { +pub struct QcomExtension304Fn {} +unsafe impl Send for QcomExtension304Fn {} +unsafe impl Sync for QcomExtension304Fn {} +impl ::std::clone::Clone for QcomExtension304Fn { fn clone(&self) -> Self { - GgpExtension263Fn {} + QcomExtension304Fn {} } } -impl GgpExtension263Fn { +impl QcomExtension304Fn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - GgpExtension263Fn {} + QcomExtension304Fn {} } } -impl BrcmExtension264Fn { +impl QcomExtension305Fn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_BRCM_extension_264\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_QCOM_extension_305\0") .expect("Wrong extension string") } pub const SPEC_VERSION: u32 = 0u32; } -pub struct BrcmExtension264Fn {} -unsafe impl Send for BrcmExtension264Fn {} -unsafe impl Sync for BrcmExtension264Fn {} -impl ::std::clone::Clone for BrcmExtension264Fn { +pub struct QcomExtension305Fn {} +unsafe impl Send for QcomExtension305Fn {} +unsafe impl Sync for QcomExtension305Fn {} +impl ::std::clone::Clone for QcomExtension305Fn { fn clone(&self) -> Self { - BrcmExtension264Fn {} + QcomExtension305Fn {} } } -impl BrcmExtension264Fn { +impl QcomExtension305Fn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - BrcmExtension264Fn {} + QcomExtension305Fn {} } } -impl BrcmExtension265Fn { +impl QcomExtension306Fn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_BRCM_extension_265\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_QCOM_extension_306\0") .expect("Wrong extension string") } pub const SPEC_VERSION: u32 = 0u32; } -pub struct BrcmExtension265Fn {} -unsafe impl Send for BrcmExtension265Fn {} -unsafe impl Sync for BrcmExtension265Fn {} -impl ::std::clone::Clone for BrcmExtension265Fn { +pub struct QcomExtension306Fn {} +unsafe impl Send for QcomExtension306Fn {} +unsafe impl Sync for QcomExtension306Fn {} +impl ::std::clone::Clone for QcomExtension306Fn { fn clone(&self) -> Self { - BrcmExtension265Fn {} + QcomExtension306Fn {} } } -impl BrcmExtension265Fn { +impl QcomExtension306Fn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - BrcmExtension265Fn {} + QcomExtension306Fn {} } } -impl ExtIndexTypeUint8Fn { +impl QcomExtension307Fn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_index_type_uint8\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_QCOM_extension_307\0") .expect("Wrong extension string") } - pub const SPEC_VERSION: u32 = 1u32; + pub const SPEC_VERSION: u32 = 0u32; } -pub struct ExtIndexTypeUint8Fn {} -unsafe impl Send for ExtIndexTypeUint8Fn {} -unsafe impl Sync for ExtIndexTypeUint8Fn {} -impl ::std::clone::Clone for ExtIndexTypeUint8Fn { +pub struct QcomExtension307Fn {} +unsafe impl Send for QcomExtension307Fn {} +unsafe impl Sync for QcomExtension307Fn {} +impl ::std::clone::Clone for QcomExtension307Fn { fn clone(&self) -> Self { - ExtIndexTypeUint8Fn {} + QcomExtension307Fn {} } } -impl ExtIndexTypeUint8Fn { +impl QcomExtension307Fn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - ExtIndexTypeUint8Fn {} + QcomExtension307Fn {} } } -#[doc = "Generated from \'VK_EXT_index_type_uint8\'"] -impl StructureType { - pub const PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT: Self = Self(1_000_265_000); -} -#[doc = "Generated from \'VK_EXT_index_type_uint8\'"] -impl IndexType { - pub const UINT8_EXT: Self = Self(1_000_265_000); -} -impl ExtExtension267Fn { +impl NvExtension308Fn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_extension_267\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_extension_308\0") .expect("Wrong extension string") } pub const SPEC_VERSION: u32 = 0u32; } -pub struct ExtExtension267Fn {} -unsafe impl Send for ExtExtension267Fn {} -unsafe impl Sync for ExtExtension267Fn {} -impl ::std::clone::Clone for ExtExtension267Fn { +pub struct NvExtension308Fn {} +unsafe impl Send for NvExtension308Fn {} +unsafe impl Sync for NvExtension308Fn {} +impl ::std::clone::Clone for NvExtension308Fn { fn clone(&self) -> Self { - ExtExtension267Fn {} + NvExtension308Fn {} } } -impl ExtExtension267Fn { +impl NvExtension308Fn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - ExtExtension267Fn {} + NvExtension308Fn {} } } -impl KhrExtension268Fn { +impl KhrExtension309Fn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_extension_268\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_extension_309\0") .expect("Wrong extension string") } pub const SPEC_VERSION: u32 = 0u32; } -pub struct KhrExtension268Fn {} -unsafe impl Send for KhrExtension268Fn {} -unsafe impl Sync for KhrExtension268Fn {} -impl ::std::clone::Clone for KhrExtension268Fn { +pub struct KhrExtension309Fn {} +unsafe impl Send for KhrExtension309Fn {} +unsafe impl Sync for KhrExtension309Fn {} +impl ::std::clone::Clone for KhrExtension309Fn { fn clone(&self) -> Self { - KhrExtension268Fn {} + KhrExtension309Fn {} } } -impl KhrExtension268Fn { +impl KhrExtension309Fn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - KhrExtension268Fn {} + KhrExtension309Fn {} } } -impl KhrDeferredHostOperationsFn { +#[doc = "Generated from \'VK_KHR_extension_309\'"] +impl MemoryHeapFlags { + pub const RESERVED_2_KHR: Self = Self(0b100); +} +impl QcomExtension310Fn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_deferred_host_operations\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_QCOM_extension_310\0") .expect("Wrong extension string") } - pub const SPEC_VERSION: u32 = 2u32; -} -#[allow(non_camel_case_types)] -pub type PFN_vkCreateDeferredOperationKHR = extern "system" fn( - device: Device, - p_allocator: *const AllocationCallbacks, - p_deferred_operation: *mut DeferredOperationKHR, -) -> Result; -#[allow(non_camel_case_types)] -pub type PFN_vkDestroyDeferredOperationKHR = extern "system" fn( - device: Device, - operation: DeferredOperationKHR, - p_allocator: *const AllocationCallbacks, -) -> c_void; -#[allow(non_camel_case_types)] -pub type PFN_vkGetDeferredOperationMaxConcurrencyKHR = - extern "system" fn(device: Device, operation: DeferredOperationKHR) -> u32; -#[allow(non_camel_case_types)] -pub type PFN_vkGetDeferredOperationResultKHR = - extern "system" fn(device: Device, operation: DeferredOperationKHR) -> Result; -#[allow(non_camel_case_types)] -pub type PFN_vkDeferredOperationJoinKHR = - extern "system" fn(device: Device, operation: DeferredOperationKHR) -> Result; -pub struct KhrDeferredHostOperationsFn { - pub create_deferred_operation_khr: extern "system" fn( - device: Device, - p_allocator: *const AllocationCallbacks, - p_deferred_operation: *mut DeferredOperationKHR, - ) -> Result, - pub destroy_deferred_operation_khr: extern "system" fn( - device: Device, - operation: DeferredOperationKHR, - p_allocator: *const AllocationCallbacks, - ) -> c_void, - pub get_deferred_operation_max_concurrency_khr: - extern "system" fn(device: Device, operation: DeferredOperationKHR) -> u32, - pub get_deferred_operation_result_khr: - extern "system" fn(device: Device, operation: DeferredOperationKHR) -> Result, - pub deferred_operation_join_khr: - extern "system" fn(device: Device, operation: DeferredOperationKHR) -> Result, + pub const SPEC_VERSION: u32 = 0u32; } -unsafe impl Send for KhrDeferredHostOperationsFn {} -unsafe impl Sync for KhrDeferredHostOperationsFn {} -impl ::std::clone::Clone for KhrDeferredHostOperationsFn { +pub struct QcomExtension310Fn {} +unsafe impl Send for QcomExtension310Fn {} +unsafe impl Sync for QcomExtension310Fn {} +impl ::std::clone::Clone for QcomExtension310Fn { fn clone(&self) -> Self { - KhrDeferredHostOperationsFn { - create_deferred_operation_khr: self.create_deferred_operation_khr, - destroy_deferred_operation_khr: self.destroy_deferred_operation_khr, - get_deferred_operation_max_concurrency_khr: self - .get_deferred_operation_max_concurrency_khr, - get_deferred_operation_result_khr: self.get_deferred_operation_result_khr, - deferred_operation_join_khr: self.deferred_operation_join_khr, - } + QcomExtension310Fn {} } } -impl KhrDeferredHostOperationsFn { +impl QcomExtension310Fn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - KhrDeferredHostOperationsFn { - create_deferred_operation_khr: unsafe { - extern "system" fn create_deferred_operation_khr( - _device: Device, - _p_allocator: *const AllocationCallbacks, - _p_deferred_operation: *mut DeferredOperationKHR, - ) -> Result { - panic!(concat!( - "Unable to load ", - stringify!(create_deferred_operation_khr) - )) - } - let raw_name = stringify!(vkCreateDeferredOperationKHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - create_deferred_operation_khr - } else { - ::std::mem::transmute(val) - } - }, - destroy_deferred_operation_khr: unsafe { - extern "system" fn destroy_deferred_operation_khr( - _device: Device, - _operation: DeferredOperationKHR, - _p_allocator: *const AllocationCallbacks, - ) -> c_void { - panic!(concat!( - "Unable to load ", - stringify!(destroy_deferred_operation_khr) - )) - } - let raw_name = stringify!(vkDestroyDeferredOperationKHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - destroy_deferred_operation_khr - } else { - ::std::mem::transmute(val) - } - }, - get_deferred_operation_max_concurrency_khr: unsafe { - extern "system" fn get_deferred_operation_max_concurrency_khr( - _device: Device, - _operation: DeferredOperationKHR, - ) -> u32 { - panic!(concat!( - "Unable to load ", - stringify!(get_deferred_operation_max_concurrency_khr) - )) - } - let raw_name = stringify!(vkGetDeferredOperationMaxConcurrencyKHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - get_deferred_operation_max_concurrency_khr - } else { - ::std::mem::transmute(val) - } - }, - get_deferred_operation_result_khr: unsafe { - extern "system" fn get_deferred_operation_result_khr( - _device: Device, - _operation: DeferredOperationKHR, - ) -> Result { - panic!(concat!( - "Unable to load ", - stringify!(get_deferred_operation_result_khr) - )) - } - let raw_name = stringify!(vkGetDeferredOperationResultKHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - get_deferred_operation_result_khr - } else { - ::std::mem::transmute(val) - } - }, - deferred_operation_join_khr: unsafe { - extern "system" fn deferred_operation_join_khr( - _device: Device, - _operation: DeferredOperationKHR, - ) -> Result { - panic!(concat!( - "Unable to load ", - stringify!(deferred_operation_join_khr) - )) - } - let raw_name = stringify!(vkDeferredOperationJoinKHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - deferred_operation_join_khr - } else { - ::std::mem::transmute(val) - } - }, - } - } - #[doc = ""] - pub unsafe fn create_deferred_operation_khr( - &self, - device: Device, - p_allocator: *const AllocationCallbacks, - p_deferred_operation: *mut DeferredOperationKHR, - ) -> Result { - (self.create_deferred_operation_khr)(device, p_allocator, p_deferred_operation) - } - #[doc = ""] - pub unsafe fn destroy_deferred_operation_khr( - &self, - device: Device, - operation: DeferredOperationKHR, - p_allocator: *const AllocationCallbacks, - ) -> c_void { - (self.destroy_deferred_operation_khr)(device, operation, p_allocator) + QcomExtension310Fn {} } - #[doc = ""] - pub unsafe fn get_deferred_operation_max_concurrency_khr( - &self, - device: Device, - operation: DeferredOperationKHR, - ) -> u32 { - (self.get_deferred_operation_max_concurrency_khr)(device, operation) +} +#[doc = "Generated from \'VK_QCOM_extension_310\'"] +impl StructureType { + pub const RESERVED_QCOM: Self = Self(1_000_309_000); +} +impl NvExtension311Fn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_extension_311\0") + .expect("Wrong extension string") } - #[doc = ""] - pub unsafe fn get_deferred_operation_result_khr( - &self, - device: Device, - operation: DeferredOperationKHR, - ) -> Result { - (self.get_deferred_operation_result_khr)(device, operation) + pub const SPEC_VERSION: u32 = 0u32; +} +pub struct NvExtension311Fn {} +unsafe impl Send for NvExtension311Fn {} +unsafe impl Sync for NvExtension311Fn {} +impl ::std::clone::Clone for NvExtension311Fn { + fn clone(&self) -> Self { + NvExtension311Fn {} } - #[doc = ""] - pub unsafe fn deferred_operation_join_khr( - &self, - device: Device, - operation: DeferredOperationKHR, - ) -> Result { - (self.deferred_operation_join_khr)(device, operation) +} +impl NvExtension311Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + NvExtension311Fn {} } } -#[doc = "Generated from \'VK_KHR_deferred_host_operations\'"] -impl StructureType { - pub const DEFERRED_OPERATION_INFO_KHR: Self = Self(1_000_268_000); +impl ExtExtension312Fn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_extension_312\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 0u32; } -#[doc = "Generated from \'VK_KHR_deferred_host_operations\'"] -impl ObjectType { - pub const DEFERRED_OPERATION_KHR: Self = Self(1_000_268_000); +pub struct ExtExtension312Fn {} +unsafe impl Send for ExtExtension312Fn {} +unsafe impl Sync for ExtExtension312Fn {} +impl ::std::clone::Clone for ExtExtension312Fn { + fn clone(&self) -> Self { + ExtExtension312Fn {} + } } -#[doc = "Generated from \'VK_KHR_deferred_host_operations\'"] -impl Result { - pub const THREAD_IDLE_KHR: Self = Self(1_000_268_000); +impl ExtExtension312Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + ExtExtension312Fn {} + } } -#[doc = "Generated from \'VK_KHR_deferred_host_operations\'"] -impl Result { - pub const THREAD_DONE_KHR: Self = Self(1_000_268_001); +impl ExtExtension313Fn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_extension_313\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 0u32; } -#[doc = "Generated from \'VK_KHR_deferred_host_operations\'"] -impl Result { - pub const OPERATION_DEFERRED_KHR: Self = Self(1_000_268_002); +pub struct ExtExtension313Fn {} +unsafe impl Send for ExtExtension313Fn {} +unsafe impl Sync for ExtExtension313Fn {} +impl ::std::clone::Clone for ExtExtension313Fn { + fn clone(&self) -> Self { + ExtExtension313Fn {} + } } -#[doc = "Generated from \'VK_KHR_deferred_host_operations\'"] -impl Result { - pub const OPERATION_NOT_DEFERRED_KHR: Self = Self(1_000_268_003); +impl ExtExtension313Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + ExtExtension313Fn {} + } } -impl KhrPipelineExecutablePropertiesFn { +impl AmdExtension314Fn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_pipeline_executable_properties\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_AMD_extension_314\0") .expect("Wrong extension string") } - pub const SPEC_VERSION: u32 = 1u32; -} -#[allow(non_camel_case_types)] -pub type PFN_vkGetPipelineExecutablePropertiesKHR = extern "system" fn( - device: Device, - p_pipeline_info: *const PipelineInfoKHR, - p_executable_count: *mut u32, - p_properties: *mut PipelineExecutablePropertiesKHR, -) -> Result; -#[allow(non_camel_case_types)] -pub type PFN_vkGetPipelineExecutableStatisticsKHR = extern "system" fn( - device: Device, - p_executable_info: *const PipelineExecutableInfoKHR, - p_statistic_count: *mut u32, - p_statistics: *mut PipelineExecutableStatisticKHR, -) -> Result; -#[allow(non_camel_case_types)] -pub type PFN_vkGetPipelineExecutableInternalRepresentationsKHR = extern "system" fn( - device: Device, - p_executable_info: *const PipelineExecutableInfoKHR, - p_internal_representation_count: *mut u32, - p_internal_representations: *mut PipelineExecutableInternalRepresentationKHR, -) -> Result; -pub struct KhrPipelineExecutablePropertiesFn { - pub get_pipeline_executable_properties_khr: extern "system" fn( - device: Device, - p_pipeline_info: *const PipelineInfoKHR, - p_executable_count: *mut u32, - p_properties: *mut PipelineExecutablePropertiesKHR, - ) -> Result, - pub get_pipeline_executable_statistics_khr: extern "system" fn( - device: Device, - p_executable_info: *const PipelineExecutableInfoKHR, - p_statistic_count: *mut u32, - p_statistics: *mut PipelineExecutableStatisticKHR, - ) -> Result, - pub get_pipeline_executable_internal_representations_khr: extern "system" fn( - device: Device, - p_executable_info: *const PipelineExecutableInfoKHR, - p_internal_representation_count: *mut u32, - p_internal_representations: *mut PipelineExecutableInternalRepresentationKHR, - ) -> Result, + pub const SPEC_VERSION: u32 = 0u32; } -unsafe impl Send for KhrPipelineExecutablePropertiesFn {} -unsafe impl Sync for KhrPipelineExecutablePropertiesFn {} -impl ::std::clone::Clone for KhrPipelineExecutablePropertiesFn { +pub struct AmdExtension314Fn {} +unsafe impl Send for AmdExtension314Fn {} +unsafe impl Sync for AmdExtension314Fn {} +impl ::std::clone::Clone for AmdExtension314Fn { fn clone(&self) -> Self { - KhrPipelineExecutablePropertiesFn { - get_pipeline_executable_properties_khr: self.get_pipeline_executable_properties_khr, - get_pipeline_executable_statistics_khr: self.get_pipeline_executable_statistics_khr, - get_pipeline_executable_internal_representations_khr: self - .get_pipeline_executable_internal_representations_khr, - } + AmdExtension314Fn {} } } -impl KhrPipelineExecutablePropertiesFn { +impl AmdExtension314Fn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - KhrPipelineExecutablePropertiesFn { - get_pipeline_executable_properties_khr: unsafe { - extern "system" fn get_pipeline_executable_properties_khr( - _device: Device, - _p_pipeline_info: *const PipelineInfoKHR, - _p_executable_count: *mut u32, - _p_properties: *mut PipelineExecutablePropertiesKHR, - ) -> Result { - panic!(concat!( - "Unable to load ", - stringify!(get_pipeline_executable_properties_khr) - )) - } - let raw_name = stringify!(vkGetPipelineExecutablePropertiesKHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - get_pipeline_executable_properties_khr - } else { - ::std::mem::transmute(val) - } - }, - get_pipeline_executable_statistics_khr: unsafe { - extern "system" fn get_pipeline_executable_statistics_khr( - _device: Device, - _p_executable_info: *const PipelineExecutableInfoKHR, - _p_statistic_count: *mut u32, - _p_statistics: *mut PipelineExecutableStatisticKHR, - ) -> Result { - panic!(concat!( - "Unable to load ", - stringify!(get_pipeline_executable_statistics_khr) - )) - } - let raw_name = stringify!(vkGetPipelineExecutableStatisticsKHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - get_pipeline_executable_statistics_khr - } else { - ::std::mem::transmute(val) - } - }, - get_pipeline_executable_internal_representations_khr: unsafe { - extern "system" fn get_pipeline_executable_internal_representations_khr( - _device: Device, - _p_executable_info: *const PipelineExecutableInfoKHR, - _p_internal_representation_count: *mut u32, - _p_internal_representations: *mut PipelineExecutableInternalRepresentationKHR, - ) -> Result { - panic!(concat!( - "Unable to load ", - stringify!(get_pipeline_executable_internal_representations_khr) - )) - } - let raw_name = stringify!(vkGetPipelineExecutableInternalRepresentationsKHR); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - get_pipeline_executable_internal_representations_khr - } else { - ::std::mem::transmute(val) - } - }, - } - } - #[doc = ""] - pub unsafe fn get_pipeline_executable_properties_khr( - &self, - device: Device, - p_pipeline_info: *const PipelineInfoKHR, - p_executable_count: *mut u32, - p_properties: *mut PipelineExecutablePropertiesKHR, - ) -> Result { - (self.get_pipeline_executable_properties_khr)( - device, - p_pipeline_info, - p_executable_count, - p_properties, - ) + AmdExtension314Fn {} } - #[doc = ""] - pub unsafe fn get_pipeline_executable_statistics_khr( - &self, - device: Device, - p_executable_info: *const PipelineExecutableInfoKHR, - p_statistic_count: *mut u32, - p_statistics: *mut PipelineExecutableStatisticKHR, - ) -> Result { - (self.get_pipeline_executable_statistics_khr)( - device, - p_executable_info, - p_statistic_count, - p_statistics, - ) +} +impl AmdExtension315Fn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_AMD_extension_315\0") + .expect("Wrong extension string") } - #[doc = ""] - pub unsafe fn get_pipeline_executable_internal_representations_khr( - &self, - device: Device, - p_executable_info: *const PipelineExecutableInfoKHR, - p_internal_representation_count: *mut u32, - p_internal_representations: *mut PipelineExecutableInternalRepresentationKHR, - ) -> Result { - (self.get_pipeline_executable_internal_representations_khr)( - device, - p_executable_info, - p_internal_representation_count, - p_internal_representations, - ) + pub const SPEC_VERSION: u32 = 0u32; +} +pub struct AmdExtension315Fn {} +unsafe impl Send for AmdExtension315Fn {} +unsafe impl Sync for AmdExtension315Fn {} +impl ::std::clone::Clone for AmdExtension315Fn { + fn clone(&self) -> Self { + AmdExtension315Fn {} } } -#[doc = "Generated from \'VK_KHR_pipeline_executable_properties\'"] -impl StructureType { - pub const PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR: Self = - Self(1_000_269_000); -} -#[doc = "Generated from \'VK_KHR_pipeline_executable_properties\'"] -impl StructureType { - pub const PIPELINE_INFO_KHR: Self = Self(1_000_269_001); +impl AmdExtension315Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + AmdExtension315Fn {} + } } -#[doc = "Generated from \'VK_KHR_pipeline_executable_properties\'"] -impl StructureType { - pub const PIPELINE_EXECUTABLE_PROPERTIES_KHR: Self = Self(1_000_269_002); +impl AmdExtension316Fn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_AMD_extension_316\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 0u32; } -#[doc = "Generated from \'VK_KHR_pipeline_executable_properties\'"] -impl StructureType { - pub const PIPELINE_EXECUTABLE_INFO_KHR: Self = Self(1_000_269_003); +pub struct AmdExtension316Fn {} +unsafe impl Send for AmdExtension316Fn {} +unsafe impl Sync for AmdExtension316Fn {} +impl ::std::clone::Clone for AmdExtension316Fn { + fn clone(&self) -> Self { + AmdExtension316Fn {} + } } -#[doc = "Generated from \'VK_KHR_pipeline_executable_properties\'"] -impl StructureType { - pub const PIPELINE_EXECUTABLE_STATISTIC_KHR: Self = Self(1_000_269_004); +impl AmdExtension316Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + AmdExtension316Fn {} + } } -#[doc = "Generated from \'VK_KHR_pipeline_executable_properties\'"] -impl StructureType { - pub const PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR: Self = Self(1_000_269_005); +impl AmdExtension317Fn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_AMD_extension_317\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 0u32; } -#[doc = "Generated from \'VK_KHR_pipeline_executable_properties\'"] -impl PipelineCreateFlags { - pub const CAPTURE_STATISTICS_KHR: Self = Self(0b100_0000); +pub struct AmdExtension317Fn {} +unsafe impl Send for AmdExtension317Fn {} +unsafe impl Sync for AmdExtension317Fn {} +impl ::std::clone::Clone for AmdExtension317Fn { + fn clone(&self) -> Self { + AmdExtension317Fn {} + } } -#[doc = "Generated from \'VK_KHR_pipeline_executable_properties\'"] -impl PipelineCreateFlags { - pub const CAPTURE_INTERNAL_REPRESENTATIONS_KHR: Self = Self(0b1000_0000); +impl AmdExtension317Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + AmdExtension317Fn {} + } } -impl IntelExtension271Fn { +impl AmdExtension318Fn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_INTEL_extension_271\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_AMD_extension_318\0") .expect("Wrong extension string") } pub const SPEC_VERSION: u32 = 0u32; } -pub struct IntelExtension271Fn {} -unsafe impl Send for IntelExtension271Fn {} -unsafe impl Sync for IntelExtension271Fn {} -impl ::std::clone::Clone for IntelExtension271Fn { +pub struct AmdExtension318Fn {} +unsafe impl Send for AmdExtension318Fn {} +unsafe impl Sync for AmdExtension318Fn {} +impl ::std::clone::Clone for AmdExtension318Fn { fn clone(&self) -> Self { - IntelExtension271Fn {} + AmdExtension318Fn {} } } -impl IntelExtension271Fn { +impl AmdExtension318Fn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - IntelExtension271Fn {} + AmdExtension318Fn {} } } -impl IntelExtension272Fn { +impl AmdExtension319Fn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_INTEL_extension_272\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_AMD_extension_319\0") .expect("Wrong extension string") } pub const SPEC_VERSION: u32 = 0u32; } -pub struct IntelExtension272Fn {} -unsafe impl Send for IntelExtension272Fn {} -unsafe impl Sync for IntelExtension272Fn {} -impl ::std::clone::Clone for IntelExtension272Fn { +pub struct AmdExtension319Fn {} +unsafe impl Send for AmdExtension319Fn {} +unsafe impl Sync for AmdExtension319Fn {} +impl ::std::clone::Clone for AmdExtension319Fn { fn clone(&self) -> Self { - IntelExtension272Fn {} + AmdExtension319Fn {} } } -impl IntelExtension272Fn { +impl AmdExtension319Fn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - IntelExtension272Fn {} + AmdExtension319Fn {} } } -impl IntelExtension273Fn { +impl AmdExtension320Fn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_INTEL_extension_273\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_AMD_extension_320\0") .expect("Wrong extension string") } pub const SPEC_VERSION: u32 = 0u32; } -pub struct IntelExtension273Fn {} -unsafe impl Send for IntelExtension273Fn {} -unsafe impl Sync for IntelExtension273Fn {} -impl ::std::clone::Clone for IntelExtension273Fn { +pub struct AmdExtension320Fn {} +unsafe impl Send for AmdExtension320Fn {} +unsafe impl Sync for AmdExtension320Fn {} +impl ::std::clone::Clone for AmdExtension320Fn { fn clone(&self) -> Self { - IntelExtension273Fn {} + AmdExtension320Fn {} } } -impl IntelExtension273Fn { +impl AmdExtension320Fn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - IntelExtension273Fn {} + AmdExtension320Fn {} } } -impl IntelExtension274Fn { +impl AmdExtension321Fn { 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_AMD_extension_321\0") .expect("Wrong extension string") } pub const SPEC_VERSION: u32 = 0u32; } -pub struct IntelExtension274Fn {} -unsafe impl Send for IntelExtension274Fn {} -unsafe impl Sync for IntelExtension274Fn {} -impl ::std::clone::Clone for IntelExtension274Fn { +pub struct AmdExtension321Fn {} +unsafe impl Send for AmdExtension321Fn {} +unsafe impl Sync for AmdExtension321Fn {} +impl ::std::clone::Clone for AmdExtension321Fn { fn clone(&self) -> Self { - IntelExtension274Fn {} + AmdExtension321Fn {} } } -impl IntelExtension274Fn { +impl AmdExtension321Fn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - IntelExtension274Fn {} + AmdExtension321Fn {} } } -impl KhrExtension275Fn { +impl AmdExtension322Fn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_extension_275\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_AMD_extension_322\0") .expect("Wrong extension string") } pub const SPEC_VERSION: u32 = 0u32; } -pub struct KhrExtension275Fn {} -unsafe impl Send for KhrExtension275Fn {} -unsafe impl Sync for KhrExtension275Fn {} -impl ::std::clone::Clone for KhrExtension275Fn { +pub struct AmdExtension322Fn {} +unsafe impl Send for AmdExtension322Fn {} +unsafe impl Sync for AmdExtension322Fn {} +impl ::std::clone::Clone for AmdExtension322Fn { fn clone(&self) -> Self { - KhrExtension275Fn {} + AmdExtension322Fn {} } } -impl KhrExtension275Fn { +impl AmdExtension322Fn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - KhrExtension275Fn {} + AmdExtension322Fn {} } } -impl KhrExtension276Fn { +impl AmdExtension323Fn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_extension_276\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_AMD_extension_323\0") .expect("Wrong extension string") } pub const SPEC_VERSION: u32 = 0u32; } -pub struct KhrExtension276Fn {} -unsafe impl Send for KhrExtension276Fn {} -unsafe impl Sync for KhrExtension276Fn {} -impl ::std::clone::Clone for KhrExtension276Fn { +pub struct AmdExtension323Fn {} +unsafe impl Send for AmdExtension323Fn {} +unsafe impl Sync for AmdExtension323Fn {} +impl ::std::clone::Clone for AmdExtension323Fn { fn clone(&self) -> Self { - KhrExtension276Fn {} + AmdExtension323Fn {} } } -impl KhrExtension276Fn { +impl AmdExtension323Fn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - KhrExtension276Fn {} + AmdExtension323Fn {} } } -impl ExtShaderDemoteToHelperInvocationFn { +impl KhrExtension324Fn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_shader_demote_to_helper_invocation\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_extension_324\0") .expect("Wrong extension string") } - pub const SPEC_VERSION: u32 = 1u32; + pub const SPEC_VERSION: u32 = 0u32; } -pub struct ExtShaderDemoteToHelperInvocationFn {} -unsafe impl Send for ExtShaderDemoteToHelperInvocationFn {} -unsafe impl Sync for ExtShaderDemoteToHelperInvocationFn {} -impl ::std::clone::Clone for ExtShaderDemoteToHelperInvocationFn { +pub struct KhrExtension324Fn {} +unsafe impl Send for KhrExtension324Fn {} +unsafe impl Sync for KhrExtension324Fn {} +impl ::std::clone::Clone for KhrExtension324Fn { fn clone(&self) -> Self { - ExtShaderDemoteToHelperInvocationFn {} + KhrExtension324Fn {} } } -impl ExtShaderDemoteToHelperInvocationFn { +impl KhrExtension324Fn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - ExtShaderDemoteToHelperInvocationFn {} + KhrExtension324Fn {} } } -#[doc = "Generated from \'VK_EXT_shader_demote_to_helper_invocation\'"] -impl StructureType { - pub const PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT: Self = - Self(1_000_276_000); +impl KhrExtension325Fn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_extension_325\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 0u32; } -impl NvDeviceGeneratedCommandsFn { +pub struct KhrExtension325Fn {} +unsafe impl Send for KhrExtension325Fn {} +unsafe impl Sync for KhrExtension325Fn {} +impl ::std::clone::Clone for KhrExtension325Fn { + fn clone(&self) -> Self { + KhrExtension325Fn {} + } +} +impl KhrExtension325Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + KhrExtension325Fn {} + } +} +impl KhrExtension326Fn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_device_generated_commands\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_extension_326\0") .expect("Wrong extension string") } - pub const SPEC_VERSION: u32 = 3u32; + pub const SPEC_VERSION: u32 = 0u32; +} +pub struct KhrExtension326Fn {} +unsafe impl Send for KhrExtension326Fn {} +unsafe impl Sync for KhrExtension326Fn {} +impl ::std::clone::Clone for KhrExtension326Fn { + fn clone(&self) -> Self { + KhrExtension326Fn {} + } +} +impl KhrExtension326Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + KhrExtension326Fn {} + } +} +impl NvFragmentShadingRateEnumsFn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_fragment_shading_rate_enums\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 1u32; } #[allow(non_camel_case_types)] -pub type PFN_vkGetGeneratedCommandsMemoryRequirementsNV = extern "system" fn( - device: Device, - p_info: *const GeneratedCommandsMemoryRequirementsInfoNV, - p_memory_requirements: *mut MemoryRequirements2, -) -> c_void; -#[allow(non_camel_case_types)] -pub type PFN_vkCmdPreprocessGeneratedCommandsNV = extern "system" fn( - command_buffer: CommandBuffer, - p_generated_commands_info: *const GeneratedCommandsInfoNV, -) -> c_void; -#[allow(non_camel_case_types)] -pub type PFN_vkCmdExecuteGeneratedCommandsNV = extern "system" fn( - command_buffer: CommandBuffer, - is_preprocessed: Bool32, - p_generated_commands_info: *const GeneratedCommandsInfoNV, -) -> c_void; -#[allow(non_camel_case_types)] -pub type PFN_vkCmdBindPipelineShaderGroupNV = extern "system" fn( - command_buffer: CommandBuffer, - pipeline_bind_point: PipelineBindPoint, - pipeline: Pipeline, - group_index: u32, -) -> c_void; -#[allow(non_camel_case_types)] -pub type PFN_vkCreateIndirectCommandsLayoutNV = extern "system" fn( - device: Device, - p_create_info: *const IndirectCommandsLayoutCreateInfoNV, - p_allocator: *const AllocationCallbacks, - p_indirect_commands_layout: *mut IndirectCommandsLayoutNV, -) -> Result; -#[allow(non_camel_case_types)] -pub type PFN_vkDestroyIndirectCommandsLayoutNV = extern "system" fn( - device: Device, - indirect_commands_layout: IndirectCommandsLayoutNV, - p_allocator: *const AllocationCallbacks, +pub type PFN_vkCmdSetFragmentShadingRateEnumNV = extern "system" fn( + command_buffer: CommandBuffer, + shading_rate: FragmentShadingRateNV, + combiner_ops: &[FragmentShadingRateCombinerOpKHR; 2], ) -> c_void; -pub struct NvDeviceGeneratedCommandsFn { - pub get_generated_commands_memory_requirements_nv: extern "system" fn( - device: Device, - p_info: *const GeneratedCommandsMemoryRequirementsInfoNV, - p_memory_requirements: *mut MemoryRequirements2, - ) -> c_void, - pub cmd_preprocess_generated_commands_nv: extern "system" fn( - command_buffer: CommandBuffer, - p_generated_commands_info: *const GeneratedCommandsInfoNV, - ) -> c_void, - pub cmd_execute_generated_commands_nv: extern "system" fn( - command_buffer: CommandBuffer, - is_preprocessed: Bool32, - p_generated_commands_info: *const GeneratedCommandsInfoNV, - ) -> c_void, - pub cmd_bind_pipeline_shader_group_nv: extern "system" fn( +pub struct NvFragmentShadingRateEnumsFn { + pub cmd_set_fragment_shading_rate_enum_nv: extern "system" fn( command_buffer: CommandBuffer, - pipeline_bind_point: PipelineBindPoint, - pipeline: Pipeline, - group_index: u32, - ) -> c_void, - pub create_indirect_commands_layout_nv: extern "system" fn( - device: Device, - p_create_info: *const IndirectCommandsLayoutCreateInfoNV, - p_allocator: *const AllocationCallbacks, - p_indirect_commands_layout: *mut IndirectCommandsLayoutNV, - ) -> Result, - pub destroy_indirect_commands_layout_nv: extern "system" fn( - device: Device, - indirect_commands_layout: IndirectCommandsLayoutNV, - p_allocator: *const AllocationCallbacks, + shading_rate: FragmentShadingRateNV, + combiner_ops: &[FragmentShadingRateCombinerOpKHR; 2], ) -> c_void, } -unsafe impl Send for NvDeviceGeneratedCommandsFn {} -unsafe impl Sync for NvDeviceGeneratedCommandsFn {} -impl ::std::clone::Clone for NvDeviceGeneratedCommandsFn { +unsafe impl Send for NvFragmentShadingRateEnumsFn {} +unsafe impl Sync for NvFragmentShadingRateEnumsFn {} +impl ::std::clone::Clone for NvFragmentShadingRateEnumsFn { fn clone(&self) -> Self { - NvDeviceGeneratedCommandsFn { - get_generated_commands_memory_requirements_nv: self - .get_generated_commands_memory_requirements_nv, - cmd_preprocess_generated_commands_nv: self.cmd_preprocess_generated_commands_nv, - cmd_execute_generated_commands_nv: self.cmd_execute_generated_commands_nv, - cmd_bind_pipeline_shader_group_nv: self.cmd_bind_pipeline_shader_group_nv, - create_indirect_commands_layout_nv: self.create_indirect_commands_layout_nv, - destroy_indirect_commands_layout_nv: self.destroy_indirect_commands_layout_nv, + NvFragmentShadingRateEnumsFn { + cmd_set_fragment_shading_rate_enum_nv: self.cmd_set_fragment_shading_rate_enum_nv, } } } -impl NvDeviceGeneratedCommandsFn { +impl NvFragmentShadingRateEnumsFn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - NvDeviceGeneratedCommandsFn { - get_generated_commands_memory_requirements_nv: unsafe { - extern "system" fn get_generated_commands_memory_requirements_nv( - _device: Device, - _p_info: *const GeneratedCommandsMemoryRequirementsInfoNV, - _p_memory_requirements: *mut MemoryRequirements2, - ) -> c_void { - panic!(concat!( - "Unable to load ", - stringify!(get_generated_commands_memory_requirements_nv) - )) - } - let raw_name = stringify!(vkGetGeneratedCommandsMemoryRequirementsNV); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - get_generated_commands_memory_requirements_nv - } else { - ::std::mem::transmute(val) - } - }, - cmd_preprocess_generated_commands_nv: unsafe { - extern "system" fn cmd_preprocess_generated_commands_nv( - _command_buffer: CommandBuffer, - _p_generated_commands_info: *const GeneratedCommandsInfoNV, - ) -> c_void { - panic!(concat!( - "Unable to load ", - stringify!(cmd_preprocess_generated_commands_nv) - )) - } - let raw_name = stringify!(vkCmdPreprocessGeneratedCommandsNV); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - cmd_preprocess_generated_commands_nv - } else { - ::std::mem::transmute(val) - } - }, - cmd_execute_generated_commands_nv: unsafe { - extern "system" fn cmd_execute_generated_commands_nv( - _command_buffer: CommandBuffer, - _is_preprocessed: Bool32, - _p_generated_commands_info: *const GeneratedCommandsInfoNV, - ) -> c_void { - panic!(concat!( - "Unable to load ", - stringify!(cmd_execute_generated_commands_nv) - )) - } - let raw_name = stringify!(vkCmdExecuteGeneratedCommandsNV); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - cmd_execute_generated_commands_nv - } else { - ::std::mem::transmute(val) - } - }, - cmd_bind_pipeline_shader_group_nv: unsafe { - extern "system" fn cmd_bind_pipeline_shader_group_nv( + NvFragmentShadingRateEnumsFn { + cmd_set_fragment_shading_rate_enum_nv: unsafe { + extern "system" fn cmd_set_fragment_shading_rate_enum_nv( _command_buffer: CommandBuffer, - _pipeline_bind_point: PipelineBindPoint, - _pipeline: Pipeline, - _group_index: u32, - ) -> c_void { - panic!(concat!( - "Unable to load ", - stringify!(cmd_bind_pipeline_shader_group_nv) - )) - } - let raw_name = stringify!(vkCmdBindPipelineShaderGroupNV); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - cmd_bind_pipeline_shader_group_nv - } else { - ::std::mem::transmute(val) - } - }, - create_indirect_commands_layout_nv: unsafe { - extern "system" fn create_indirect_commands_layout_nv( - _device: Device, - _p_create_info: *const IndirectCommandsLayoutCreateInfoNV, - _p_allocator: *const AllocationCallbacks, - _p_indirect_commands_layout: *mut IndirectCommandsLayoutNV, - ) -> Result { - panic!(concat!( - "Unable to load ", - stringify!(create_indirect_commands_layout_nv) - )) - } - let raw_name = stringify!(vkCreateIndirectCommandsLayoutNV); - let cname = ::std::ffi::CString::new(raw_name).unwrap(); - let val = _f(&cname); - if val.is_null() { - create_indirect_commands_layout_nv - } else { - ::std::mem::transmute(val) - } - }, - destroy_indirect_commands_layout_nv: unsafe { - extern "system" fn destroy_indirect_commands_layout_nv( - _device: Device, - _indirect_commands_layout: IndirectCommandsLayoutNV, - _p_allocator: *const AllocationCallbacks, + _shading_rate: FragmentShadingRateNV, + _combiner_ops: &[FragmentShadingRateCombinerOpKHR; 2], ) -> c_void { panic!(concat!( "Unable to load ", - stringify!(destroy_indirect_commands_layout_nv) + stringify!(cmd_set_fragment_shading_rate_enum_nv) )) } - let raw_name = stringify!(vkDestroyIndirectCommandsLayoutNV); + let raw_name = stringify!(vkCmdSetFragmentShadingRateEnumNV); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { - destroy_indirect_commands_layout_nv + cmd_set_fragment_shading_rate_enum_nv } else { ::std::mem::transmute(val) } }, } } - #[doc = ""] - pub unsafe fn get_generated_commands_memory_requirements_nv( - &self, - device: Device, - p_info: *const GeneratedCommandsMemoryRequirementsInfoNV, - p_memory_requirements: *mut MemoryRequirements2, - ) -> c_void { - (self.get_generated_commands_memory_requirements_nv)(device, p_info, p_memory_requirements) - } - #[doc = ""] - pub unsafe fn cmd_preprocess_generated_commands_nv( - &self, - command_buffer: CommandBuffer, - p_generated_commands_info: *const GeneratedCommandsInfoNV, - ) -> c_void { - (self.cmd_preprocess_generated_commands_nv)(command_buffer, p_generated_commands_info) - } - #[doc = ""] - pub unsafe fn cmd_execute_generated_commands_nv( - &self, - command_buffer: CommandBuffer, - is_preprocessed: Bool32, - p_generated_commands_info: *const GeneratedCommandsInfoNV, - ) -> c_void { - (self.cmd_execute_generated_commands_nv)( - command_buffer, - is_preprocessed, - p_generated_commands_info, - ) - } - #[doc = ""] - pub unsafe fn cmd_bind_pipeline_shader_group_nv( + #[doc = ""] + pub unsafe fn cmd_set_fragment_shading_rate_enum_nv( &self, command_buffer: CommandBuffer, - pipeline_bind_point: PipelineBindPoint, - pipeline: Pipeline, - group_index: u32, - ) -> c_void { - (self.cmd_bind_pipeline_shader_group_nv)( - command_buffer, - pipeline_bind_point, - pipeline, - group_index, - ) - } - #[doc = ""] - pub unsafe fn create_indirect_commands_layout_nv( - &self, - device: Device, - p_create_info: *const IndirectCommandsLayoutCreateInfoNV, - p_allocator: *const AllocationCallbacks, - p_indirect_commands_layout: *mut IndirectCommandsLayoutNV, - ) -> Result { - (self.create_indirect_commands_layout_nv)( - device, - p_create_info, - p_allocator, - p_indirect_commands_layout, - ) - } - #[doc = ""] - pub unsafe fn destroy_indirect_commands_layout_nv( - &self, - device: Device, - indirect_commands_layout: IndirectCommandsLayoutNV, - p_allocator: *const AllocationCallbacks, + shading_rate: FragmentShadingRateNV, + combiner_ops: &[FragmentShadingRateCombinerOpKHR; 2], ) -> c_void { - (self.destroy_indirect_commands_layout_nv)(device, indirect_commands_layout, p_allocator) + (self.cmd_set_fragment_shading_rate_enum_nv)(command_buffer, shading_rate, combiner_ops) } } -#[doc = "Generated from \'VK_NV_device_generated_commands\'"] -impl StructureType { - pub const PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV: Self = Self(1_000_277_000); -} -#[doc = "Generated from \'VK_NV_device_generated_commands\'"] -impl StructureType { - pub const GRAPHICS_SHADER_GROUP_CREATE_INFO_NV: Self = Self(1_000_277_001); -} -#[doc = "Generated from \'VK_NV_device_generated_commands\'"] -impl StructureType { - pub const GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV: Self = Self(1_000_277_002); -} -#[doc = "Generated from \'VK_NV_device_generated_commands\'"] -impl StructureType { - pub const INDIRECT_COMMANDS_LAYOUT_TOKEN_NV: Self = Self(1_000_277_003); -} -#[doc = "Generated from \'VK_NV_device_generated_commands\'"] -impl StructureType { - pub const INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NV: Self = Self(1_000_277_004); -} -#[doc = "Generated from \'VK_NV_device_generated_commands\'"] +#[doc = "Generated from \'VK_NV_fragment_shading_rate_enums\'"] impl StructureType { - pub const GENERATED_COMMANDS_INFO_NV: Self = Self(1_000_277_005); + pub const PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV: Self = Self(1_000_326_000); } -#[doc = "Generated from \'VK_NV_device_generated_commands\'"] +#[doc = "Generated from \'VK_NV_fragment_shading_rate_enums\'"] impl StructureType { - pub const GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_NV: Self = Self(1_000_277_006); + pub const PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV: Self = Self(1_000_326_001); } -#[doc = "Generated from \'VK_NV_device_generated_commands\'"] +#[doc = "Generated from \'VK_NV_fragment_shading_rate_enums\'"] impl StructureType { - pub const PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV: Self = Self(1_000_277_007); + pub const PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV: Self = Self(1_000_326_002); } -#[doc = "Generated from \'VK_NV_device_generated_commands\'"] -impl PipelineCreateFlags { - pub const INDIRECT_BINDABLE_NV: Self = Self(0b100_0000_0000_0000_0000); +impl NvExtension328Fn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_extension_328\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 0u32; } -#[doc = "Generated from \'VK_NV_device_generated_commands\'"] -impl PipelineStageFlags { - pub const COMMAND_PREPROCESS_NV: Self = Self(0b10_0000_0000_0000_0000); +pub struct NvExtension328Fn {} +unsafe impl Send for NvExtension328Fn {} +unsafe impl Sync for NvExtension328Fn {} +impl ::std::clone::Clone for NvExtension328Fn { + fn clone(&self) -> Self { + NvExtension328Fn {} + } } -#[doc = "Generated from \'VK_NV_device_generated_commands\'"] -impl AccessFlags { - pub const COMMAND_PREPROCESS_READ_NV: Self = Self(0b10_0000_0000_0000_0000); +impl NvExtension328Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + NvExtension328Fn {} + } } -#[doc = "Generated from \'VK_NV_device_generated_commands\'"] -impl AccessFlags { - pub const COMMAND_PREPROCESS_WRITE_NV: Self = Self(0b100_0000_0000_0000_0000); +impl NvExtension329Fn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_extension_329\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 0u32; } -#[doc = "Generated from \'VK_NV_device_generated_commands\'"] -impl ObjectType { - pub const INDIRECT_COMMANDS_LAYOUT_NV: Self = Self(1_000_277_000); +pub struct NvExtension329Fn {} +unsafe impl Send for NvExtension329Fn {} +unsafe impl Sync for NvExtension329Fn {} +impl ::std::clone::Clone for NvExtension329Fn { + fn clone(&self) -> Self { + NvExtension329Fn {} + } } -impl NvExtension279Fn { +impl NvExtension329Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + NvExtension329Fn {} + } +} +impl NvExtension330Fn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_extension_279\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_extension_330\0") .expect("Wrong extension string") } pub const SPEC_VERSION: u32 = 0u32; } -pub struct NvExtension279Fn {} -unsafe impl Send for NvExtension279Fn {} -unsafe impl Sync for NvExtension279Fn {} -impl ::std::clone::Clone for NvExtension279Fn { +pub struct NvExtension330Fn {} +unsafe impl Send for NvExtension330Fn {} +unsafe impl Sync for NvExtension330Fn {} +impl ::std::clone::Clone for NvExtension330Fn { fn clone(&self) -> Self { - NvExtension279Fn {} + NvExtension330Fn {} } } -impl NvExtension279Fn { +impl NvExtension330Fn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - NvExtension279Fn {} + NvExtension330Fn {} } } -impl KhrExtension280Fn { +impl NvExtension331Fn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_extension_280\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_extension_331\0") .expect("Wrong extension string") } pub const SPEC_VERSION: u32 = 0u32; } -pub struct KhrExtension280Fn {} -unsafe impl Send for KhrExtension280Fn {} -unsafe impl Sync for KhrExtension280Fn {} -impl ::std::clone::Clone for KhrExtension280Fn { +pub struct NvExtension331Fn {} +unsafe impl Send for NvExtension331Fn {} +unsafe impl Sync for NvExtension331Fn {} +impl ::std::clone::Clone for NvExtension331Fn { fn clone(&self) -> Self { - KhrExtension280Fn {} + NvExtension331Fn {} } } -impl KhrExtension280Fn { +impl NvExtension331Fn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - KhrExtension280Fn {} + NvExtension331Fn {} } } -impl ArmExtension281Fn { +impl NvExtension332Fn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_ARM_extension_281\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_extension_332\0") .expect("Wrong extension string") } pub const SPEC_VERSION: u32 = 0u32; } -pub struct ArmExtension281Fn {} -unsafe impl Send for ArmExtension281Fn {} -unsafe impl Sync for ArmExtension281Fn {} -impl ::std::clone::Clone for ArmExtension281Fn { +pub struct NvExtension332Fn {} +unsafe impl Send for NvExtension332Fn {} +unsafe impl Sync for NvExtension332Fn {} +impl ::std::clone::Clone for NvExtension332Fn { fn clone(&self) -> Self { - ArmExtension281Fn {} + NvExtension332Fn {} } } -impl ArmExtension281Fn { +impl NvExtension332Fn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - ArmExtension281Fn {} + NvExtension332Fn {} } } -impl ExtTexelBufferAlignmentFn { +impl ExtFragmentDensityMap2Fn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_texel_buffer_alignment\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_fragment_density_map2\0") .expect("Wrong extension string") } pub const SPEC_VERSION: u32 = 1u32; } -pub struct ExtTexelBufferAlignmentFn {} -unsafe impl Send for ExtTexelBufferAlignmentFn {} -unsafe impl Sync for ExtTexelBufferAlignmentFn {} -impl ::std::clone::Clone for ExtTexelBufferAlignmentFn { +pub struct ExtFragmentDensityMap2Fn {} +unsafe impl Send for ExtFragmentDensityMap2Fn {} +unsafe impl Sync for ExtFragmentDensityMap2Fn {} +impl ::std::clone::Clone for ExtFragmentDensityMap2Fn { fn clone(&self) -> Self { - ExtTexelBufferAlignmentFn {} + ExtFragmentDensityMap2Fn {} } } -impl ExtTexelBufferAlignmentFn { +impl ExtFragmentDensityMap2Fn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - ExtTexelBufferAlignmentFn {} + ExtFragmentDensityMap2Fn {} } } -#[doc = "Generated from \'VK_EXT_texel_buffer_alignment\'"] +#[doc = "Generated from \'VK_EXT_fragment_density_map2\'"] impl StructureType { - pub const PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT: Self = Self(1_000_281_000); + pub const PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT: Self = Self(1_000_332_000); } -#[doc = "Generated from \'VK_EXT_texel_buffer_alignment\'"] +#[doc = "Generated from \'VK_EXT_fragment_density_map2\'"] impl StructureType { - pub const PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT: Self = Self(1_000_281_001); + pub const PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT: Self = Self(1_000_332_001); } -impl QcomRenderPassTransformFn { +#[doc = "Generated from \'VK_EXT_fragment_density_map2\'"] +impl ImageViewCreateFlags { + pub const FRAGMENT_DENSITY_MAP_DEFERRED_EXT: Self = Self(0b10); +} +impl QcomRotatedCopyCommandsFn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_QCOM_render_pass_transform\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_QCOM_rotated_copy_commands\0") .expect("Wrong extension string") } - pub const SPEC_VERSION: u32 = 1u32; + pub const SPEC_VERSION: u32 = 0u32; } -pub struct QcomRenderPassTransformFn {} -unsafe impl Send for QcomRenderPassTransformFn {} -unsafe impl Sync for QcomRenderPassTransformFn {} -impl ::std::clone::Clone for QcomRenderPassTransformFn { +pub struct QcomRotatedCopyCommandsFn {} +unsafe impl Send for QcomRotatedCopyCommandsFn {} +unsafe impl Sync for QcomRotatedCopyCommandsFn {} +impl ::std::clone::Clone for QcomRotatedCopyCommandsFn { fn clone(&self) -> Self { - QcomRenderPassTransformFn {} + QcomRotatedCopyCommandsFn {} } } -impl QcomRenderPassTransformFn { +impl QcomRotatedCopyCommandsFn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - QcomRenderPassTransformFn {} + QcomRotatedCopyCommandsFn {} } } -#[doc = "Generated from \'VK_QCOM_render_pass_transform\'"] +#[doc = "Generated from \'VK_QCOM_rotated_copy_commands\'"] impl StructureType { - pub const COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM: Self = - Self(1_000_282_000); + pub const COPY_COMMAND_TRANSFORM_INFO_QCOM: Self = Self(1_000_333_000); } -#[doc = "Generated from \'VK_QCOM_render_pass_transform\'"] -impl StructureType { - pub const RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM: Self = Self(1_000_282_001); +impl KhrExtension335Fn { + pub fn name() -> &'static ::std::ffi::CStr { + ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_extension_335\0") + .expect("Wrong extension string") + } + pub const SPEC_VERSION: u32 = 0u32; } -#[doc = "Generated from \'VK_QCOM_render_pass_transform\'"] -impl RenderPassCreateFlags { - pub const TRANSFORM_QCOM: Self = Self(0b10); +pub struct KhrExtension335Fn {} +unsafe impl Send for KhrExtension335Fn {} +unsafe impl Sync for KhrExtension335Fn {} +impl ::std::clone::Clone for KhrExtension335Fn { + fn clone(&self) -> Self { + KhrExtension335Fn {} + } } -impl ExtExtension284Fn { +impl KhrExtension335Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + KhrExtension335Fn {} + } +} +impl ExtImageRobustnessFn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_extension_284\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_image_robustness\0") .expect("Wrong extension string") } - pub const SPEC_VERSION: u32 = 0u32; + pub const SPEC_VERSION: u32 = 1u32; } -pub struct ExtExtension284Fn {} -unsafe impl Send for ExtExtension284Fn {} -unsafe impl Sync for ExtExtension284Fn {} -impl ::std::clone::Clone for ExtExtension284Fn { +pub struct ExtImageRobustnessFn {} +unsafe impl Send for ExtImageRobustnessFn {} +unsafe impl Sync for ExtImageRobustnessFn {} +impl ::std::clone::Clone for ExtImageRobustnessFn { fn clone(&self) -> Self { - ExtExtension284Fn {} + ExtImageRobustnessFn {} } } -impl ExtExtension284Fn { +impl ExtImageRobustnessFn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - ExtExtension284Fn {} + ExtImageRobustnessFn {} } } -impl ExtExtension285Fn { +#[doc = "Generated from \'VK_EXT_image_robustness\'"] +impl StructureType { + pub const PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES_EXT: Self = Self(1_000_335_000); +} +impl KhrExtension337Fn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_extension_285\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_extension_337\0") .expect("Wrong extension string") } pub const SPEC_VERSION: u32 = 0u32; } -pub struct ExtExtension285Fn {} -unsafe impl Send for ExtExtension285Fn {} -unsafe impl Sync for ExtExtension285Fn {} -impl ::std::clone::Clone for ExtExtension285Fn { +pub struct KhrExtension337Fn {} +unsafe impl Send for KhrExtension337Fn {} +unsafe impl Sync for KhrExtension337Fn {} +impl ::std::clone::Clone for KhrExtension337Fn { fn clone(&self) -> Self { - ExtExtension285Fn {} + KhrExtension337Fn {} } } -impl ExtExtension285Fn { +impl KhrExtension337Fn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - ExtExtension285Fn {} + KhrExtension337Fn {} } } -impl ExtExtension286Fn { +impl KhrCopyCommands2Fn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_extension_286\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_copy_commands2\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_vkCmdCopyBuffer2KHR = extern "system" fn( + command_buffer: CommandBuffer, + p_copy_buffer_info: *const CopyBufferInfo2KHR, +) -> c_void; +#[allow(non_camel_case_types)] +pub type PFN_vkCmdCopyImage2KHR = extern "system" fn( + command_buffer: CommandBuffer, + p_copy_image_info: *const CopyImageInfo2KHR, +) -> c_void; +#[allow(non_camel_case_types)] +pub type PFN_vkCmdCopyBufferToImage2KHR = extern "system" fn( + command_buffer: CommandBuffer, + p_copy_buffer_to_image_info: *const CopyBufferToImageInfo2KHR, +) -> c_void; +#[allow(non_camel_case_types)] +pub type PFN_vkCmdCopyImageToBuffer2KHR = extern "system" fn( + command_buffer: CommandBuffer, + p_copy_image_to_buffer_info: *const CopyImageToBufferInfo2KHR, +) -> c_void; +#[allow(non_camel_case_types)] +pub type PFN_vkCmdBlitImage2KHR = extern "system" fn( + command_buffer: CommandBuffer, + p_blit_image_info: *const BlitImageInfo2KHR, +) -> c_void; +#[allow(non_camel_case_types)] +pub type PFN_vkCmdResolveImage2KHR = extern "system" fn( + command_buffer: CommandBuffer, + p_resolve_image_info: *const ResolveImageInfo2KHR, +) -> c_void; +pub struct KhrCopyCommands2Fn { + pub cmd_copy_buffer2_khr: extern "system" fn( + command_buffer: CommandBuffer, + p_copy_buffer_info: *const CopyBufferInfo2KHR, + ) -> c_void, + pub cmd_copy_image2_khr: extern "system" fn( + command_buffer: CommandBuffer, + p_copy_image_info: *const CopyImageInfo2KHR, + ) -> c_void, + pub cmd_copy_buffer_to_image2_khr: extern "system" fn( + command_buffer: CommandBuffer, + p_copy_buffer_to_image_info: *const CopyBufferToImageInfo2KHR, + ) -> c_void, + pub cmd_copy_image_to_buffer2_khr: extern "system" fn( + command_buffer: CommandBuffer, + p_copy_image_to_buffer_info: *const CopyImageToBufferInfo2KHR, + ) -> c_void, + pub cmd_blit_image2_khr: extern "system" fn( + command_buffer: CommandBuffer, + p_blit_image_info: *const BlitImageInfo2KHR, + ) -> c_void, + pub cmd_resolve_image2_khr: extern "system" fn( + command_buffer: CommandBuffer, + p_resolve_image_info: *const ResolveImageInfo2KHR, + ) -> c_void, +} +unsafe impl Send for KhrCopyCommands2Fn {} +unsafe impl Sync for KhrCopyCommands2Fn {} +impl ::std::clone::Clone for KhrCopyCommands2Fn { + fn clone(&self) -> Self { + KhrCopyCommands2Fn { + cmd_copy_buffer2_khr: self.cmd_copy_buffer2_khr, + cmd_copy_image2_khr: self.cmd_copy_image2_khr, + cmd_copy_buffer_to_image2_khr: self.cmd_copy_buffer_to_image2_khr, + cmd_copy_image_to_buffer2_khr: self.cmd_copy_image_to_buffer2_khr, + cmd_blit_image2_khr: self.cmd_blit_image2_khr, + cmd_resolve_image2_khr: self.cmd_resolve_image2_khr, + } + } +} +impl KhrCopyCommands2Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + KhrCopyCommands2Fn { + cmd_copy_buffer2_khr: unsafe { + extern "system" fn cmd_copy_buffer2_khr( + _command_buffer: CommandBuffer, + _p_copy_buffer_info: *const CopyBufferInfo2KHR, + ) -> c_void { + panic!(concat!("Unable to load ", stringify!(cmd_copy_buffer2_khr))) + } + let raw_name = stringify!(vkCmdCopyBuffer2KHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + cmd_copy_buffer2_khr + } else { + ::std::mem::transmute(val) + } + }, + cmd_copy_image2_khr: unsafe { + extern "system" fn cmd_copy_image2_khr( + _command_buffer: CommandBuffer, + _p_copy_image_info: *const CopyImageInfo2KHR, + ) -> c_void { + panic!(concat!("Unable to load ", stringify!(cmd_copy_image2_khr))) + } + let raw_name = stringify!(vkCmdCopyImage2KHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + cmd_copy_image2_khr + } else { + ::std::mem::transmute(val) + } + }, + cmd_copy_buffer_to_image2_khr: unsafe { + extern "system" fn cmd_copy_buffer_to_image2_khr( + _command_buffer: CommandBuffer, + _p_copy_buffer_to_image_info: *const CopyBufferToImageInfo2KHR, + ) -> c_void { + panic!(concat!( + "Unable to load ", + stringify!(cmd_copy_buffer_to_image2_khr) + )) + } + let raw_name = stringify!(vkCmdCopyBufferToImage2KHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + cmd_copy_buffer_to_image2_khr + } else { + ::std::mem::transmute(val) + } + }, + cmd_copy_image_to_buffer2_khr: unsafe { + extern "system" fn cmd_copy_image_to_buffer2_khr( + _command_buffer: CommandBuffer, + _p_copy_image_to_buffer_info: *const CopyImageToBufferInfo2KHR, + ) -> c_void { + panic!(concat!( + "Unable to load ", + stringify!(cmd_copy_image_to_buffer2_khr) + )) + } + let raw_name = stringify!(vkCmdCopyImageToBuffer2KHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + cmd_copy_image_to_buffer2_khr + } else { + ::std::mem::transmute(val) + } + }, + cmd_blit_image2_khr: unsafe { + extern "system" fn cmd_blit_image2_khr( + _command_buffer: CommandBuffer, + _p_blit_image_info: *const BlitImageInfo2KHR, + ) -> c_void { + panic!(concat!("Unable to load ", stringify!(cmd_blit_image2_khr))) + } + let raw_name = stringify!(vkCmdBlitImage2KHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + cmd_blit_image2_khr + } else { + ::std::mem::transmute(val) + } + }, + cmd_resolve_image2_khr: unsafe { + extern "system" fn cmd_resolve_image2_khr( + _command_buffer: CommandBuffer, + _p_resolve_image_info: *const ResolveImageInfo2KHR, + ) -> c_void { + panic!(concat!( + "Unable to load ", + stringify!(cmd_resolve_image2_khr) + )) + } + let raw_name = stringify!(vkCmdResolveImage2KHR); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + cmd_resolve_image2_khr + } else { + ::std::mem::transmute(val) + } + }, + } + } + #[doc = ""] + pub unsafe fn cmd_copy_buffer2_khr( + &self, + command_buffer: CommandBuffer, + p_copy_buffer_info: *const CopyBufferInfo2KHR, + ) -> c_void { + (self.cmd_copy_buffer2_khr)(command_buffer, p_copy_buffer_info) + } + #[doc = ""] + pub unsafe fn cmd_copy_image2_khr( + &self, + command_buffer: CommandBuffer, + p_copy_image_info: *const CopyImageInfo2KHR, + ) -> c_void { + (self.cmd_copy_image2_khr)(command_buffer, p_copy_image_info) + } + #[doc = ""] + pub unsafe fn cmd_copy_buffer_to_image2_khr( + &self, + command_buffer: CommandBuffer, + p_copy_buffer_to_image_info: *const CopyBufferToImageInfo2KHR, + ) -> c_void { + (self.cmd_copy_buffer_to_image2_khr)(command_buffer, p_copy_buffer_to_image_info) + } + #[doc = ""] + pub unsafe fn cmd_copy_image_to_buffer2_khr( + &self, + command_buffer: CommandBuffer, + p_copy_image_to_buffer_info: *const CopyImageToBufferInfo2KHR, + ) -> c_void { + (self.cmd_copy_image_to_buffer2_khr)(command_buffer, p_copy_image_to_buffer_info) + } + #[doc = ""] + pub unsafe fn cmd_blit_image2_khr( + &self, + command_buffer: CommandBuffer, + p_blit_image_info: *const BlitImageInfo2KHR, + ) -> c_void { + (self.cmd_blit_image2_khr)(command_buffer, p_blit_image_info) + } + #[doc = ""] + pub unsafe fn cmd_resolve_image2_khr( + &self, + command_buffer: CommandBuffer, + p_resolve_image_info: *const ResolveImageInfo2KHR, + ) -> c_void { + (self.cmd_resolve_image2_khr)(command_buffer, p_resolve_image_info) + } } -pub struct ExtExtension286Fn {} -unsafe impl Send for ExtExtension286Fn {} -unsafe impl Sync for ExtExtension286Fn {} -impl ::std::clone::Clone for ExtExtension286Fn { - fn clone(&self) -> Self { - ExtExtension286Fn {} - } +#[doc = "Generated from \'VK_KHR_copy_commands2\'"] +impl StructureType { + pub const COPY_BUFFER_INFO_2_KHR: Self = Self(1_000_337_000); } -impl ExtExtension286Fn { - pub fn load(mut _f: F) -> Self - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - ExtExtension286Fn {} - } +#[doc = "Generated from \'VK_KHR_copy_commands2\'"] +impl StructureType { + pub const COPY_IMAGE_INFO_2_KHR: Self = Self(1_000_337_001); } -impl NvxExtension287Fn { - pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_NVX_extension_287\0") - .expect("Wrong extension string") - } - pub const SPEC_VERSION: u32 = 0u32; +#[doc = "Generated from \'VK_KHR_copy_commands2\'"] +impl StructureType { + pub const COPY_BUFFER_TO_IMAGE_INFO_2_KHR: Self = Self(1_000_337_002); } -pub struct NvxExtension287Fn {} -unsafe impl Send for NvxExtension287Fn {} -unsafe impl Sync for NvxExtension287Fn {} -impl ::std::clone::Clone for NvxExtension287Fn { - fn clone(&self) -> Self { - NvxExtension287Fn {} - } +#[doc = "Generated from \'VK_KHR_copy_commands2\'"] +impl StructureType { + pub const COPY_IMAGE_TO_BUFFER_INFO_2_KHR: Self = Self(1_000_337_003); } -impl NvxExtension287Fn { - pub fn load(mut _f: F) -> Self - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - NvxExtension287Fn {} - } +#[doc = "Generated from \'VK_KHR_copy_commands2\'"] +impl StructureType { + pub const BLIT_IMAGE_INFO_2_KHR: Self = Self(1_000_337_004); } -impl NvxExtension288Fn { - pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_NVX_extension_288\0") - .expect("Wrong extension string") - } - pub const SPEC_VERSION: u32 = 0u32; +#[doc = "Generated from \'VK_KHR_copy_commands2\'"] +impl StructureType { + pub const RESOLVE_IMAGE_INFO_2_KHR: Self = Self(1_000_337_005); } -pub struct NvxExtension288Fn {} -unsafe impl Send for NvxExtension288Fn {} -unsafe impl Sync for NvxExtension288Fn {} -impl ::std::clone::Clone for NvxExtension288Fn { - fn clone(&self) -> Self { - NvxExtension288Fn {} - } +#[doc = "Generated from \'VK_KHR_copy_commands2\'"] +impl StructureType { + pub const BUFFER_COPY_2_KHR: Self = Self(1_000_337_006); } -impl NvxExtension288Fn { - pub fn load(mut _f: F) -> Self - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - NvxExtension288Fn {} - } +#[doc = "Generated from \'VK_KHR_copy_commands2\'"] +impl StructureType { + pub const IMAGE_COPY_2_KHR: Self = Self(1_000_337_007); } -impl ExtExtension289Fn { +#[doc = "Generated from \'VK_KHR_copy_commands2\'"] +impl StructureType { + pub const IMAGE_BLIT_2_KHR: Self = Self(1_000_337_008); +} +#[doc = "Generated from \'VK_KHR_copy_commands2\'"] +impl StructureType { + pub const BUFFER_IMAGE_COPY_2_KHR: Self = Self(1_000_337_009); +} +#[doc = "Generated from \'VK_KHR_copy_commands2\'"] +impl StructureType { + pub const IMAGE_RESOLVE_2_KHR: Self = Self(1_000_337_010); +} +impl ArmExtension339Fn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_extension_289\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_ARM_extension_339\0") .expect("Wrong extension string") } pub const SPEC_VERSION: u32 = 0u32; } -pub struct ExtExtension289Fn {} -unsafe impl Send for ExtExtension289Fn {} -unsafe impl Sync for ExtExtension289Fn {} -impl ::std::clone::Clone for ExtExtension289Fn { +pub struct ArmExtension339Fn {} +unsafe impl Send for ArmExtension339Fn {} +unsafe impl Sync for ArmExtension339Fn {} +impl ::std::clone::Clone for ArmExtension339Fn { fn clone(&self) -> Self { - ExtExtension289Fn {} + ArmExtension339Fn {} } } -impl ExtExtension289Fn { +impl ArmExtension339Fn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - ExtExtension289Fn {} + ArmExtension339Fn {} } } -impl GoogleUserTypeFn { +impl ExtExtension340Fn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_GOOGLE_user_type\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_extension_340\0") .expect("Wrong extension string") } - pub const SPEC_VERSION: u32 = 1u32; + pub const SPEC_VERSION: u32 = 0u32; } -pub struct GoogleUserTypeFn {} -unsafe impl Send for GoogleUserTypeFn {} -unsafe impl Sync for GoogleUserTypeFn {} -impl ::std::clone::Clone for GoogleUserTypeFn { +pub struct ExtExtension340Fn {} +unsafe impl Send for ExtExtension340Fn {} +unsafe impl Sync for ExtExtension340Fn {} +impl ::std::clone::Clone for ExtExtension340Fn { fn clone(&self) -> Self { - GoogleUserTypeFn {} + ExtExtension340Fn {} } } -impl GoogleUserTypeFn { +impl ExtExtension340Fn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - GoogleUserTypeFn {} + ExtExtension340Fn {} } } -impl KhrPipelineLibraryFn { +impl Ext4444FormatsFn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_pipeline_library\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_4444_formats\0") .expect("Wrong extension string") } pub const SPEC_VERSION: u32 = 1u32; } -pub struct KhrPipelineLibraryFn {} -unsafe impl Send for KhrPipelineLibraryFn {} -unsafe impl Sync for KhrPipelineLibraryFn {} -impl ::std::clone::Clone for KhrPipelineLibraryFn { +pub struct Ext4444FormatsFn {} +unsafe impl Send for Ext4444FormatsFn {} +unsafe impl Sync for Ext4444FormatsFn {} +impl ::std::clone::Clone for Ext4444FormatsFn { fn clone(&self) -> Self { - KhrPipelineLibraryFn {} + Ext4444FormatsFn {} } } -impl KhrPipelineLibraryFn { +impl Ext4444FormatsFn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - KhrPipelineLibraryFn {} + Ext4444FormatsFn {} } } -#[doc = "Generated from \'VK_KHR_pipeline_library\'"] -impl PipelineCreateFlags { - pub const LIBRARY_KHR: Self = Self(0b1000_0000_0000); -} -#[doc = "Generated from \'VK_KHR_pipeline_library\'"] +#[doc = "Generated from \'VK_EXT_4444_formats\'"] impl StructureType { - pub const PIPELINE_LIBRARY_CREATE_INFO_KHR: Self = Self(1_000_290_000); -} -impl NvExtension292Fn { - pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_extension_292\0") - .expect("Wrong extension string") - } - pub const SPEC_VERSION: u32 = 0u32; + pub const PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT: Self = Self(1_000_340_000); } -pub struct NvExtension292Fn {} -unsafe impl Send for NvExtension292Fn {} -unsafe impl Sync for NvExtension292Fn {} -impl ::std::clone::Clone for NvExtension292Fn { - fn clone(&self) -> Self { - NvExtension292Fn {} - } +#[doc = "Generated from \'VK_EXT_4444_formats\'"] +impl Format { + pub const A4R4G4B4_UNORM_PACK16_EXT: Self = Self(1_000_340_000); } -impl NvExtension292Fn { - pub fn load(mut _f: F) -> Self - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - NvExtension292Fn {} - } +#[doc = "Generated from \'VK_EXT_4444_formats\'"] +impl Format { + pub const A4B4G4R4_UNORM_PACK16_EXT: Self = Self(1_000_340_001); } -impl NvExtension293Fn { +impl ExtExtension342Fn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_extension_293\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_extension_342\0") .expect("Wrong extension string") } pub const SPEC_VERSION: u32 = 0u32; } -pub struct NvExtension293Fn {} -unsafe impl Send for NvExtension293Fn {} -unsafe impl Sync for NvExtension293Fn {} -impl ::std::clone::Clone for NvExtension293Fn { +pub struct ExtExtension342Fn {} +unsafe impl Send for ExtExtension342Fn {} +unsafe impl Sync for ExtExtension342Fn {} +impl ::std::clone::Clone for ExtExtension342Fn { fn clone(&self) -> Self { - NvExtension293Fn {} + ExtExtension342Fn {} } } -impl NvExtension293Fn { +impl ExtExtension342Fn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - NvExtension293Fn {} + ExtExtension342Fn {} } } -impl KhrShaderNonSemanticInfoFn { +impl ArmExtension343Fn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_shader_non_semantic_info\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_ARM_extension_343\0") .expect("Wrong extension string") } - pub const SPEC_VERSION: u32 = 1u32; + pub const SPEC_VERSION: u32 = 0u32; } -pub struct KhrShaderNonSemanticInfoFn {} -unsafe impl Send for KhrShaderNonSemanticInfoFn {} -unsafe impl Sync for KhrShaderNonSemanticInfoFn {} -impl ::std::clone::Clone for KhrShaderNonSemanticInfoFn { +pub struct ArmExtension343Fn {} +unsafe impl Send for ArmExtension343Fn {} +unsafe impl Sync for ArmExtension343Fn {} +impl ::std::clone::Clone for ArmExtension343Fn { fn clone(&self) -> Self { - KhrShaderNonSemanticInfoFn {} + ArmExtension343Fn {} } } -impl KhrShaderNonSemanticInfoFn { +impl ArmExtension343Fn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - KhrShaderNonSemanticInfoFn {} + ArmExtension343Fn {} } } -impl KhrExtension295Fn { +impl ArmExtension344Fn { 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_ARM_extension_344\0") .expect("Wrong extension string") } pub const SPEC_VERSION: u32 = 0u32; } -pub struct KhrExtension295Fn {} -unsafe impl Send for KhrExtension295Fn {} -unsafe impl Sync for KhrExtension295Fn {} -impl ::std::clone::Clone for KhrExtension295Fn { +pub struct ArmExtension344Fn {} +unsafe impl Send for ArmExtension344Fn {} +unsafe impl Sync for ArmExtension344Fn {} +impl ::std::clone::Clone for ArmExtension344Fn { fn clone(&self) -> Self { - KhrExtension295Fn {} + ArmExtension344Fn {} } } -impl KhrExtension295Fn { +impl ArmExtension344Fn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - KhrExtension295Fn {} + ArmExtension344Fn {} } } -impl NvExtension296Fn { +impl ArmExtension345Fn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_extension_296\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_ARM_extension_345\0") .expect("Wrong extension string") } pub const SPEC_VERSION: u32 = 0u32; } -pub struct NvExtension296Fn {} -unsafe impl Send for NvExtension296Fn {} -unsafe impl Sync for NvExtension296Fn {} -impl ::std::clone::Clone for NvExtension296Fn { +pub struct ArmExtension345Fn {} +unsafe impl Send for ArmExtension345Fn {} +unsafe impl Sync for ArmExtension345Fn {} +impl ::std::clone::Clone for ArmExtension345Fn { fn clone(&self) -> Self { - NvExtension296Fn {} + ArmExtension345Fn {} } } -impl NvExtension296Fn { +impl ArmExtension345Fn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - NvExtension296Fn {} + ArmExtension345Fn {} } } -impl KhrExtension297Fn { +impl NvExtension346Fn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_extension_297\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_extension_346\0") .expect("Wrong extension string") } pub const SPEC_VERSION: u32 = 0u32; } -pub struct KhrExtension297Fn {} -unsafe impl Send for KhrExtension297Fn {} -unsafe impl Sync for KhrExtension297Fn {} -impl ::std::clone::Clone for KhrExtension297Fn { +pub struct NvExtension346Fn {} +unsafe impl Send for NvExtension346Fn {} +unsafe impl Sync for NvExtension346Fn {} +impl ::std::clone::Clone for NvExtension346Fn { fn clone(&self) -> Self { - KhrExtension297Fn {} + NvExtension346Fn {} } } -impl KhrExtension297Fn { +impl NvExtension346Fn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - KhrExtension297Fn {} + NvExtension346Fn {} } } -#[doc = "Generated from \'VK_KHR_extension_297\'"] -impl PipelineShaderStageCreateFlags { - pub const RESERVED_3_KHR: Self = Self(0b1000); -} -impl ExtPipelineCreationCacheControlFn { +impl ExtDirectfbSurfaceFn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_pipeline_creation_cache_control\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_directfb_surface\0") .expect("Wrong extension string") } - pub const SPEC_VERSION: u32 = 2u32; -} -pub struct ExtPipelineCreationCacheControlFn {} -unsafe impl Send for ExtPipelineCreationCacheControlFn {} -unsafe impl Sync for ExtPipelineCreationCacheControlFn {} -impl ::std::clone::Clone for ExtPipelineCreationCacheControlFn { - fn clone(&self) -> Self { - ExtPipelineCreationCacheControlFn {} - } -} -impl ExtPipelineCreationCacheControlFn { - pub fn load(mut _f: F) -> Self - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - ExtPipelineCreationCacheControlFn {} - } -} -#[doc = "Generated from \'VK_EXT_pipeline_creation_cache_control\'"] -impl StructureType { - pub const PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES_EXT: Self = - Self(1_000_297_000); -} -#[doc = "Generated from \'VK_EXT_pipeline_creation_cache_control\'"] -impl PipelineCreateFlags { - pub const FAIL_ON_PIPELINE_COMPILE_REQUIRED_EXT: Self = Self(0b1_0000_0000); -} -#[doc = "Generated from \'VK_EXT_pipeline_creation_cache_control\'"] -impl PipelineCreateFlags { - pub const EARLY_RETURN_ON_FAILURE_EXT: Self = Self(0b10_0000_0000); -} -#[doc = "Generated from \'VK_EXT_pipeline_creation_cache_control\'"] -impl Result { - pub const ERROR_PIPELINE_COMPILE_REQUIRED_EXT: Self = Self(1_000_297_000); -} -#[doc = "Generated from \'VK_EXT_pipeline_creation_cache_control\'"] -impl PipelineCacheCreateFlags { - pub const EXTERNALLY_SYNCHRONIZED_EXT: Self = Self(0b1); + pub const SPEC_VERSION: u32 = 1u32; } -impl KhrExtension299Fn { - pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_extension_299\0") - .expect("Wrong extension string") - } - pub const SPEC_VERSION: u32 = 0u32; +#[allow(non_camel_case_types)] +pub type PFN_vkCreateDirectFBSurfaceEXT = extern "system" fn( + instance: Instance, + p_create_info: *const DirectFBSurfaceCreateInfoEXT, + p_allocator: *const AllocationCallbacks, + p_surface: *mut SurfaceKHR, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetPhysicalDeviceDirectFBPresentationSupportEXT = extern "system" fn( + physical_device: PhysicalDevice, + queue_family_index: u32, + dfb: *mut IDirectFB, +) -> Bool32; +pub struct ExtDirectfbSurfaceFn { + pub create_direct_fb_surface_ext: extern "system" fn( + instance: Instance, + p_create_info: *const DirectFBSurfaceCreateInfoEXT, + p_allocator: *const AllocationCallbacks, + p_surface: *mut SurfaceKHR, + ) -> Result, + pub get_physical_device_direct_fb_presentation_support_ext: extern "system" fn( + physical_device: PhysicalDevice, + queue_family_index: u32, + dfb: *mut IDirectFB, + ) -> Bool32, } -pub struct KhrExtension299Fn {} -unsafe impl Send for KhrExtension299Fn {} -unsafe impl Sync for KhrExtension299Fn {} -impl ::std::clone::Clone for KhrExtension299Fn { +unsafe impl Send for ExtDirectfbSurfaceFn {} +unsafe impl Sync for ExtDirectfbSurfaceFn {} +impl ::std::clone::Clone for ExtDirectfbSurfaceFn { fn clone(&self) -> Self { - KhrExtension299Fn {} + ExtDirectfbSurfaceFn { + create_direct_fb_surface_ext: self.create_direct_fb_surface_ext, + get_physical_device_direct_fb_presentation_support_ext: self + .get_physical_device_direct_fb_presentation_support_ext, + } } } -impl KhrExtension299Fn { +impl ExtDirectfbSurfaceFn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - KhrExtension299Fn {} - } -} -impl KhrExtension300Fn { - pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_extension_300\0") - .expect("Wrong extension string") + ExtDirectfbSurfaceFn { + create_direct_fb_surface_ext: unsafe { + extern "system" fn create_direct_fb_surface_ext( + _instance: Instance, + _p_create_info: *const DirectFBSurfaceCreateInfoEXT, + _p_allocator: *const AllocationCallbacks, + _p_surface: *mut SurfaceKHR, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(create_direct_fb_surface_ext) + )) + } + let raw_name = stringify!(vkCreateDirectFBSurfaceEXT); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + create_direct_fb_surface_ext + } else { + ::std::mem::transmute(val) + } + }, + get_physical_device_direct_fb_presentation_support_ext: unsafe { + 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 raw_name = stringify!(vkGetPhysicalDeviceDirectFBPresentationSupportEXT); + let cname = ::std::ffi::CString::new(raw_name).unwrap(); + let val = _f(&cname); + if val.is_null() { + get_physical_device_direct_fb_presentation_support_ext + } else { + ::std::mem::transmute(val) + } + }, + } } - pub const SPEC_VERSION: u32 = 0u32; -} -pub struct KhrExtension300Fn {} -unsafe impl Send for KhrExtension300Fn {} -unsafe impl Sync for KhrExtension300Fn {} -impl ::std::clone::Clone for KhrExtension300Fn { - fn clone(&self) -> Self { - KhrExtension300Fn {} + #[doc = ""] + pub unsafe fn create_direct_fb_surface_ext( + &self, + instance: Instance, + p_create_info: *const DirectFBSurfaceCreateInfoEXT, + p_allocator: *const AllocationCallbacks, + p_surface: *mut SurfaceKHR, + ) -> Result { + (self.create_direct_fb_surface_ext)(instance, p_create_info, p_allocator, p_surface) } -} -impl KhrExtension300Fn { - pub fn load(mut _f: F) -> Self - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - KhrExtension300Fn {} + #[doc = ""] + pub unsafe fn get_physical_device_direct_fb_presentation_support_ext( + &self, + physical_device: PhysicalDevice, + queue_family_index: u32, + dfb: *mut IDirectFB, + ) -> Bool32 { + (self.get_physical_device_direct_fb_presentation_support_ext)( + physical_device, + queue_family_index, + dfb, + ) } } -impl NvDeviceDiagnosticsConfigFn { +#[doc = "Generated from \'VK_EXT_directfb_surface\'"] +impl StructureType { + pub const DIRECTFB_SURFACE_CREATE_INFO_EXT: Self = Self(1_000_346_000); +} +impl KhrExtension350Fn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_device_diagnostics_config\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_extension_350\0") .expect("Wrong extension string") } - pub const SPEC_VERSION: u32 = 1u32; + pub const SPEC_VERSION: u32 = 0u32; } -pub struct NvDeviceDiagnosticsConfigFn {} -unsafe impl Send for NvDeviceDiagnosticsConfigFn {} -unsafe impl Sync for NvDeviceDiagnosticsConfigFn {} -impl ::std::clone::Clone for NvDeviceDiagnosticsConfigFn { +pub struct KhrExtension350Fn {} +unsafe impl Send for KhrExtension350Fn {} +unsafe impl Sync for KhrExtension350Fn {} +impl ::std::clone::Clone for KhrExtension350Fn { fn clone(&self) -> Self { - NvDeviceDiagnosticsConfigFn {} + KhrExtension350Fn {} } } -impl NvDeviceDiagnosticsConfigFn { +impl KhrExtension350Fn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - NvDeviceDiagnosticsConfigFn {} + KhrExtension350Fn {} } } -#[doc = "Generated from \'VK_NV_device_diagnostics_config\'"] -impl StructureType { - pub const PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV: Self = Self(1_000_300_000); -} -#[doc = "Generated from \'VK_NV_device_diagnostics_config\'"] -impl StructureType { - pub const DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV: Self = Self(1_000_300_001); +#[doc = "Generated from \'VK_KHR_extension_350\'"] +impl PipelineCacheCreateFlags { + pub const RESERVED_2_EXT: Self = Self(0b100); } -impl QcomExtension302Fn { +impl NvExtension351Fn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_QCOM_extension_302\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_extension_351\0") .expect("Wrong extension string") } pub const SPEC_VERSION: u32 = 0u32; } -pub struct QcomExtension302Fn {} -unsafe impl Send for QcomExtension302Fn {} -unsafe impl Sync for QcomExtension302Fn {} -impl ::std::clone::Clone for QcomExtension302Fn { +pub struct NvExtension351Fn {} +unsafe impl Send for NvExtension351Fn {} +unsafe impl Sync for NvExtension351Fn {} +impl ::std::clone::Clone for NvExtension351Fn { fn clone(&self) -> Self { - QcomExtension302Fn {} + NvExtension351Fn {} } } -impl QcomExtension302Fn { +impl NvExtension351Fn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - QcomExtension302Fn {} + NvExtension351Fn {} } } -impl QcomExtension303Fn { +impl ExtExtension352Fn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_QCOM_extension_303\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_extension_352\0") .expect("Wrong extension string") } pub const SPEC_VERSION: u32 = 0u32; } -pub struct QcomExtension303Fn {} -unsafe impl Send for QcomExtension303Fn {} -unsafe impl Sync for QcomExtension303Fn {} -impl ::std::clone::Clone for QcomExtension303Fn { +pub struct ExtExtension352Fn {} +unsafe impl Send for ExtExtension352Fn {} +unsafe impl Sync for ExtExtension352Fn {} +impl ::std::clone::Clone for ExtExtension352Fn { fn clone(&self) -> Self { - QcomExtension303Fn {} + ExtExtension352Fn {} } } -impl QcomExtension303Fn { +impl ExtExtension352Fn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - QcomExtension303Fn {} + ExtExtension352Fn {} } } -impl QcomExtension304Fn { +impl ExtExtension353Fn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_QCOM_extension_304\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_extension_353\0") .expect("Wrong extension string") } pub const SPEC_VERSION: u32 = 0u32; } -pub struct QcomExtension304Fn {} -unsafe impl Send for QcomExtension304Fn {} -unsafe impl Sync for QcomExtension304Fn {} -impl ::std::clone::Clone for QcomExtension304Fn { +pub struct ExtExtension353Fn {} +unsafe impl Send for ExtExtension353Fn {} +unsafe impl Sync for ExtExtension353Fn {} +impl ::std::clone::Clone for ExtExtension353Fn { fn clone(&self) -> Self { - QcomExtension304Fn {} + ExtExtension353Fn {} } } -impl QcomExtension304Fn { +impl ExtExtension353Fn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - QcomExtension304Fn {} + ExtExtension353Fn {} } } -impl QcomExtension305Fn { +impl ExtExtension354Fn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_QCOM_extension_305\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_extension_354\0") .expect("Wrong extension string") } pub const SPEC_VERSION: u32 = 0u32; } -pub struct QcomExtension305Fn {} -unsafe impl Send for QcomExtension305Fn {} -unsafe impl Sync for QcomExtension305Fn {} -impl ::std::clone::Clone for QcomExtension305Fn { +pub struct ExtExtension354Fn {} +unsafe impl Send for ExtExtension354Fn {} +unsafe impl Sync for ExtExtension354Fn {} +impl ::std::clone::Clone for ExtExtension354Fn { fn clone(&self) -> Self { - QcomExtension305Fn {} + ExtExtension354Fn {} } } -impl QcomExtension305Fn { +impl ExtExtension354Fn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - QcomExtension305Fn {} + ExtExtension354Fn {} } } -impl QcomExtension306Fn { +impl ExtExtension355Fn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_QCOM_extension_306\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_extension_355\0") .expect("Wrong extension string") } pub const SPEC_VERSION: u32 = 0u32; } -pub struct QcomExtension306Fn {} -unsafe impl Send for QcomExtension306Fn {} -unsafe impl Sync for QcomExtension306Fn {} -impl ::std::clone::Clone for QcomExtension306Fn { +pub struct ExtExtension355Fn {} +unsafe impl Send for ExtExtension355Fn {} +unsafe impl Sync for ExtExtension355Fn {} +impl ::std::clone::Clone for ExtExtension355Fn { fn clone(&self) -> Self { - QcomExtension306Fn {} + ExtExtension355Fn {} } } -impl QcomExtension306Fn { +impl ExtExtension355Fn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - QcomExtension306Fn {} + ExtExtension355Fn {} } } -impl QcomExtension307Fn { +impl ExtVertexAttributeAliasingFn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_QCOM_extension_307\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_vertex_attribute_aliasing\0") .expect("Wrong extension string") } pub const SPEC_VERSION: u32 = 0u32; } -pub struct QcomExtension307Fn {} -unsafe impl Send for QcomExtension307Fn {} -unsafe impl Sync for QcomExtension307Fn {} -impl ::std::clone::Clone for QcomExtension307Fn { +pub struct ExtVertexAttributeAliasingFn {} +unsafe impl Send for ExtVertexAttributeAliasingFn {} +unsafe impl Sync for ExtVertexAttributeAliasingFn {} +impl ::std::clone::Clone for ExtVertexAttributeAliasingFn { fn clone(&self) -> Self { - QcomExtension307Fn {} + ExtVertexAttributeAliasingFn {} } } -impl QcomExtension307Fn { +impl ExtVertexAttributeAliasingFn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - QcomExtension307Fn {} + ExtVertexAttributeAliasingFn {} } } -impl NvExtension308Fn { +impl ExtExtension357Fn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_extension_308\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_extension_357\0") .expect("Wrong extension string") } - pub const SPEC_VERSION: u32 = 0u32; } -pub struct NvExtension308Fn {} -unsafe impl Send for NvExtension308Fn {} -unsafe impl Sync for NvExtension308Fn {} -impl ::std::clone::Clone for NvExtension308Fn { +pub struct ExtExtension357Fn {} +unsafe impl Send for ExtExtension357Fn {} +unsafe impl Sync for ExtExtension357Fn {} +impl ::std::clone::Clone for ExtExtension357Fn { fn clone(&self) -> Self { - NvExtension308Fn {} + ExtExtension357Fn {} } } -impl NvExtension308Fn { +impl ExtExtension357Fn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - NvExtension308Fn {} + ExtExtension357Fn {} } } -impl KhrExtension309Fn { +impl KhrExtension358Fn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_extension_309\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_extension_358\0") .expect("Wrong extension string") } pub const SPEC_VERSION: u32 = 0u32; } -pub struct KhrExtension309Fn {} -unsafe impl Send for KhrExtension309Fn {} -unsafe impl Sync for KhrExtension309Fn {} -impl ::std::clone::Clone for KhrExtension309Fn { +pub struct KhrExtension358Fn {} +unsafe impl Send for KhrExtension358Fn {} +unsafe impl Sync for KhrExtension358Fn {} +impl ::std::clone::Clone for KhrExtension358Fn { fn clone(&self) -> Self { - KhrExtension309Fn {} + KhrExtension358Fn {} } } -impl KhrExtension309Fn { +impl KhrExtension358Fn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - KhrExtension309Fn {} + KhrExtension358Fn {} } } -#[doc = "Generated from \'VK_KHR_extension_309\'"] -impl MemoryHeapFlags { - pub const RESERVED_2_KHR: Self = Self(0b100); -} -impl QcomExtension310Fn { +impl ExtExtension359Fn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_QCOM_extension_310\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_extension_359\0") .expect("Wrong extension string") } - pub const SPEC_VERSION: u32 = 0u32; } -pub struct QcomExtension310Fn {} -unsafe impl Send for QcomExtension310Fn {} -unsafe impl Sync for QcomExtension310Fn {} -impl ::std::clone::Clone for QcomExtension310Fn { +pub struct ExtExtension359Fn {} +unsafe impl Send for ExtExtension359Fn {} +unsafe impl Sync for ExtExtension359Fn {} +impl ::std::clone::Clone for ExtExtension359Fn { fn clone(&self) -> Self { - QcomExtension310Fn {} + ExtExtension359Fn {} } } -impl QcomExtension310Fn { +impl ExtExtension359Fn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - QcomExtension310Fn {} + ExtExtension359Fn {} } } -#[doc = "Generated from \'VK_QCOM_extension_310\'"] -impl StructureType { - pub const RESERVED_QCOM: Self = Self(1_000_309_000); -} -impl NvExtension311Fn { +impl ExtExtension360Fn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_extension_311\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_extension_360\0") .expect("Wrong extension string") } - pub const SPEC_VERSION: u32 = 0u32; } -pub struct NvExtension311Fn {} -unsafe impl Send for NvExtension311Fn {} -unsafe impl Sync for NvExtension311Fn {} -impl ::std::clone::Clone for NvExtension311Fn { +pub struct ExtExtension360Fn {} +unsafe impl Send for ExtExtension360Fn {} +unsafe impl Sync for ExtExtension360Fn {} +impl ::std::clone::Clone for ExtExtension360Fn { fn clone(&self) -> Self { - NvExtension311Fn {} + ExtExtension360Fn {} } } -impl NvExtension311Fn { +impl ExtExtension360Fn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - NvExtension311Fn {} + ExtExtension360Fn {} } } -impl ExtExtension312Fn { +impl KhrExtension361Fn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_extension_312\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_extension_361\0") .expect("Wrong extension string") } - pub const SPEC_VERSION: u32 = 0u32; } -pub struct ExtExtension312Fn {} -unsafe impl Send for ExtExtension312Fn {} -unsafe impl Sync for ExtExtension312Fn {} -impl ::std::clone::Clone for ExtExtension312Fn { +pub struct KhrExtension361Fn {} +unsafe impl Send for KhrExtension361Fn {} +unsafe impl Sync for KhrExtension361Fn {} +impl ::std::clone::Clone for KhrExtension361Fn { fn clone(&self) -> Self { - ExtExtension312Fn {} + KhrExtension361Fn {} } } -impl ExtExtension312Fn { +impl KhrExtension361Fn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - ExtExtension312Fn {} + KhrExtension361Fn {} } } -impl ExtExtension313Fn { +impl ExtExtension362Fn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_extension_313\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_extension_362\0") .expect("Wrong extension string") } pub const SPEC_VERSION: u32 = 0u32; } -pub struct ExtExtension313Fn {} -unsafe impl Send for ExtExtension313Fn {} -unsafe impl Sync for ExtExtension313Fn {} -impl ::std::clone::Clone for ExtExtension313Fn { +pub struct ExtExtension362Fn {} +unsafe impl Send for ExtExtension362Fn {} +unsafe impl Sync for ExtExtension362Fn {} +impl ::std::clone::Clone for ExtExtension362Fn { fn clone(&self) -> Self { - ExtExtension313Fn {} + ExtExtension362Fn {} } } -impl ExtExtension313Fn { +impl ExtExtension362Fn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - ExtExtension313Fn {} + ExtExtension362Fn {} } } -impl AmdExtension314Fn { +impl ExtExtension363Fn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_AMD_extension_314\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_extension_363\0") .expect("Wrong extension string") } pub const SPEC_VERSION: u32 = 0u32; } -pub struct AmdExtension314Fn {} -unsafe impl Send for AmdExtension314Fn {} -unsafe impl Sync for AmdExtension314Fn {} -impl ::std::clone::Clone for AmdExtension314Fn { +pub struct ExtExtension363Fn {} +unsafe impl Send for ExtExtension363Fn {} +unsafe impl Sync for ExtExtension363Fn {} +impl ::std::clone::Clone for ExtExtension363Fn { fn clone(&self) -> Self { - AmdExtension314Fn {} + ExtExtension363Fn {} } } -impl AmdExtension314Fn { +impl ExtExtension363Fn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - AmdExtension314Fn {} + ExtExtension363Fn {} } } -impl AmdExtension315Fn { +impl FuchsiaExtension364Fn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_AMD_extension_315\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_FUCHSIA_extension_364\0") .expect("Wrong extension string") } pub const SPEC_VERSION: u32 = 0u32; } -pub struct AmdExtension315Fn {} -unsafe impl Send for AmdExtension315Fn {} -unsafe impl Sync for AmdExtension315Fn {} -impl ::std::clone::Clone for AmdExtension315Fn { +pub struct FuchsiaExtension364Fn {} +unsafe impl Send for FuchsiaExtension364Fn {} +unsafe impl Sync for FuchsiaExtension364Fn {} +impl ::std::clone::Clone for FuchsiaExtension364Fn { fn clone(&self) -> Self { - AmdExtension315Fn {} + FuchsiaExtension364Fn {} } } -impl AmdExtension315Fn { +impl FuchsiaExtension364Fn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - AmdExtension315Fn {} + FuchsiaExtension364Fn {} } } -impl AmdExtension316Fn { +impl FuchsiaExtension365Fn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_AMD_extension_316\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_FUCHSIA_extension_365\0") .expect("Wrong extension string") } pub const SPEC_VERSION: u32 = 0u32; } -pub struct AmdExtension316Fn {} -unsafe impl Send for AmdExtension316Fn {} -unsafe impl Sync for AmdExtension316Fn {} -impl ::std::clone::Clone for AmdExtension316Fn { +pub struct FuchsiaExtension365Fn {} +unsafe impl Send for FuchsiaExtension365Fn {} +unsafe impl Sync for FuchsiaExtension365Fn {} +impl ::std::clone::Clone for FuchsiaExtension365Fn { fn clone(&self) -> Self { - AmdExtension316Fn {} + FuchsiaExtension365Fn {} } } -impl AmdExtension316Fn { +impl FuchsiaExtension365Fn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - AmdExtension316Fn {} + FuchsiaExtension365Fn {} } } -impl AmdExtension317Fn { +impl FuchsiaExtension366Fn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_AMD_extension_317\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_FUCHSIA_extension_366\0") .expect("Wrong extension string") } pub const SPEC_VERSION: u32 = 0u32; } -pub struct AmdExtension317Fn {} -unsafe impl Send for AmdExtension317Fn {} -unsafe impl Sync for AmdExtension317Fn {} -impl ::std::clone::Clone for AmdExtension317Fn { +pub struct FuchsiaExtension366Fn {} +unsafe impl Send for FuchsiaExtension366Fn {} +unsafe impl Sync for FuchsiaExtension366Fn {} +impl ::std::clone::Clone for FuchsiaExtension366Fn { fn clone(&self) -> Self { - AmdExtension317Fn {} + FuchsiaExtension366Fn {} } } -impl AmdExtension317Fn { +impl FuchsiaExtension366Fn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - AmdExtension317Fn {} + FuchsiaExtension366Fn {} } } -impl AmdExtension318Fn { +impl FuchsiaExtension367Fn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_AMD_extension_318\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_FUCHSIA_extension_367\0") .expect("Wrong extension string") } pub const SPEC_VERSION: u32 = 0u32; } -pub struct AmdExtension318Fn {} -unsafe impl Send for AmdExtension318Fn {} -unsafe impl Sync for AmdExtension318Fn {} -impl ::std::clone::Clone for AmdExtension318Fn { +pub struct FuchsiaExtension367Fn {} +unsafe impl Send for FuchsiaExtension367Fn {} +unsafe impl Sync for FuchsiaExtension367Fn {} +impl ::std::clone::Clone for FuchsiaExtension367Fn { fn clone(&self) -> Self { - AmdExtension318Fn {} + FuchsiaExtension367Fn {} } } -impl AmdExtension318Fn { +impl FuchsiaExtension367Fn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - AmdExtension318Fn {} + FuchsiaExtension367Fn {} } } -impl AmdExtension319Fn { +impl FuchsiaExtension368Fn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_AMD_extension_319\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_FUCHSIA_extension_368\0") .expect("Wrong extension string") } pub const SPEC_VERSION: u32 = 0u32; } -pub struct AmdExtension319Fn {} -unsafe impl Send for AmdExtension319Fn {} -unsafe impl Sync for AmdExtension319Fn {} -impl ::std::clone::Clone for AmdExtension319Fn { +pub struct FuchsiaExtension368Fn {} +unsafe impl Send for FuchsiaExtension368Fn {} +unsafe impl Sync for FuchsiaExtension368Fn {} +impl ::std::clone::Clone for FuchsiaExtension368Fn { fn clone(&self) -> Self { - AmdExtension319Fn {} + FuchsiaExtension368Fn {} } } -impl AmdExtension319Fn { +impl FuchsiaExtension368Fn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - AmdExtension319Fn {} + FuchsiaExtension368Fn {} } } -impl AmdExtension320Fn { +impl QcomExtension369Fn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_AMD_extension_320\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_QCOM_extension_369\0") .expect("Wrong extension string") } pub const SPEC_VERSION: u32 = 0u32; } -pub struct AmdExtension320Fn {} -unsafe impl Send for AmdExtension320Fn {} -unsafe impl Sync for AmdExtension320Fn {} -impl ::std::clone::Clone for AmdExtension320Fn { +pub struct QcomExtension369Fn {} +unsafe impl Send for QcomExtension369Fn {} +unsafe impl Sync for QcomExtension369Fn {} +impl ::std::clone::Clone for QcomExtension369Fn { fn clone(&self) -> Self { - AmdExtension320Fn {} + QcomExtension369Fn {} } } -impl AmdExtension320Fn { +impl QcomExtension369Fn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - AmdExtension320Fn {} + QcomExtension369Fn {} } } -impl AmdExtension321Fn { +#[doc = "Generated from \'VK_QCOM_extension_369\'"] +impl DescriptorBindingFlags { + pub const RESERVED_4_QCOM: Self = Self(0b1_0000); +} +impl HuaweiExtension370Fn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_AMD_extension_321\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_HUAWEI_extension_370\0") .expect("Wrong extension string") } pub const SPEC_VERSION: u32 = 0u32; } -pub struct AmdExtension321Fn {} -unsafe impl Send for AmdExtension321Fn {} -unsafe impl Sync for AmdExtension321Fn {} -impl ::std::clone::Clone for AmdExtension321Fn { +pub struct HuaweiExtension370Fn {} +unsafe impl Send for HuaweiExtension370Fn {} +unsafe impl Sync for HuaweiExtension370Fn {} +impl ::std::clone::Clone for HuaweiExtension370Fn { fn clone(&self) -> Self { - AmdExtension321Fn {} + HuaweiExtension370Fn {} } } -impl AmdExtension321Fn { +impl HuaweiExtension370Fn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - AmdExtension321Fn {} + HuaweiExtension370Fn {} } } -impl AmdExtension322Fn { +impl HuaweiExtension371Fn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_AMD_extension_322\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_HUAWEI_extension_371\0") .expect("Wrong extension string") } pub const SPEC_VERSION: u32 = 0u32; } -pub struct AmdExtension322Fn {} -unsafe impl Send for AmdExtension322Fn {} -unsafe impl Sync for AmdExtension322Fn {} -impl ::std::clone::Clone for AmdExtension322Fn { +pub struct HuaweiExtension371Fn {} +unsafe impl Send for HuaweiExtension371Fn {} +unsafe impl Sync for HuaweiExtension371Fn {} +impl ::std::clone::Clone for HuaweiExtension371Fn { fn clone(&self) -> Self { - AmdExtension322Fn {} + HuaweiExtension371Fn {} } } -impl AmdExtension322Fn { +impl HuaweiExtension371Fn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - AmdExtension322Fn {} + HuaweiExtension371Fn {} } } -impl AmdExtension323Fn { +impl NvExtension372Fn { pub fn name() -> &'static ::std::ffi::CStr { - ::std::ffi::CStr::from_bytes_with_nul(b"VK_AMD_extension_323\0") + ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_extension_372\0") .expect("Wrong extension string") } pub const SPEC_VERSION: u32 = 0u32; } -pub struct AmdExtension323Fn {} -unsafe impl Send for AmdExtension323Fn {} -unsafe impl Sync for AmdExtension323Fn {} -impl ::std::clone::Clone for AmdExtension323Fn { +pub struct NvExtension372Fn {} +unsafe impl Send for NvExtension372Fn {} +unsafe impl Sync for NvExtension372Fn {} +impl ::std::clone::Clone for NvExtension372Fn { fn clone(&self) -> Self { - AmdExtension323Fn {} + NvExtension372Fn {} } } -impl AmdExtension323Fn { +impl NvExtension372Fn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - AmdExtension323Fn {} + NvExtension372Fn {} } } +#[doc = "Generated from \'VK_NV_extension_372\'"] +impl BufferCreateFlags { + pub const RESERVED_5_NV: Self = Self(0b10_0000); +} +#[doc = "Generated from \'VK_NV_extension_372\'"] +impl ImageCreateFlags { + pub const RESERVED_15_NV: Self = Self(0b1000_0000_0000_0000); +} diff --git a/ash/src/vk/platform_types.rs b/ash/src/vk/platform_types.rs index 340403cae..2187d2866 100644 --- a/ash/src/vk/platform_types.rs +++ b/ash/src/vk/platform_types.rs @@ -30,3 +30,5 @@ pub type AHardwareBuffer = c_void; pub type CAMetalLayer = c_void; pub type GgpStreamDescriptor = u32; pub type GgpFrameToken = u64; +pub type IDirectFB = c_void; +pub type IDirectFBSurface = c_void; diff --git a/generator/Vulkan-Headers b/generator/Vulkan-Headers index fb7f9c9bc..d2308183f 160000 --- a/generator/Vulkan-Headers +++ b/generator/Vulkan-Headers @@ -1 +1 @@ -Subproject commit fb7f9c9bcd1d1544ea203a1f3d4253d0e90c5a90 +Subproject commit d2308183f2846a1453ce7ae8c77ea7b5a7424ad2 diff --git a/generator/src/lib.rs b/generator/src/lib.rs index 13a657e99..a9820e3c8 100644 --- a/generator/src/lib.rs +++ b/generator/src/lib.rs @@ -380,6 +380,8 @@ pub fn platform_specific_types() -> Tokens { // https://github.com/google/gapid/commit/22aafebec4638c6aaa77667096bca30f6e842d95#diff-ab3ab4a7d89b4fc8a344ff4e9332865f268ea1669ee379c1b516a954ecc2e7a6R20-R21 pub type GgpStreamDescriptor = u32; pub type GgpFrameToken = u64; + pub type IDirectFB = c_void; + pub type IDirectFBSurface = c_void; } } #[derive(Debug, Copy, Clone)] @@ -1721,20 +1723,30 @@ pub fn derive_setters( // Unique cases if name == "pCode" { return Some(quote!{ - pub fn code(mut self, code: &'a [u32]) -> #name_builder<'a> { - self.inner.code_size = code.len() * 4; - self.inner.p_code = code.as_ptr() as *const u32; - self - } + pub fn code(mut self, code: &'a [u32]) -> #name_builder<'a> { + self.inner.code_size = code.len() * 4; + self.inner.p_code = code.as_ptr() as *const u32; + self + } }); } if name == "pSampleMask" { return Some(quote!{ - pub fn sample_mask(mut self, sample_mask: &'a [SampleMask]) -> #name_builder<'a> { - self.inner.p_sample_mask = sample_mask.as_ptr() as *const SampleMask; - self - } + pub fn sample_mask(mut self, sample_mask: &'a [SampleMask]) -> #name_builder<'a> { + self.inner.p_sample_mask = sample_mask.as_ptr() as *const SampleMask; + self + } + }); + } + + if name == "ppGeometries" { + return Some(quote!{ + pub fn geometries_ptrs(mut self, geometries: &'a [*const AccelerationStructureGeometryKHR]) -> #name_builder<'a> { + self.inner.geometry_count = geometries.len() as _; + self.inner.pp_geometries = geometries.as_ptr(); + self + } }); } } @@ -1971,13 +1983,19 @@ pub fn generate_struct( if &_struct.name == "VkAccelerationStructureInstanceKHR" { return quote! { + #[repr(C)] + #[derive(Copy, Clone)] + pub union AccelerationStructureReferenceKHR { + pub device_handle: DeviceAddress, + pub host_handle: AccelerationStructureKHR, + } #[repr(C)] #[derive(Copy, Clone)] pub struct AccelerationStructureInstanceKHR { pub transform: TransformMatrixKHR, pub instance_custom_index_and_mask: u32, pub instance_shader_binding_table_record_offset_and_flags: u32, - pub acceleration_structure_reference: u64, + pub acceleration_structure_reference: AccelerationStructureReferenceKHR, } }; }