diff --git a/ash/src/vk.rs b/ash/src/vk.rs index a60465d..001baad 100644 --- a/ash/src/vk.rs +++ b/ash/src/vk.rs @@ -33202,6 +33202,164 @@ impl<'a> SubpassDescriptionDepthStencilResolveKHRBuilder<'a> { } #[repr(C)] #[derive(Copy, Clone, Debug)] +pub struct PhysicalDeviceDepthStencilResolvePropertiesKHR { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub supported_depth_resolve_modes: ResolveModeFlagsKHR, + pub supported_stencil_resolve_modes: ResolveModeFlagsKHR, + pub independent_resolve_none: Bool32, + pub independent_resolve: Bool32, +} +impl ::std::default::Default for PhysicalDeviceDepthStencilResolvePropertiesKHR { + fn default() -> PhysicalDeviceDepthStencilResolvePropertiesKHR { + PhysicalDeviceDepthStencilResolvePropertiesKHR { + s_type: StructureType::PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES_KHR, + p_next: ::std::ptr::null_mut(), + supported_depth_resolve_modes: ResolveModeFlagsKHR::default(), + supported_stencil_resolve_modes: ResolveModeFlagsKHR::default(), + independent_resolve_none: Bool32::default(), + independent_resolve: Bool32::default(), + } + } +} +impl PhysicalDeviceDepthStencilResolvePropertiesKHR { + pub fn builder<'a>() -> PhysicalDeviceDepthStencilResolvePropertiesKHRBuilder<'a> { + PhysicalDeviceDepthStencilResolvePropertiesKHRBuilder { + inner: PhysicalDeviceDepthStencilResolvePropertiesKHR::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct PhysicalDeviceDepthStencilResolvePropertiesKHRBuilder<'a> { + inner: PhysicalDeviceDepthStencilResolvePropertiesKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsPhysicalDeviceDepthStencilResolvePropertiesKHR {} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceDepthStencilResolvePropertiesKHR {} +impl<'a> ::std::ops::Deref for PhysicalDeviceDepthStencilResolvePropertiesKHRBuilder<'a> { + type Target = PhysicalDeviceDepthStencilResolvePropertiesKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> PhysicalDeviceDepthStencilResolvePropertiesKHRBuilder<'a> { + pub fn supported_depth_resolve_modes( + mut self, + supported_depth_resolve_modes: ResolveModeFlagsKHR, + ) -> PhysicalDeviceDepthStencilResolvePropertiesKHRBuilder<'a> { + self.inner.supported_depth_resolve_modes = supported_depth_resolve_modes; + self + } + pub fn supported_stencil_resolve_modes( + mut self, + supported_stencil_resolve_modes: ResolveModeFlagsKHR, + ) -> PhysicalDeviceDepthStencilResolvePropertiesKHRBuilder<'a> { + self.inner.supported_stencil_resolve_modes = supported_stencil_resolve_modes; + self + } + pub fn independent_resolve_none( + mut self, + independent_resolve_none: bool, + ) -> PhysicalDeviceDepthStencilResolvePropertiesKHRBuilder<'a> { + self.inner.independent_resolve_none = independent_resolve_none.into(); + self + } + pub fn independent_resolve( + mut self, + independent_resolve: bool, + ) -> PhysicalDeviceDepthStencilResolvePropertiesKHRBuilder<'a> { + self.inner.independent_resolve = independent_resolve.into(); + self + } + pub fn next( + mut self, + next: &'a mut T, + ) -> PhysicalDeviceDepthStencilResolvePropertiesKHRBuilder<'a> + where + T: ExtendsPhysicalDeviceDepthStencilResolvePropertiesKHR, + { + self.inner.p_next = next as *mut T as *mut c_void; + self + } + pub fn build(self) -> PhysicalDeviceDepthStencilResolvePropertiesKHR { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +pub struct SubpassDescriptionDepthStencilResolveKHR { + pub s_type: StructureType, + pub p_next: *const c_void, + pub depth_resolve_mode: ResolveModeFlagsKHR, + pub stencil_resolve_mode: ResolveModeFlagsKHR, + pub p_depth_stencil_resolve_attachment: *const AttachmentReference2KHR, +} +impl ::std::default::Default for SubpassDescriptionDepthStencilResolveKHR { + fn default() -> SubpassDescriptionDepthStencilResolveKHR { + SubpassDescriptionDepthStencilResolveKHR { + s_type: StructureType::SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE_KHR, + p_next: ::std::ptr::null(), + depth_resolve_mode: ResolveModeFlagsKHR::default(), + stencil_resolve_mode: ResolveModeFlagsKHR::default(), + p_depth_stencil_resolve_attachment: ::std::ptr::null(), + } + } +} +impl SubpassDescriptionDepthStencilResolveKHR { + pub fn builder<'a>() -> SubpassDescriptionDepthStencilResolveKHRBuilder<'a> { + SubpassDescriptionDepthStencilResolveKHRBuilder { + inner: SubpassDescriptionDepthStencilResolveKHR::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct SubpassDescriptionDepthStencilResolveKHRBuilder<'a> { + inner: SubpassDescriptionDepthStencilResolveKHR, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsSubpassDescriptionDepthStencilResolveKHR {} +unsafe impl ExtendsSubpassDescription2KHR for SubpassDescriptionDepthStencilResolveKHR {} +impl<'a> ::std::ops::Deref for SubpassDescriptionDepthStencilResolveKHRBuilder<'a> { + type Target = SubpassDescriptionDepthStencilResolveKHR; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> SubpassDescriptionDepthStencilResolveKHRBuilder<'a> { + pub fn depth_resolve_mode( + mut self, + depth_resolve_mode: ResolveModeFlagsKHR, + ) -> SubpassDescriptionDepthStencilResolveKHRBuilder<'a> { + self.inner.depth_resolve_mode = depth_resolve_mode; + self + } + pub fn stencil_resolve_mode( + mut self, + stencil_resolve_mode: ResolveModeFlagsKHR, + ) -> SubpassDescriptionDepthStencilResolveKHRBuilder<'a> { + self.inner.stencil_resolve_mode = stencil_resolve_mode; + self + } + pub fn depth_stencil_resolve_attachment( + mut self, + depth_stencil_resolve_attachment: &'a AttachmentReference2KHR, + ) -> SubpassDescriptionDepthStencilResolveKHRBuilder<'a> { + self.inner.p_depth_stencil_resolve_attachment = depth_stencil_resolve_attachment; + self + } + pub fn next(mut self, next: &'a T) -> SubpassDescriptionDepthStencilResolveKHRBuilder<'a> + where + T: ExtendsSubpassDescriptionDepthStencilResolveKHR, + { + self.inner.p_next = next as *const T as *const c_void; + self + } + pub fn build(self) -> SubpassDescriptionDepthStencilResolveKHR { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] pub struct ImageViewASTCDecodeModeEXT { pub s_type: StructureType, pub p_next: *const c_void, @@ -36822,6 +36980,627 @@ impl<'a> BufferDeviceAddressCreateInfoEXTBuilder<'a> { self.inner } } +#[repr(C)] +#[derive(Copy, Clone, Debug)] +pub struct PhysicalDeviceFragmentDensityMapFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub fragment_density_map: Bool32, + pub fragment_density_map_dynamic: Bool32, + pub fragment_density_map_non_subsampled_images: Bool32, +} +impl ::std::default::Default for PhysicalDeviceFragmentDensityMapFeaturesEXT { + fn default() -> PhysicalDeviceFragmentDensityMapFeaturesEXT { + PhysicalDeviceFragmentDensityMapFeaturesEXT { + s_type: StructureType::PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT, + p_next: ::std::ptr::null_mut(), + fragment_density_map: Bool32::default(), + fragment_density_map_dynamic: Bool32::default(), + fragment_density_map_non_subsampled_images: Bool32::default(), + } + } +} +impl PhysicalDeviceFragmentDensityMapFeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceFragmentDensityMapFeaturesEXTBuilder<'a> { + PhysicalDeviceFragmentDensityMapFeaturesEXTBuilder { + inner: PhysicalDeviceFragmentDensityMapFeaturesEXT::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct PhysicalDeviceFragmentDensityMapFeaturesEXTBuilder<'a> { + inner: PhysicalDeviceFragmentDensityMapFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsPhysicalDeviceFragmentDensityMapFeaturesEXT {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceFragmentDensityMapFeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFragmentDensityMapFeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceFragmentDensityMapFeaturesEXTBuilder<'a> { + type Target = PhysicalDeviceFragmentDensityMapFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> PhysicalDeviceFragmentDensityMapFeaturesEXTBuilder<'a> { + pub fn fragment_density_map( + mut self, + fragment_density_map: bool, + ) -> PhysicalDeviceFragmentDensityMapFeaturesEXTBuilder<'a> { + self.inner.fragment_density_map = fragment_density_map.into(); + self + } + pub fn fragment_density_map_dynamic( + mut self, + fragment_density_map_dynamic: bool, + ) -> PhysicalDeviceFragmentDensityMapFeaturesEXTBuilder<'a> { + self.inner.fragment_density_map_dynamic = fragment_density_map_dynamic.into(); + self + } + pub fn fragment_density_map_non_subsampled_images( + mut self, + fragment_density_map_non_subsampled_images: bool, + ) -> PhysicalDeviceFragmentDensityMapFeaturesEXTBuilder<'a> { + self.inner.fragment_density_map_non_subsampled_images = + fragment_density_map_non_subsampled_images.into(); + self + } + pub fn next( + mut self, + next: &'a mut T, + ) -> PhysicalDeviceFragmentDensityMapFeaturesEXTBuilder<'a> + where + T: ExtendsPhysicalDeviceFragmentDensityMapFeaturesEXT, + { + self.inner.p_next = next as *mut T as *mut c_void; + self + } + pub fn build(self) -> PhysicalDeviceFragmentDensityMapFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +pub struct PhysicalDeviceFragmentDensityMapPropertiesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub min_fragment_density_texel_size: Extent2D, + pub max_fragment_density_texel_size: Extent2D, + pub fragment_density_invocations: Bool32, +} +impl ::std::default::Default for PhysicalDeviceFragmentDensityMapPropertiesEXT { + fn default() -> PhysicalDeviceFragmentDensityMapPropertiesEXT { + PhysicalDeviceFragmentDensityMapPropertiesEXT { + s_type: StructureType::PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT, + p_next: ::std::ptr::null_mut(), + min_fragment_density_texel_size: Extent2D::default(), + max_fragment_density_texel_size: Extent2D::default(), + fragment_density_invocations: Bool32::default(), + } + } +} +impl PhysicalDeviceFragmentDensityMapPropertiesEXT { + pub fn builder<'a>() -> PhysicalDeviceFragmentDensityMapPropertiesEXTBuilder<'a> { + PhysicalDeviceFragmentDensityMapPropertiesEXTBuilder { + inner: PhysicalDeviceFragmentDensityMapPropertiesEXT::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct PhysicalDeviceFragmentDensityMapPropertiesEXTBuilder<'a> { + inner: PhysicalDeviceFragmentDensityMapPropertiesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsPhysicalDeviceFragmentDensityMapPropertiesEXT {} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceFragmentDensityMapPropertiesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceFragmentDensityMapPropertiesEXTBuilder<'a> { + type Target = PhysicalDeviceFragmentDensityMapPropertiesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> PhysicalDeviceFragmentDensityMapPropertiesEXTBuilder<'a> { + pub fn min_fragment_density_texel_size( + mut self, + min_fragment_density_texel_size: Extent2D, + ) -> PhysicalDeviceFragmentDensityMapPropertiesEXTBuilder<'a> { + self.inner.min_fragment_density_texel_size = min_fragment_density_texel_size; + self + } + pub fn max_fragment_density_texel_size( + mut self, + max_fragment_density_texel_size: Extent2D, + ) -> PhysicalDeviceFragmentDensityMapPropertiesEXTBuilder<'a> { + self.inner.max_fragment_density_texel_size = max_fragment_density_texel_size; + self + } + pub fn fragment_density_invocations( + mut self, + fragment_density_invocations: bool, + ) -> PhysicalDeviceFragmentDensityMapPropertiesEXTBuilder<'a> { + self.inner.fragment_density_invocations = fragment_density_invocations.into(); + self + } + pub fn next( + mut self, + next: &'a mut T, + ) -> PhysicalDeviceFragmentDensityMapPropertiesEXTBuilder<'a> + where + T: ExtendsPhysicalDeviceFragmentDensityMapPropertiesEXT, + { + self.inner.p_next = next as *mut T as *mut c_void; + self + } + pub fn build(self) -> PhysicalDeviceFragmentDensityMapPropertiesEXT { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +pub struct RenderPassFragmentDensityMapCreateInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub fragment_density_map_attachment: AttachmentReference, +} +impl ::std::default::Default for RenderPassFragmentDensityMapCreateInfoEXT { + fn default() -> RenderPassFragmentDensityMapCreateInfoEXT { + RenderPassFragmentDensityMapCreateInfoEXT { + s_type: StructureType::RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT, + p_next: ::std::ptr::null(), + fragment_density_map_attachment: AttachmentReference::default(), + } + } +} +impl RenderPassFragmentDensityMapCreateInfoEXT { + pub fn builder<'a>() -> RenderPassFragmentDensityMapCreateInfoEXTBuilder<'a> { + RenderPassFragmentDensityMapCreateInfoEXTBuilder { + inner: RenderPassFragmentDensityMapCreateInfoEXT::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct RenderPassFragmentDensityMapCreateInfoEXTBuilder<'a> { + inner: RenderPassFragmentDensityMapCreateInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsRenderPassFragmentDensityMapCreateInfoEXT {} +unsafe impl ExtendsRenderPassCreateInfo for RenderPassFragmentDensityMapCreateInfoEXT {} +impl<'a> ::std::ops::Deref for RenderPassFragmentDensityMapCreateInfoEXTBuilder<'a> { + type Target = RenderPassFragmentDensityMapCreateInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> RenderPassFragmentDensityMapCreateInfoEXTBuilder<'a> { + pub fn fragment_density_map_attachment( + mut self, + fragment_density_map_attachment: AttachmentReference, + ) -> RenderPassFragmentDensityMapCreateInfoEXTBuilder<'a> { + self.inner.fragment_density_map_attachment = fragment_density_map_attachment; + self + } + pub fn next(mut self, next: &'a T) -> RenderPassFragmentDensityMapCreateInfoEXTBuilder<'a> + where + T: ExtendsRenderPassFragmentDensityMapCreateInfoEXT, + { + self.inner.p_next = next as *const T as *const c_void; + self + } + pub fn build(self) -> RenderPassFragmentDensityMapCreateInfoEXT { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +pub struct PhysicalDeviceScalarBlockLayoutFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub scalar_block_layout: Bool32, +} +impl ::std::default::Default for PhysicalDeviceScalarBlockLayoutFeaturesEXT { + fn default() -> PhysicalDeviceScalarBlockLayoutFeaturesEXT { + PhysicalDeviceScalarBlockLayoutFeaturesEXT { + s_type: StructureType::PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES_EXT, + p_next: ::std::ptr::null_mut(), + scalar_block_layout: Bool32::default(), + } + } +} +impl PhysicalDeviceScalarBlockLayoutFeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceScalarBlockLayoutFeaturesEXTBuilder<'a> { + PhysicalDeviceScalarBlockLayoutFeaturesEXTBuilder { + inner: PhysicalDeviceScalarBlockLayoutFeaturesEXT::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct PhysicalDeviceScalarBlockLayoutFeaturesEXTBuilder<'a> { + inner: PhysicalDeviceScalarBlockLayoutFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsPhysicalDeviceScalarBlockLayoutFeaturesEXT {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceScalarBlockLayoutFeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceScalarBlockLayoutFeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceScalarBlockLayoutFeaturesEXTBuilder<'a> { + type Target = PhysicalDeviceScalarBlockLayoutFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> PhysicalDeviceScalarBlockLayoutFeaturesEXTBuilder<'a> { + pub fn scalar_block_layout( + mut self, + scalar_block_layout: bool, + ) -> PhysicalDeviceScalarBlockLayoutFeaturesEXTBuilder<'a> { + self.inner.scalar_block_layout = scalar_block_layout.into(); + self + } + pub fn next( + mut self, + next: &'a mut T, + ) -> PhysicalDeviceScalarBlockLayoutFeaturesEXTBuilder<'a> + where + T: ExtendsPhysicalDeviceScalarBlockLayoutFeaturesEXT, + { + self.inner.p_next = next as *mut T as *mut c_void; + self + } + pub fn build(self) -> PhysicalDeviceScalarBlockLayoutFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +pub struct PhysicalDeviceMemoryBudgetPropertiesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub heap_budget: [DeviceSize; MAX_MEMORY_HEAPS], + pub heap_usage: [DeviceSize; MAX_MEMORY_HEAPS], +} +impl ::std::default::Default for PhysicalDeviceMemoryBudgetPropertiesEXT { + fn default() -> PhysicalDeviceMemoryBudgetPropertiesEXT { + PhysicalDeviceMemoryBudgetPropertiesEXT { + s_type: StructureType::PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT, + p_next: ::std::ptr::null_mut(), + heap_budget: unsafe { ::std::mem::zeroed() }, + heap_usage: unsafe { ::std::mem::zeroed() }, + } + } +} +impl PhysicalDeviceMemoryBudgetPropertiesEXT { + pub fn builder<'a>() -> PhysicalDeviceMemoryBudgetPropertiesEXTBuilder<'a> { + PhysicalDeviceMemoryBudgetPropertiesEXTBuilder { + inner: PhysicalDeviceMemoryBudgetPropertiesEXT::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct PhysicalDeviceMemoryBudgetPropertiesEXTBuilder<'a> { + inner: PhysicalDeviceMemoryBudgetPropertiesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsPhysicalDeviceMemoryBudgetPropertiesEXT {} +unsafe impl ExtendsPhysicalDeviceMemoryProperties2 for PhysicalDeviceMemoryBudgetPropertiesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceMemoryBudgetPropertiesEXTBuilder<'a> { + type Target = PhysicalDeviceMemoryBudgetPropertiesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> PhysicalDeviceMemoryBudgetPropertiesEXTBuilder<'a> { + pub fn heap_budget( + mut self, + heap_budget: [DeviceSize; MAX_MEMORY_HEAPS], + ) -> PhysicalDeviceMemoryBudgetPropertiesEXTBuilder<'a> { + self.inner.heap_budget = heap_budget; + self + } + pub fn heap_usage( + mut self, + heap_usage: [DeviceSize; MAX_MEMORY_HEAPS], + ) -> PhysicalDeviceMemoryBudgetPropertiesEXTBuilder<'a> { + self.inner.heap_usage = heap_usage; + self + } + pub fn next(mut self, next: &'a mut T) -> PhysicalDeviceMemoryBudgetPropertiesEXTBuilder<'a> + where + T: ExtendsPhysicalDeviceMemoryBudgetPropertiesEXT, + { + self.inner.p_next = next as *mut T as *mut c_void; + self + } + pub fn build(self) -> PhysicalDeviceMemoryBudgetPropertiesEXT { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +pub struct PhysicalDeviceMemoryPriorityFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub memory_priority: Bool32, +} +impl ::std::default::Default for PhysicalDeviceMemoryPriorityFeaturesEXT { + fn default() -> PhysicalDeviceMemoryPriorityFeaturesEXT { + PhysicalDeviceMemoryPriorityFeaturesEXT { + s_type: StructureType::PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT, + p_next: ::std::ptr::null_mut(), + memory_priority: Bool32::default(), + } + } +} +impl PhysicalDeviceMemoryPriorityFeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceMemoryPriorityFeaturesEXTBuilder<'a> { + PhysicalDeviceMemoryPriorityFeaturesEXTBuilder { + inner: PhysicalDeviceMemoryPriorityFeaturesEXT::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct PhysicalDeviceMemoryPriorityFeaturesEXTBuilder<'a> { + inner: PhysicalDeviceMemoryPriorityFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsPhysicalDeviceMemoryPriorityFeaturesEXT {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceMemoryPriorityFeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMemoryPriorityFeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceMemoryPriorityFeaturesEXTBuilder<'a> { + type Target = PhysicalDeviceMemoryPriorityFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> PhysicalDeviceMemoryPriorityFeaturesEXTBuilder<'a> { + pub fn memory_priority( + mut self, + memory_priority: bool, + ) -> PhysicalDeviceMemoryPriorityFeaturesEXTBuilder<'a> { + self.inner.memory_priority = memory_priority.into(); + self + } + pub fn next(mut self, next: &'a mut T) -> PhysicalDeviceMemoryPriorityFeaturesEXTBuilder<'a> + where + T: ExtendsPhysicalDeviceMemoryPriorityFeaturesEXT, + { + self.inner.p_next = next as *mut T as *mut c_void; + self + } + pub fn build(self) -> PhysicalDeviceMemoryPriorityFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +pub struct MemoryPriorityAllocateInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub priority: f32, +} +impl ::std::default::Default for MemoryPriorityAllocateInfoEXT { + fn default() -> MemoryPriorityAllocateInfoEXT { + MemoryPriorityAllocateInfoEXT { + s_type: StructureType::MEMORY_PRIORITY_ALLOCATE_INFO_EXT, + p_next: ::std::ptr::null(), + priority: f32::default(), + } + } +} +impl MemoryPriorityAllocateInfoEXT { + pub fn builder<'a>() -> MemoryPriorityAllocateInfoEXTBuilder<'a> { + MemoryPriorityAllocateInfoEXTBuilder { + inner: MemoryPriorityAllocateInfoEXT::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct MemoryPriorityAllocateInfoEXTBuilder<'a> { + inner: MemoryPriorityAllocateInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsMemoryPriorityAllocateInfoEXT {} +unsafe impl ExtendsMemoryAllocateInfo for MemoryPriorityAllocateInfoEXT {} +impl<'a> ::std::ops::Deref for MemoryPriorityAllocateInfoEXTBuilder<'a> { + type Target = MemoryPriorityAllocateInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> MemoryPriorityAllocateInfoEXTBuilder<'a> { + pub fn priority(mut self, priority: f32) -> MemoryPriorityAllocateInfoEXTBuilder<'a> { + self.inner.priority = priority; + self + } + pub fn next(mut self, next: &'a T) -> MemoryPriorityAllocateInfoEXTBuilder<'a> + where + T: ExtendsMemoryPriorityAllocateInfoEXT, + { + self.inner.p_next = next as *const T as *const c_void; + self + } + pub fn build(self) -> MemoryPriorityAllocateInfoEXT { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +pub struct PhysicalDeviceBufferAddressFeaturesEXT { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub buffer_device_address: Bool32, + pub buffer_device_address_capture_replay: Bool32, + pub buffer_device_address_multi_device: Bool32, +} +impl ::std::default::Default for PhysicalDeviceBufferAddressFeaturesEXT { + fn default() -> PhysicalDeviceBufferAddressFeaturesEXT { + PhysicalDeviceBufferAddressFeaturesEXT { + s_type: StructureType::PHYSICAL_DEVICE_BUFFER_ADDRESS_FEATURES_EXT, + p_next: ::std::ptr::null_mut(), + buffer_device_address: Bool32::default(), + buffer_device_address_capture_replay: Bool32::default(), + buffer_device_address_multi_device: Bool32::default(), + } + } +} +impl PhysicalDeviceBufferAddressFeaturesEXT { + pub fn builder<'a>() -> PhysicalDeviceBufferAddressFeaturesEXTBuilder<'a> { + PhysicalDeviceBufferAddressFeaturesEXTBuilder { + inner: PhysicalDeviceBufferAddressFeaturesEXT::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct PhysicalDeviceBufferAddressFeaturesEXTBuilder<'a> { + inner: PhysicalDeviceBufferAddressFeaturesEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsPhysicalDeviceBufferAddressFeaturesEXT {} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceBufferAddressFeaturesEXT {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceBufferAddressFeaturesEXT {} +impl<'a> ::std::ops::Deref for PhysicalDeviceBufferAddressFeaturesEXTBuilder<'a> { + type Target = PhysicalDeviceBufferAddressFeaturesEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> PhysicalDeviceBufferAddressFeaturesEXTBuilder<'a> { + pub fn buffer_device_address( + mut self, + buffer_device_address: bool, + ) -> PhysicalDeviceBufferAddressFeaturesEXTBuilder<'a> { + self.inner.buffer_device_address = buffer_device_address.into(); + self + } + pub fn buffer_device_address_capture_replay( + mut self, + buffer_device_address_capture_replay: bool, + ) -> PhysicalDeviceBufferAddressFeaturesEXTBuilder<'a> { + self.inner.buffer_device_address_capture_replay = + buffer_device_address_capture_replay.into(); + self + } + pub fn buffer_device_address_multi_device( + mut self, + buffer_device_address_multi_device: bool, + ) -> PhysicalDeviceBufferAddressFeaturesEXTBuilder<'a> { + self.inner.buffer_device_address_multi_device = buffer_device_address_multi_device.into(); + self + } + pub fn next(mut self, next: &'a mut T) -> PhysicalDeviceBufferAddressFeaturesEXTBuilder<'a> + where + T: ExtendsPhysicalDeviceBufferAddressFeaturesEXT, + { + self.inner.p_next = next as *mut T as *mut c_void; + self + } + pub fn build(self) -> PhysicalDeviceBufferAddressFeaturesEXT { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +pub struct BufferDeviceAddressInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub buffer: Buffer, +} +impl ::std::default::Default for BufferDeviceAddressInfoEXT { + fn default() -> BufferDeviceAddressInfoEXT { + BufferDeviceAddressInfoEXT { + s_type: StructureType::BUFFER_DEVICE_ADDRESS_INFO_EXT, + p_next: ::std::ptr::null(), + buffer: Buffer::default(), + } + } +} +impl BufferDeviceAddressInfoEXT { + pub fn builder<'a>() -> BufferDeviceAddressInfoEXTBuilder<'a> { + BufferDeviceAddressInfoEXTBuilder { + inner: BufferDeviceAddressInfoEXT::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct BufferDeviceAddressInfoEXTBuilder<'a> { + inner: BufferDeviceAddressInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsBufferDeviceAddressInfoEXT {} +impl<'a> ::std::ops::Deref for BufferDeviceAddressInfoEXTBuilder<'a> { + type Target = BufferDeviceAddressInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> BufferDeviceAddressInfoEXTBuilder<'a> { + pub fn buffer(mut self, buffer: Buffer) -> BufferDeviceAddressInfoEXTBuilder<'a> { + self.inner.buffer = buffer; + self + } + pub fn next(mut self, next: &'a T) -> BufferDeviceAddressInfoEXTBuilder<'a> + where + T: ExtendsBufferDeviceAddressInfoEXT, + { + self.inner.p_next = next as *const T as *const c_void; + self + } + pub fn build(self) -> BufferDeviceAddressInfoEXT { + self.inner + } +} +#[repr(C)] +#[derive(Copy, Clone, Debug)] +pub struct BufferDeviceAddressCreateInfoEXT { + pub s_type: StructureType, + pub p_next: *const c_void, + pub device_address: DeviceSize, +} +impl ::std::default::Default for BufferDeviceAddressCreateInfoEXT { + fn default() -> BufferDeviceAddressCreateInfoEXT { + BufferDeviceAddressCreateInfoEXT { + s_type: StructureType::BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT, + p_next: ::std::ptr::null(), + device_address: DeviceSize::default(), + } + } +} +impl BufferDeviceAddressCreateInfoEXT { + pub fn builder<'a>() -> BufferDeviceAddressCreateInfoEXTBuilder<'a> { + BufferDeviceAddressCreateInfoEXTBuilder { + inner: BufferDeviceAddressCreateInfoEXT::default(), + marker: ::std::marker::PhantomData, + } + } +} +pub struct BufferDeviceAddressCreateInfoEXTBuilder<'a> { + inner: BufferDeviceAddressCreateInfoEXT, + marker: ::std::marker::PhantomData<&'a ()>, +} +pub unsafe trait ExtendsBufferDeviceAddressCreateInfoEXT {} +unsafe impl ExtendsBufferCreateInfo for BufferDeviceAddressCreateInfoEXT {} +impl<'a> ::std::ops::Deref for BufferDeviceAddressCreateInfoEXTBuilder<'a> { + type Target = BufferDeviceAddressCreateInfoEXT; + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl<'a> BufferDeviceAddressCreateInfoEXTBuilder<'a> { + pub fn device_address( + mut self, + device_address: DeviceSize, + ) -> BufferDeviceAddressCreateInfoEXTBuilder<'a> { + self.inner.device_address = device_address; + self + } + pub fn next(mut self, next: &'a T) -> BufferDeviceAddressCreateInfoEXTBuilder<'a> + where + T: ExtendsBufferDeviceAddressCreateInfoEXT, + { + self.inner.p_next = next as *const T as *const c_void; + self + } + pub fn build(self) -> BufferDeviceAddressCreateInfoEXT { + self.inner + } +} #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(transparent)] pub struct ImageLayout(pub(crate) i32);