diff --git a/analysis/src/decl.rs b/analysis/src/decl.rs index 9c9ff2797..669a37644 100644 --- a/analysis/src/decl.rs +++ b/analysis/src/decl.rs @@ -1,7 +1,13 @@ +use proc_macro2::{Literal, TokenStream}; + use crate::{ - item::RequireMap, + item::{RequireMap, structure::Length}, name::{ConstantName, FuncPointerName, TypeName, VariableName}, - xml::cdecl::{CArrayLen, CDecl, CType}, + to_rust::RustTranslator, + xml::{ + cdecl::{CArrayLen, CDecl, CType}, + cexpr::{self, CExprItem, CExprItems}, + }, }; #[derive(Debug)] @@ -11,7 +17,10 @@ pub struct Decl { } impl Decl { - pub(crate) fn from_c(require_map: &RequireMap, c_decl: &CDecl<'static>) -> Decl { + pub(crate) fn from_c( + require_map: &RequireMap, + c_decl: &CDecl<'static>, + ) -> Decl { Decl { name: VariableName::new(c_decl.name), ty: Ty::from_c(require_map, &c_decl.ty), @@ -19,7 +28,7 @@ impl Decl { } } -#[derive(Debug)] +#[derive(Debug, Clone, Copy, PartialEq, Eq)] pub enum Mutability { Not, Mut, @@ -65,25 +74,47 @@ impl CPrimaryType { } } -#[derive(Debug)] +#[derive(Debug, Clone)] pub enum ArrayLen { Constant(ConstantName), Literal(u128), } -#[derive(Debug)] +impl ArrayLen { + pub fn to_rust(&self, translator: &impl RustTranslator) -> TokenStream { + match self { + ArrayLen::Constant(constant_name) => translator.constant_to_rust(*constant_name, true), + ArrayLen::Literal(value) => { + let literal = Literal::u128_unsuffixed(*value); + quote::quote! { #literal } + } + } + } +} + +#[derive(Debug, Clone)] pub enum Ty { SpecType(TypeName), SpecFuncPointer(FuncPointerName), CPrimary(CPrimaryType), + RustType(RustType), Platform(&'static str), Ptr(&'static Ty, Mutability), Ref(&'static Ty, Mutability), + Slice(&'static Ty, Mutability, Option), Array(&'static Ty, ArrayLen), } +#[derive(Debug, Clone, Copy)] +pub enum RustType { + CStr, +} + impl Ty { - pub(crate) fn from_c(require_map: &RequireMap, c_type: &CType<'static>) -> Ty { + pub(crate) fn from_c( + require_map: &RequireMap, + c_type: &CType<'static>, + ) -> Ty { match c_type { CType::Base(cbase_type) => { let name = cbase_type.name; diff --git a/analysis/src/item/function.rs b/analysis/src/item/function.rs index 6927a3514..c22f7827e 100644 --- a/analysis/src/item/function.rs +++ b/analysis/src/item/function.rs @@ -32,7 +32,8 @@ impl FuncPointer { params: (xml.params.iter()) .map(|c_decl| Decl::from_c(require_map, c_decl)) .collect(), - return_type: (xml.return_type.as_ref()).map(|c_type| Ty::from_c(require_map, c_type)), + return_type: (xml.return_type.as_ref()) + .map(|c_type| Ty::from_c(require_map, c_type)), }) } } @@ -70,7 +71,8 @@ impl Command { decl: Decl::from_c(require_map, ¶m.c_decl), }) .collect(), - return_type: (xml.return_type.as_ref()).map(|c_type| Ty::from_c(require_map, c_type)), + return_type: (xml.return_type.as_ref()) + .map(|c_type| Ty::from_c(require_map, c_type)), }) } } diff --git a/analysis/src/item/structure.rs b/analysis/src/item/structure.rs index efff4e82d..2152630fb 100644 --- a/analysis/src/item/structure.rs +++ b/analysis/src/item/structure.rs @@ -1,7 +1,7 @@ use crate::{ decl::{Decl, Ty}, item::{Named, RequireMap, RequiredBy}, - name::TypeName, + name::{EnumeratorName, TypeName, VariableName}, xml, }; use std::{cmp::Ordering, ops::Range}; @@ -15,7 +15,7 @@ pub struct BitfieldRange { #[derive(Debug)] pub enum StructMember { - Normal(Decl), + Normal(StructDecl), BitField(Vec), } @@ -23,9 +23,25 @@ pub enum StructMember { pub struct Struct { pub required_by: RequiredBy, pub name: TypeName, + pub extends: Vec, + pub structure_type: Option, pub members: Vec, } +#[derive(Debug)] +pub struct StructDecl { + pub decl: Decl, + pub len: Vec, +} + +#[derive(Debug, PartialEq, Eq)] +pub enum Length { + Member(VariableName), + NullTerminated, + Pointer, + Custom(&'static str), +} + impl Named for Struct { fn name(&self) -> TypeName { self.name @@ -40,7 +56,33 @@ impl Struct { let mut members = Vec::new(); let mut used_bitwidth = None; + + let extends = xml + .structextends + .iter() + .map(|&extending| TypeName::new(extending)) + .collect(); + + let mut structure_type = None; + for member in &xml.members { + let lens = if member.len.iter().any(|&s| s.starts_with("latexmath:")) { + &member.altlen + } else { + &member.len + }; + + let len = lens + .iter() + .map(|&s| match s { + "null-terminated" => Length::NullTerminated, + "1" => Length::Pointer, + name if xml.members.iter().any(|mem| mem.c_decl.name == name) => { + Length::Member(VariableName::new(name)) + } + custom => Length::Custom(custom), + }) + .collect::>(); let decl = Decl::from_c(require_map, &member.c_decl); if let Some(width) = member.c_decl.bitfield_width { // this is currently the case everywhere, @@ -72,13 +114,23 @@ impl Struct { } } else { assert_eq!(used_bitwidth, None, "bitfield not fully used"); - members.push(StructMember::Normal(decl)); + // should exist only once + if let Some(value) = member.values + && let Ty::SpecType(ty) = decl.ty + && ty == TypeName::VK_STRUCTURE_TYPE + && decl.name.original() == "sType" + { + structure_type = Some(EnumeratorName::new(value)); + } + members.push(StructMember::Normal(StructDecl { decl, len })); } } Some(Struct { required_by, name: xml.name, + extends, + structure_type, members, }) } diff --git a/analysis/src/lifetime.rs b/analysis/src/lifetime.rs index bdbf902ab..a3944437b 100644 --- a/analysis/src/lifetime.rs +++ b/analysis/src/lifetime.rs @@ -6,7 +6,10 @@ use syn::Ident; use crate::{ decl::{Decl, Ty}, - item::{TypeItem, structure::StructMember}, + item::{ + TypeItem, + structure::{StructDecl, StructMember}, + }, name::TypeName, }; @@ -53,10 +56,10 @@ fn determine_for_type( TypeItem::Struct(item) => item.members.iter().any(|member| { matches!( member, - StructMember::Normal(Decl { + StructMember::Normal(StructDecl { decl: Decl{ ty, .. - })if determine_for_type(store, types, ty, true) + }, ..})if determine_for_type(store, types, ty, true) ) }), TypeItem::Union(item) => item.members.iter().any(|member| { diff --git a/analysis/src/name.rs b/analysis/src/name.rs index 22aac4f1e..53e5efe93 100644 --- a/analysis/src/name.rs +++ b/analysis/src/name.rs @@ -12,6 +12,8 @@ impl TypeName { pub const VK_QUEUE: Self = Self::new("VkQueue"); pub const VK_INSTANCE: Self = Self::new("VkInstance"); pub const VK_PHYSICAL_DEVICE: Self = Self::new("VkPhysicalDevice"); + pub const VK_STRUCTURE_TYPE: Self = Self::new("VkStructureType"); + pub const VK_BOOL32: Self = Self::new("VkBool32"); pub const fn new(original: &'static str) -> Self { Self(original) diff --git a/analysis/src/to_rust.rs b/analysis/src/to_rust.rs index c09e7bbd9..5855df631 100644 --- a/analysis/src/to_rust.rs +++ b/analysis/src/to_rust.rs @@ -1,5 +1,5 @@ use crate::{ - decl::{ArrayLen, CPrimaryType, Decl, Mutability, Ty}, + decl::{CPrimaryType, Decl, Mutability, RustType, Ty}, lifetime::Lifetime, name::{ CMacroName, CommandName, ConstantName, EnumeratorName, FuncPointerName, TypeName, @@ -7,7 +7,7 @@ use crate::{ }, xml::cexpr::CExprItem, }; -use proc_macro2::{Literal, TokenStream}; +use proc_macro2::{TokenStream}; use quote::quote; use std::{borrow::Borrow, mem}; use syn::Ident; @@ -32,7 +32,9 @@ pub trait RustTranslator { fn cmacro_to_rust(&self, name: CMacroName, qualified: bool) -> TokenStream; - fn platform_type_to_rust(&self, raw: &'static str, qualified: bool) -> TokenStream; + fn platform_type_to_rust(&self, raw: &str, qualified: bool) -> TokenStream; + + fn rust_type_to_rust(&self, ty: &RustType) -> TokenStream; fn primary_type_to_rust(&self, primary_ty: CPrimaryType) -> TokenStream { match primary_ty { @@ -88,18 +90,27 @@ impl Ty { let ty = ty.to_rust(translator, lifetime); quote! { & #lifetime #mutability #ty } } + Ty::Slice(ty, mutability, len) => { + let mutability = match mutability { + Mutability::Not => quote! {}, + Mutability::Mut => quote! { mut }, + }; + let len = len.as_ref().map(|len| { + let len = len.to_rust(translator); + quote! { ; #len} + }); + let ty = ty.to_rust(translator, lifetime); + quote! { & #lifetime #mutability [#ty #len] } + } Ty::Array(ty, array_len) => { let ty = ty.to_rust(translator, lifetime); - let array_len = match array_len { - ArrayLen::Constant(constant) => translator.constant_to_rust(*constant, true), - ArrayLen::Literal(value) => { - let literal = Literal::u128_unsuffixed(*value); - quote! { #literal } - } - }; - + let array_len = array_len.to_rust(translator); quote! { [#ty; #array_len as _] } } + Ty::RustType(ty) => { + let ty = translator.rust_type_to_rust(ty); + quote! { #ty } + } } } } diff --git a/analysis/src/xml.rs b/analysis/src/xml.rs index 5296a0d4a..7be499ff7 100644 --- a/analysis/src/xml.rs +++ b/analysis/src/xml.rs @@ -469,7 +469,7 @@ pub struct StructureMember { pub c_decl: CDecl<'static>, pub values: Option<&'static str>, pub len: Vec<&'static str>, - pub altlen: Option<&'static str>, + pub altlen: Vec<&'static str>, pub optional: Vec<&'static str>, } @@ -479,7 +479,7 @@ impl StructureMember { c_decl: CDecl::from_xml(CDeclMode::StructMember, node.children()), values: attribute(node, "values"), len: attribute_comma_separated(node, "len"), - altlen: attribute(node, "altlen"), + altlen: attribute_comma_separated(node, "altlen"), optional: attribute_comma_separated(node, "optional"), } } diff --git a/ash-rewrite/src/generated/amd/anti_lag.rs b/ash-rewrite/src/generated/amd/anti_lag.rs index de1e10ad8..b2ee5a43f 100644 --- a/ash-rewrite/src/generated/amd/anti_lag.rs +++ b/ash-rewrite/src/generated/amd/anti_lag.rs @@ -43,6 +43,29 @@ pub(crate) mod reexport { pub anti_lag: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for PhysicalDeviceAntiLagFeaturesAMD<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_ANTI_LAG_FEATURES_AMD; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceAntiLagFeaturesAMD<'a> {} + unsafe impl<'a> crate::Extends> + for PhysicalDeviceAntiLagFeaturesAMD<'a> {} + impl<'a> Default for PhysicalDeviceAntiLagFeaturesAMD<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + anti_lag: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceAntiLagFeaturesAMD<'a> { + pub fn anti_lag(mut self, anti_lag: bool) -> Self { + self.anti_lag = anti_lag.into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct AntiLagDataAMD<'a> { @@ -53,6 +76,38 @@ pub(crate) mod reexport { pub p_presentation_info: *const crate::vk::AntiLagPresentationInfoAMD<'a>, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for AntiLagDataAMD<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::ANTI_LAG_DATA_AMD; + } + impl<'a> Default for AntiLagDataAMD<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + mode: Default::default(), + max_fps: Default::default(), + p_presentation_info: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> AntiLagDataAMD<'a> { + pub fn mode(mut self, mode: crate::vk::AntiLagModeAMD) -> Self { + self.mode = mode; + self + } + pub fn max_fps(mut self, max_fps: u32) -> Self { + self.max_fps = max_fps; + self + } + pub fn p_presentation_info( + mut self, + p_presentation_info: &'a crate::vk::AntiLagPresentationInfoAMD<'a>, + ) -> Self { + self.p_presentation_info = p_presentation_info; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct AntiLagPresentationInfoAMD<'a> { @@ -62,6 +117,30 @@ pub(crate) mod reexport { pub frame_index: u64, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for AntiLagPresentationInfoAMD<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::ANTI_LAG_PRESENTATION_INFO_AMD; + } + impl<'a> Default for AntiLagPresentationInfoAMD<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + stage: Default::default(), + frame_index: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> AntiLagPresentationInfoAMD<'a> { + pub fn stage(mut self, stage: crate::vk::AntiLagStageAMD) -> Self { + self.stage = stage; + self + } + pub fn frame_index(mut self, frame_index: u64) -> Self { + self.frame_index = frame_index; + self + } + } ///Provided by [`amd::anti_lag`](crate::amd::anti_lag) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_ANTI_LAG_FEATURES_AMD: Self = Self(1000476000); diff --git a/ash-rewrite/src/generated/amd/device_coherent_memory.rs b/ash-rewrite/src/generated/amd/device_coherent_memory.rs index fe117be43..84adb656f 100644 --- a/ash-rewrite/src/generated/amd/device_coherent_memory.rs +++ b/ash-rewrite/src/generated/amd/device_coherent_memory.rs @@ -9,6 +9,30 @@ pub struct PhysicalDeviceCoherentMemoryFeaturesAMD<'a> { pub device_coherent_memory: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceCoherentMemoryFeaturesAMD<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceCoherentMemoryFeaturesAMD<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceCoherentMemoryFeaturesAMD<'a> {} +impl<'a> Default for PhysicalDeviceCoherentMemoryFeaturesAMD<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + device_coherent_memory: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceCoherentMemoryFeaturesAMD<'a> { + pub fn device_coherent_memory(mut self, device_coherent_memory: bool) -> Self { + self.device_coherent_memory = device_coherent_memory.into(); + self + } +} ///Provided by [`amd::device_coherent_memory`](crate::amd::device_coherent_memory) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD: Self = Self(1000229000); diff --git a/ash-rewrite/src/generated/amd/display_native_hdr.rs b/ash-rewrite/src/generated/amd/display_native_hdr.rs index 6048844d6..66e623951 100644 --- a/ash-rewrite/src/generated/amd/display_native_hdr.rs +++ b/ash-rewrite/src/generated/amd/display_native_hdr.rs @@ -44,6 +44,28 @@ pub(crate) mod reexport { pub local_dimming_support: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for DisplayNativeHdrSurfaceCapabilitiesAMD<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD; + } + unsafe impl<'a> crate::Extends> + for DisplayNativeHdrSurfaceCapabilitiesAMD<'a> {} + impl<'a> Default for DisplayNativeHdrSurfaceCapabilitiesAMD<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + local_dimming_support: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> DisplayNativeHdrSurfaceCapabilitiesAMD<'a> { + pub fn local_dimming_support(mut self, local_dimming_support: bool) -> Self { + self.local_dimming_support = local_dimming_support.into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct SwapchainDisplayNativeHdrCreateInfoAMD<'a> { @@ -52,6 +74,28 @@ pub(crate) mod reexport { pub local_dimming_enable: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for SwapchainDisplayNativeHdrCreateInfoAMD<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD; + } + unsafe impl<'a> crate::Extends> + for SwapchainDisplayNativeHdrCreateInfoAMD<'a> {} + impl<'a> Default for SwapchainDisplayNativeHdrCreateInfoAMD<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + local_dimming_enable: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> SwapchainDisplayNativeHdrCreateInfoAMD<'a> { + pub fn local_dimming_enable(mut self, local_dimming_enable: bool) -> Self { + self.local_dimming_enable = local_dimming_enable.into(); + self + } + } ///Provided by [`amd::display_native_hdr`](crate::amd::display_native_hdr) impl crate::vk::StructureType { pub const DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD: Self = Self(1000213000); diff --git a/ash-rewrite/src/generated/amd/memory_overallocation_behavior.rs b/ash-rewrite/src/generated/amd/memory_overallocation_behavior.rs index 9688bfc34..a709c3093 100644 --- a/ash-rewrite/src/generated/amd/memory_overallocation_behavior.rs +++ b/ash-rewrite/src/generated/amd/memory_overallocation_behavior.rs @@ -9,6 +9,31 @@ pub struct DeviceMemoryOverallocationCreateInfoAMD<'a> { pub overallocation_behavior: crate::vk::MemoryOverallocationBehaviorAMD, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for DeviceMemoryOverallocationCreateInfoAMD<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD; +} +unsafe impl<'a> crate::Extends> +for DeviceMemoryOverallocationCreateInfoAMD<'a> {} +impl<'a> Default for DeviceMemoryOverallocationCreateInfoAMD<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + overallocation_behavior: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> DeviceMemoryOverallocationCreateInfoAMD<'a> { + pub fn overallocation_behavior( + mut self, + overallocation_behavior: crate::vk::MemoryOverallocationBehaviorAMD, + ) -> Self { + self.overallocation_behavior = overallocation_behavior; + self + } +} ///Provided by [`amd::memory_overallocation_behavior`](crate::amd::memory_overallocation_behavior) impl crate::vk::StructureType { pub const DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD: Self = Self(1000189000); diff --git a/ash-rewrite/src/generated/amd/mixed_attachment_samples.rs b/ash-rewrite/src/generated/amd/mixed_attachment_samples.rs index 91e653285..5ab7abdd2 100644 --- a/ash-rewrite/src/generated/amd/mixed_attachment_samples.rs +++ b/ash-rewrite/src/generated/amd/mixed_attachment_samples.rs @@ -11,6 +11,46 @@ pub struct AttachmentSampleCountInfoAMD<'a> { pub depth_stencil_attachment_samples: crate::vk::SampleCountFlagBits, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> for AttachmentSampleCountInfoAMD<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::ATTACHMENT_SAMPLE_COUNT_INFO_AMD; +} +unsafe impl<'a> crate::Extends> +for AttachmentSampleCountInfoAMD<'a> {} +unsafe impl<'a> crate::Extends> +for AttachmentSampleCountInfoAMD<'a> {} +impl<'a> Default for AttachmentSampleCountInfoAMD<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + color_attachment_count: Default::default(), + p_color_attachment_samples: Default::default(), + depth_stencil_attachment_samples: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> AttachmentSampleCountInfoAMD<'a> { + pub fn color_attachment_count(mut self, color_attachment_count: u32) -> Self { + self.color_attachment_count = color_attachment_count; + self + } + pub fn p_color_attachment_samples( + mut self, + p_color_attachment_samples: &'a [crate::vk::SampleCountFlagBits], + ) -> Self { + self.color_attachment_count = p_color_attachment_samples.len() as _; + self.p_color_attachment_samples = p_color_attachment_samples.as_ptr(); + self + } + pub fn depth_stencil_attachment_samples( + mut self, + depth_stencil_attachment_samples: crate::vk::SampleCountFlagBits, + ) -> Self { + self.depth_stencil_attachment_samples = depth_stencil_attachment_samples; + self + } +} ///Provided by [`amd::mixed_attachment_samples`](crate::amd::mixed_attachment_samples) impl crate::vk::StructureType { pub const ATTACHMENT_SAMPLE_COUNT_INFO_AMD: Self = Self(1000044008); diff --git a/ash-rewrite/src/generated/amd/pipeline_compiler_control.rs b/ash-rewrite/src/generated/amd/pipeline_compiler_control.rs index 691ba00f5..7877825a1 100644 --- a/ash-rewrite/src/generated/amd/pipeline_compiler_control.rs +++ b/ash-rewrite/src/generated/amd/pipeline_compiler_control.rs @@ -9,6 +9,34 @@ pub struct PipelineCompilerControlCreateInfoAMD<'a> { pub compiler_control_flags: crate::vk::PipelineCompilerControlFlagsAMD, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> for PipelineCompilerControlCreateInfoAMD<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD; +} +unsafe impl<'a> crate::Extends> +for PipelineCompilerControlCreateInfoAMD<'a> {} +unsafe impl<'a> crate::Extends> +for PipelineCompilerControlCreateInfoAMD<'a> {} +unsafe impl<'a> crate::Extends> +for PipelineCompilerControlCreateInfoAMD<'a> {} +impl<'a> Default for PipelineCompilerControlCreateInfoAMD<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + compiler_control_flags: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PipelineCompilerControlCreateInfoAMD<'a> { + pub fn compiler_control_flags( + mut self, + compiler_control_flags: crate::vk::PipelineCompilerControlFlagsAMD, + ) -> Self { + self.compiler_control_flags = compiler_control_flags; + self + } +} ///Provided by [`amd::pipeline_compiler_control`](crate::amd::pipeline_compiler_control) impl crate::vk::StructureType { pub const PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD: Self = Self(1000183000); @@ -81,7 +109,7 @@ impl core::ops::Not for PipelineCompilerControlFlagsAMD { } } #[repr(transparent)] -#[derive(Clone, Copy)] +#[derive(Clone, Copy, Default)] pub struct PipelineCompilerControlFlagBitsAMD(pub(crate) u32); pub const AMD_PIPELINE_COMPILER_CONTROL_SPEC_VERSION: u32 = 1; pub const AMD_PIPELINE_COMPILER_CONTROL_EXTENSION_NAME: &core::ffi::CStr = c"VK_AMD_pipeline_compiler_control"; diff --git a/ash-rewrite/src/generated/amd/rasterization_order.rs b/ash-rewrite/src/generated/amd/rasterization_order.rs index c97599bf9..9c1b35418 100644 --- a/ash-rewrite/src/generated/amd/rasterization_order.rs +++ b/ash-rewrite/src/generated/amd/rasterization_order.rs @@ -9,6 +9,31 @@ pub struct PipelineRasterizationStateRasterizationOrderAMD<'a> { pub rasterization_order: crate::vk::RasterizationOrderAMD, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PipelineRasterizationStateRasterizationOrderAMD<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD; +} +unsafe impl<'a> crate::Extends> +for PipelineRasterizationStateRasterizationOrderAMD<'a> {} +impl<'a> Default for PipelineRasterizationStateRasterizationOrderAMD<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + rasterization_order: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PipelineRasterizationStateRasterizationOrderAMD<'a> { + pub fn rasterization_order( + mut self, + rasterization_order: crate::vk::RasterizationOrderAMD, + ) -> Self { + self.rasterization_order = rasterization_order; + self + } +} ///Provided by [`amd::rasterization_order`](crate::amd::rasterization_order) impl crate::vk::StructureType { pub const PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD: Self = Self( diff --git a/ash-rewrite/src/generated/amd/shader_core_properties.rs b/ash-rewrite/src/generated/amd/shader_core_properties.rs index ff72a288e..7928cb32c 100644 --- a/ash-rewrite/src/generated/amd/shader_core_properties.rs +++ b/ash-rewrite/src/generated/amd/shader_core_properties.rs @@ -22,6 +22,105 @@ pub struct PhysicalDeviceShaderCorePropertiesAMD<'a> { pub vgpr_allocation_granularity: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceShaderCorePropertiesAMD<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceShaderCorePropertiesAMD<'a> {} +impl<'a> Default for PhysicalDeviceShaderCorePropertiesAMD<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + shader_engine_count: Default::default(), + shader_arrays_per_engine_count: Default::default(), + compute_units_per_shader_array: Default::default(), + simd_per_compute_unit: Default::default(), + wavefronts_per_simd: Default::default(), + wavefront_size: Default::default(), + sgprs_per_simd: Default::default(), + min_sgpr_allocation: Default::default(), + max_sgpr_allocation: Default::default(), + sgpr_allocation_granularity: Default::default(), + vgprs_per_simd: Default::default(), + min_vgpr_allocation: Default::default(), + max_vgpr_allocation: Default::default(), + vgpr_allocation_granularity: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceShaderCorePropertiesAMD<'a> { + pub fn shader_engine_count(mut self, shader_engine_count: u32) -> Self { + self.shader_engine_count = shader_engine_count; + self + } + pub fn shader_arrays_per_engine_count( + mut self, + shader_arrays_per_engine_count: u32, + ) -> Self { + self.shader_arrays_per_engine_count = shader_arrays_per_engine_count; + self + } + pub fn compute_units_per_shader_array( + mut self, + compute_units_per_shader_array: u32, + ) -> Self { + self.compute_units_per_shader_array = compute_units_per_shader_array; + self + } + pub fn simd_per_compute_unit(mut self, simd_per_compute_unit: u32) -> Self { + self.simd_per_compute_unit = simd_per_compute_unit; + self + } + pub fn wavefronts_per_simd(mut self, wavefronts_per_simd: u32) -> Self { + self.wavefronts_per_simd = wavefronts_per_simd; + self + } + pub fn wavefront_size(mut self, wavefront_size: u32) -> Self { + self.wavefront_size = wavefront_size; + self + } + pub fn sgprs_per_simd(mut self, sgprs_per_simd: u32) -> Self { + self.sgprs_per_simd = sgprs_per_simd; + self + } + pub fn min_sgpr_allocation(mut self, min_sgpr_allocation: u32) -> Self { + self.min_sgpr_allocation = min_sgpr_allocation; + self + } + pub fn max_sgpr_allocation(mut self, max_sgpr_allocation: u32) -> Self { + self.max_sgpr_allocation = max_sgpr_allocation; + self + } + pub fn sgpr_allocation_granularity( + mut self, + sgpr_allocation_granularity: u32, + ) -> Self { + self.sgpr_allocation_granularity = sgpr_allocation_granularity; + self + } + pub fn vgprs_per_simd(mut self, vgprs_per_simd: u32) -> Self { + self.vgprs_per_simd = vgprs_per_simd; + self + } + pub fn min_vgpr_allocation(mut self, min_vgpr_allocation: u32) -> Self { + self.min_vgpr_allocation = min_vgpr_allocation; + self + } + pub fn max_vgpr_allocation(mut self, max_vgpr_allocation: u32) -> Self { + self.max_vgpr_allocation = max_vgpr_allocation; + self + } + pub fn vgpr_allocation_granularity( + mut self, + vgpr_allocation_granularity: u32, + ) -> Self { + self.vgpr_allocation_granularity = vgpr_allocation_granularity; + self + } +} ///Provided by [`amd::shader_core_properties`](crate::amd::shader_core_properties) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD: Self = Self(1000185000); diff --git a/ash-rewrite/src/generated/amd/shader_core_properties2.rs b/ash-rewrite/src/generated/amd/shader_core_properties2.rs index b2a457097..36f517789 100644 --- a/ash-rewrite/src/generated/amd/shader_core_properties2.rs +++ b/ash-rewrite/src/generated/amd/shader_core_properties2.rs @@ -10,6 +10,36 @@ pub struct PhysicalDeviceShaderCoreProperties2AMD<'a> { pub active_compute_unit_count: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceShaderCoreProperties2AMD<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceShaderCoreProperties2AMD<'a> {} +impl<'a> Default for PhysicalDeviceShaderCoreProperties2AMD<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + shader_core_features: Default::default(), + active_compute_unit_count: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceShaderCoreProperties2AMD<'a> { + pub fn shader_core_features( + mut self, + shader_core_features: crate::vk::ShaderCorePropertiesFlagsAMD, + ) -> Self { + self.shader_core_features = shader_core_features; + self + } + pub fn active_compute_unit_count(mut self, active_compute_unit_count: u32) -> Self { + self.active_compute_unit_count = active_compute_unit_count; + self + } +} ///Provided by [`amd::shader_core_properties2`](crate::amd::shader_core_properties2) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD: Self = Self(1000227000); @@ -82,7 +112,7 @@ impl core::ops::Not for ShaderCorePropertiesFlagsAMD { } } #[repr(transparent)] -#[derive(Clone, Copy)] +#[derive(Clone, Copy, Default)] pub struct ShaderCorePropertiesFlagBitsAMD(pub(crate) u32); pub const AMD_SHADER_CORE_PROPERTIES_2_SPEC_VERSION: u32 = 1; pub const AMD_SHADER_CORE_PROPERTIES_2_EXTENSION_NAME: &core::ffi::CStr = c"VK_AMD_shader_core_properties2"; diff --git a/ash-rewrite/src/generated/amd/shader_early_and_late_fragment_tests.rs b/ash-rewrite/src/generated/amd/shader_early_and_late_fragment_tests.rs index 45d95d39a..e1c1cf51d 100644 --- a/ash-rewrite/src/generated/amd/shader_early_and_late_fragment_tests.rs +++ b/ash-rewrite/src/generated/amd/shader_early_and_late_fragment_tests.rs @@ -9,6 +9,34 @@ pub struct PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD<'a> { pub shader_early_and_late_fragment_tests: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD<'a> {} +impl<'a> Default for PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + shader_early_and_late_fragment_tests: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD<'a> { + pub fn shader_early_and_late_fragment_tests( + mut self, + shader_early_and_late_fragment_tests: bool, + ) -> Self { + self.shader_early_and_late_fragment_tests = shader_early_and_late_fragment_tests + .into(); + self + } +} ///Provided by [`amd::shader_early_and_late_fragment_tests`](crate::amd::shader_early_and_late_fragment_tests) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD: Self = Self( diff --git a/ash-rewrite/src/generated/amd/shader_info.rs b/ash-rewrite/src/generated/amd/shader_info.rs index 4e7f9282f..b20fb0195 100644 --- a/ash-rewrite/src/generated/amd/shader_info.rs +++ b/ash-rewrite/src/generated/amd/shader_info.rs @@ -40,7 +40,7 @@ impl DeviceFn { } pub(crate) mod reexport { #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct ShaderResourceUsageAMD { pub num_used_vgprs: u32, pub num_used_sgprs: u32, @@ -48,6 +48,37 @@ pub(crate) mod reexport { pub lds_usage_size_in_bytes: usize, pub scratch_mem_usage_in_bytes: usize, } + impl ShaderResourceUsageAMD { + pub fn num_used_vgprs(mut self, num_used_vgprs: u32) -> Self { + self.num_used_vgprs = num_used_vgprs; + self + } + pub fn num_used_sgprs(mut self, num_used_sgprs: u32) -> Self { + self.num_used_sgprs = num_used_sgprs; + self + } + pub fn lds_size_per_local_work_group( + mut self, + lds_size_per_local_work_group: u32, + ) -> Self { + self.lds_size_per_local_work_group = lds_size_per_local_work_group; + self + } + pub fn lds_usage_size_in_bytes( + mut self, + lds_usage_size_in_bytes: usize, + ) -> Self { + self.lds_usage_size_in_bytes = lds_usage_size_in_bytes; + self + } + pub fn scratch_mem_usage_in_bytes( + mut self, + scratch_mem_usage_in_bytes: usize, + ) -> Self { + self.scratch_mem_usage_in_bytes = scratch_mem_usage_in_bytes; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct ShaderStatisticsInfoAMD { @@ -59,6 +90,58 @@ pub(crate) mod reexport { pub num_available_sgprs: u32, pub compute_work_group_size: [u32; 3 as _], } + impl Default for ShaderStatisticsInfoAMD { + fn default() -> Self { + Self { + shader_stage_mask: Default::default(), + resource_usage: Default::default(), + num_physical_vgprs: Default::default(), + num_physical_sgprs: Default::default(), + num_available_vgprs: Default::default(), + num_available_sgprs: Default::default(), + compute_work_group_size: unsafe { core::mem::zeroed() }, + } + } + } + impl ShaderStatisticsInfoAMD { + pub fn shader_stage_mask( + mut self, + shader_stage_mask: crate::vk::ShaderStageFlags, + ) -> Self { + self.shader_stage_mask = shader_stage_mask; + self + } + pub fn resource_usage( + mut self, + resource_usage: crate::vk::ShaderResourceUsageAMD, + ) -> Self { + self.resource_usage = resource_usage; + self + } + pub fn num_physical_vgprs(mut self, num_physical_vgprs: u32) -> Self { + self.num_physical_vgprs = num_physical_vgprs; + self + } + pub fn num_physical_sgprs(mut self, num_physical_sgprs: u32) -> Self { + self.num_physical_sgprs = num_physical_sgprs; + self + } + pub fn num_available_vgprs(mut self, num_available_vgprs: u32) -> Self { + self.num_available_vgprs = num_available_vgprs; + self + } + pub fn num_available_sgprs(mut self, num_available_sgprs: u32) -> Self { + self.num_available_sgprs = num_available_sgprs; + self + } + pub fn compute_work_group_size( + mut self, + compute_work_group_size: [u32; 3 as _], + ) -> Self { + self.compute_work_group_size = compute_work_group_size; + self + } + } #[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[derive(Debug)] diff --git a/ash-rewrite/src/generated/amd/texture_gather_bias_lod.rs b/ash-rewrite/src/generated/amd/texture_gather_bias_lod.rs index e505a419d..66a24e932 100644 --- a/ash-rewrite/src/generated/amd/texture_gather_bias_lod.rs +++ b/ash-rewrite/src/generated/amd/texture_gather_bias_lod.rs @@ -9,6 +9,31 @@ pub struct TextureLODGatherFormatPropertiesAMD<'a> { pub supports_texture_gather_lod_bias_amd: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> for TextureLODGatherFormatPropertiesAMD<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD; +} +unsafe impl<'a> crate::Extends> +for TextureLODGatherFormatPropertiesAMD<'a> {} +impl<'a> Default for TextureLODGatherFormatPropertiesAMD<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + supports_texture_gather_lod_bias_amd: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> TextureLODGatherFormatPropertiesAMD<'a> { + pub fn supports_texture_gather_lod_bias_amd( + mut self, + supports_texture_gather_lod_bias_amd: bool, + ) -> Self { + self.supports_texture_gather_lod_bias_amd = supports_texture_gather_lod_bias_amd + .into(); + self + } +} ///Provided by [`amd::texture_gather_bias_lod`](crate::amd::texture_gather_bias_lod) impl crate::vk::StructureType { pub const TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD: Self = Self(1000041000); diff --git a/ash-rewrite/src/generated/amdx/dense_geometry_format.rs b/ash-rewrite/src/generated/amdx/dense_geometry_format.rs index f724fa736..d1bd77ced 100644 --- a/ash-rewrite/src/generated/amdx/dense_geometry_format.rs +++ b/ash-rewrite/src/generated/amdx/dense_geometry_format.rs @@ -9,6 +9,30 @@ pub struct PhysicalDeviceDenseGeometryFormatFeaturesAMDX<'a> { pub dense_geometry_format: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceDenseGeometryFormatFeaturesAMDX<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_DENSE_GEOMETRY_FORMAT_FEATURES_AMDX; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceDenseGeometryFormatFeaturesAMDX<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceDenseGeometryFormatFeaturesAMDX<'a> {} +impl<'a> Default for PhysicalDeviceDenseGeometryFormatFeaturesAMDX<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + dense_geometry_format: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceDenseGeometryFormatFeaturesAMDX<'a> { + pub fn dense_geometry_format(mut self, dense_geometry_format: bool) -> Self { + self.dense_geometry_format = dense_geometry_format.into(); + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct AccelerationStructureDenseGeometryFormatTrianglesDataAMDX<'a> { @@ -23,6 +47,61 @@ pub struct AccelerationStructureDenseGeometryFormatTrianglesDataAMDX<'a> { pub format: crate::vk::CompressedTriangleFormatAMDX, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for AccelerationStructureDenseGeometryFormatTrianglesDataAMDX<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::ACCELERATION_STRUCTURE_DENSE_GEOMETRY_FORMAT_TRIANGLES_DATA_AMDX; +} +unsafe impl<'a> crate::Extends> +for AccelerationStructureDenseGeometryFormatTrianglesDataAMDX<'a> {} +impl<'a> Default for AccelerationStructureDenseGeometryFormatTrianglesDataAMDX<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + compressed_data: Default::default(), + data_size: Default::default(), + num_triangles: Default::default(), + num_vertices: Default::default(), + max_primitive_index: Default::default(), + max_geometry_index: Default::default(), + format: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> AccelerationStructureDenseGeometryFormatTrianglesDataAMDX<'a> { + pub fn compressed_data( + mut self, + compressed_data: crate::vk::DeviceOrHostAddressConstKHR, + ) -> Self { + self.compressed_data = compressed_data; + self + } + pub fn data_size(mut self, data_size: crate::vk::DeviceSize) -> Self { + self.data_size = data_size; + self + } + pub fn num_triangles(mut self, num_triangles: u32) -> Self { + self.num_triangles = num_triangles; + self + } + pub fn num_vertices(mut self, num_vertices: u32) -> Self { + self.num_vertices = num_vertices; + self + } + pub fn max_primitive_index(mut self, max_primitive_index: u32) -> Self { + self.max_primitive_index = max_primitive_index; + self + } + pub fn max_geometry_index(mut self, max_geometry_index: u32) -> Self { + self.max_geometry_index = max_geometry_index; + self + } + pub fn format(mut self, format: crate::vk::CompressedTriangleFormatAMDX) -> Self { + self.format = format; + self + } +} ///Provided by [`amdx::dense_geometry_format`](crate::amdx::dense_geometry_format) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_DENSE_GEOMETRY_FORMAT_FEATURES_AMDX: Self = Self( diff --git a/ash-rewrite/src/generated/amdx/shader_enqueue.rs b/ash-rewrite/src/generated/amdx/shader_enqueue.rs index 978ccbf9b..1b7dce44f 100644 --- a/ash-rewrite/src/generated/amdx/shader_enqueue.rs +++ b/ash-rewrite/src/generated/amdx/shader_enqueue.rs @@ -154,6 +154,79 @@ pub(crate) mod reexport { pub max_execution_graph_workgroups: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceShaderEnqueuePropertiesAMDX<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_SHADER_ENQUEUE_PROPERTIES_AMDX; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceShaderEnqueuePropertiesAMDX<'a> {} + impl<'a> Default for PhysicalDeviceShaderEnqueuePropertiesAMDX<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + max_execution_graph_depth: Default::default(), + max_execution_graph_shader_output_nodes: Default::default(), + max_execution_graph_shader_payload_size: Default::default(), + max_execution_graph_shader_payload_count: Default::default(), + execution_graph_dispatch_address_alignment: Default::default(), + max_execution_graph_workgroup_count: unsafe { core::mem::zeroed() }, + max_execution_graph_workgroups: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceShaderEnqueuePropertiesAMDX<'a> { + pub fn max_execution_graph_depth( + mut self, + max_execution_graph_depth: u32, + ) -> Self { + self.max_execution_graph_depth = max_execution_graph_depth; + self + } + pub fn max_execution_graph_shader_output_nodes( + mut self, + max_execution_graph_shader_output_nodes: u32, + ) -> Self { + self.max_execution_graph_shader_output_nodes = max_execution_graph_shader_output_nodes; + self + } + pub fn max_execution_graph_shader_payload_size( + mut self, + max_execution_graph_shader_payload_size: u32, + ) -> Self { + self.max_execution_graph_shader_payload_size = max_execution_graph_shader_payload_size; + self + } + pub fn max_execution_graph_shader_payload_count( + mut self, + max_execution_graph_shader_payload_count: u32, + ) -> Self { + self.max_execution_graph_shader_payload_count = max_execution_graph_shader_payload_count; + self + } + pub fn execution_graph_dispatch_address_alignment( + mut self, + execution_graph_dispatch_address_alignment: u32, + ) -> Self { + self.execution_graph_dispatch_address_alignment = execution_graph_dispatch_address_alignment; + self + } + pub fn max_execution_graph_workgroup_count( + mut self, + max_execution_graph_workgroup_count: [u32; 3 as _], + ) -> Self { + self.max_execution_graph_workgroup_count = max_execution_graph_workgroup_count; + self + } + pub fn max_execution_graph_workgroups( + mut self, + max_execution_graph_workgroups: u32, + ) -> Self { + self.max_execution_graph_workgroups = max_execution_graph_workgroups; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceShaderEnqueueFeaturesAMDX<'a> { @@ -163,6 +236,35 @@ pub(crate) mod reexport { pub shader_mesh_enqueue: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceShaderEnqueueFeaturesAMDX<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_SHADER_ENQUEUE_FEATURES_AMDX; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceShaderEnqueueFeaturesAMDX<'a> {} + unsafe impl<'a> crate::Extends> + for PhysicalDeviceShaderEnqueueFeaturesAMDX<'a> {} + impl<'a> Default for PhysicalDeviceShaderEnqueueFeaturesAMDX<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + shader_enqueue: Default::default(), + shader_mesh_enqueue: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceShaderEnqueueFeaturesAMDX<'a> { + pub fn shader_enqueue(mut self, shader_enqueue: bool) -> Self { + self.shader_enqueue = shader_enqueue.into(); + self + } + pub fn shader_mesh_enqueue(mut self, shader_mesh_enqueue: bool) -> Self { + self.shader_mesh_enqueue = shader_mesh_enqueue.into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct ExecutionGraphPipelineCreateInfoAMDX<'a> { @@ -177,6 +279,66 @@ pub(crate) mod reexport { pub base_pipeline_index: i32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for ExecutionGraphPipelineCreateInfoAMDX<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::EXECUTION_GRAPH_PIPELINE_CREATE_INFO_AMDX; + } + impl<'a> Default for ExecutionGraphPipelineCreateInfoAMDX<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + flags: Default::default(), + stage_count: Default::default(), + p_stages: Default::default(), + p_library_info: Default::default(), + layout: Default::default(), + base_pipeline_handle: Default::default(), + base_pipeline_index: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> ExecutionGraphPipelineCreateInfoAMDX<'a> { + pub fn flags(mut self, flags: crate::vk::PipelineCreateFlags) -> Self { + self.flags = flags; + self + } + pub fn stage_count(mut self, stage_count: u32) -> Self { + self.stage_count = stage_count; + self + } + pub fn p_stages( + mut self, + p_stages: &'a [crate::vk::PipelineShaderStageCreateInfo<'a>], + ) -> Self { + self.stage_count = p_stages.len() as _; + self.p_stages = p_stages.as_ptr(); + self + } + pub fn p_library_info( + mut self, + p_library_info: &'a crate::vk::PipelineLibraryCreateInfoKHR<'a>, + ) -> Self { + self.p_library_info = p_library_info; + self + } + pub fn layout(mut self, layout: crate::vk::PipelineLayout) -> Self { + self.layout = layout; + self + } + pub fn base_pipeline_handle( + mut self, + base_pipeline_handle: crate::vk::Pipeline, + ) -> Self { + self.base_pipeline_handle = base_pipeline_handle; + self + } + pub fn base_pipeline_index(mut self, base_pipeline_index: i32) -> Self { + self.base_pipeline_index = base_pipeline_index; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PipelineShaderStageNodeCreateInfoAMDX<'a> { @@ -186,6 +348,40 @@ pub(crate) mod reexport { pub index: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PipelineShaderStageNodeCreateInfoAMDX<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PIPELINE_SHADER_STAGE_NODE_CREATE_INFO_AMDX; + } + unsafe impl<'a> crate::Extends> + for PipelineShaderStageNodeCreateInfoAMDX<'a> {} + impl<'a> Default for PipelineShaderStageNodeCreateInfoAMDX<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + p_name: Default::default(), + index: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PipelineShaderStageNodeCreateInfoAMDX<'a> { + pub fn p_name(mut self, p_name: &'a core::ffi::CStr) -> Self { + self.p_name = p_name.as_ptr(); + self + } + pub unsafe fn p_name_as_c_str(&self) -> Option<&core::ffi::CStr> { + if self.p_name.is_null() { + None + } else { + Some(unsafe { core::ffi::CStr::from_ptr(self.p_name) }) + } + } + pub fn index(mut self, index: u32) -> Self { + self.index = index; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct ExecutionGraphPipelineScratchSizeAMDX<'a> { @@ -196,27 +392,100 @@ pub(crate) mod reexport { pub size_granularity: crate::vk::DeviceSize, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for ExecutionGraphPipelineScratchSizeAMDX<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::EXECUTION_GRAPH_PIPELINE_SCRATCH_SIZE_AMDX; + } + impl<'a> Default for ExecutionGraphPipelineScratchSizeAMDX<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + min_size: Default::default(), + max_size: Default::default(), + size_granularity: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> ExecutionGraphPipelineScratchSizeAMDX<'a> { + pub fn min_size(mut self, min_size: crate::vk::DeviceSize) -> Self { + self.min_size = min_size; + self + } + pub fn max_size(mut self, max_size: crate::vk::DeviceSize) -> Self { + self.max_size = max_size; + self + } + pub fn size_granularity( + mut self, + size_granularity: crate::vk::DeviceSize, + ) -> Self { + self.size_granularity = size_granularity; + self + } + } #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct DispatchGraphInfoAMDX { pub node_index: u32, pub payload_count: u32, pub payloads: crate::vk::DeviceOrHostAddressConstAMDX, pub payload_stride: u64, } + impl DispatchGraphInfoAMDX { + pub fn node_index(mut self, node_index: u32) -> Self { + self.node_index = node_index; + self + } + pub fn payload_count(mut self, payload_count: u32) -> Self { + self.payload_count = payload_count; + self + } + pub fn payloads( + mut self, + payloads: crate::vk::DeviceOrHostAddressConstAMDX, + ) -> Self { + self.payloads = payloads; + self + } + pub fn payload_stride(mut self, payload_stride: u64) -> Self { + self.payload_stride = payload_stride; + self + } + } #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct DispatchGraphCountInfoAMDX { pub count: u32, pub infos: crate::vk::DeviceOrHostAddressConstAMDX, pub stride: u64, } + impl DispatchGraphCountInfoAMDX { + pub fn count(mut self, count: u32) -> Self { + self.count = count; + self + } + pub fn infos(mut self, infos: crate::vk::DeviceOrHostAddressConstAMDX) -> Self { + self.infos = infos; + self + } + pub fn stride(mut self, stride: u64) -> Self { + self.stride = stride; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub union DeviceOrHostAddressConstAMDX { pub device_address: crate::vk::DeviceAddress, pub host_address: *const core::ffi::c_void, } + impl Default for DeviceOrHostAddressConstAMDX { + fn default() -> Self { + unsafe { core::mem::zeroed() } + } + } ///Provided by [`amdx::shader_enqueue`](crate::amdx::shader_enqueue) impl crate::vk::PipelineBindPoint { pub const EXECUTION_GRAPH_AMDX: Self = Self(1000134000); diff --git a/ash-rewrite/src/generated/android/external_format_resolve.rs b/ash-rewrite/src/generated/android/external_format_resolve.rs index cfcf8a35e..e5a99f11d 100644 --- a/ash-rewrite/src/generated/android/external_format_resolve.rs +++ b/ash-rewrite/src/generated/android/external_format_resolve.rs @@ -9,6 +9,30 @@ pub struct PhysicalDeviceExternalFormatResolveFeaturesANDROID<'a> { pub external_format_resolve: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceExternalFormatResolveFeaturesANDROID<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_FEATURES_ANDROID; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceExternalFormatResolveFeaturesANDROID<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceExternalFormatResolveFeaturesANDROID<'a> {} +impl<'a> Default for PhysicalDeviceExternalFormatResolveFeaturesANDROID<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + external_format_resolve: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceExternalFormatResolveFeaturesANDROID<'a> { + pub fn external_format_resolve(mut self, external_format_resolve: bool) -> Self { + self.external_format_resolve = external_format_resolve.into(); + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceExternalFormatResolvePropertiesANDROID<'a> { @@ -19,6 +43,48 @@ pub struct PhysicalDeviceExternalFormatResolvePropertiesANDROID<'a> { pub external_format_resolve_chroma_offset_y: crate::vk::ChromaLocation, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceExternalFormatResolvePropertiesANDROID<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_PROPERTIES_ANDROID; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceExternalFormatResolvePropertiesANDROID<'a> {} +impl<'a> Default for PhysicalDeviceExternalFormatResolvePropertiesANDROID<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + null_color_attachment_with_external_format_resolve: Default::default(), + external_format_resolve_chroma_offset_x: Default::default(), + external_format_resolve_chroma_offset_y: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceExternalFormatResolvePropertiesANDROID<'a> { + pub fn null_color_attachment_with_external_format_resolve( + mut self, + null_color_attachment_with_external_format_resolve: bool, + ) -> Self { + self.null_color_attachment_with_external_format_resolve = null_color_attachment_with_external_format_resolve + .into(); + self + } + pub fn external_format_resolve_chroma_offset_x( + mut self, + external_format_resolve_chroma_offset_x: crate::vk::ChromaLocation, + ) -> Self { + self.external_format_resolve_chroma_offset_x = external_format_resolve_chroma_offset_x; + self + } + pub fn external_format_resolve_chroma_offset_y( + mut self, + external_format_resolve_chroma_offset_y: crate::vk::ChromaLocation, + ) -> Self { + self.external_format_resolve_chroma_offset_y = external_format_resolve_chroma_offset_y; + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct AndroidHardwareBufferFormatResolvePropertiesANDROID<'a> { @@ -27,6 +93,31 @@ pub struct AndroidHardwareBufferFormatResolvePropertiesANDROID<'a> { pub color_attachment_format: crate::vk::Format, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for AndroidHardwareBufferFormatResolvePropertiesANDROID<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::ANDROID_HARDWARE_BUFFER_FORMAT_RESOLVE_PROPERTIES_ANDROID; +} +unsafe impl<'a> crate::Extends> +for AndroidHardwareBufferFormatResolvePropertiesANDROID<'a> {} +impl<'a> Default for AndroidHardwareBufferFormatResolvePropertiesANDROID<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + color_attachment_format: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> AndroidHardwareBufferFormatResolvePropertiesANDROID<'a> { + pub fn color_attachment_format( + mut self, + color_attachment_format: crate::vk::Format, + ) -> Self { + self.color_attachment_format = color_attachment_format; + self + } +} ///Provided by [`android::external_format_resolve`](crate::android::external_format_resolve) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_FEATURES_ANDROID: Self = Self( diff --git a/ash-rewrite/src/generated/android/external_memory_android_hardware_buffer.rs b/ash-rewrite/src/generated/android/external_memory_android_hardware_buffer.rs index bedfedb5c..d56aa4046 100644 --- a/ash-rewrite/src/generated/android/external_memory_android_hardware_buffer.rs +++ b/ash-rewrite/src/generated/android/external_memory_android_hardware_buffer.rs @@ -60,6 +60,31 @@ pub(crate) mod reexport { pub buffer: *mut crate::platform_types::AHardwareBuffer, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for ImportAndroidHardwareBufferInfoANDROID<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID; + } + unsafe impl<'a> crate::Extends> + for ImportAndroidHardwareBufferInfoANDROID<'a> {} + impl<'a> Default for ImportAndroidHardwareBufferInfoANDROID<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + buffer: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> ImportAndroidHardwareBufferInfoANDROID<'a> { + pub fn buffer( + mut self, + buffer: &'a mut crate::platform_types::AHardwareBuffer, + ) -> Self { + self.buffer = buffer; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct AndroidHardwareBufferUsageANDROID<'a> { @@ -68,6 +93,31 @@ pub(crate) mod reexport { pub android_hardware_buffer_usage: u64, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for AndroidHardwareBufferUsageANDROID<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::ANDROID_HARDWARE_BUFFER_USAGE_ANDROID; + } + unsafe impl<'a> crate::Extends> + for AndroidHardwareBufferUsageANDROID<'a> {} + impl<'a> Default for AndroidHardwareBufferUsageANDROID<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + android_hardware_buffer_usage: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> AndroidHardwareBufferUsageANDROID<'a> { + pub fn android_hardware_buffer_usage( + mut self, + android_hardware_buffer_usage: u64, + ) -> Self { + self.android_hardware_buffer_usage = android_hardware_buffer_usage; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct AndroidHardwareBufferPropertiesANDROID<'a> { @@ -77,6 +127,34 @@ pub(crate) mod reexport { pub memory_type_bits: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for AndroidHardwareBufferPropertiesANDROID<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID; + } + impl<'a> Default for AndroidHardwareBufferPropertiesANDROID<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + allocation_size: Default::default(), + memory_type_bits: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> AndroidHardwareBufferPropertiesANDROID<'a> { + pub fn allocation_size( + mut self, + allocation_size: crate::vk::DeviceSize, + ) -> Self { + self.allocation_size = allocation_size; + self + } + pub fn memory_type_bits(mut self, memory_type_bits: u32) -> Self { + self.memory_type_bits = memory_type_bits; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct MemoryGetAndroidHardwareBufferInfoANDROID<'a> { @@ -85,6 +163,26 @@ pub(crate) mod reexport { pub memory: crate::vk::DeviceMemory, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for MemoryGetAndroidHardwareBufferInfoANDROID<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID; + } + impl<'a> Default for MemoryGetAndroidHardwareBufferInfoANDROID<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + memory: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> MemoryGetAndroidHardwareBufferInfoANDROID<'a> { + pub fn memory(mut self, memory: crate::vk::DeviceMemory) -> Self { + self.memory = memory; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct AndroidHardwareBufferFormatPropertiesANDROID<'a> { @@ -100,6 +198,81 @@ pub(crate) mod reexport { pub suggested_y_chroma_offset: crate::vk::ChromaLocation, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for AndroidHardwareBufferFormatPropertiesANDROID<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID; + } + unsafe impl<'a> crate::Extends> + for AndroidHardwareBufferFormatPropertiesANDROID<'a> {} + impl<'a> Default for AndroidHardwareBufferFormatPropertiesANDROID<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + format: Default::default(), + external_format: Default::default(), + format_features: Default::default(), + sampler_ycbcr_conversion_components: Default::default(), + suggested_ycbcr_model: Default::default(), + suggested_ycbcr_range: Default::default(), + suggested_x_chroma_offset: Default::default(), + suggested_y_chroma_offset: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> AndroidHardwareBufferFormatPropertiesANDROID<'a> { + pub fn format(mut self, format: crate::vk::Format) -> Self { + self.format = format; + self + } + pub fn external_format(mut self, external_format: u64) -> Self { + self.external_format = external_format; + self + } + pub fn format_features( + mut self, + format_features: crate::vk::FormatFeatureFlags, + ) -> Self { + self.format_features = format_features; + self + } + pub fn sampler_ycbcr_conversion_components( + mut self, + sampler_ycbcr_conversion_components: crate::vk::ComponentMapping, + ) -> Self { + self.sampler_ycbcr_conversion_components = sampler_ycbcr_conversion_components; + self + } + pub fn suggested_ycbcr_model( + mut self, + suggested_ycbcr_model: crate::vk::SamplerYcbcrModelConversion, + ) -> Self { + self.suggested_ycbcr_model = suggested_ycbcr_model; + self + } + pub fn suggested_ycbcr_range( + mut self, + suggested_ycbcr_range: crate::vk::SamplerYcbcrRange, + ) -> Self { + self.suggested_ycbcr_range = suggested_ycbcr_range; + self + } + pub fn suggested_x_chroma_offset( + mut self, + suggested_x_chroma_offset: crate::vk::ChromaLocation, + ) -> Self { + self.suggested_x_chroma_offset = suggested_x_chroma_offset; + self + } + pub fn suggested_y_chroma_offset( + mut self, + suggested_y_chroma_offset: crate::vk::ChromaLocation, + ) -> Self { + self.suggested_y_chroma_offset = suggested_y_chroma_offset; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct ExternalFormatANDROID<'a> { @@ -108,6 +281,35 @@ pub(crate) mod reexport { pub external_format: u64, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for ExternalFormatANDROID<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::EXTERNAL_FORMAT_ANDROID; + } + unsafe impl<'a> crate::Extends> + for ExternalFormatANDROID<'a> {} + unsafe impl<'a> crate::Extends> + for ExternalFormatANDROID<'a> {} + unsafe impl<'a> crate::Extends> + for ExternalFormatANDROID<'a> {} + unsafe impl<'a> crate::Extends> + for ExternalFormatANDROID<'a> {} + unsafe impl<'a> crate::Extends> + for ExternalFormatANDROID<'a> {} + impl<'a> Default for ExternalFormatANDROID<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + external_format: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> ExternalFormatANDROID<'a> { + pub fn external_format(mut self, external_format: u64) -> Self { + self.external_format = external_format; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct AndroidHardwareBufferFormatProperties2ANDROID<'a> { @@ -123,6 +325,81 @@ pub(crate) mod reexport { pub suggested_y_chroma_offset: crate::vk::ChromaLocation, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for AndroidHardwareBufferFormatProperties2ANDROID<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID; + } + unsafe impl<'a> crate::Extends> + for AndroidHardwareBufferFormatProperties2ANDROID<'a> {} + impl<'a> Default for AndroidHardwareBufferFormatProperties2ANDROID<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + format: Default::default(), + external_format: Default::default(), + format_features: Default::default(), + sampler_ycbcr_conversion_components: Default::default(), + suggested_ycbcr_model: Default::default(), + suggested_ycbcr_range: Default::default(), + suggested_x_chroma_offset: Default::default(), + suggested_y_chroma_offset: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> AndroidHardwareBufferFormatProperties2ANDROID<'a> { + pub fn format(mut self, format: crate::vk::Format) -> Self { + self.format = format; + self + } + pub fn external_format(mut self, external_format: u64) -> Self { + self.external_format = external_format; + self + } + pub fn format_features( + mut self, + format_features: crate::vk::FormatFeatureFlags2, + ) -> Self { + self.format_features = format_features; + self + } + pub fn sampler_ycbcr_conversion_components( + mut self, + sampler_ycbcr_conversion_components: crate::vk::ComponentMapping, + ) -> Self { + self.sampler_ycbcr_conversion_components = sampler_ycbcr_conversion_components; + self + } + pub fn suggested_ycbcr_model( + mut self, + suggested_ycbcr_model: crate::vk::SamplerYcbcrModelConversion, + ) -> Self { + self.suggested_ycbcr_model = suggested_ycbcr_model; + self + } + pub fn suggested_ycbcr_range( + mut self, + suggested_ycbcr_range: crate::vk::SamplerYcbcrRange, + ) -> Self { + self.suggested_ycbcr_range = suggested_ycbcr_range; + self + } + pub fn suggested_x_chroma_offset( + mut self, + suggested_x_chroma_offset: crate::vk::ChromaLocation, + ) -> Self { + self.suggested_x_chroma_offset = suggested_x_chroma_offset; + self + } + pub fn suggested_y_chroma_offset( + mut self, + suggested_y_chroma_offset: crate::vk::ChromaLocation, + ) -> Self { + self.suggested_y_chroma_offset = suggested_y_chroma_offset; + self + } + } ///Provided by [`android::external_memory_android_hardware_buffer`](crate::android::external_memory_android_hardware_buffer) impl crate::vk::StructureType { pub const ANDROID_HARDWARE_BUFFER_USAGE_ANDROID: Self = Self(1000129000); diff --git a/ash-rewrite/src/generated/arm/data_graph.rs b/ash-rewrite/src/generated/arm/data_graph.rs index e549a96ca..2940f6e3a 100644 --- a/ash-rewrite/src/generated/arm/data_graph.rs +++ b/ash-rewrite/src/generated/arm/data_graph.rs @@ -255,6 +255,63 @@ pub(crate) mod reexport { pub data_graph_shader_module: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceDataGraphFeaturesARM<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_DATA_GRAPH_FEATURES_ARM; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceDataGraphFeaturesARM<'a> {} + unsafe impl<'a> crate::Extends> + for PhysicalDeviceDataGraphFeaturesARM<'a> {} + impl<'a> Default for PhysicalDeviceDataGraphFeaturesARM<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + data_graph: Default::default(), + data_graph_update_after_bind: Default::default(), + data_graph_specialization_constants: Default::default(), + data_graph_descriptor_buffer: Default::default(), + data_graph_shader_module: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceDataGraphFeaturesARM<'a> { + pub fn data_graph(mut self, data_graph: bool) -> Self { + self.data_graph = data_graph.into(); + self + } + pub fn data_graph_update_after_bind( + mut self, + data_graph_update_after_bind: bool, + ) -> Self { + self.data_graph_update_after_bind = data_graph_update_after_bind.into(); + self + } + pub fn data_graph_specialization_constants( + mut self, + data_graph_specialization_constants: bool, + ) -> Self { + self.data_graph_specialization_constants = data_graph_specialization_constants + .into(); + self + } + pub fn data_graph_descriptor_buffer( + mut self, + data_graph_descriptor_buffer: bool, + ) -> Self { + self.data_graph_descriptor_buffer = data_graph_descriptor_buffer.into(); + self + } + pub fn data_graph_shader_module( + mut self, + data_graph_shader_module: bool, + ) -> Self { + self.data_graph_shader_module = data_graph_shader_module.into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct DataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM<'a> { @@ -265,6 +322,39 @@ pub(crate) mod reexport { pub group_size: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for DataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::DATA_GRAPH_PIPELINE_CONSTANT_TENSOR_SEMI_STRUCTURED_SPARSITY_INFO_ARM; + } + unsafe impl<'a> crate::Extends> + for DataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM<'a> {} + impl<'a> Default + for DataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + dimension: Default::default(), + zero_count: Default::default(), + group_size: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> DataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM<'a> { + pub fn dimension(mut self, dimension: u32) -> Self { + self.dimension = dimension; + self + } + pub fn zero_count(mut self, zero_count: u32) -> Self { + self.zero_count = zero_count; + self + } + pub fn group_size(mut self, group_size: u32) -> Self { + self.group_size = group_size; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct DataGraphPipelineConstantARM<'a> { @@ -274,6 +364,33 @@ pub(crate) mod reexport { pub p_constant_data: *const core::ffi::c_void, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for DataGraphPipelineConstantARM<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::DATA_GRAPH_PIPELINE_CONSTANT_ARM; + } + impl<'a> Default for DataGraphPipelineConstantARM<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + id: Default::default(), + p_constant_data: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> DataGraphPipelineConstantARM<'a> { + pub fn id(mut self, id: u32) -> Self { + self.id = id; + self + } + pub fn p_constant_data( + mut self, + p_constant_data: &'a core::ffi::c_void, + ) -> Self { + self.p_constant_data = p_constant_data; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct DataGraphPipelineResourceInfoARM<'a> { @@ -284,6 +401,35 @@ pub(crate) mod reexport { pub array_element: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for DataGraphPipelineResourceInfoARM<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::DATA_GRAPH_PIPELINE_RESOURCE_INFO_ARM; + } + impl<'a> Default for DataGraphPipelineResourceInfoARM<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + descriptor_set: Default::default(), + binding: Default::default(), + array_element: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> DataGraphPipelineResourceInfoARM<'a> { + pub fn descriptor_set(mut self, descriptor_set: u32) -> Self { + self.descriptor_set = descriptor_set; + self + } + pub fn binding(mut self, binding: u32) -> Self { + self.binding = binding; + self + } + pub fn array_element(mut self, array_element: u32) -> Self { + self.array_element = array_element; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct DataGraphPipelineCompilerControlCreateInfoARM<'a> { @@ -292,6 +438,38 @@ pub(crate) mod reexport { pub p_vendor_options: *const core::ffi::c_char, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for DataGraphPipelineCompilerControlCreateInfoARM<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::DATA_GRAPH_PIPELINE_COMPILER_CONTROL_CREATE_INFO_ARM; + } + unsafe impl<'a> crate::Extends> + for DataGraphPipelineCompilerControlCreateInfoARM<'a> {} + impl<'a> Default for DataGraphPipelineCompilerControlCreateInfoARM<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + p_vendor_options: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> DataGraphPipelineCompilerControlCreateInfoARM<'a> { + pub fn p_vendor_options( + mut self, + p_vendor_options: &'a core::ffi::CStr, + ) -> Self { + self.p_vendor_options = p_vendor_options.as_ptr(); + self + } + pub unsafe fn p_vendor_options_as_c_str(&self) -> Option<&core::ffi::CStr> { + if self.p_vendor_options.is_null() { + None + } else { + Some(unsafe { core::ffi::CStr::from_ptr(self.p_vendor_options) }) + } + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct DataGraphPipelineCreateInfoARM<'a> { @@ -303,6 +481,44 @@ pub(crate) mod reexport { pub p_resource_infos: *const crate::vk::DataGraphPipelineResourceInfoARM<'a>, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for DataGraphPipelineCreateInfoARM<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::DATA_GRAPH_PIPELINE_CREATE_INFO_ARM; + } + impl<'a> Default for DataGraphPipelineCreateInfoARM<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + flags: Default::default(), + layout: Default::default(), + resource_info_count: Default::default(), + p_resource_infos: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> DataGraphPipelineCreateInfoARM<'a> { + pub fn flags(mut self, flags: crate::vk::PipelineCreateFlags2) -> Self { + self.flags = flags; + self + } + pub fn layout(mut self, layout: crate::vk::PipelineLayout) -> Self { + self.layout = layout; + self + } + pub fn resource_info_count(mut self, resource_info_count: u32) -> Self { + self.resource_info_count = resource_info_count; + self + } + pub fn p_resource_infos( + mut self, + p_resource_infos: &'a [crate::vk::DataGraphPipelineResourceInfoARM<'a>], + ) -> Self { + self.resource_info_count = p_resource_infos.len() as _; + self.p_resource_infos = p_resource_infos.as_ptr(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct DataGraphPipelineShaderModuleCreateInfoARM<'a> { @@ -315,6 +531,62 @@ pub(crate) mod reexport { pub p_constants: *const crate::vk::DataGraphPipelineConstantARM<'a>, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for DataGraphPipelineShaderModuleCreateInfoARM<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::DATA_GRAPH_PIPELINE_SHADER_MODULE_CREATE_INFO_ARM; + } + unsafe impl<'a> crate::Extends> + for DataGraphPipelineShaderModuleCreateInfoARM<'a> {} + impl<'a> Default for DataGraphPipelineShaderModuleCreateInfoARM<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + module: Default::default(), + p_name: Default::default(), + p_specialization_info: Default::default(), + constant_count: Default::default(), + p_constants: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> DataGraphPipelineShaderModuleCreateInfoARM<'a> { + pub fn module(mut self, module: crate::vk::ShaderModule) -> Self { + self.module = module; + self + } + pub fn p_name(mut self, p_name: &'a core::ffi::CStr) -> Self { + self.p_name = p_name.as_ptr(); + self + } + pub unsafe fn p_name_as_c_str(&self) -> Option<&core::ffi::CStr> { + if self.p_name.is_null() { + None + } else { + Some(unsafe { core::ffi::CStr::from_ptr(self.p_name) }) + } + } + pub fn p_specialization_info( + mut self, + p_specialization_info: &'a crate::vk::SpecializationInfo<'a>, + ) -> Self { + self.p_specialization_info = p_specialization_info; + self + } + pub fn constant_count(mut self, constant_count: u32) -> Self { + self.constant_count = constant_count; + self + } + pub fn p_constants( + mut self, + p_constants: &'a [crate::vk::DataGraphPipelineConstantARM<'a>], + ) -> Self { + self.constant_count = p_constants.len() as _; + self.p_constants = p_constants.as_ptr(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct DataGraphPipelineSessionCreateInfoARM<'a> { @@ -324,6 +596,37 @@ pub(crate) mod reexport { pub data_graph_pipeline: crate::vk::Pipeline, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for DataGraphPipelineSessionCreateInfoARM<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::DATA_GRAPH_PIPELINE_SESSION_CREATE_INFO_ARM; + } + impl<'a> Default for DataGraphPipelineSessionCreateInfoARM<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + flags: Default::default(), + data_graph_pipeline: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> DataGraphPipelineSessionCreateInfoARM<'a> { + pub fn flags( + mut self, + flags: crate::vk::DataGraphPipelineSessionCreateFlagsARM, + ) -> Self { + self.flags = flags; + self + } + pub fn data_graph_pipeline( + mut self, + data_graph_pipeline: crate::vk::Pipeline, + ) -> Self { + self.data_graph_pipeline = data_graph_pipeline; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct DataGraphPipelineSessionBindPointRequirementsInfoARM<'a> { @@ -332,6 +635,29 @@ pub(crate) mod reexport { pub session: crate::vk::DataGraphPipelineSessionARM, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for DataGraphPipelineSessionBindPointRequirementsInfoARM<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_REQUIREMENTS_INFO_ARM; + } + impl<'a> Default for DataGraphPipelineSessionBindPointRequirementsInfoARM<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + session: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> DataGraphPipelineSessionBindPointRequirementsInfoARM<'a> { + pub fn session( + mut self, + session: crate::vk::DataGraphPipelineSessionARM, + ) -> Self { + self.session = session; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct DataGraphPipelineSessionBindPointRequirementARM<'a> { @@ -342,6 +668,42 @@ pub(crate) mod reexport { pub num_objects: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for DataGraphPipelineSessionBindPointRequirementARM<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_REQUIREMENT_ARM; + } + impl<'a> Default for DataGraphPipelineSessionBindPointRequirementARM<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + bind_point: Default::default(), + bind_point_type: Default::default(), + num_objects: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> DataGraphPipelineSessionBindPointRequirementARM<'a> { + pub fn bind_point( + mut self, + bind_point: crate::vk::DataGraphPipelineSessionBindPointARM, + ) -> Self { + self.bind_point = bind_point; + self + } + pub fn bind_point_type( + mut self, + bind_point_type: crate::vk::DataGraphPipelineSessionBindPointTypeARM, + ) -> Self { + self.bind_point_type = bind_point_type; + self + } + pub fn num_objects(mut self, num_objects: u32) -> Self { + self.num_objects = num_objects; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct DataGraphPipelineSessionMemoryRequirementsInfoARM<'a> { @@ -352,6 +714,42 @@ pub(crate) mod reexport { pub object_index: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for DataGraphPipelineSessionMemoryRequirementsInfoARM<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::DATA_GRAPH_PIPELINE_SESSION_MEMORY_REQUIREMENTS_INFO_ARM; + } + impl<'a> Default for DataGraphPipelineSessionMemoryRequirementsInfoARM<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + session: Default::default(), + bind_point: Default::default(), + object_index: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> DataGraphPipelineSessionMemoryRequirementsInfoARM<'a> { + pub fn session( + mut self, + session: crate::vk::DataGraphPipelineSessionARM, + ) -> Self { + self.session = session; + self + } + pub fn bind_point( + mut self, + bind_point: crate::vk::DataGraphPipelineSessionBindPointARM, + ) -> Self { + self.bind_point = bind_point; + self + } + pub fn object_index(mut self, object_index: u32) -> Self { + self.object_index = object_index; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct BindDataGraphPipelineSessionMemoryInfoARM<'a> { @@ -364,6 +762,52 @@ pub(crate) mod reexport { pub memory_offset: crate::vk::DeviceSize, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for BindDataGraphPipelineSessionMemoryInfoARM<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::BIND_DATA_GRAPH_PIPELINE_SESSION_MEMORY_INFO_ARM; + } + impl<'a> Default for BindDataGraphPipelineSessionMemoryInfoARM<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + session: Default::default(), + bind_point: Default::default(), + object_index: Default::default(), + memory: Default::default(), + memory_offset: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> BindDataGraphPipelineSessionMemoryInfoARM<'a> { + pub fn session( + mut self, + session: crate::vk::DataGraphPipelineSessionARM, + ) -> Self { + self.session = session; + self + } + pub fn bind_point( + mut self, + bind_point: crate::vk::DataGraphPipelineSessionBindPointARM, + ) -> Self { + self.bind_point = bind_point; + self + } + pub fn object_index(mut self, object_index: u32) -> Self { + self.object_index = object_index; + self + } + pub fn memory(mut self, memory: crate::vk::DeviceMemory) -> Self { + self.memory = memory; + self + } + pub fn memory_offset(mut self, memory_offset: crate::vk::DeviceSize) -> Self { + self.memory_offset = memory_offset; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct DataGraphPipelineInfoARM<'a> { @@ -372,6 +816,28 @@ pub(crate) mod reexport { pub data_graph_pipeline: crate::vk::Pipeline, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for DataGraphPipelineInfoARM<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::DATA_GRAPH_PIPELINE_INFO_ARM; + } + impl<'a> Default for DataGraphPipelineInfoARM<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + data_graph_pipeline: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> DataGraphPipelineInfoARM<'a> { + pub fn data_graph_pipeline( + mut self, + data_graph_pipeline: crate::vk::Pipeline, + ) -> Self { + self.data_graph_pipeline = data_graph_pipeline; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct DataGraphPipelinePropertyQueryResultARM<'a> { @@ -383,6 +849,45 @@ pub(crate) mod reexport { pub p_data: *mut core::ffi::c_void, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for DataGraphPipelinePropertyQueryResultARM<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::DATA_GRAPH_PIPELINE_PROPERTY_QUERY_RESULT_ARM; + } + impl<'a> Default for DataGraphPipelinePropertyQueryResultARM<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + property: Default::default(), + is_text: Default::default(), + data_size: Default::default(), + p_data: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> DataGraphPipelinePropertyQueryResultARM<'a> { + pub fn property( + mut self, + property: crate::vk::DataGraphPipelinePropertyARM, + ) -> Self { + self.property = property; + self + } + pub fn is_text(mut self, is_text: bool) -> Self { + self.is_text = is_text.into(); + self + } + pub fn data_size(mut self, data_size: usize) -> Self { + self.data_size = data_size; + self + } + pub fn p_data(mut self, p_data: &'a mut [u8]) -> Self { + self.data_size = p_data.len() as _; + self.p_data = p_data.as_mut_ptr().cast(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct DataGraphPipelineIdentifierCreateInfoARM<'a> { @@ -392,6 +897,34 @@ pub(crate) mod reexport { pub p_identifier: *const u8, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for DataGraphPipelineIdentifierCreateInfoARM<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::DATA_GRAPH_PIPELINE_IDENTIFIER_CREATE_INFO_ARM; + } + unsafe impl<'a> crate::Extends> + for DataGraphPipelineIdentifierCreateInfoARM<'a> {} + impl<'a> Default for DataGraphPipelineIdentifierCreateInfoARM<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + identifier_size: Default::default(), + p_identifier: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> DataGraphPipelineIdentifierCreateInfoARM<'a> { + pub fn identifier_size(mut self, identifier_size: u32) -> Self { + self.identifier_size = identifier_size; + self + } + pub fn p_identifier(mut self, p_identifier: &'a [u8]) -> Self { + self.identifier_size = p_identifier.len() as _; + self.p_identifier = p_identifier.as_ptr(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct DataGraphPipelineDispatchInfoARM<'a> { @@ -400,12 +933,47 @@ pub(crate) mod reexport { pub flags: crate::vk::DataGraphPipelineDispatchFlagsARM, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for DataGraphPipelineDispatchInfoARM<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::DATA_GRAPH_PIPELINE_DISPATCH_INFO_ARM; + } + impl<'a> Default for DataGraphPipelineDispatchInfoARM<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + flags: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> DataGraphPipelineDispatchInfoARM<'a> { + pub fn flags( + mut self, + flags: crate::vk::DataGraphPipelineDispatchFlagsARM, + ) -> Self { + self.flags = flags; + self + } + } #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct PhysicalDeviceDataGraphProcessingEngineARM { pub _type: crate::vk::PhysicalDeviceDataGraphProcessingEngineTypeARM, pub is_foreign: crate::vk::Bool32, } + impl PhysicalDeviceDataGraphProcessingEngineARM { + pub fn _type( + mut self, + _type: crate::vk::PhysicalDeviceDataGraphProcessingEngineTypeARM, + ) -> Self { + self._type = _type; + self + } + pub fn is_foreign(mut self, is_foreign: bool) -> Self { + self.is_foreign = is_foreign.into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceDataGraphOperationSupportARM { @@ -414,6 +982,39 @@ pub(crate) mod reexport { as _], pub version: u32, } + impl Default for PhysicalDeviceDataGraphOperationSupportARM { + fn default() -> Self { + Self { + operation_type: Default::default(), + name: unsafe { core::mem::zeroed() }, + version: Default::default(), + } + } + } + impl PhysicalDeviceDataGraphOperationSupportARM { + pub fn operation_type( + mut self, + operation_type: crate::vk::PhysicalDeviceDataGraphOperationTypeARM, + ) -> Self { + self.operation_type = operation_type; + self + } + pub fn name( + mut self, + name: &core::ffi::CStr, + ) -> core::result::Result { + crate::write_c_str_slice_with_nul(&mut self.name, name).map(|_| self) + } + pub fn name_as_c_str( + &self, + ) -> core::result::Result<&core::ffi::CStr, core::ffi::FromBytesUntilNulError> { + crate::wrap_c_str_slice_until_nul(&self.name) + } + pub fn version(mut self, version: u32) -> Self { + self.version = version; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct QueueFamilyDataGraphPropertiesARM<'a> { @@ -423,6 +1024,37 @@ pub(crate) mod reexport { pub operation: crate::vk::PhysicalDeviceDataGraphOperationSupportARM, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for QueueFamilyDataGraphPropertiesARM<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::QUEUE_FAMILY_DATA_GRAPH_PROPERTIES_ARM; + } + impl<'a> Default for QueueFamilyDataGraphPropertiesARM<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + engine: Default::default(), + operation: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> QueueFamilyDataGraphPropertiesARM<'a> { + pub fn engine( + mut self, + engine: crate::vk::PhysicalDeviceDataGraphProcessingEngineARM, + ) -> Self { + self.engine = engine; + self + } + pub fn operation( + mut self, + operation: crate::vk::PhysicalDeviceDataGraphOperationSupportARM, + ) -> Self { + self.operation = operation; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM<'a> { @@ -432,6 +1064,34 @@ pub(crate) mod reexport { pub engine_type: crate::vk::PhysicalDeviceDataGraphProcessingEngineTypeARM, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_QUEUE_FAMILY_DATA_GRAPH_PROCESSING_ENGINE_INFO_ARM; + } + impl<'a> Default for PhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + queue_family_index: Default::default(), + engine_type: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM<'a> { + pub fn queue_family_index(mut self, queue_family_index: u32) -> Self { + self.queue_family_index = queue_family_index; + self + } + pub fn engine_type( + mut self, + engine_type: crate::vk::PhysicalDeviceDataGraphProcessingEngineTypeARM, + ) -> Self { + self.engine_type = engine_type; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct QueueFamilyDataGraphProcessingEnginePropertiesARM<'a> { @@ -441,6 +1101,37 @@ pub(crate) mod reexport { pub foreign_memory_handle_types: crate::vk::ExternalMemoryHandleTypeFlags, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for QueueFamilyDataGraphProcessingEnginePropertiesARM<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::QUEUE_FAMILY_DATA_GRAPH_PROCESSING_ENGINE_PROPERTIES_ARM; + } + impl<'a> Default for QueueFamilyDataGraphProcessingEnginePropertiesARM<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + foreign_semaphore_handle_types: Default::default(), + foreign_memory_handle_types: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> QueueFamilyDataGraphProcessingEnginePropertiesARM<'a> { + pub fn foreign_semaphore_handle_types( + mut self, + foreign_semaphore_handle_types: crate::vk::ExternalSemaphoreHandleTypeFlags, + ) -> Self { + self.foreign_semaphore_handle_types = foreign_semaphore_handle_types; + self + } + pub fn foreign_memory_handle_types( + mut self, + foreign_memory_handle_types: crate::vk::ExternalMemoryHandleTypeFlags, + ) -> Self { + self.foreign_memory_handle_types = foreign_memory_handle_types; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct DataGraphProcessingEngineCreateInfoARM<'a> { @@ -450,6 +1141,41 @@ pub(crate) mod reexport { pub p_processing_engines: *mut crate::vk::PhysicalDeviceDataGraphProcessingEngineARM, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for DataGraphProcessingEngineCreateInfoARM<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::DATA_GRAPH_PROCESSING_ENGINE_CREATE_INFO_ARM; + } + unsafe impl<'a> crate::Extends> + for DataGraphProcessingEngineCreateInfoARM<'a> {} + unsafe impl<'a> crate::Extends> + for DataGraphProcessingEngineCreateInfoARM<'a> {} + unsafe impl<'a> crate::Extends> + for DataGraphProcessingEngineCreateInfoARM<'a> {} + impl<'a> Default for DataGraphProcessingEngineCreateInfoARM<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + processing_engine_count: Default::default(), + p_processing_engines: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> DataGraphProcessingEngineCreateInfoARM<'a> { + pub fn processing_engine_count(mut self, processing_engine_count: u32) -> Self { + self.processing_engine_count = processing_engine_count; + self + } + pub fn p_processing_engines( + mut self, + p_processing_engines: &'a mut [crate::vk::PhysicalDeviceDataGraphProcessingEngineARM], + ) -> Self { + self.processing_engine_count = p_processing_engines.len() as _; + self.p_processing_engines = p_processing_engines.as_mut_ptr(); + self + } + } ///Provided by [`arm::data_graph`](crate::arm::data_graph) impl crate::vk::PipelineBindPoint { pub const DATA_GRAPH_ARM: Self = Self(1000507000); @@ -681,7 +1407,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct DataGraphPipelineSessionCreateFlagBitsARM(pub(crate) u64); ///Provided by [`arm::data_graph`](crate::arm::data_graph) impl DataGraphPipelineSessionCreateFlagBitsARM { @@ -755,7 +1481,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct DataGraphPipelineDispatchFlagBitsARM(pub(crate) u64); #[repr(transparent)] #[derive(Eq, PartialEq, Ord, PartialOrd, Clone, Copy, Hash, Default)] diff --git a/ash-rewrite/src/generated/arm/data_graph_instruction_set_tosa.rs b/ash-rewrite/src/generated/arm/data_graph_instruction_set_tosa.rs index 91034cb53..1f8ac2968 100644 --- a/ash-rewrite/src/generated/arm/data_graph_instruction_set_tosa.rs +++ b/ash-rewrite/src/generated/arm/data_graph_instruction_set_tosa.rs @@ -47,6 +47,34 @@ pub(crate) mod reexport { pub name: [core::ffi::c_char; crate::vk::MAX_DATA_GRAPH_TOSA_NAME_SIZE_ARM as _], pub quality_flags: crate::vk::DataGraphTOSAQualityFlagsARM, } + impl Default for DataGraphTOSANameQualityARM { + fn default() -> Self { + Self { + name: unsafe { core::mem::zeroed() }, + quality_flags: Default::default(), + } + } + } + impl DataGraphTOSANameQualityARM { + pub fn name( + mut self, + name: &core::ffi::CStr, + ) -> core::result::Result { + crate::write_c_str_slice_with_nul(&mut self.name, name).map(|_| self) + } + pub fn name_as_c_str( + &self, + ) -> core::result::Result<&core::ffi::CStr, core::ffi::FromBytesUntilNulError> { + crate::wrap_c_str_slice_until_nul(&self.name) + } + pub fn quality_flags( + mut self, + quality_flags: crate::vk::DataGraphTOSAQualityFlagsARM, + ) -> Self { + self.quality_flags = quality_flags; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct QueueFamilyDataGraphTOSAPropertiesARM<'a> { @@ -59,6 +87,54 @@ pub(crate) mod reexport { pub level: crate::vk::DataGraphTOSALevelARM, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for QueueFamilyDataGraphTOSAPropertiesARM<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::QUEUE_FAMILY_DATA_GRAPH_TOSA_PROPERTIES_ARM; + } + impl<'a> Default for QueueFamilyDataGraphTOSAPropertiesARM<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + profile_count: Default::default(), + p_profiles: Default::default(), + extension_count: Default::default(), + p_extensions: Default::default(), + level: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> QueueFamilyDataGraphTOSAPropertiesARM<'a> { + pub fn profile_count(mut self, profile_count: u32) -> Self { + self.profile_count = profile_count; + self + } + pub fn p_profiles( + mut self, + p_profiles: &'a [crate::vk::DataGraphTOSANameQualityARM], + ) -> Self { + self.profile_count = p_profiles.len() as _; + self.p_profiles = p_profiles.as_ptr(); + self + } + pub fn extension_count(mut self, extension_count: u32) -> Self { + self.extension_count = extension_count; + self + } + pub fn p_extensions( + mut self, + p_extensions: &'a [crate::vk::DataGraphTOSANameQualityARM], + ) -> Self { + self.extension_count = p_extensions.len() as _; + self.p_extensions = p_extensions.as_ptr(); + self + } + pub fn level(mut self, level: crate::vk::DataGraphTOSALevelARM) -> Self { + self.level = level; + self + } + } ///Provided by [`arm::data_graph_instruction_set_tosa`](crate::arm::data_graph_instruction_set_tosa) impl crate::vk::StructureType { pub const QUEUE_FAMILY_DATA_GRAPH_TOSA_PROPERTIES_ARM: Self = Self(1000508000); @@ -160,7 +236,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct DataGraphTOSAQualityFlagBitsARM(pub(crate) u32); ///Provided by [`arm::data_graph_instruction_set_tosa`](crate::arm::data_graph_instruction_set_tosa) impl DataGraphTOSAQualityFlagBitsARM { diff --git a/ash-rewrite/src/generated/arm/data_graph_neural_accelerator_statistics.rs b/ash-rewrite/src/generated/arm/data_graph_neural_accelerator_statistics.rs index f96ffeec4..88037c167 100644 --- a/ash-rewrite/src/generated/arm/data_graph_neural_accelerator_statistics.rs +++ b/ash-rewrite/src/generated/arm/data_graph_neural_accelerator_statistics.rs @@ -9,6 +9,34 @@ pub struct PhysicalDeviceDataGraphNeuralAcceleratorStatisticsFeaturesARM<'a> { pub data_graph_neural_accelerator_statistics: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceDataGraphNeuralAcceleratorStatisticsFeaturesARM<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_DATA_GRAPH_NEURAL_ACCELERATOR_STATISTICS_FEATURES_ARM; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceDataGraphNeuralAcceleratorStatisticsFeaturesARM<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceDataGraphNeuralAcceleratorStatisticsFeaturesARM<'a> {} +impl<'a> Default for PhysicalDeviceDataGraphNeuralAcceleratorStatisticsFeaturesARM<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + data_graph_neural_accelerator_statistics: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceDataGraphNeuralAcceleratorStatisticsFeaturesARM<'a> { + pub fn data_graph_neural_accelerator_statistics( + mut self, + data_graph_neural_accelerator_statistics: bool, + ) -> Self { + self.data_graph_neural_accelerator_statistics = data_graph_neural_accelerator_statistics + .into(); + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct DataGraphPipelineNeuralStatisticsCreateInfoARM<'a> { @@ -17,6 +45,28 @@ pub struct DataGraphPipelineNeuralStatisticsCreateInfoARM<'a> { pub allow_neural_statistics: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for DataGraphPipelineNeuralStatisticsCreateInfoARM<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::DATA_GRAPH_PIPELINE_NEURAL_STATISTICS_CREATE_INFO_ARM; +} +unsafe impl<'a> crate::Extends> +for DataGraphPipelineNeuralStatisticsCreateInfoARM<'a> {} +impl<'a> Default for DataGraphPipelineNeuralStatisticsCreateInfoARM<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + allow_neural_statistics: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> DataGraphPipelineNeuralStatisticsCreateInfoARM<'a> { + pub fn allow_neural_statistics(mut self, allow_neural_statistics: bool) -> Self { + self.allow_neural_statistics = allow_neural_statistics.into(); + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct DataGraphPipelineSessionNeuralStatisticsCreateInfoARM<'a> { @@ -25,6 +75,28 @@ pub struct DataGraphPipelineSessionNeuralStatisticsCreateInfoARM<'a> { pub mode: crate::vk::NeuralAcceleratorStatisticsModeARM, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for DataGraphPipelineSessionNeuralStatisticsCreateInfoARM<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::DATA_GRAPH_PIPELINE_SESSION_NEURAL_STATISTICS_CREATE_INFO_ARM; +} +unsafe impl<'a> crate::Extends> +for DataGraphPipelineSessionNeuralStatisticsCreateInfoARM<'a> {} +impl<'a> Default for DataGraphPipelineSessionNeuralStatisticsCreateInfoARM<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + mode: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> DataGraphPipelineSessionNeuralStatisticsCreateInfoARM<'a> { + pub fn mode(mut self, mode: crate::vk::NeuralAcceleratorStatisticsModeARM) -> Self { + self.mode = mode; + self + } +} ///Provided by [`arm::data_graph_neural_accelerator_statistics`](crate::arm::data_graph_neural_accelerator_statistics) impl crate::vk::StructureType { pub const DATA_GRAPH_PIPELINE_NEURAL_STATISTICS_CREATE_INFO_ARM: Self = Self( diff --git a/ash-rewrite/src/generated/arm/data_graph_optical_flow.rs b/ash-rewrite/src/generated/arm/data_graph_optical_flow.rs index d818338ea..cee40e39b 100644 --- a/ash-rewrite/src/generated/arm/data_graph_optical_flow.rs +++ b/ash-rewrite/src/generated/arm/data_graph_optical_flow.rs @@ -51,6 +51,28 @@ pub(crate) mod reexport { pub layout: crate::vk::ImageLayout, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for DataGraphPipelineResourceInfoImageLayoutARM<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::DATA_GRAPH_PIPELINE_RESOURCE_INFO_IMAGE_LAYOUT_ARM; + } + unsafe impl<'a> crate::Extends> + for DataGraphPipelineResourceInfoImageLayoutARM<'a> {} + impl<'a> Default for DataGraphPipelineResourceInfoImageLayoutARM<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + layout: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> DataGraphPipelineResourceInfoImageLayoutARM<'a> { + pub fn layout(mut self, layout: crate::vk::ImageLayout) -> Self { + self.layout = layout; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct DataGraphPipelineSingleNodeConnectionARM<'a> { @@ -61,6 +83,39 @@ pub(crate) mod reexport { pub connection: crate::vk::DataGraphPipelineNodeConnectionTypeARM, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for DataGraphPipelineSingleNodeConnectionARM<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::DATA_GRAPH_PIPELINE_SINGLE_NODE_CONNECTION_ARM; + } + impl<'a> Default for DataGraphPipelineSingleNodeConnectionARM<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + set: Default::default(), + binding: Default::default(), + connection: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> DataGraphPipelineSingleNodeConnectionARM<'a> { + pub fn set(mut self, set: u32) -> Self { + self.set = set; + self + } + pub fn binding(mut self, binding: u32) -> Self { + self.binding = binding; + self + } + pub fn connection( + mut self, + connection: crate::vk::DataGraphPipelineNodeConnectionTypeARM, + ) -> Self { + self.connection = connection; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceDataGraphOpticalFlowFeaturesARM<'a> { @@ -69,6 +124,30 @@ pub(crate) mod reexport { pub data_graph_optical_flow: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceDataGraphOpticalFlowFeaturesARM<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_DATA_GRAPH_OPTICAL_FLOW_FEATURES_ARM; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceDataGraphOpticalFlowFeaturesARM<'a> {} + unsafe impl<'a> crate::Extends> + for PhysicalDeviceDataGraphOpticalFlowFeaturesARM<'a> {} + impl<'a> Default for PhysicalDeviceDataGraphOpticalFlowFeaturesARM<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + data_graph_optical_flow: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceDataGraphOpticalFlowFeaturesARM<'a> { + pub fn data_graph_optical_flow(mut self, data_graph_optical_flow: bool) -> Self { + self.data_graph_optical_flow = data_graph_optical_flow.into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct QueueFamilyDataGraphOpticalFlowPropertiesARM<'a> { @@ -84,6 +163,67 @@ pub(crate) mod reexport { pub max_height: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for QueueFamilyDataGraphOpticalFlowPropertiesARM<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::QUEUE_FAMILY_DATA_GRAPH_OPTICAL_FLOW_PROPERTIES_ARM; + } + impl<'a> Default for QueueFamilyDataGraphOpticalFlowPropertiesARM<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + supported_output_grid_sizes: Default::default(), + supported_hint_grid_sizes: Default::default(), + hint_supported: Default::default(), + cost_supported: Default::default(), + min_width: Default::default(), + min_height: Default::default(), + max_width: Default::default(), + max_height: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> QueueFamilyDataGraphOpticalFlowPropertiesARM<'a> { + pub fn supported_output_grid_sizes( + mut self, + supported_output_grid_sizes: crate::vk::DataGraphOpticalFlowGridSizeFlagsARM, + ) -> Self { + self.supported_output_grid_sizes = supported_output_grid_sizes; + self + } + pub fn supported_hint_grid_sizes( + mut self, + supported_hint_grid_sizes: crate::vk::DataGraphOpticalFlowGridSizeFlagsARM, + ) -> Self { + self.supported_hint_grid_sizes = supported_hint_grid_sizes; + self + } + pub fn hint_supported(mut self, hint_supported: bool) -> Self { + self.hint_supported = hint_supported.into(); + self + } + pub fn cost_supported(mut self, cost_supported: bool) -> Self { + self.cost_supported = cost_supported.into(); + self + } + pub fn min_width(mut self, min_width: u32) -> Self { + self.min_width = min_width; + self + } + pub fn min_height(mut self, min_height: u32) -> Self { + self.min_height = min_height; + self + } + pub fn max_width(mut self, max_width: u32) -> Self { + self.max_width = max_width; + self + } + pub fn max_height(mut self, max_height: u32) -> Self { + self.max_height = max_height; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct DataGraphOpticalFlowImageFormatInfoARM<'a> { @@ -92,6 +232,33 @@ pub(crate) mod reexport { pub usage: crate::vk::DataGraphOpticalFlowImageUsageFlagsARM, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for DataGraphOpticalFlowImageFormatInfoARM<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::DATA_GRAPH_OPTICAL_FLOW_IMAGE_FORMAT_INFO_ARM; + } + unsafe impl<'a> crate::Extends> + for DataGraphOpticalFlowImageFormatInfoARM<'a> {} + unsafe impl<'a> crate::Extends> + for DataGraphOpticalFlowImageFormatInfoARM<'a> {} + impl<'a> Default for DataGraphOpticalFlowImageFormatInfoARM<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + usage: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> DataGraphOpticalFlowImageFormatInfoARM<'a> { + pub fn usage( + mut self, + usage: crate::vk::DataGraphOpticalFlowImageUsageFlagsARM, + ) -> Self { + self.usage = usage; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct DataGraphOpticalFlowImageFormatPropertiesARM<'a> { @@ -100,6 +267,26 @@ pub(crate) mod reexport { pub format: crate::vk::Format, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for DataGraphOpticalFlowImageFormatPropertiesARM<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::DATA_GRAPH_OPTICAL_FLOW_IMAGE_FORMAT_PROPERTIES_ARM; + } + impl<'a> Default for DataGraphOpticalFlowImageFormatPropertiesARM<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + format: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> DataGraphOpticalFlowImageFormatPropertiesARM<'a> { + pub fn format(mut self, format: crate::vk::Format) -> Self { + self.format = format; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct DataGraphPipelineSingleNodeCreateInfoARM<'a> { @@ -112,6 +299,45 @@ pub(crate) mod reexport { >, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for DataGraphPipelineSingleNodeCreateInfoARM<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::DATA_GRAPH_PIPELINE_SINGLE_NODE_CREATE_INFO_ARM; + } + unsafe impl<'a> crate::Extends> + for DataGraphPipelineSingleNodeCreateInfoARM<'a> {} + impl<'a> Default for DataGraphPipelineSingleNodeCreateInfoARM<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + node_type: Default::default(), + connection_count: Default::default(), + p_connections: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> DataGraphPipelineSingleNodeCreateInfoARM<'a> { + pub fn node_type( + mut self, + node_type: crate::vk::DataGraphPipelineNodeTypeARM, + ) -> Self { + self.node_type = node_type; + self + } + pub fn connection_count(mut self, connection_count: u32) -> Self { + self.connection_count = connection_count; + self + } + pub fn p_connections( + mut self, + p_connections: &'a [crate::vk::DataGraphPipelineSingleNodeConnectionARM<'a>], + ) -> Self { + self.connection_count = p_connections.len() as _; + self.p_connections = p_connections.as_ptr(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct DataGraphPipelineOpticalFlowCreateInfoARM<'a> { @@ -128,6 +354,83 @@ pub(crate) mod reexport { pub flags: crate::vk::DataGraphOpticalFlowCreateFlagsARM, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for DataGraphPipelineOpticalFlowCreateInfoARM<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::DATA_GRAPH_PIPELINE_OPTICAL_FLOW_CREATE_INFO_ARM; + } + unsafe impl<'a> crate::Extends> + for DataGraphPipelineOpticalFlowCreateInfoARM<'a> {} + impl<'a> Default for DataGraphPipelineOpticalFlowCreateInfoARM<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + width: Default::default(), + height: Default::default(), + image_format: Default::default(), + flow_vector_format: Default::default(), + cost_format: Default::default(), + output_grid_size: Default::default(), + hint_grid_size: Default::default(), + performance_level: Default::default(), + flags: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> DataGraphPipelineOpticalFlowCreateInfoARM<'a> { + pub fn width(mut self, width: u32) -> Self { + self.width = width; + self + } + pub fn height(mut self, height: u32) -> Self { + self.height = height; + self + } + pub fn image_format(mut self, image_format: crate::vk::Format) -> Self { + self.image_format = image_format; + self + } + pub fn flow_vector_format( + mut self, + flow_vector_format: crate::vk::Format, + ) -> Self { + self.flow_vector_format = flow_vector_format; + self + } + pub fn cost_format(mut self, cost_format: crate::vk::Format) -> Self { + self.cost_format = cost_format; + self + } + pub fn output_grid_size( + mut self, + output_grid_size: crate::vk::DataGraphOpticalFlowGridSizeFlagsARM, + ) -> Self { + self.output_grid_size = output_grid_size; + self + } + pub fn hint_grid_size( + mut self, + hint_grid_size: crate::vk::DataGraphOpticalFlowGridSizeFlagsARM, + ) -> Self { + self.hint_grid_size = hint_grid_size; + self + } + pub fn performance_level( + mut self, + performance_level: crate::vk::DataGraphOpticalFlowPerformanceLevelARM, + ) -> Self { + self.performance_level = performance_level; + self + } + pub fn flags( + mut self, + flags: crate::vk::DataGraphOpticalFlowCreateFlagsARM, + ) -> Self { + self.flags = flags; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct DataGraphPipelineOpticalFlowDispatchInfoARM<'a> { @@ -137,6 +440,36 @@ pub(crate) mod reexport { pub mean_flow_l1_norm_hint: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for DataGraphPipelineOpticalFlowDispatchInfoARM<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::DATA_GRAPH_PIPELINE_OPTICAL_FLOW_DISPATCH_INFO_ARM; + } + unsafe impl<'a> crate::Extends> + for DataGraphPipelineOpticalFlowDispatchInfoARM<'a> {} + impl<'a> Default for DataGraphPipelineOpticalFlowDispatchInfoARM<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + flags: Default::default(), + mean_flow_l1_norm_hint: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> DataGraphPipelineOpticalFlowDispatchInfoARM<'a> { + pub fn flags( + mut self, + flags: crate::vk::DataGraphOpticalFlowExecuteFlagsARM, + ) -> Self { + self.flags = flags; + self + } + pub fn mean_flow_l1_norm_hint(mut self, mean_flow_l1_norm_hint: u32) -> Self { + self.mean_flow_l1_norm_hint = mean_flow_l1_norm_hint; + self + } + } ///Provided by [`arm::data_graph_optical_flow`](crate::arm::data_graph_optical_flow) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_DATA_GRAPH_OPTICAL_FLOW_FEATURES_ARM: Self = Self( @@ -321,7 +654,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct DataGraphOpticalFlowGridSizeFlagBitsARM(pub(crate) u32); ///Provided by [`arm::data_graph_optical_flow`](crate::arm::data_graph_optical_flow) impl DataGraphOpticalFlowGridSizeFlagBitsARM { @@ -414,7 +747,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct DataGraphOpticalFlowImageUsageFlagBitsARM(pub(crate) u32); ///Provided by [`arm::data_graph_optical_flow`](crate::arm::data_graph_optical_flow) impl DataGraphOpticalFlowImageUsageFlagBitsARM { @@ -501,7 +834,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct DataGraphOpticalFlowCreateFlagBitsARM(pub(crate) u32); ///Provided by [`arm::data_graph_optical_flow`](crate::arm::data_graph_optical_flow) impl DataGraphOpticalFlowCreateFlagBitsARM { @@ -592,7 +925,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct DataGraphOpticalFlowExecuteFlagBitsARM(pub(crate) u32); ///Provided by [`arm::data_graph_optical_flow`](crate::arm::data_graph_optical_flow) impl DataGraphOpticalFlowExecuteFlagBitsARM { diff --git a/ash-rewrite/src/generated/arm/format_pack.rs b/ash-rewrite/src/generated/arm/format_pack.rs index 9af81cc33..99bb7f28d 100644 --- a/ash-rewrite/src/generated/arm/format_pack.rs +++ b/ash-rewrite/src/generated/arm/format_pack.rs @@ -9,6 +9,29 @@ pub struct PhysicalDeviceFormatPackFeaturesARM<'a> { pub format_pack: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> for PhysicalDeviceFormatPackFeaturesARM<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_FORMAT_PACK_FEATURES_ARM; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceFormatPackFeaturesARM<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceFormatPackFeaturesARM<'a> {} +impl<'a> Default for PhysicalDeviceFormatPackFeaturesARM<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + format_pack: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceFormatPackFeaturesARM<'a> { + pub fn format_pack(mut self, format_pack: bool) -> Self { + self.format_pack = format_pack.into(); + self + } +} ///Provided by [`arm::format_pack`](crate::arm::format_pack) impl crate::vk::Format { pub const R10X6_UINT_PACK16_ARM: Self = Self(1000609000); diff --git a/ash-rewrite/src/generated/arm/performance_counters_by_region.rs b/ash-rewrite/src/generated/arm/performance_counters_by_region.rs index 250520d1c..6321976f9 100644 --- a/ash-rewrite/src/generated/arm/performance_counters_by_region.rs +++ b/ash-rewrite/src/generated/arm/performance_counters_by_region.rs @@ -50,6 +50,33 @@ pub(crate) mod reexport { pub performance_counters_by_region: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDevicePerformanceCountersByRegionFeaturesARM<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_PERFORMANCE_COUNTERS_BY_REGION_FEATURES_ARM; + } + unsafe impl<'a> crate::Extends> + for PhysicalDevicePerformanceCountersByRegionFeaturesARM<'a> {} + unsafe impl<'a> crate::Extends> + for PhysicalDevicePerformanceCountersByRegionFeaturesARM<'a> {} + impl<'a> Default for PhysicalDevicePerformanceCountersByRegionFeaturesARM<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + performance_counters_by_region: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDevicePerformanceCountersByRegionFeaturesARM<'a> { + pub fn performance_counters_by_region( + mut self, + performance_counters_by_region: bool, + ) -> Self { + self.performance_counters_by_region = performance_counters_by_region.into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDevicePerformanceCountersByRegionPropertiesARM<'a> { @@ -62,6 +89,57 @@ pub(crate) mod reexport { pub identity_transform_order: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDevicePerformanceCountersByRegionPropertiesARM<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_PERFORMANCE_COUNTERS_BY_REGION_PROPERTIES_ARM; + } + unsafe impl<'a> crate::Extends> + for PhysicalDevicePerformanceCountersByRegionPropertiesARM<'a> {} + impl<'a> Default for PhysicalDevicePerformanceCountersByRegionPropertiesARM<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + max_per_region_performance_counters: Default::default(), + performance_counter_region_size: Default::default(), + row_stride_alignment: Default::default(), + region_alignment: Default::default(), + identity_transform_order: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDevicePerformanceCountersByRegionPropertiesARM<'a> { + pub fn max_per_region_performance_counters( + mut self, + max_per_region_performance_counters: u32, + ) -> Self { + self.max_per_region_performance_counters = max_per_region_performance_counters; + self + } + pub fn performance_counter_region_size( + mut self, + performance_counter_region_size: crate::vk::Extent2D, + ) -> Self { + self.performance_counter_region_size = performance_counter_region_size; + self + } + pub fn row_stride_alignment(mut self, row_stride_alignment: u32) -> Self { + self.row_stride_alignment = row_stride_alignment; + self + } + pub fn region_alignment(mut self, region_alignment: u32) -> Self { + self.region_alignment = region_alignment; + self + } + pub fn identity_transform_order( + mut self, + identity_transform_order: bool, + ) -> Self { + self.identity_transform_order = identity_transform_order.into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PerformanceCounterARM<'a> { @@ -70,6 +148,25 @@ pub(crate) mod reexport { pub counter_id: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for PerformanceCounterARM<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PERFORMANCE_COUNTER_ARM; + } + impl<'a> Default for PerformanceCounterARM<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + counter_id: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PerformanceCounterARM<'a> { + pub fn counter_id(mut self, counter_id: u32) -> Self { + self.counter_id = counter_id; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PerformanceCounterDescriptionARM<'a> { @@ -79,6 +176,40 @@ pub(crate) mod reexport { pub name: [core::ffi::c_char; crate::vk::MAX_DESCRIPTION_SIZE as _], pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for PerformanceCounterDescriptionARM<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PERFORMANCE_COUNTER_DESCRIPTION_ARM; + } + impl<'a> Default for PerformanceCounterDescriptionARM<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + flags: Default::default(), + name: unsafe { core::mem::zeroed() }, + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PerformanceCounterDescriptionARM<'a> { + pub fn flags( + mut self, + flags: crate::vk::PerformanceCounterDescriptionFlagsARM, + ) -> Self { + self.flags = flags; + self + } + pub fn name( + mut self, + name: &core::ffi::CStr, + ) -> core::result::Result { + crate::write_c_str_slice_with_nul(&mut self.name, name).map(|_| self) + } + pub fn name_as_c_str( + &self, + ) -> core::result::Result<&core::ffi::CStr, core::ffi::FromBytesUntilNulError> { + crate::wrap_c_str_slice_until_nul(&self.name) + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct RenderPassPerformanceCountersByRegionBeginInfoARM<'a> { @@ -91,6 +222,55 @@ pub(crate) mod reexport { pub p_counter_indices: *mut u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for RenderPassPerformanceCountersByRegionBeginInfoARM<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::RENDER_PASS_PERFORMANCE_COUNTERS_BY_REGION_BEGIN_INFO_ARM; + } + unsafe impl<'a> crate::Extends> + for RenderPassPerformanceCountersByRegionBeginInfoARM<'a> {} + unsafe impl<'a> crate::Extends> + for RenderPassPerformanceCountersByRegionBeginInfoARM<'a> {} + impl<'a> Default for RenderPassPerformanceCountersByRegionBeginInfoARM<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + counter_address_count: Default::default(), + p_counter_addresses: Default::default(), + serialize_regions: Default::default(), + counter_index_count: Default::default(), + p_counter_indices: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> RenderPassPerformanceCountersByRegionBeginInfoARM<'a> { + pub fn counter_address_count(mut self, counter_address_count: u32) -> Self { + self.counter_address_count = counter_address_count; + self + } + pub fn p_counter_addresses( + mut self, + p_counter_addresses: &'a [crate::vk::DeviceAddress], + ) -> Self { + self.counter_address_count = p_counter_addresses.len() as _; + self.p_counter_addresses = p_counter_addresses.as_ptr(); + self + } + pub fn serialize_regions(mut self, serialize_regions: bool) -> Self { + self.serialize_regions = serialize_regions.into(); + self + } + pub fn counter_index_count(mut self, counter_index_count: u32) -> Self { + self.counter_index_count = counter_index_count; + self + } + pub fn p_counter_indices(mut self, p_counter_indices: &'a mut [u32]) -> Self { + self.counter_index_count = p_counter_indices.len() as _; + self.p_counter_indices = p_counter_indices.as_mut_ptr(); + self + } + } ///Provided by [`arm::performance_counters_by_region`](crate::arm::performance_counters_by_region) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_PERFORMANCE_COUNTERS_BY_REGION_FEATURES_ARM: Self = Self( diff --git a/ash-rewrite/src/generated/arm/pipeline_opacity_micromap.rs b/ash-rewrite/src/generated/arm/pipeline_opacity_micromap.rs index 010dbab47..24f1dfa86 100644 --- a/ash-rewrite/src/generated/arm/pipeline_opacity_micromap.rs +++ b/ash-rewrite/src/generated/arm/pipeline_opacity_micromap.rs @@ -9,6 +9,30 @@ pub struct PhysicalDevicePipelineOpacityMicromapFeaturesARM<'a> { pub pipeline_opacity_micromap: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDevicePipelineOpacityMicromapFeaturesARM<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_PIPELINE_OPACITY_MICROMAP_FEATURES_ARM; +} +unsafe impl<'a> crate::Extends> +for PhysicalDevicePipelineOpacityMicromapFeaturesARM<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDevicePipelineOpacityMicromapFeaturesARM<'a> {} +impl<'a> Default for PhysicalDevicePipelineOpacityMicromapFeaturesARM<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + pipeline_opacity_micromap: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDevicePipelineOpacityMicromapFeaturesARM<'a> { + pub fn pipeline_opacity_micromap(mut self, pipeline_opacity_micromap: bool) -> Self { + self.pipeline_opacity_micromap = pipeline_opacity_micromap.into(); + self + } +} ///Provided by [`arm::pipeline_opacity_micromap`](crate::arm::pipeline_opacity_micromap) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_PIPELINE_OPACITY_MICROMAP_FEATURES_ARM: Self = Self( diff --git a/ash-rewrite/src/generated/arm/render_pass_striped.rs b/ash-rewrite/src/generated/arm/render_pass_striped.rs index c886a311e..1f3d4db2b 100644 --- a/ash-rewrite/src/generated/arm/render_pass_striped.rs +++ b/ash-rewrite/src/generated/arm/render_pass_striped.rs @@ -9,6 +9,30 @@ pub struct PhysicalDeviceRenderPassStripedFeaturesARM<'a> { pub render_pass_striped: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceRenderPassStripedFeaturesARM<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_RENDER_PASS_STRIPED_FEATURES_ARM; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceRenderPassStripedFeaturesARM<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceRenderPassStripedFeaturesARM<'a> {} +impl<'a> Default for PhysicalDeviceRenderPassStripedFeaturesARM<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + render_pass_striped: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceRenderPassStripedFeaturesARM<'a> { + pub fn render_pass_striped(mut self, render_pass_striped: bool) -> Self { + self.render_pass_striped = render_pass_striped.into(); + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceRenderPassStripedPropertiesARM<'a> { @@ -18,6 +42,36 @@ pub struct PhysicalDeviceRenderPassStripedPropertiesARM<'a> { pub max_render_pass_stripes: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceRenderPassStripedPropertiesARM<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_RENDER_PASS_STRIPED_PROPERTIES_ARM; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceRenderPassStripedPropertiesARM<'a> {} +impl<'a> Default for PhysicalDeviceRenderPassStripedPropertiesARM<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + render_pass_stripe_granularity: Default::default(), + max_render_pass_stripes: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceRenderPassStripedPropertiesARM<'a> { + pub fn render_pass_stripe_granularity( + mut self, + render_pass_stripe_granularity: crate::vk::Extent2D, + ) -> Self { + self.render_pass_stripe_granularity = render_pass_stripe_granularity; + self + } + pub fn max_render_pass_stripes(mut self, max_render_pass_stripes: u32) -> Self { + self.max_render_pass_stripes = max_render_pass_stripes; + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct RenderPassStripeInfoARM<'a> { @@ -26,6 +80,25 @@ pub struct RenderPassStripeInfoARM<'a> { pub stripe_area: crate::vk::Rect2D, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> for RenderPassStripeInfoARM<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::RENDER_PASS_STRIPE_INFO_ARM; +} +impl<'a> Default for RenderPassStripeInfoARM<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + stripe_area: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> RenderPassStripeInfoARM<'a> { + pub fn stripe_area(mut self, stripe_area: crate::vk::Rect2D) -> Self { + self.stripe_area = stripe_area; + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct RenderPassStripeBeginInfoARM<'a> { @@ -35,6 +108,38 @@ pub struct RenderPassStripeBeginInfoARM<'a> { pub p_stripe_infos: *const crate::vk::RenderPassStripeInfoARM<'a>, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> for RenderPassStripeBeginInfoARM<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::RENDER_PASS_STRIPE_BEGIN_INFO_ARM; +} +unsafe impl<'a> crate::Extends> +for RenderPassStripeBeginInfoARM<'a> {} +unsafe impl<'a> crate::Extends> +for RenderPassStripeBeginInfoARM<'a> {} +impl<'a> Default for RenderPassStripeBeginInfoARM<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + stripe_info_count: Default::default(), + p_stripe_infos: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> RenderPassStripeBeginInfoARM<'a> { + pub fn stripe_info_count(mut self, stripe_info_count: u32) -> Self { + self.stripe_info_count = stripe_info_count; + self + } + pub fn p_stripe_infos( + mut self, + p_stripe_infos: &'a [crate::vk::RenderPassStripeInfoARM<'a>], + ) -> Self { + self.stripe_info_count = p_stripe_infos.len() as _; + self.p_stripe_infos = p_stripe_infos.as_ptr(); + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct RenderPassStripeSubmitInfoARM<'a> { @@ -44,6 +149,39 @@ pub struct RenderPassStripeSubmitInfoARM<'a> { pub p_stripe_semaphore_infos: *const crate::vk::SemaphoreSubmitInfo<'a>, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> for RenderPassStripeSubmitInfoARM<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::RENDER_PASS_STRIPE_SUBMIT_INFO_ARM; +} +unsafe impl<'a> crate::Extends> +for RenderPassStripeSubmitInfoARM<'a> {} +impl<'a> Default for RenderPassStripeSubmitInfoARM<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + stripe_semaphore_info_count: Default::default(), + p_stripe_semaphore_infos: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> RenderPassStripeSubmitInfoARM<'a> { + pub fn stripe_semaphore_info_count( + mut self, + stripe_semaphore_info_count: u32, + ) -> Self { + self.stripe_semaphore_info_count = stripe_semaphore_info_count; + self + } + pub fn p_stripe_semaphore_infos( + mut self, + p_stripe_semaphore_infos: &'a [crate::vk::SemaphoreSubmitInfo<'a>], + ) -> Self { + self.stripe_semaphore_info_count = p_stripe_semaphore_infos.len() as _; + self.p_stripe_semaphore_infos = p_stripe_semaphore_infos.as_ptr(); + self + } +} ///Provided by [`arm::render_pass_striped`](crate::arm::render_pass_striped) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_RENDER_PASS_STRIPED_FEATURES_ARM: Self = Self(1000424000); diff --git a/ash-rewrite/src/generated/arm/scheduling_controls.rs b/ash-rewrite/src/generated/arm/scheduling_controls.rs index 3c16cb7d5..e46ebcb5a 100644 --- a/ash-rewrite/src/generated/arm/scheduling_controls.rs +++ b/ash-rewrite/src/generated/arm/scheduling_controls.rs @@ -43,6 +43,30 @@ pub(crate) mod reexport { pub shader_core_count: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for DeviceQueueShaderCoreControlCreateInfoARM<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::DEVICE_QUEUE_SHADER_CORE_CONTROL_CREATE_INFO_ARM; + } + unsafe impl<'a> crate::Extends> + for DeviceQueueShaderCoreControlCreateInfoARM<'a> {} + unsafe impl<'a> crate::Extends> + for DeviceQueueShaderCoreControlCreateInfoARM<'a> {} + impl<'a> Default for DeviceQueueShaderCoreControlCreateInfoARM<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + shader_core_count: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> DeviceQueueShaderCoreControlCreateInfoARM<'a> { + pub fn shader_core_count(mut self, shader_core_count: u32) -> Self { + self.shader_core_count = shader_core_count; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceSchedulingControlsFeaturesARM<'a> { @@ -51,6 +75,30 @@ pub(crate) mod reexport { pub scheduling_controls: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceSchedulingControlsFeaturesARM<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceSchedulingControlsFeaturesARM<'a> {} + unsafe impl<'a> crate::Extends> + for PhysicalDeviceSchedulingControlsFeaturesARM<'a> {} + impl<'a> Default for PhysicalDeviceSchedulingControlsFeaturesARM<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + scheduling_controls: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceSchedulingControlsFeaturesARM<'a> { + pub fn scheduling_controls(mut self, scheduling_controls: bool) -> Self { + self.scheduling_controls = scheduling_controls.into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceSchedulingControlsPropertiesARM<'a> { @@ -59,6 +107,31 @@ pub(crate) mod reexport { pub scheduling_controls_flags: crate::vk::PhysicalDeviceSchedulingControlsFlagsARM, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceSchedulingControlsPropertiesARM<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_SCHEDULING_CONTROLS_PROPERTIES_ARM; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceSchedulingControlsPropertiesARM<'a> {} + impl<'a> Default for PhysicalDeviceSchedulingControlsPropertiesARM<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + scheduling_controls_flags: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceSchedulingControlsPropertiesARM<'a> { + pub fn scheduling_controls_flags( + mut self, + scheduling_controls_flags: crate::vk::PhysicalDeviceSchedulingControlsFlagsARM, + ) -> Self { + self.scheduling_controls_flags = scheduling_controls_flags; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceSchedulingControlsDispatchParametersPropertiesARM<'a> { @@ -69,6 +142,48 @@ pub(crate) mod reexport { pub scheduling_controls_max_work_group_batch_size: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceSchedulingControlsDispatchParametersPropertiesARM<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_SCHEDULING_CONTROLS_DISPATCH_PARAMETERS_PROPERTIES_ARM; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceSchedulingControlsDispatchParametersPropertiesARM<'a> {} + impl<'a> Default + for PhysicalDeviceSchedulingControlsDispatchParametersPropertiesARM<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + scheduling_controls_max_warps_count: Default::default(), + scheduling_controls_max_queued_batches_count: Default::default(), + scheduling_controls_max_work_group_batch_size: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceSchedulingControlsDispatchParametersPropertiesARM<'a> { + pub fn scheduling_controls_max_warps_count( + mut self, + scheduling_controls_max_warps_count: u32, + ) -> Self { + self.scheduling_controls_max_warps_count = scheduling_controls_max_warps_count; + self + } + pub fn scheduling_controls_max_queued_batches_count( + mut self, + scheduling_controls_max_queued_batches_count: u32, + ) -> Self { + self.scheduling_controls_max_queued_batches_count = scheduling_controls_max_queued_batches_count; + self + } + pub fn scheduling_controls_max_work_group_batch_size( + mut self, + scheduling_controls_max_work_group_batch_size: u32, + ) -> Self { + self.scheduling_controls_max_work_group_batch_size = scheduling_controls_max_work_group_batch_size; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct DispatchParametersARM<'a> { @@ -79,6 +194,41 @@ pub(crate) mod reexport { pub max_warps_per_shader_core: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for DispatchParametersARM<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::DISPATCH_PARAMETERS_ARM; + } + impl<'a> Default for DispatchParametersARM<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + work_group_batch_size: Default::default(), + max_queued_work_group_batches: Default::default(), + max_warps_per_shader_core: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> DispatchParametersARM<'a> { + pub fn work_group_batch_size(mut self, work_group_batch_size: u32) -> Self { + self.work_group_batch_size = work_group_batch_size; + self + } + pub fn max_queued_work_group_batches( + mut self, + max_queued_work_group_batches: u32, + ) -> Self { + self.max_queued_work_group_batches = max_queued_work_group_batches; + self + } + pub fn max_warps_per_shader_core( + mut self, + max_warps_per_shader_core: u32, + ) -> Self { + self.max_warps_per_shader_core = max_warps_per_shader_core; + self + } + } ///Provided by [`arm::scheduling_controls`](crate::arm::scheduling_controls) impl crate::vk::StructureType { pub const DEVICE_QUEUE_SHADER_CORE_CONTROL_CREATE_INFO_ARM: Self = Self( @@ -169,7 +319,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct PhysicalDeviceSchedulingControlsFlagBitsARM(pub(crate) u64); ///Provided by [`arm::scheduling_controls`](crate::arm::scheduling_controls) impl PhysicalDeviceSchedulingControlsFlagBitsARM { diff --git a/ash-rewrite/src/generated/arm/shader_core_builtins.rs b/ash-rewrite/src/generated/arm/shader_core_builtins.rs index 53b3051f3..8da59f017 100644 --- a/ash-rewrite/src/generated/arm/shader_core_builtins.rs +++ b/ash-rewrite/src/generated/arm/shader_core_builtins.rs @@ -11,6 +11,38 @@ pub struct PhysicalDeviceShaderCoreBuiltinsPropertiesARM<'a> { pub shader_warps_per_core: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceShaderCoreBuiltinsPropertiesARM<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceShaderCoreBuiltinsPropertiesARM<'a> {} +impl<'a> Default for PhysicalDeviceShaderCoreBuiltinsPropertiesARM<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + shader_core_mask: Default::default(), + shader_core_count: Default::default(), + shader_warps_per_core: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceShaderCoreBuiltinsPropertiesARM<'a> { + pub fn shader_core_mask(mut self, shader_core_mask: u64) -> Self { + self.shader_core_mask = shader_core_mask; + self + } + pub fn shader_core_count(mut self, shader_core_count: u32) -> Self { + self.shader_core_count = shader_core_count; + self + } + pub fn shader_warps_per_core(mut self, shader_warps_per_core: u32) -> Self { + self.shader_warps_per_core = shader_warps_per_core; + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceShaderCoreBuiltinsFeaturesARM<'a> { @@ -19,6 +51,30 @@ pub struct PhysicalDeviceShaderCoreBuiltinsFeaturesARM<'a> { pub shader_core_builtins: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceShaderCoreBuiltinsFeaturesARM<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceShaderCoreBuiltinsFeaturesARM<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceShaderCoreBuiltinsFeaturesARM<'a> {} +impl<'a> Default for PhysicalDeviceShaderCoreBuiltinsFeaturesARM<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + shader_core_builtins: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceShaderCoreBuiltinsFeaturesARM<'a> { + pub fn shader_core_builtins(mut self, shader_core_builtins: bool) -> Self { + self.shader_core_builtins = shader_core_builtins.into(); + self + } +} ///Provided by [`arm::shader_core_builtins`](crate::arm::shader_core_builtins) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM: Self = Self(1000497000); diff --git a/ash-rewrite/src/generated/arm/shader_core_properties.rs b/ash-rewrite/src/generated/arm/shader_core_properties.rs index 08f15c751..072b7d779 100644 --- a/ash-rewrite/src/generated/arm/shader_core_properties.rs +++ b/ash-rewrite/src/generated/arm/shader_core_properties.rs @@ -11,6 +11,38 @@ pub struct PhysicalDeviceShaderCorePropertiesARM<'a> { pub fma_rate: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceShaderCorePropertiesARM<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceShaderCorePropertiesARM<'a> {} +impl<'a> Default for PhysicalDeviceShaderCorePropertiesARM<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + pixel_rate: Default::default(), + texel_rate: Default::default(), + fma_rate: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceShaderCorePropertiesARM<'a> { + pub fn pixel_rate(mut self, pixel_rate: u32) -> Self { + self.pixel_rate = pixel_rate; + self + } + pub fn texel_rate(mut self, texel_rate: u32) -> Self { + self.texel_rate = texel_rate; + self + } + pub fn fma_rate(mut self, fma_rate: u32) -> Self { + self.fma_rate = fma_rate; + self + } +} ///Provided by [`arm::shader_core_properties`](crate::arm::shader_core_properties) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM: Self = Self(1000415000); diff --git a/ash-rewrite/src/generated/arm/shader_instrumentation.rs b/ash-rewrite/src/generated/arm/shader_instrumentation.rs index 7b05746d7..f85cee6f3 100644 --- a/ash-rewrite/src/generated/arm/shader_instrumentation.rs +++ b/ash-rewrite/src/generated/arm/shader_instrumentation.rs @@ -161,6 +161,30 @@ pub(crate) mod reexport { pub shader_instrumentation: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceShaderInstrumentationFeaturesARM<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_SHADER_INSTRUMENTATION_FEATURES_ARM; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceShaderInstrumentationFeaturesARM<'a> {} + unsafe impl<'a> crate::Extends> + for PhysicalDeviceShaderInstrumentationFeaturesARM<'a> {} + impl<'a> Default for PhysicalDeviceShaderInstrumentationFeaturesARM<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + shader_instrumentation: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceShaderInstrumentationFeaturesARM<'a> { + pub fn shader_instrumentation(mut self, shader_instrumentation: bool) -> Self { + self.shader_instrumentation = shader_instrumentation.into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceShaderInstrumentationPropertiesARM<'a> { @@ -170,6 +194,36 @@ pub(crate) mod reexport { pub per_basic_block_granularity: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceShaderInstrumentationPropertiesARM<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_SHADER_INSTRUMENTATION_PROPERTIES_ARM; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceShaderInstrumentationPropertiesARM<'a> {} + impl<'a> Default for PhysicalDeviceShaderInstrumentationPropertiesARM<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + num_metrics: Default::default(), + per_basic_block_granularity: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceShaderInstrumentationPropertiesARM<'a> { + pub fn num_metrics(mut self, num_metrics: u32) -> Self { + self.num_metrics = num_metrics; + self + } + pub fn per_basic_block_granularity( + mut self, + per_basic_block_granularity: bool, + ) -> Self { + self.per_basic_block_granularity = per_basic_block_granularity.into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct ShaderInstrumentationCreateInfoARM<'a> { @@ -177,6 +231,20 @@ pub(crate) mod reexport { pub p_next: *mut core::ffi::c_void, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for ShaderInstrumentationCreateInfoARM<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::SHADER_INSTRUMENTATION_CREATE_INFO_ARM; + } + impl<'a> Default for ShaderInstrumentationCreateInfoARM<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> ShaderInstrumentationCreateInfoARM<'a> {} #[repr(C)] #[derive(Clone, Copy)] pub struct ShaderInstrumentationMetricDescriptionARM<'a> { @@ -186,14 +254,72 @@ pub(crate) mod reexport { pub description: [core::ffi::c_char; crate::vk::MAX_DESCRIPTION_SIZE as _], pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for ShaderInstrumentationMetricDescriptionARM<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::SHADER_INSTRUMENTATION_METRIC_DESCRIPTION_ARM; + } + impl<'a> Default for ShaderInstrumentationMetricDescriptionARM<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + name: unsafe { core::mem::zeroed() }, + description: unsafe { core::mem::zeroed() }, + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> ShaderInstrumentationMetricDescriptionARM<'a> { + pub fn name( + mut self, + name: &core::ffi::CStr, + ) -> core::result::Result { + crate::write_c_str_slice_with_nul(&mut self.name, name).map(|_| self) + } + pub fn name_as_c_str( + &self, + ) -> core::result::Result<&core::ffi::CStr, core::ffi::FromBytesUntilNulError> { + crate::wrap_c_str_slice_until_nul(&self.name) + } + pub fn description( + mut self, + description: &core::ffi::CStr, + ) -> core::result::Result { + crate::write_c_str_slice_with_nul(&mut self.description, description) + .map(|_| self) + } + pub fn description_as_c_str( + &self, + ) -> core::result::Result<&core::ffi::CStr, core::ffi::FromBytesUntilNulError> { + crate::wrap_c_str_slice_until_nul(&self.description) + } + } #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct ShaderInstrumentationMetricDataHeaderARM { pub result_index: u32, pub result_sub_index: u32, pub stages: crate::vk::ShaderStageFlags, pub basic_block_index: u32, } + impl ShaderInstrumentationMetricDataHeaderARM { + pub fn result_index(mut self, result_index: u32) -> Self { + self.result_index = result_index; + self + } + pub fn result_sub_index(mut self, result_sub_index: u32) -> Self { + self.result_sub_index = result_sub_index; + self + } + pub fn stages(mut self, stages: crate::vk::ShaderStageFlags) -> Self { + self.stages = stages; + self + } + pub fn basic_block_index(mut self, basic_block_index: u32) -> Self { + self.basic_block_index = basic_block_index; + self + } + } ///Provided by [`arm::shader_instrumentation`](crate::arm::shader_instrumentation) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_SHADER_INSTRUMENTATION_FEATURES_ARM: Self = Self( diff --git a/ash-rewrite/src/generated/arm/tensors.rs b/ash-rewrite/src/generated/arm/tensors.rs index b3372468a..38beb823b 100644 --- a/ash-rewrite/src/generated/arm/tensors.rs +++ b/ash-rewrite/src/generated/arm/tensors.rs @@ -232,6 +232,56 @@ pub(crate) mod reexport { pub usage: crate::vk::TensorUsageFlagsARM, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for TensorDescriptionARM<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::TENSOR_DESCRIPTION_ARM; + } + unsafe impl<'a> crate::Extends> + for TensorDescriptionARM<'a> {} + unsafe impl<'a> crate::Extends> + for TensorDescriptionARM<'a> {} + impl<'a> Default for TensorDescriptionARM<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + tiling: Default::default(), + format: Default::default(), + dimension_count: Default::default(), + p_dimensions: Default::default(), + p_strides: Default::default(), + usage: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> TensorDescriptionARM<'a> { + pub fn tiling(mut self, tiling: crate::vk::TensorTilingARM) -> Self { + self.tiling = tiling; + self + } + pub fn format(mut self, format: crate::vk::Format) -> Self { + self.format = format; + self + } + pub fn dimension_count(mut self, dimension_count: u32) -> Self { + self.dimension_count = dimension_count; + self + } + pub fn p_dimensions(mut self, p_dimensions: &'a [i64]) -> Self { + self.dimension_count = p_dimensions.len() as _; + self.p_dimensions = p_dimensions.as_ptr(); + self + } + pub fn p_strides(mut self, p_strides: &'a [i64]) -> Self { + self.dimension_count = p_strides.len() as _; + self.p_strides = p_strides.as_ptr(); + self + } + pub fn usage(mut self, usage: crate::vk::TensorUsageFlagsARM) -> Self { + self.usage = usage; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct TensorCreateInfoARM<'a> { @@ -244,6 +294,55 @@ pub(crate) mod reexport { pub p_queue_family_indices: *const u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for TensorCreateInfoARM<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::TENSOR_CREATE_INFO_ARM; + } + impl<'a> Default for TensorCreateInfoARM<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + flags: Default::default(), + p_description: Default::default(), + sharing_mode: Default::default(), + queue_family_index_count: Default::default(), + p_queue_family_indices: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> TensorCreateInfoARM<'a> { + pub fn flags(mut self, flags: crate::vk::TensorCreateFlagsARM) -> Self { + self.flags = flags; + self + } + pub fn p_description( + mut self, + p_description: &'a crate::vk::TensorDescriptionARM<'a>, + ) -> Self { + self.p_description = p_description; + self + } + pub fn sharing_mode(mut self, sharing_mode: crate::vk::SharingMode) -> Self { + self.sharing_mode = sharing_mode; + self + } + pub fn queue_family_index_count( + mut self, + queue_family_index_count: u32, + ) -> Self { + self.queue_family_index_count = queue_family_index_count; + self + } + pub fn p_queue_family_indices( + mut self, + p_queue_family_indices: &'a [u32], + ) -> Self { + self.queue_family_index_count = p_queue_family_indices.len() as _; + self.p_queue_family_indices = p_queue_family_indices.as_ptr(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct TensorMemoryRequirementsInfoARM<'a> { @@ -252,6 +351,25 @@ pub(crate) mod reexport { pub tensor: crate::vk::TensorARM, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for TensorMemoryRequirementsInfoARM<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::TENSOR_MEMORY_REQUIREMENTS_INFO_ARM; + } + impl<'a> Default for TensorMemoryRequirementsInfoARM<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + tensor: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> TensorMemoryRequirementsInfoARM<'a> { + pub fn tensor(mut self, tensor: crate::vk::TensorARM) -> Self { + self.tensor = tensor; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct BindTensorMemoryInfoARM<'a> { @@ -262,6 +380,35 @@ pub(crate) mod reexport { pub memory_offset: crate::vk::DeviceSize, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for BindTensorMemoryInfoARM<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::BIND_TENSOR_MEMORY_INFO_ARM; + } + impl<'a> Default for BindTensorMemoryInfoARM<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + tensor: Default::default(), + memory: Default::default(), + memory_offset: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> BindTensorMemoryInfoARM<'a> { + pub fn tensor(mut self, tensor: crate::vk::TensorARM) -> Self { + self.tensor = tensor; + self + } + pub fn memory(mut self, memory: crate::vk::DeviceMemory) -> Self { + self.memory = memory; + self + } + pub fn memory_offset(mut self, memory_offset: crate::vk::DeviceSize) -> Self { + self.memory_offset = memory_offset; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct WriteDescriptorSetTensorARM<'a> { @@ -271,6 +418,36 @@ pub(crate) mod reexport { pub p_tensor_views: *const crate::vk::TensorViewARM, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for WriteDescriptorSetTensorARM<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::WRITE_DESCRIPTOR_SET_TENSOR_ARM; + } + unsafe impl<'a> crate::Extends> + for WriteDescriptorSetTensorARM<'a> {} + impl<'a> Default for WriteDescriptorSetTensorARM<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + tensor_view_count: Default::default(), + p_tensor_views: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> WriteDescriptorSetTensorARM<'a> { + pub fn tensor_view_count(mut self, tensor_view_count: u32) -> Self { + self.tensor_view_count = tensor_view_count; + self + } + pub fn p_tensor_views( + mut self, + p_tensor_views: &'a [crate::vk::TensorViewARM], + ) -> Self { + self.tensor_view_count = p_tensor_views.len() as _; + self.p_tensor_views = p_tensor_views.as_ptr(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct TensorFormatPropertiesARM<'a> { @@ -280,6 +457,38 @@ pub(crate) mod reexport { pub linear_tiling_tensor_features: crate::vk::FormatFeatureFlags2, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for TensorFormatPropertiesARM<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::TENSOR_FORMAT_PROPERTIES_ARM; + } + unsafe impl<'a> crate::Extends> + for TensorFormatPropertiesARM<'a> {} + impl<'a> Default for TensorFormatPropertiesARM<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + optimal_tiling_tensor_features: Default::default(), + linear_tiling_tensor_features: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> TensorFormatPropertiesARM<'a> { + pub fn optimal_tiling_tensor_features( + mut self, + optimal_tiling_tensor_features: crate::vk::FormatFeatureFlags2, + ) -> Self { + self.optimal_tiling_tensor_features = optimal_tiling_tensor_features; + self + } + pub fn linear_tiling_tensor_features( + mut self, + linear_tiling_tensor_features: crate::vk::FormatFeatureFlags2, + ) -> Self { + self.linear_tiling_tensor_features = linear_tiling_tensor_features; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceTensorPropertiesARM<'a> { @@ -300,6 +509,119 @@ pub(crate) mod reexport { pub shader_tensor_supported_stages: crate::vk::ShaderStageFlags, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceTensorPropertiesARM<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_TENSOR_PROPERTIES_ARM; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceTensorPropertiesARM<'a> {} + impl<'a> Default for PhysicalDeviceTensorPropertiesARM<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + max_tensor_dimension_count: Default::default(), + max_tensor_elements: Default::default(), + max_per_dimension_tensor_elements: Default::default(), + max_tensor_stride: Default::default(), + max_tensor_size: Default::default(), + max_tensor_shader_access_array_length: Default::default(), + max_tensor_shader_access_size: Default::default(), + max_descriptor_set_storage_tensors: Default::default(), + max_per_stage_descriptor_set_storage_tensors: Default::default(), + max_descriptor_set_update_after_bind_storage_tensors: Default::default(), + max_per_stage_descriptor_update_after_bind_storage_tensors: Default::default(), + shader_storage_tensor_array_non_uniform_indexing_native: Default::default(), + shader_tensor_supported_stages: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceTensorPropertiesARM<'a> { + pub fn max_tensor_dimension_count( + mut self, + max_tensor_dimension_count: u32, + ) -> Self { + self.max_tensor_dimension_count = max_tensor_dimension_count; + self + } + pub fn max_tensor_elements(mut self, max_tensor_elements: u64) -> Self { + self.max_tensor_elements = max_tensor_elements; + self + } + pub fn max_per_dimension_tensor_elements( + mut self, + max_per_dimension_tensor_elements: u64, + ) -> Self { + self.max_per_dimension_tensor_elements = max_per_dimension_tensor_elements; + self + } + pub fn max_tensor_stride(mut self, max_tensor_stride: i64) -> Self { + self.max_tensor_stride = max_tensor_stride; + self + } + pub fn max_tensor_size(mut self, max_tensor_size: u64) -> Self { + self.max_tensor_size = max_tensor_size; + self + } + pub fn max_tensor_shader_access_array_length( + mut self, + max_tensor_shader_access_array_length: u32, + ) -> Self { + self.max_tensor_shader_access_array_length = max_tensor_shader_access_array_length; + self + } + pub fn max_tensor_shader_access_size( + mut self, + max_tensor_shader_access_size: u32, + ) -> Self { + self.max_tensor_shader_access_size = max_tensor_shader_access_size; + self + } + pub fn max_descriptor_set_storage_tensors( + mut self, + max_descriptor_set_storage_tensors: u32, + ) -> Self { + self.max_descriptor_set_storage_tensors = max_descriptor_set_storage_tensors; + self + } + pub fn max_per_stage_descriptor_set_storage_tensors( + mut self, + max_per_stage_descriptor_set_storage_tensors: u32, + ) -> Self { + self.max_per_stage_descriptor_set_storage_tensors = max_per_stage_descriptor_set_storage_tensors; + self + } + pub fn max_descriptor_set_update_after_bind_storage_tensors( + mut self, + max_descriptor_set_update_after_bind_storage_tensors: u32, + ) -> Self { + self.max_descriptor_set_update_after_bind_storage_tensors = max_descriptor_set_update_after_bind_storage_tensors; + self + } + pub fn max_per_stage_descriptor_update_after_bind_storage_tensors( + mut self, + max_per_stage_descriptor_update_after_bind_storage_tensors: u32, + ) -> Self { + self.max_per_stage_descriptor_update_after_bind_storage_tensors = max_per_stage_descriptor_update_after_bind_storage_tensors; + self + } + pub fn shader_storage_tensor_array_non_uniform_indexing_native( + mut self, + shader_storage_tensor_array_non_uniform_indexing_native: bool, + ) -> Self { + self.shader_storage_tensor_array_non_uniform_indexing_native = shader_storage_tensor_array_non_uniform_indexing_native + .into(); + self + } + pub fn shader_tensor_supported_stages( + mut self, + shader_tensor_supported_stages: crate::vk::ShaderStageFlags, + ) -> Self { + self.shader_tensor_supported_stages = shader_tensor_supported_stages; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct TensorMemoryBarrierARM<'a> { @@ -314,6 +636,69 @@ pub(crate) mod reexport { pub tensor: crate::vk::TensorARM, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for TensorMemoryBarrierARM<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::TENSOR_MEMORY_BARRIER_ARM; + } + unsafe impl<'a> crate::Extends> + for TensorMemoryBarrierARM<'a> {} + impl<'a> Default for TensorMemoryBarrierARM<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + src_stage_mask: Default::default(), + src_access_mask: Default::default(), + dst_stage_mask: Default::default(), + dst_access_mask: Default::default(), + src_queue_family_index: Default::default(), + dst_queue_family_index: Default::default(), + tensor: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> TensorMemoryBarrierARM<'a> { + pub fn src_stage_mask( + mut self, + src_stage_mask: crate::vk::PipelineStageFlags2, + ) -> Self { + self.src_stage_mask = src_stage_mask; + self + } + pub fn src_access_mask( + mut self, + src_access_mask: crate::vk::AccessFlags2, + ) -> Self { + self.src_access_mask = src_access_mask; + self + } + pub fn dst_stage_mask( + mut self, + dst_stage_mask: crate::vk::PipelineStageFlags2, + ) -> Self { + self.dst_stage_mask = dst_stage_mask; + self + } + pub fn dst_access_mask( + mut self, + dst_access_mask: crate::vk::AccessFlags2, + ) -> Self { + self.dst_access_mask = dst_access_mask; + self + } + pub fn src_queue_family_index(mut self, src_queue_family_index: u32) -> Self { + self.src_queue_family_index = src_queue_family_index; + self + } + pub fn dst_queue_family_index(mut self, dst_queue_family_index: u32) -> Self { + self.dst_queue_family_index = dst_queue_family_index; + self + } + pub fn tensor(mut self, tensor: crate::vk::TensorARM) -> Self { + self.tensor = tensor; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct TensorDependencyInfoARM<'a> { @@ -323,6 +708,39 @@ pub(crate) mod reexport { pub p_tensor_memory_barriers: *const crate::vk::TensorMemoryBarrierARM<'a>, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for TensorDependencyInfoARM<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::TENSOR_DEPENDENCY_INFO_ARM; + } + unsafe impl<'a> crate::Extends> + for TensorDependencyInfoARM<'a> {} + impl<'a> Default for TensorDependencyInfoARM<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + tensor_memory_barrier_count: Default::default(), + p_tensor_memory_barriers: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> TensorDependencyInfoARM<'a> { + pub fn tensor_memory_barrier_count( + mut self, + tensor_memory_barrier_count: u32, + ) -> Self { + self.tensor_memory_barrier_count = tensor_memory_barrier_count; + self + } + pub fn p_tensor_memory_barriers( + mut self, + p_tensor_memory_barriers: &'a [crate::vk::TensorMemoryBarrierARM<'a>], + ) -> Self { + self.tensor_memory_barrier_count = p_tensor_memory_barriers.len() as _; + self.p_tensor_memory_barriers = p_tensor_memory_barriers.as_ptr(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceTensorFeaturesARM<'a> { @@ -336,6 +754,66 @@ pub(crate) mod reexport { pub tensors: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for PhysicalDeviceTensorFeaturesARM<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_TENSOR_FEATURES_ARM; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceTensorFeaturesARM<'a> {} + unsafe impl<'a> crate::Extends> + for PhysicalDeviceTensorFeaturesARM<'a> {} + impl<'a> Default for PhysicalDeviceTensorFeaturesARM<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + tensor_non_packed: Default::default(), + shader_tensor_access: Default::default(), + shader_storage_tensor_array_dynamic_indexing: Default::default(), + shader_storage_tensor_array_non_uniform_indexing: Default::default(), + descriptor_binding_storage_tensor_update_after_bind: Default::default(), + tensors: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceTensorFeaturesARM<'a> { + pub fn tensor_non_packed(mut self, tensor_non_packed: bool) -> Self { + self.tensor_non_packed = tensor_non_packed.into(); + self + } + pub fn shader_tensor_access(mut self, shader_tensor_access: bool) -> Self { + self.shader_tensor_access = shader_tensor_access.into(); + self + } + pub fn shader_storage_tensor_array_dynamic_indexing( + mut self, + shader_storage_tensor_array_dynamic_indexing: bool, + ) -> Self { + self.shader_storage_tensor_array_dynamic_indexing = shader_storage_tensor_array_dynamic_indexing + .into(); + self + } + pub fn shader_storage_tensor_array_non_uniform_indexing( + mut self, + shader_storage_tensor_array_non_uniform_indexing: bool, + ) -> Self { + self.shader_storage_tensor_array_non_uniform_indexing = shader_storage_tensor_array_non_uniform_indexing + .into(); + self + } + pub fn descriptor_binding_storage_tensor_update_after_bind( + mut self, + descriptor_binding_storage_tensor_update_after_bind: bool, + ) -> Self { + self.descriptor_binding_storage_tensor_update_after_bind = descriptor_binding_storage_tensor_update_after_bind + .into(); + self + } + pub fn tensors(mut self, tensors: bool) -> Self { + self.tensors = tensors.into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct DeviceTensorMemoryRequirementsARM<'a> { @@ -344,6 +822,29 @@ pub(crate) mod reexport { pub p_create_info: *const crate::vk::TensorCreateInfoARM<'a>, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for DeviceTensorMemoryRequirementsARM<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::DEVICE_TENSOR_MEMORY_REQUIREMENTS_ARM; + } + impl<'a> Default for DeviceTensorMemoryRequirementsARM<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + p_create_info: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> DeviceTensorMemoryRequirementsARM<'a> { + pub fn p_create_info( + mut self, + p_create_info: &'a crate::vk::TensorCreateInfoARM<'a>, + ) -> Self { + self.p_create_info = p_create_info; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct CopyTensorInfoARM<'a> { @@ -355,6 +856,44 @@ pub(crate) mod reexport { pub p_regions: *const crate::vk::TensorCopyARM<'a>, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for CopyTensorInfoARM<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::COPY_TENSOR_INFO_ARM; + } + impl<'a> Default for CopyTensorInfoARM<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + src_tensor: Default::default(), + dst_tensor: Default::default(), + region_count: Default::default(), + p_regions: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> CopyTensorInfoARM<'a> { + pub fn src_tensor(mut self, src_tensor: crate::vk::TensorARM) -> Self { + self.src_tensor = src_tensor; + self + } + pub fn dst_tensor(mut self, dst_tensor: crate::vk::TensorARM) -> Self { + self.dst_tensor = dst_tensor; + self + } + pub fn region_count(mut self, region_count: u32) -> Self { + self.region_count = region_count; + self + } + pub fn p_regions( + mut self, + p_regions: &'a [crate::vk::TensorCopyARM<'a>], + ) -> Self { + self.region_count = p_regions.len() as _; + self.p_regions = p_regions.as_ptr(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct TensorCopyARM<'a> { @@ -366,6 +905,43 @@ pub(crate) mod reexport { pub p_extent: *const u64, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for TensorCopyARM<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::TENSOR_COPY_ARM; + } + impl<'a> Default for TensorCopyARM<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + dimension_count: Default::default(), + p_src_offset: Default::default(), + p_dst_offset: Default::default(), + p_extent: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> TensorCopyARM<'a> { + pub fn dimension_count(mut self, dimension_count: u32) -> Self { + self.dimension_count = dimension_count; + self + } + pub fn p_src_offset(mut self, p_src_offset: &'a [u64]) -> Self { + self.dimension_count = p_src_offset.len() as _; + self.p_src_offset = p_src_offset.as_ptr(); + self + } + pub fn p_dst_offset(mut self, p_dst_offset: &'a [u64]) -> Self { + self.dimension_count = p_dst_offset.len() as _; + self.p_dst_offset = p_dst_offset.as_ptr(); + self + } + pub fn p_extent(mut self, p_extent: &'a [u64]) -> Self { + self.dimension_count = p_extent.len() as _; + self.p_extent = p_extent.as_ptr(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct MemoryDedicatedAllocateInfoTensorARM<'a> { @@ -374,6 +950,28 @@ pub(crate) mod reexport { pub tensor: crate::vk::TensorARM, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for MemoryDedicatedAllocateInfoTensorARM<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::MEMORY_DEDICATED_ALLOCATE_INFO_TENSOR_ARM; + } + unsafe impl<'a> crate::Extends> + for MemoryDedicatedAllocateInfoTensorARM<'a> {} + impl<'a> Default for MemoryDedicatedAllocateInfoTensorARM<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + tensor: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> MemoryDedicatedAllocateInfoTensorARM<'a> { + pub fn tensor(mut self, tensor: crate::vk::TensorARM) -> Self { + self.tensor = tensor; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceDescriptorBufferTensorPropertiesARM<'a> { @@ -384,6 +982,44 @@ pub(crate) mod reexport { pub tensor_descriptor_size: usize, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceDescriptorBufferTensorPropertiesARM<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_PROPERTIES_ARM; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceDescriptorBufferTensorPropertiesARM<'a> {} + impl<'a> Default for PhysicalDeviceDescriptorBufferTensorPropertiesARM<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + tensor_capture_replay_descriptor_data_size: Default::default(), + tensor_view_capture_replay_descriptor_data_size: Default::default(), + tensor_descriptor_size: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceDescriptorBufferTensorPropertiesARM<'a> { + pub fn tensor_capture_replay_descriptor_data_size( + mut self, + tensor_capture_replay_descriptor_data_size: usize, + ) -> Self { + self.tensor_capture_replay_descriptor_data_size = tensor_capture_replay_descriptor_data_size; + self + } + pub fn tensor_view_capture_replay_descriptor_data_size( + mut self, + tensor_view_capture_replay_descriptor_data_size: usize, + ) -> Self { + self.tensor_view_capture_replay_descriptor_data_size = tensor_view_capture_replay_descriptor_data_size; + self + } + pub fn tensor_descriptor_size(mut self, tensor_descriptor_size: usize) -> Self { + self.tensor_descriptor_size = tensor_descriptor_size; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceDescriptorBufferTensorFeaturesARM<'a> { @@ -392,6 +1028,34 @@ pub(crate) mod reexport { pub descriptor_buffer_tensor_descriptors: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceDescriptorBufferTensorFeaturesARM<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_FEATURES_ARM; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceDescriptorBufferTensorFeaturesARM<'a> {} + unsafe impl<'a> crate::Extends> + for PhysicalDeviceDescriptorBufferTensorFeaturesARM<'a> {} + impl<'a> Default for PhysicalDeviceDescriptorBufferTensorFeaturesARM<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + descriptor_buffer_tensor_descriptors: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceDescriptorBufferTensorFeaturesARM<'a> { + pub fn descriptor_buffer_tensor_descriptors( + mut self, + descriptor_buffer_tensor_descriptors: bool, + ) -> Self { + self.descriptor_buffer_tensor_descriptors = descriptor_buffer_tensor_descriptors + .into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct TensorCaptureDescriptorDataInfoARM<'a> { @@ -400,6 +1064,26 @@ pub(crate) mod reexport { pub tensor: crate::vk::TensorARM, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for TensorCaptureDescriptorDataInfoARM<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::TENSOR_CAPTURE_DESCRIPTOR_DATA_INFO_ARM; + } + impl<'a> Default for TensorCaptureDescriptorDataInfoARM<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + tensor: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> TensorCaptureDescriptorDataInfoARM<'a> { + pub fn tensor(mut self, tensor: crate::vk::TensorARM) -> Self { + self.tensor = tensor; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct TensorViewCaptureDescriptorDataInfoARM<'a> { @@ -408,6 +1092,26 @@ pub(crate) mod reexport { pub tensor_view: crate::vk::TensorViewARM, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for TensorViewCaptureDescriptorDataInfoARM<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::TENSOR_VIEW_CAPTURE_DESCRIPTOR_DATA_INFO_ARM; + } + impl<'a> Default for TensorViewCaptureDescriptorDataInfoARM<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + tensor_view: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> TensorViewCaptureDescriptorDataInfoARM<'a> { + pub fn tensor_view(mut self, tensor_view: crate::vk::TensorViewARM) -> Self { + self.tensor_view = tensor_view; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct DescriptorGetTensorInfoARM<'a> { @@ -416,6 +1120,27 @@ pub(crate) mod reexport { pub tensor_view: crate::vk::TensorViewARM, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for DescriptorGetTensorInfoARM<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::DESCRIPTOR_GET_TENSOR_INFO_ARM; + } + unsafe impl<'a> crate::Extends> + for DescriptorGetTensorInfoARM<'a> {} + impl<'a> Default for DescriptorGetTensorInfoARM<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + tensor_view: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> DescriptorGetTensorInfoARM<'a> { + pub fn tensor_view(mut self, tensor_view: crate::vk::TensorViewARM) -> Self { + self.tensor_view = tensor_view; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct FrameBoundaryTensorsARM<'a> { @@ -425,6 +1150,39 @@ pub(crate) mod reexport { pub p_tensors: *const crate::vk::TensorARM, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for FrameBoundaryTensorsARM<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::FRAME_BOUNDARY_TENSORS_ARM; + } + unsafe impl<'a> crate::Extends> + for FrameBoundaryTensorsARM<'a> {} + unsafe impl<'a> crate::Extends> + for FrameBoundaryTensorsARM<'a> {} + unsafe impl<'a> crate::Extends> + for FrameBoundaryTensorsARM<'a> {} + unsafe impl<'a> crate::Extends> + for FrameBoundaryTensorsARM<'a> {} + impl<'a> Default for FrameBoundaryTensorsARM<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + tensor_count: Default::default(), + p_tensors: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> FrameBoundaryTensorsARM<'a> { + pub fn tensor_count(mut self, tensor_count: u32) -> Self { + self.tensor_count = tensor_count; + self + } + pub fn p_tensors(mut self, p_tensors: &'a [crate::vk::TensorARM]) -> Self { + self.tensor_count = p_tensors.len() as _; + self.p_tensors = p_tensors.as_ptr(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceExternalTensorInfoARM<'a> { @@ -435,6 +1193,42 @@ pub(crate) mod reexport { pub handle_type: crate::vk::ExternalMemoryHandleTypeFlagBits, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceExternalTensorInfoARM<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_EXTERNAL_TENSOR_INFO_ARM; + } + impl<'a> Default for PhysicalDeviceExternalTensorInfoARM<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + flags: Default::default(), + p_description: Default::default(), + handle_type: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceExternalTensorInfoARM<'a> { + pub fn flags(mut self, flags: crate::vk::TensorCreateFlagsARM) -> Self { + self.flags = flags; + self + } + pub fn p_description( + mut self, + p_description: &'a crate::vk::TensorDescriptionARM<'a>, + ) -> Self { + self.p_description = p_description; + self + } + pub fn handle_type( + mut self, + handle_type: crate::vk::ExternalMemoryHandleTypeFlagBits, + ) -> Self { + self.handle_type = handle_type; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct ExternalTensorPropertiesARM<'a> { @@ -443,6 +1237,28 @@ pub(crate) mod reexport { pub external_memory_properties: crate::vk::ExternalMemoryProperties, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for ExternalTensorPropertiesARM<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::EXTERNAL_TENSOR_PROPERTIES_ARM; + } + impl<'a> Default for ExternalTensorPropertiesARM<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + external_memory_properties: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> ExternalTensorPropertiesARM<'a> { + pub fn external_memory_properties( + mut self, + external_memory_properties: crate::vk::ExternalMemoryProperties, + ) -> Self { + self.external_memory_properties = external_memory_properties; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct ExternalMemoryTensorCreateInfoARM<'a> { @@ -451,6 +1267,31 @@ pub(crate) mod reexport { pub handle_types: crate::vk::ExternalMemoryHandleTypeFlags, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for ExternalMemoryTensorCreateInfoARM<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::EXTERNAL_MEMORY_TENSOR_CREATE_INFO_ARM; + } + unsafe impl<'a> crate::Extends> + for ExternalMemoryTensorCreateInfoARM<'a> {} + impl<'a> Default for ExternalMemoryTensorCreateInfoARM<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + handle_types: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> ExternalMemoryTensorCreateInfoARM<'a> { + pub fn handle_types( + mut self, + handle_types: crate::vk::ExternalMemoryHandleTypeFlags, + ) -> Self { + self.handle_types = handle_types; + self + } + } ///Provided by [`arm::tensors`](crate::arm::tensors) impl crate::vk::ImageLayout { pub const TENSOR_ALIASING_ARM: Self = Self(1000460000); @@ -606,7 +1447,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct TensorCreateFlagBitsARM(pub(crate) u64); ///Provided by [`arm::tensors`](crate::arm::tensors) impl TensorCreateFlagBitsARM { @@ -693,7 +1534,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct TensorUsageFlagBitsARM(pub(crate) u64); ///Provided by [`arm::tensors`](crate::arm::tensors) impl TensorUsageFlagBitsARM { diff --git a/ash-rewrite/src/generated/ext/_4444_formats.rs b/ash-rewrite/src/generated/ext/_4444_formats.rs index 6768901dd..c326de5c1 100644 --- a/ash-rewrite/src/generated/ext/_4444_formats.rs +++ b/ash-rewrite/src/generated/ext/_4444_formats.rs @@ -10,6 +10,34 @@ pub struct PhysicalDevice4444FormatsFeaturesEXT<'a> { pub format_a4b4g4r4: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> for PhysicalDevice4444FormatsFeaturesEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT; +} +unsafe impl<'a> crate::Extends> +for PhysicalDevice4444FormatsFeaturesEXT<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDevice4444FormatsFeaturesEXT<'a> {} +impl<'a> Default for PhysicalDevice4444FormatsFeaturesEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + format_a4r4g4b4: Default::default(), + format_a4b4g4r4: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDevice4444FormatsFeaturesEXT<'a> { + pub fn format_a4r4g4b4(mut self, format_a4r4g4b4: bool) -> Self { + self.format_a4r4g4b4 = format_a4r4g4b4.into(); + self + } + pub fn format_a4b4g4r4(mut self, format_a4b4g4r4: bool) -> Self { + self.format_a4b4g4r4 = format_a4b4g4r4.into(); + self + } +} ///Provided by [`ext::_4444_formats`](crate::ext::_4444_formats) impl crate::vk::Format { pub const A4R4G4B4_UNORM_PACK16_EXT: Self = Self::A4R4G4B4_UNORM_PACK16; diff --git a/ash-rewrite/src/generated/ext/astc_decode_mode.rs b/ash-rewrite/src/generated/ext/astc_decode_mode.rs index 8302e3e6e..78de0ba05 100644 --- a/ash-rewrite/src/generated/ext/astc_decode_mode.rs +++ b/ash-rewrite/src/generated/ext/astc_decode_mode.rs @@ -9,6 +9,27 @@ pub struct ImageViewASTCDecodeModeEXT<'a> { pub decode_mode: crate::vk::Format, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> for ImageViewASTCDecodeModeEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::IMAGE_VIEW_ASTC_DECODE_MODE_EXT; +} +unsafe impl<'a> crate::Extends> +for ImageViewASTCDecodeModeEXT<'a> {} +impl<'a> Default for ImageViewASTCDecodeModeEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + decode_mode: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> ImageViewASTCDecodeModeEXT<'a> { + pub fn decode_mode(mut self, decode_mode: crate::vk::Format) -> Self { + self.decode_mode = decode_mode; + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceASTCDecodeFeaturesEXT<'a> { @@ -17,6 +38,32 @@ pub struct PhysicalDeviceASTCDecodeFeaturesEXT<'a> { pub decode_mode_shared_exponent: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> for PhysicalDeviceASTCDecodeFeaturesEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceASTCDecodeFeaturesEXT<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceASTCDecodeFeaturesEXT<'a> {} +impl<'a> Default for PhysicalDeviceASTCDecodeFeaturesEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + decode_mode_shared_exponent: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceASTCDecodeFeaturesEXT<'a> { + pub fn decode_mode_shared_exponent( + mut self, + decode_mode_shared_exponent: bool, + ) -> Self { + self.decode_mode_shared_exponent = decode_mode_shared_exponent.into(); + self + } +} ///Provided by [`ext::astc_decode_mode`](crate::ext::astc_decode_mode) impl crate::vk::StructureType { pub const IMAGE_VIEW_ASTC_DECODE_MODE_EXT: Self = Self(1000067000); diff --git a/ash-rewrite/src/generated/ext/attachment_feedback_loop_dynamic_state.rs b/ash-rewrite/src/generated/ext/attachment_feedback_loop_dynamic_state.rs index e9a3f4689..c19d9643b 100644 --- a/ash-rewrite/src/generated/ext/attachment_feedback_loop_dynamic_state.rs +++ b/ash-rewrite/src/generated/ext/attachment_feedback_loop_dynamic_state.rs @@ -43,6 +43,35 @@ pub(crate) mod reexport { pub attachment_feedback_loop_dynamic_state: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT<'a> {} + unsafe impl<'a> crate::Extends> + for PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT<'a> {} + impl<'a> Default + for PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + attachment_feedback_loop_dynamic_state: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT<'a> { + pub fn attachment_feedback_loop_dynamic_state( + mut self, + attachment_feedback_loop_dynamic_state: bool, + ) -> Self { + self.attachment_feedback_loop_dynamic_state = attachment_feedback_loop_dynamic_state + .into(); + self + } + } ///Provided by [`ext::attachment_feedback_loop_dynamic_state`](crate::ext::attachment_feedback_loop_dynamic_state) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT: Self = Self( diff --git a/ash-rewrite/src/generated/ext/attachment_feedback_loop_layout.rs b/ash-rewrite/src/generated/ext/attachment_feedback_loop_layout.rs index 5f47fe8d0..c8799c792 100644 --- a/ash-rewrite/src/generated/ext/attachment_feedback_loop_layout.rs +++ b/ash-rewrite/src/generated/ext/attachment_feedback_loop_layout.rs @@ -9,6 +9,33 @@ pub struct PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT<'a> { pub attachment_feedback_loop_layout: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT<'a> {} +impl<'a> Default for PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + attachment_feedback_loop_layout: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT<'a> { + pub fn attachment_feedback_loop_layout( + mut self, + attachment_feedback_loop_layout: bool, + ) -> Self { + self.attachment_feedback_loop_layout = attachment_feedback_loop_layout.into(); + self + } +} ///Provided by [`ext::attachment_feedback_loop_layout`](crate::ext::attachment_feedback_loop_layout) impl crate::vk::ImageLayout { pub const ATTACHMENT_FEEDBACK_LOOP_OPTIMAL_EXT: Self = Self(1000339000); diff --git a/ash-rewrite/src/generated/ext/blend_operation_advanced.rs b/ash-rewrite/src/generated/ext/blend_operation_advanced.rs index 4d86b1815..a72d2d5dd 100644 --- a/ash-rewrite/src/generated/ext/blend_operation_advanced.rs +++ b/ash-rewrite/src/generated/ext/blend_operation_advanced.rs @@ -9,6 +9,34 @@ pub struct PhysicalDeviceBlendOperationAdvancedFeaturesEXT<'a> { pub advanced_blend_coherent_operations: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceBlendOperationAdvancedFeaturesEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceBlendOperationAdvancedFeaturesEXT<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceBlendOperationAdvancedFeaturesEXT<'a> {} +impl<'a> Default for PhysicalDeviceBlendOperationAdvancedFeaturesEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + advanced_blend_coherent_operations: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceBlendOperationAdvancedFeaturesEXT<'a> { + pub fn advanced_blend_coherent_operations( + mut self, + advanced_blend_coherent_operations: bool, + ) -> Self { + self.advanced_blend_coherent_operations = advanced_blend_coherent_operations + .into(); + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceBlendOperationAdvancedPropertiesEXT<'a> { @@ -22,6 +50,74 @@ pub struct PhysicalDeviceBlendOperationAdvancedPropertiesEXT<'a> { pub advanced_blend_all_operations: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceBlendOperationAdvancedPropertiesEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceBlendOperationAdvancedPropertiesEXT<'a> {} +impl<'a> Default for PhysicalDeviceBlendOperationAdvancedPropertiesEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + advanced_blend_max_color_attachments: Default::default(), + advanced_blend_independent_blend: Default::default(), + advanced_blend_non_premultiplied_src_color: Default::default(), + advanced_blend_non_premultiplied_dst_color: Default::default(), + advanced_blend_correlated_overlap: Default::default(), + advanced_blend_all_operations: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceBlendOperationAdvancedPropertiesEXT<'a> { + pub fn advanced_blend_max_color_attachments( + mut self, + advanced_blend_max_color_attachments: u32, + ) -> Self { + self.advanced_blend_max_color_attachments = advanced_blend_max_color_attachments; + self + } + pub fn advanced_blend_independent_blend( + mut self, + advanced_blend_independent_blend: bool, + ) -> Self { + self.advanced_blend_independent_blend = advanced_blend_independent_blend.into(); + self + } + pub fn advanced_blend_non_premultiplied_src_color( + mut self, + advanced_blend_non_premultiplied_src_color: bool, + ) -> Self { + self.advanced_blend_non_premultiplied_src_color = advanced_blend_non_premultiplied_src_color + .into(); + self + } + pub fn advanced_blend_non_premultiplied_dst_color( + mut self, + advanced_blend_non_premultiplied_dst_color: bool, + ) -> Self { + self.advanced_blend_non_premultiplied_dst_color = advanced_blend_non_premultiplied_dst_color + .into(); + self + } + pub fn advanced_blend_correlated_overlap( + mut self, + advanced_blend_correlated_overlap: bool, + ) -> Self { + self.advanced_blend_correlated_overlap = advanced_blend_correlated_overlap + .into(); + self + } + pub fn advanced_blend_all_operations( + mut self, + advanced_blend_all_operations: bool, + ) -> Self { + self.advanced_blend_all_operations = advanced_blend_all_operations.into(); + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct PipelineColorBlendAdvancedStateCreateInfoEXT<'a> { @@ -32,6 +128,38 @@ pub struct PipelineColorBlendAdvancedStateCreateInfoEXT<'a> { pub blend_overlap: crate::vk::BlendOverlapEXT, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PipelineColorBlendAdvancedStateCreateInfoEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT; +} +unsafe impl<'a> crate::Extends> +for PipelineColorBlendAdvancedStateCreateInfoEXT<'a> {} +impl<'a> Default for PipelineColorBlendAdvancedStateCreateInfoEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + src_premultiplied: Default::default(), + dst_premultiplied: Default::default(), + blend_overlap: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PipelineColorBlendAdvancedStateCreateInfoEXT<'a> { + pub fn src_premultiplied(mut self, src_premultiplied: bool) -> Self { + self.src_premultiplied = src_premultiplied.into(); + self + } + pub fn dst_premultiplied(mut self, dst_premultiplied: bool) -> Self { + self.dst_premultiplied = dst_premultiplied.into(); + self + } + pub fn blend_overlap(mut self, blend_overlap: crate::vk::BlendOverlapEXT) -> Self { + self.blend_overlap = blend_overlap; + self + } +} ///Provided by [`ext::blend_operation_advanced`](crate::ext::blend_operation_advanced) impl crate::vk::BlendOp { pub const ZERO_EXT: Self = Self(1000148000); diff --git a/ash-rewrite/src/generated/ext/border_color_swizzle.rs b/ash-rewrite/src/generated/ext/border_color_swizzle.rs index 58772b9b5..7f8d6a62c 100644 --- a/ash-rewrite/src/generated/ext/border_color_swizzle.rs +++ b/ash-rewrite/src/generated/ext/border_color_swizzle.rs @@ -10,6 +10,33 @@ pub struct SamplerBorderColorComponentMappingCreateInfoEXT<'a> { pub srgb: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for SamplerBorderColorComponentMappingCreateInfoEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT; +} +unsafe impl<'a> crate::Extends> +for SamplerBorderColorComponentMappingCreateInfoEXT<'a> {} +impl<'a> Default for SamplerBorderColorComponentMappingCreateInfoEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + components: Default::default(), + srgb: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> SamplerBorderColorComponentMappingCreateInfoEXT<'a> { + pub fn components(mut self, components: crate::vk::ComponentMapping) -> Self { + self.components = components; + self + } + pub fn srgb(mut self, srgb: bool) -> Self { + self.srgb = srgb.into(); + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceBorderColorSwizzleFeaturesEXT<'a> { @@ -19,6 +46,38 @@ pub struct PhysicalDeviceBorderColorSwizzleFeaturesEXT<'a> { pub border_color_swizzle_from_image: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceBorderColorSwizzleFeaturesEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceBorderColorSwizzleFeaturesEXT<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceBorderColorSwizzleFeaturesEXT<'a> {} +impl<'a> Default for PhysicalDeviceBorderColorSwizzleFeaturesEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + border_color_swizzle: Default::default(), + border_color_swizzle_from_image: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceBorderColorSwizzleFeaturesEXT<'a> { + pub fn border_color_swizzle(mut self, border_color_swizzle: bool) -> Self { + self.border_color_swizzle = border_color_swizzle.into(); + self + } + pub fn border_color_swizzle_from_image( + mut self, + border_color_swizzle_from_image: bool, + ) -> Self { + self.border_color_swizzle_from_image = border_color_swizzle_from_image.into(); + self + } +} ///Provided by [`ext::border_color_swizzle`](crate::ext::border_color_swizzle) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT: Self = Self(1000411000); diff --git a/ash-rewrite/src/generated/ext/buffer_device_address.rs b/ash-rewrite/src/generated/ext/buffer_device_address.rs index d2ce5e708..a9aead621 100644 --- a/ash-rewrite/src/generated/ext/buffer_device_address.rs +++ b/ash-rewrite/src/generated/ext/buffer_device_address.rs @@ -45,6 +45,48 @@ pub(crate) mod reexport { pub buffer_device_address_multi_device: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceBufferDeviceAddressFeaturesEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceBufferDeviceAddressFeaturesEXT<'a> {} + unsafe impl<'a> crate::Extends> + for PhysicalDeviceBufferDeviceAddressFeaturesEXT<'a> {} + impl<'a> Default for PhysicalDeviceBufferDeviceAddressFeaturesEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + buffer_device_address: Default::default(), + buffer_device_address_capture_replay: Default::default(), + buffer_device_address_multi_device: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceBufferDeviceAddressFeaturesEXT<'a> { + pub fn buffer_device_address(mut self, buffer_device_address: bool) -> Self { + self.buffer_device_address = buffer_device_address.into(); + self + } + pub fn buffer_device_address_capture_replay( + mut self, + buffer_device_address_capture_replay: bool, + ) -> Self { + self.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, + ) -> Self { + self.buffer_device_address_multi_device = buffer_device_address_multi_device + .into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct BufferDeviceAddressCreateInfoEXT<'a> { @@ -53,6 +95,30 @@ pub(crate) mod reexport { pub device_address: crate::vk::DeviceAddress, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for BufferDeviceAddressCreateInfoEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT; + } + unsafe impl<'a> crate::Extends> + for BufferDeviceAddressCreateInfoEXT<'a> {} + impl<'a> Default for BufferDeviceAddressCreateInfoEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + device_address: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> BufferDeviceAddressCreateInfoEXT<'a> { + pub fn device_address( + mut self, + device_address: crate::vk::DeviceAddress, + ) -> Self { + self.device_address = device_address; + self + } + } pub type PhysicalDeviceBufferAddressFeaturesEXT<'a> = crate::vk::PhysicalDeviceBufferDeviceAddressFeaturesEXT< 'a, >; diff --git a/ash-rewrite/src/generated/ext/color_write_enable.rs b/ash-rewrite/src/generated/ext/color_write_enable.rs index 5cdca1769..57833bad7 100644 --- a/ash-rewrite/src/generated/ext/color_write_enable.rs +++ b/ash-rewrite/src/generated/ext/color_write_enable.rs @@ -44,6 +44,30 @@ pub(crate) mod reexport { pub color_write_enable: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceColorWriteEnableFeaturesEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceColorWriteEnableFeaturesEXT<'a> {} + unsafe impl<'a> crate::Extends> + for PhysicalDeviceColorWriteEnableFeaturesEXT<'a> {} + impl<'a> Default for PhysicalDeviceColorWriteEnableFeaturesEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + color_write_enable: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceColorWriteEnableFeaturesEXT<'a> { + pub fn color_write_enable(mut self, color_write_enable: bool) -> Self { + self.color_write_enable = color_write_enable.into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PipelineColorWriteCreateInfoEXT<'a> { @@ -53,6 +77,36 @@ pub(crate) mod reexport { pub p_color_write_enables: *const crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for PipelineColorWriteCreateInfoEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PIPELINE_COLOR_WRITE_CREATE_INFO_EXT; + } + unsafe impl<'a> crate::Extends> + for PipelineColorWriteCreateInfoEXT<'a> {} + impl<'a> Default for PipelineColorWriteCreateInfoEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + attachment_count: Default::default(), + p_color_write_enables: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PipelineColorWriteCreateInfoEXT<'a> { + pub fn attachment_count(mut self, attachment_count: u32) -> Self { + self.attachment_count = attachment_count; + self + } + pub fn p_color_write_enables( + mut self, + p_color_write_enables: &'a [crate::vk::Bool32], + ) -> Self { + self.attachment_count = p_color_write_enables.len() as _; + self.p_color_write_enables = p_color_write_enables.as_ptr(); + self + } + } ///Provided by [`ext::color_write_enable`](crate::ext::color_write_enable) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT: Self = Self( diff --git a/ash-rewrite/src/generated/ext/conditional_rendering.rs b/ash-rewrite/src/generated/ext/conditional_rendering.rs index 51fa9e5f1..2710ba088 100644 --- a/ash-rewrite/src/generated/ext/conditional_rendering.rs +++ b/ash-rewrite/src/generated/ext/conditional_rendering.rs @@ -59,6 +59,35 @@ pub(crate) mod reexport { pub flags: crate::vk::ConditionalRenderingFlagsEXT, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for ConditionalRenderingBeginInfoEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::CONDITIONAL_RENDERING_BEGIN_INFO_EXT; + } + impl<'a> Default for ConditionalRenderingBeginInfoEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + buffer: Default::default(), + offset: Default::default(), + flags: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> ConditionalRenderingBeginInfoEXT<'a> { + pub fn buffer(mut self, buffer: crate::vk::Buffer) -> Self { + self.buffer = buffer; + self + } + pub fn offset(mut self, offset: crate::vk::DeviceSize) -> Self { + self.offset = offset; + self + } + pub fn flags(mut self, flags: crate::vk::ConditionalRenderingFlagsEXT) -> Self { + self.flags = flags; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct CommandBufferInheritanceConditionalRenderingInfoEXT<'a> { @@ -67,6 +96,31 @@ pub(crate) mod reexport { pub conditional_rendering_enable: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for CommandBufferInheritanceConditionalRenderingInfoEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT; + } + unsafe impl<'a> crate::Extends> + for CommandBufferInheritanceConditionalRenderingInfoEXT<'a> {} + impl<'a> Default for CommandBufferInheritanceConditionalRenderingInfoEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + conditional_rendering_enable: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> CommandBufferInheritanceConditionalRenderingInfoEXT<'a> { + pub fn conditional_rendering_enable( + mut self, + conditional_rendering_enable: bool, + ) -> Self { + self.conditional_rendering_enable = conditional_rendering_enable.into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceConditionalRenderingFeaturesEXT<'a> { @@ -76,6 +130,39 @@ pub(crate) mod reexport { pub inherited_conditional_rendering: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceConditionalRenderingFeaturesEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceConditionalRenderingFeaturesEXT<'a> {} + unsafe impl<'a> crate::Extends> + for PhysicalDeviceConditionalRenderingFeaturesEXT<'a> {} + impl<'a> Default for PhysicalDeviceConditionalRenderingFeaturesEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + conditional_rendering: Default::default(), + inherited_conditional_rendering: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceConditionalRenderingFeaturesEXT<'a> { + pub fn conditional_rendering(mut self, conditional_rendering: bool) -> Self { + self.conditional_rendering = conditional_rendering.into(); + self + } + pub fn inherited_conditional_rendering( + mut self, + inherited_conditional_rendering: bool, + ) -> Self { + self.inherited_conditional_rendering = inherited_conditional_rendering + .into(); + self + } + } ///Provided by [`ext::conditional_rendering`](crate::ext::conditional_rendering) impl crate::vk::StructureType { pub const COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT: Self = Self( @@ -169,7 +256,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct ConditionalRenderingFlagBitsEXT(pub(crate) u32); ///Provided by [`ext::conditional_rendering`](crate::ext::conditional_rendering) impl ConditionalRenderingFlagBitsEXT { diff --git a/ash-rewrite/src/generated/ext/conservative_rasterization.rs b/ash-rewrite/src/generated/ext/conservative_rasterization.rs index 7a5a129f0..bac9c6c8c 100644 --- a/ash-rewrite/src/generated/ext/conservative_rasterization.rs +++ b/ash-rewrite/src/generated/ext/conservative_rasterization.rs @@ -17,6 +17,95 @@ pub struct PhysicalDeviceConservativeRasterizationPropertiesEXT<'a> { pub conservative_rasterization_post_depth_coverage: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceConservativeRasterizationPropertiesEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceConservativeRasterizationPropertiesEXT<'a> {} +impl<'a> Default for PhysicalDeviceConservativeRasterizationPropertiesEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + primitive_overestimation_size: Default::default(), + max_extra_primitive_overestimation_size: Default::default(), + extra_primitive_overestimation_size_granularity: Default::default(), + primitive_underestimation: Default::default(), + conservative_point_and_line_rasterization: Default::default(), + degenerate_triangles_rasterized: Default::default(), + degenerate_lines_rasterized: Default::default(), + fully_covered_fragment_shader_input_variable: Default::default(), + conservative_rasterization_post_depth_coverage: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceConservativeRasterizationPropertiesEXT<'a> { + pub fn primitive_overestimation_size( + mut self, + primitive_overestimation_size: core::ffi::c_float, + ) -> Self { + self.primitive_overestimation_size = primitive_overestimation_size; + self + } + pub fn max_extra_primitive_overestimation_size( + mut self, + max_extra_primitive_overestimation_size: core::ffi::c_float, + ) -> Self { + self.max_extra_primitive_overestimation_size = max_extra_primitive_overestimation_size; + self + } + pub fn extra_primitive_overestimation_size_granularity( + mut self, + extra_primitive_overestimation_size_granularity: core::ffi::c_float, + ) -> Self { + self.extra_primitive_overestimation_size_granularity = extra_primitive_overestimation_size_granularity; + self + } + pub fn primitive_underestimation(mut self, primitive_underestimation: bool) -> Self { + self.primitive_underestimation = primitive_underestimation.into(); + self + } + pub fn conservative_point_and_line_rasterization( + mut self, + conservative_point_and_line_rasterization: bool, + ) -> Self { + self.conservative_point_and_line_rasterization = conservative_point_and_line_rasterization + .into(); + self + } + pub fn degenerate_triangles_rasterized( + mut self, + degenerate_triangles_rasterized: bool, + ) -> Self { + self.degenerate_triangles_rasterized = degenerate_triangles_rasterized.into(); + self + } + pub fn degenerate_lines_rasterized( + mut self, + degenerate_lines_rasterized: bool, + ) -> Self { + self.degenerate_lines_rasterized = degenerate_lines_rasterized.into(); + self + } + pub fn fully_covered_fragment_shader_input_variable( + mut self, + fully_covered_fragment_shader_input_variable: bool, + ) -> Self { + self.fully_covered_fragment_shader_input_variable = fully_covered_fragment_shader_input_variable + .into(); + self + } + pub fn conservative_rasterization_post_depth_coverage( + mut self, + conservative_rasterization_post_depth_coverage: bool, + ) -> Self { + self.conservative_rasterization_post_depth_coverage = conservative_rasterization_post_depth_coverage + .into(); + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct PipelineRasterizationConservativeStateCreateInfoEXT<'a> { @@ -27,6 +116,47 @@ pub struct PipelineRasterizationConservativeStateCreateInfoEXT<'a> { pub extra_primitive_overestimation_size: core::ffi::c_float, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PipelineRasterizationConservativeStateCreateInfoEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT; +} +unsafe impl<'a> crate::Extends> +for PipelineRasterizationConservativeStateCreateInfoEXT<'a> {} +impl<'a> Default for PipelineRasterizationConservativeStateCreateInfoEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + flags: Default::default(), + conservative_rasterization_mode: Default::default(), + extra_primitive_overestimation_size: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PipelineRasterizationConservativeStateCreateInfoEXT<'a> { + pub fn flags( + mut self, + flags: crate::vk::PipelineRasterizationConservativeStateCreateFlagsEXT, + ) -> Self { + self.flags = flags; + self + } + pub fn conservative_rasterization_mode( + mut self, + conservative_rasterization_mode: crate::vk::ConservativeRasterizationModeEXT, + ) -> Self { + self.conservative_rasterization_mode = conservative_rasterization_mode; + self + } + pub fn extra_primitive_overestimation_size( + mut self, + extra_primitive_overestimation_size: core::ffi::c_float, + ) -> Self { + self.extra_primitive_overestimation_size = extra_primitive_overestimation_size; + self + } +} ///Provided by [`ext::conservative_rasterization`](crate::ext::conservative_rasterization) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT: Self = Self( diff --git a/ash-rewrite/src/generated/ext/custom_border_color.rs b/ash-rewrite/src/generated/ext/custom_border_color.rs index 9cef8086f..79b259ce6 100644 --- a/ash-rewrite/src/generated/ext/custom_border_color.rs +++ b/ash-rewrite/src/generated/ext/custom_border_color.rs @@ -10,6 +10,36 @@ pub struct SamplerCustomBorderColorCreateInfoEXT<'a> { pub format: crate::vk::Format, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for SamplerCustomBorderColorCreateInfoEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT; +} +unsafe impl<'a> crate::Extends> +for SamplerCustomBorderColorCreateInfoEXT<'a> {} +impl<'a> Default for SamplerCustomBorderColorCreateInfoEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + custom_border_color: Default::default(), + format: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> SamplerCustomBorderColorCreateInfoEXT<'a> { + pub fn custom_border_color( + mut self, + custom_border_color: crate::vk::ClearColorValue, + ) -> Self { + self.custom_border_color = custom_border_color; + self + } + pub fn format(mut self, format: crate::vk::Format) -> Self { + self.format = format; + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceCustomBorderColorPropertiesEXT<'a> { @@ -18,6 +48,31 @@ pub struct PhysicalDeviceCustomBorderColorPropertiesEXT<'a> { pub max_custom_border_color_samplers: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceCustomBorderColorPropertiesEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceCustomBorderColorPropertiesEXT<'a> {} +impl<'a> Default for PhysicalDeviceCustomBorderColorPropertiesEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + max_custom_border_color_samplers: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceCustomBorderColorPropertiesEXT<'a> { + pub fn max_custom_border_color_samplers( + mut self, + max_custom_border_color_samplers: u32, + ) -> Self { + self.max_custom_border_color_samplers = max_custom_border_color_samplers; + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceCustomBorderColorFeaturesEXT<'a> { @@ -27,6 +82,39 @@ pub struct PhysicalDeviceCustomBorderColorFeaturesEXT<'a> { pub custom_border_color_without_format: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceCustomBorderColorFeaturesEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceCustomBorderColorFeaturesEXT<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceCustomBorderColorFeaturesEXT<'a> {} +impl<'a> Default for PhysicalDeviceCustomBorderColorFeaturesEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + custom_border_colors: Default::default(), + custom_border_color_without_format: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceCustomBorderColorFeaturesEXT<'a> { + pub fn custom_border_colors(mut self, custom_border_colors: bool) -> Self { + self.custom_border_colors = custom_border_colors.into(); + self + } + pub fn custom_border_color_without_format( + mut self, + custom_border_color_without_format: bool, + ) -> Self { + self.custom_border_color_without_format = custom_border_color_without_format + .into(); + self + } +} ///Provided by [`ext::custom_border_color`](crate::ext::custom_border_color) impl crate::vk::BorderColor { pub const FLOAT_CUSTOM_EXT: Self = Self(1000287003); diff --git a/ash-rewrite/src/generated/ext/custom_resolve.rs b/ash-rewrite/src/generated/ext/custom_resolve.rs index b5b64f180..b72c6947e 100644 --- a/ash-rewrite/src/generated/ext/custom_resolve.rs +++ b/ash-rewrite/src/generated/ext/custom_resolve.rs @@ -42,6 +42,19 @@ pub(crate) mod reexport { pub p_next: *mut core::ffi::c_void, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for BeginCustomResolveInfoEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::BEGIN_CUSTOM_RESOLVE_INFO_EXT; + } + impl<'a> Default for BeginCustomResolveInfoEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> BeginCustomResolveInfoEXT<'a> {} #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceCustomResolveFeaturesEXT<'a> { @@ -50,6 +63,30 @@ pub(crate) mod reexport { pub custom_resolve: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceCustomResolveFeaturesEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_CUSTOM_RESOLVE_FEATURES_EXT; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceCustomResolveFeaturesEXT<'a> {} + unsafe impl<'a> crate::Extends> + for PhysicalDeviceCustomResolveFeaturesEXT<'a> {} + impl<'a> Default for PhysicalDeviceCustomResolveFeaturesEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + custom_resolve: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceCustomResolveFeaturesEXT<'a> { + pub fn custom_resolve(mut self, custom_resolve: bool) -> Self { + self.custom_resolve = custom_resolve.into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct CustomResolveCreateInfoEXT<'a> { @@ -62,6 +99,61 @@ pub(crate) mod reexport { pub stencil_attachment_format: crate::vk::Format, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for CustomResolveCreateInfoEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::CUSTOM_RESOLVE_CREATE_INFO_EXT; + } + unsafe impl<'a> crate::Extends> + for CustomResolveCreateInfoEXT<'a> {} + unsafe impl<'a> crate::Extends> + for CustomResolveCreateInfoEXT<'a> {} + unsafe impl<'a> crate::Extends> + for CustomResolveCreateInfoEXT<'a> {} + impl<'a> Default for CustomResolveCreateInfoEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + custom_resolve: Default::default(), + color_attachment_count: Default::default(), + p_color_attachment_formats: Default::default(), + depth_attachment_format: Default::default(), + stencil_attachment_format: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> CustomResolveCreateInfoEXT<'a> { + pub fn custom_resolve(mut self, custom_resolve: bool) -> Self { + self.custom_resolve = custom_resolve.into(); + self + } + pub fn color_attachment_count(mut self, color_attachment_count: u32) -> Self { + self.color_attachment_count = color_attachment_count; + self + } + pub fn p_color_attachment_formats( + mut self, + p_color_attachment_formats: &'a [crate::vk::Format], + ) -> Self { + self.color_attachment_count = p_color_attachment_formats.len() as _; + self.p_color_attachment_formats = p_color_attachment_formats.as_ptr(); + self + } + pub fn depth_attachment_format( + mut self, + depth_attachment_format: crate::vk::Format, + ) -> Self { + self.depth_attachment_format = depth_attachment_format; + self + } + pub fn stencil_attachment_format( + mut self, + stencil_attachment_format: crate::vk::Format, + ) -> Self { + self.stencil_attachment_format = stencil_attachment_format; + self + } + } ///Provided by [`ext::custom_resolve`](crate::ext::custom_resolve) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_CUSTOM_RESOLVE_FEATURES_EXT: Self = Self(1000628000); diff --git a/ash-rewrite/src/generated/ext/debug_marker.rs b/ash-rewrite/src/generated/ext/debug_marker.rs index ab2c9aeb6..144b80d70 100644 --- a/ash-rewrite/src/generated/ext/debug_marker.rs +++ b/ash-rewrite/src/generated/ext/debug_marker.rs @@ -104,6 +104,45 @@ pub(crate) mod reexport { pub p_object_name: *const core::ffi::c_char, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for DebugMarkerObjectNameInfoEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::DEBUG_MARKER_OBJECT_NAME_INFO_EXT; + } + impl<'a> Default for DebugMarkerObjectNameInfoEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + object_type: Default::default(), + object: Default::default(), + p_object_name: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> DebugMarkerObjectNameInfoEXT<'a> { + pub fn object_type( + mut self, + object_type: crate::vk::DebugReportObjectTypeEXT, + ) -> Self { + self.object_type = object_type; + self + } + pub fn object(mut self, object: u64) -> Self { + self.object = object; + self + } + pub fn p_object_name(mut self, p_object_name: &'a core::ffi::CStr) -> Self { + self.p_object_name = p_object_name.as_ptr(); + self + } + pub unsafe fn p_object_name_as_c_str(&self) -> Option<&core::ffi::CStr> { + if self.p_object_name.is_null() { + None + } else { + Some(unsafe { core::ffi::CStr::from_ptr(self.p_object_name) }) + } + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct DebugMarkerObjectTagInfoEXT<'a> { @@ -116,6 +155,49 @@ pub(crate) mod reexport { pub p_tag: *const core::ffi::c_void, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for DebugMarkerObjectTagInfoEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::DEBUG_MARKER_OBJECT_TAG_INFO_EXT; + } + impl<'a> Default for DebugMarkerObjectTagInfoEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + object_type: Default::default(), + object: Default::default(), + tag_name: Default::default(), + tag_size: Default::default(), + p_tag: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> DebugMarkerObjectTagInfoEXT<'a> { + pub fn object_type( + mut self, + object_type: crate::vk::DebugReportObjectTypeEXT, + ) -> Self { + self.object_type = object_type; + self + } + pub fn object(mut self, object: u64) -> Self { + self.object = object; + self + } + pub fn tag_name(mut self, tag_name: u64) -> Self { + self.tag_name = tag_name; + self + } + pub fn tag_size(mut self, tag_size: usize) -> Self { + self.tag_size = tag_size; + self + } + pub fn p_tag(mut self, p_tag: &'a [u8]) -> Self { + self.tag_size = p_tag.len() as _; + self.p_tag = p_tag.as_ptr().cast(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct DebugMarkerMarkerInfoEXT<'a> { @@ -125,6 +207,37 @@ pub(crate) mod reexport { pub color: [core::ffi::c_float; 4 as _], pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for DebugMarkerMarkerInfoEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::DEBUG_MARKER_MARKER_INFO_EXT; + } + impl<'a> Default for DebugMarkerMarkerInfoEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + p_marker_name: Default::default(), + color: unsafe { core::mem::zeroed() }, + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> DebugMarkerMarkerInfoEXT<'a> { + pub fn p_marker_name(mut self, p_marker_name: &'a core::ffi::CStr) -> Self { + self.p_marker_name = p_marker_name.as_ptr(); + self + } + pub unsafe fn p_marker_name_as_c_str(&self) -> Option<&core::ffi::CStr> { + if self.p_marker_name.is_null() { + None + } else { + Some(unsafe { core::ffi::CStr::from_ptr(self.p_marker_name) }) + } + } + pub fn color(mut self, color: [core::ffi::c_float; 4 as _]) -> Self { + self.color = color; + self + } + } ///Provided by [`ext::debug_marker`](crate::ext::debug_marker) impl crate::vk::StructureType { pub const DEBUG_MARKER_OBJECT_NAME_INFO_EXT: Self = Self(1000022000); diff --git a/ash-rewrite/src/generated/ext/debug_report.rs b/ash-rewrite/src/generated/ext/debug_report.rs index 135ec919c..c5cd1829f 100644 --- a/ash-rewrite/src/generated/ext/debug_report.rs +++ b/ash-rewrite/src/generated/ext/debug_report.rs @@ -84,6 +84,40 @@ pub(crate) mod reexport { pub p_user_data: *mut core::ffi::c_void, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for DebugReportCallbackCreateInfoEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT; + } + unsafe impl<'a> crate::Extends> + for DebugReportCallbackCreateInfoEXT<'a> {} + impl<'a> Default for DebugReportCallbackCreateInfoEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + flags: Default::default(), + pfn_callback: Default::default(), + p_user_data: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> DebugReportCallbackCreateInfoEXT<'a> { + pub fn flags(mut self, flags: crate::vk::DebugReportFlagsEXT) -> Self { + self.flags = flags; + self + } + pub fn pfn_callback( + mut self, + pfn_callback: crate::vk::PFN_vkDebugReportCallbackEXT, + ) -> Self { + self.pfn_callback = pfn_callback; + self + } + pub fn p_user_data(mut self, p_user_data: &'a mut core::ffi::c_void) -> Self { + self.p_user_data = p_user_data; + self + } + } ///Provided by [`ext::debug_report`](crate::ext::debug_report) impl crate::vk::StructureType { pub const DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT: Self = Self(1000011000); @@ -222,7 +256,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct DebugReportFlagBitsEXT(pub(crate) u32); ///Provided by [`ext::debug_report`](crate::ext::debug_report) impl DebugReportFlagBitsEXT { diff --git a/ash-rewrite/src/generated/ext/debug_utils.rs b/ash-rewrite/src/generated/ext/debug_utils.rs index 146c23687..ea882d553 100644 --- a/ash-rewrite/src/generated/ext/debug_utils.rs +++ b/ash-rewrite/src/generated/ext/debug_utils.rs @@ -216,6 +216,48 @@ pub(crate) mod reexport { pub p_object_name: *const core::ffi::c_char, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for DebugUtilsObjectNameInfoEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::DEBUG_UTILS_OBJECT_NAME_INFO_EXT; + } + unsafe impl<'a> crate::Extends> + for DebugUtilsObjectNameInfoEXT<'a> {} + unsafe impl<'a> crate::Extends> + for DebugUtilsObjectNameInfoEXT<'a> {} + unsafe impl<'a> crate::Extends> + for DebugUtilsObjectNameInfoEXT<'a> {} + impl<'a> Default for DebugUtilsObjectNameInfoEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + object_type: Default::default(), + object_handle: Default::default(), + p_object_name: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> DebugUtilsObjectNameInfoEXT<'a> { + pub fn object_type(mut self, object_type: crate::vk::ObjectType) -> Self { + self.object_type = object_type; + self + } + pub fn object_handle(mut self, object_handle: u64) -> Self { + self.object_handle = object_handle; + self + } + pub fn p_object_name(mut self, p_object_name: &'a core::ffi::CStr) -> Self { + self.p_object_name = p_object_name.as_ptr(); + self + } + pub unsafe fn p_object_name_as_c_str(&self) -> Option<&core::ffi::CStr> { + if self.p_object_name.is_null() { + None + } else { + Some(unsafe { core::ffi::CStr::from_ptr(self.p_object_name) }) + } + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct DebugUtilsObjectTagInfoEXT<'a> { @@ -228,6 +270,46 @@ pub(crate) mod reexport { pub p_tag: *const core::ffi::c_void, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for DebugUtilsObjectTagInfoEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::DEBUG_UTILS_OBJECT_TAG_INFO_EXT; + } + impl<'a> Default for DebugUtilsObjectTagInfoEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + object_type: Default::default(), + object_handle: Default::default(), + tag_name: Default::default(), + tag_size: Default::default(), + p_tag: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> DebugUtilsObjectTagInfoEXT<'a> { + pub fn object_type(mut self, object_type: crate::vk::ObjectType) -> Self { + self.object_type = object_type; + self + } + pub fn object_handle(mut self, object_handle: u64) -> Self { + self.object_handle = object_handle; + self + } + pub fn tag_name(mut self, tag_name: u64) -> Self { + self.tag_name = tag_name; + self + } + pub fn tag_size(mut self, tag_size: usize) -> Self { + self.tag_size = tag_size; + self + } + pub fn p_tag(mut self, p_tag: &'a [u8]) -> Self { + self.tag_size = p_tag.len() as _; + self.p_tag = p_tag.as_ptr().cast(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct DebugUtilsLabelEXT<'a> { @@ -237,6 +319,37 @@ pub(crate) mod reexport { pub color: [core::ffi::c_float; 4 as _], pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for DebugUtilsLabelEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::DEBUG_UTILS_LABEL_EXT; + } + impl<'a> Default for DebugUtilsLabelEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + p_label_name: Default::default(), + color: unsafe { core::mem::zeroed() }, + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> DebugUtilsLabelEXT<'a> { + pub fn p_label_name(mut self, p_label_name: &'a core::ffi::CStr) -> Self { + self.p_label_name = p_label_name.as_ptr(); + self + } + pub unsafe fn p_label_name_as_c_str(&self) -> Option<&core::ffi::CStr> { + if self.p_label_name.is_null() { + None + } else { + Some(unsafe { core::ffi::CStr::from_ptr(self.p_label_name) }) + } + } + pub fn color(mut self, color: [core::ffi::c_float; 4 as _]) -> Self { + self.color = color; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct DebugUtilsMessengerCreateInfoEXT<'a> { @@ -249,6 +362,59 @@ pub(crate) mod reexport { pub p_user_data: *mut core::ffi::c_void, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for DebugUtilsMessengerCreateInfoEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT; + } + unsafe impl<'a> crate::Extends> + for DebugUtilsMessengerCreateInfoEXT<'a> {} + impl<'a> Default for DebugUtilsMessengerCreateInfoEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + flags: Default::default(), + message_severity: Default::default(), + message_type: Default::default(), + pfn_user_callback: Default::default(), + p_user_data: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> DebugUtilsMessengerCreateInfoEXT<'a> { + pub fn flags( + mut self, + flags: crate::vk::DebugUtilsMessengerCreateFlagsEXT, + ) -> Self { + self.flags = flags; + self + } + pub fn message_severity( + mut self, + message_severity: crate::vk::DebugUtilsMessageSeverityFlagsEXT, + ) -> Self { + self.message_severity = message_severity; + self + } + pub fn message_type( + mut self, + message_type: crate::vk::DebugUtilsMessageTypeFlagsEXT, + ) -> Self { + self.message_type = message_type; + self + } + pub fn pfn_user_callback( + mut self, + pfn_user_callback: crate::vk::PFN_vkDebugUtilsMessengerCallbackEXT, + ) -> Self { + self.pfn_user_callback = pfn_user_callback; + self + } + pub fn p_user_data(mut self, p_user_data: &'a mut core::ffi::c_void) -> Self { + self.p_user_data = p_user_data; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct DebugUtilsMessengerCallbackDataEXT<'a> { @@ -266,6 +432,103 @@ pub(crate) mod reexport { pub p_objects: *const crate::vk::DebugUtilsObjectNameInfoEXT<'a>, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for DebugUtilsMessengerCallbackDataEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT; + } + impl<'a> Default for DebugUtilsMessengerCallbackDataEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + flags: Default::default(), + p_message_id_name: Default::default(), + message_id_number: Default::default(), + p_message: Default::default(), + queue_label_count: Default::default(), + p_queue_labels: Default::default(), + cmd_buf_label_count: Default::default(), + p_cmd_buf_labels: Default::default(), + object_count: Default::default(), + p_objects: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> DebugUtilsMessengerCallbackDataEXT<'a> { + pub fn flags( + mut self, + flags: crate::vk::DebugUtilsMessengerCallbackDataFlagsEXT, + ) -> Self { + self.flags = flags; + self + } + pub fn p_message_id_name( + mut self, + p_message_id_name: &'a core::ffi::CStr, + ) -> Self { + self.p_message_id_name = p_message_id_name.as_ptr(); + self + } + pub unsafe fn p_message_id_name_as_c_str(&self) -> Option<&core::ffi::CStr> { + if self.p_message_id_name.is_null() { + None + } else { + Some(unsafe { core::ffi::CStr::from_ptr(self.p_message_id_name) }) + } + } + pub fn message_id_number(mut self, message_id_number: i32) -> Self { + self.message_id_number = message_id_number; + self + } + pub fn p_message(mut self, p_message: &'a core::ffi::CStr) -> Self { + self.p_message = p_message.as_ptr(); + self + } + pub unsafe fn p_message_as_c_str(&self) -> Option<&core::ffi::CStr> { + if self.p_message.is_null() { + None + } else { + Some(unsafe { core::ffi::CStr::from_ptr(self.p_message) }) + } + } + pub fn queue_label_count(mut self, queue_label_count: u32) -> Self { + self.queue_label_count = queue_label_count; + self + } + pub fn p_queue_labels( + mut self, + p_queue_labels: &'a [crate::vk::DebugUtilsLabelEXT<'a>], + ) -> Self { + self.queue_label_count = p_queue_labels.len() as _; + self.p_queue_labels = p_queue_labels.as_ptr(); + self + } + pub fn cmd_buf_label_count(mut self, cmd_buf_label_count: u32) -> Self { + self.cmd_buf_label_count = cmd_buf_label_count; + self + } + pub fn p_cmd_buf_labels( + mut self, + p_cmd_buf_labels: &'a [crate::vk::DebugUtilsLabelEXT<'a>], + ) -> Self { + self.cmd_buf_label_count = p_cmd_buf_labels.len() as _; + self.p_cmd_buf_labels = p_cmd_buf_labels.as_ptr(); + self + } + pub fn object_count(mut self, object_count: u32) -> Self { + self.object_count = object_count; + self + } + pub fn p_objects( + mut self, + p_objects: &'a [crate::vk::DebugUtilsObjectNameInfoEXT<'a>], + ) -> Self { + self.object_count = p_objects.len() as _; + self.p_objects = p_objects.as_ptr(); + self + } + } ///Provided by [`ext::debug_utils`](crate::ext::debug_utils) impl crate::vk::StructureType { pub const DEBUG_UTILS_OBJECT_NAME_INFO_EXT: Self = Self(1000128000); @@ -358,7 +621,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct DebugUtilsMessageSeverityFlagBitsEXT(pub(crate) u32); ///Provided by [`ext::debug_utils`](crate::ext::debug_utils) impl DebugUtilsMessageSeverityFlagBitsEXT { @@ -447,7 +710,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct DebugUtilsMessageTypeFlagBitsEXT(pub(crate) u32); ///Provided by [`ext::debug_utils`](crate::ext::debug_utils) impl DebugUtilsMessageTypeFlagBitsEXT { diff --git a/ash-rewrite/src/generated/ext/depth_bias_control.rs b/ash-rewrite/src/generated/ext/depth_bias_control.rs index 8d6310a41..28d98924b 100644 --- a/ash-rewrite/src/generated/ext/depth_bias_control.rs +++ b/ash-rewrite/src/generated/ext/depth_bias_control.rs @@ -45,6 +45,41 @@ pub(crate) mod reexport { pub depth_bias_slope_factor: core::ffi::c_float, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for DepthBiasInfoEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::DEPTH_BIAS_INFO_EXT; + } + impl<'a> Default for DepthBiasInfoEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + depth_bias_constant_factor: Default::default(), + depth_bias_clamp: Default::default(), + depth_bias_slope_factor: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> DepthBiasInfoEXT<'a> { + pub fn depth_bias_constant_factor( + mut self, + depth_bias_constant_factor: core::ffi::c_float, + ) -> Self { + self.depth_bias_constant_factor = depth_bias_constant_factor; + self + } + pub fn depth_bias_clamp(mut self, depth_bias_clamp: core::ffi::c_float) -> Self { + self.depth_bias_clamp = depth_bias_clamp; + self + } + pub fn depth_bias_slope_factor( + mut self, + depth_bias_slope_factor: core::ffi::c_float, + ) -> Self { + self.depth_bias_slope_factor = depth_bias_slope_factor; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct DepthBiasRepresentationInfoEXT<'a> { @@ -54,6 +89,37 @@ pub(crate) mod reexport { pub depth_bias_exact: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for DepthBiasRepresentationInfoEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::DEPTH_BIAS_REPRESENTATION_INFO_EXT; + } + unsafe impl<'a> crate::Extends> + for DepthBiasRepresentationInfoEXT<'a> {} + unsafe impl<'a> crate::Extends> + for DepthBiasRepresentationInfoEXT<'a> {} + impl<'a> Default for DepthBiasRepresentationInfoEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + depth_bias_representation: Default::default(), + depth_bias_exact: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> DepthBiasRepresentationInfoEXT<'a> { + pub fn depth_bias_representation( + mut self, + depth_bias_representation: crate::vk::DepthBiasRepresentationEXT, + ) -> Self { + self.depth_bias_representation = depth_bias_representation; + self + } + pub fn depth_bias_exact(mut self, depth_bias_exact: bool) -> Self { + self.depth_bias_exact = depth_bias_exact.into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceDepthBiasControlFeaturesEXT<'a> { @@ -65,6 +131,49 @@ pub(crate) mod reexport { pub depth_bias_exact: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceDepthBiasControlFeaturesEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceDepthBiasControlFeaturesEXT<'a> {} + unsafe impl<'a> crate::Extends> + for PhysicalDeviceDepthBiasControlFeaturesEXT<'a> {} + impl<'a> Default for PhysicalDeviceDepthBiasControlFeaturesEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + depth_bias_control: Default::default(), + least_representable_value_force_unorm_representation: Default::default(), + float_representation: Default::default(), + depth_bias_exact: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceDepthBiasControlFeaturesEXT<'a> { + pub fn depth_bias_control(mut self, depth_bias_control: bool) -> Self { + self.depth_bias_control = depth_bias_control.into(); + self + } + pub fn least_representable_value_force_unorm_representation( + mut self, + least_representable_value_force_unorm_representation: bool, + ) -> Self { + self.least_representable_value_force_unorm_representation = least_representable_value_force_unorm_representation + .into(); + self + } + pub fn float_representation(mut self, float_representation: bool) -> Self { + self.float_representation = float_representation.into(); + self + } + pub fn depth_bias_exact(mut self, depth_bias_exact: bool) -> Self { + self.depth_bias_exact = depth_bias_exact.into(); + self + } + } ///Provided by [`ext::depth_bias_control`](crate::ext::depth_bias_control) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT: Self = Self( diff --git a/ash-rewrite/src/generated/ext/depth_clamp_control.rs b/ash-rewrite/src/generated/ext/depth_clamp_control.rs index 6fd75cec4..4958515d9 100644 --- a/ash-rewrite/src/generated/ext/depth_clamp_control.rs +++ b/ash-rewrite/src/generated/ext/depth_clamp_control.rs @@ -9,6 +9,30 @@ pub struct PhysicalDeviceDepthClampControlFeaturesEXT<'a> { pub depth_clamp_control: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceDepthClampControlFeaturesEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceDepthClampControlFeaturesEXT<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceDepthClampControlFeaturesEXT<'a> {} +impl<'a> Default for PhysicalDeviceDepthClampControlFeaturesEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + depth_clamp_control: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceDepthClampControlFeaturesEXT<'a> { + pub fn depth_clamp_control(mut self, depth_clamp_control: bool) -> Self { + self.depth_clamp_control = depth_clamp_control.into(); + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct PipelineViewportDepthClampControlCreateInfoEXT<'a> { @@ -18,12 +42,55 @@ pub struct PipelineViewportDepthClampControlCreateInfoEXT<'a> { pub p_depth_clamp_range: *const crate::vk::DepthClampRangeEXT, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PipelineViewportDepthClampControlCreateInfoEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PIPELINE_VIEWPORT_DEPTH_CLAMP_CONTROL_CREATE_INFO_EXT; +} +unsafe impl<'a> crate::Extends> +for PipelineViewportDepthClampControlCreateInfoEXT<'a> {} +impl<'a> Default for PipelineViewportDepthClampControlCreateInfoEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + depth_clamp_mode: Default::default(), + p_depth_clamp_range: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PipelineViewportDepthClampControlCreateInfoEXT<'a> { + pub fn depth_clamp_mode( + mut self, + depth_clamp_mode: crate::vk::DepthClampModeEXT, + ) -> Self { + self.depth_clamp_mode = depth_clamp_mode; + self + } + pub fn p_depth_clamp_range( + mut self, + p_depth_clamp_range: &'a crate::vk::DepthClampRangeEXT, + ) -> Self { + self.p_depth_clamp_range = p_depth_clamp_range; + self + } +} #[repr(C)] -#[derive(Clone, Copy)] +#[derive(Clone, Copy, Default)] pub struct DepthClampRangeEXT { pub min_depth_clamp: core::ffi::c_float, pub max_depth_clamp: core::ffi::c_float, } +impl DepthClampRangeEXT { + pub fn min_depth_clamp(mut self, min_depth_clamp: core::ffi::c_float) -> Self { + self.min_depth_clamp = min_depth_clamp; + self + } + pub fn max_depth_clamp(mut self, max_depth_clamp: core::ffi::c_float) -> Self { + self.max_depth_clamp = max_depth_clamp; + self + } +} ///Provided by [`ext::depth_clamp_control`](crate::ext::depth_clamp_control) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT: Self = Self(1000582000); diff --git a/ash-rewrite/src/generated/ext/depth_clip_control.rs b/ash-rewrite/src/generated/ext/depth_clip_control.rs index 24682545e..c35d658bf 100644 --- a/ash-rewrite/src/generated/ext/depth_clip_control.rs +++ b/ash-rewrite/src/generated/ext/depth_clip_control.rs @@ -9,6 +9,30 @@ pub struct PhysicalDeviceDepthClipControlFeaturesEXT<'a> { pub depth_clip_control: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceDepthClipControlFeaturesEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceDepthClipControlFeaturesEXT<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceDepthClipControlFeaturesEXT<'a> {} +impl<'a> Default for PhysicalDeviceDepthClipControlFeaturesEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + depth_clip_control: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceDepthClipControlFeaturesEXT<'a> { + pub fn depth_clip_control(mut self, depth_clip_control: bool) -> Self { + self.depth_clip_control = depth_clip_control.into(); + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct PipelineViewportDepthClipControlCreateInfoEXT<'a> { @@ -17,6 +41,28 @@ pub struct PipelineViewportDepthClipControlCreateInfoEXT<'a> { pub negative_one_to_one: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PipelineViewportDepthClipControlCreateInfoEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT; +} +unsafe impl<'a> crate::Extends> +for PipelineViewportDepthClipControlCreateInfoEXT<'a> {} +impl<'a> Default for PipelineViewportDepthClipControlCreateInfoEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + negative_one_to_one: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PipelineViewportDepthClipControlCreateInfoEXT<'a> { + pub fn negative_one_to_one(mut self, negative_one_to_one: bool) -> Self { + self.negative_one_to_one = negative_one_to_one.into(); + self + } +} ///Provided by [`ext::depth_clip_control`](crate::ext::depth_clip_control) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT: Self = Self(1000355000); diff --git a/ash-rewrite/src/generated/ext/depth_clip_enable.rs b/ash-rewrite/src/generated/ext/depth_clip_enable.rs index 4b694cb92..1a9cb3f5a 100644 --- a/ash-rewrite/src/generated/ext/depth_clip_enable.rs +++ b/ash-rewrite/src/generated/ext/depth_clip_enable.rs @@ -9,6 +9,30 @@ pub struct PhysicalDeviceDepthClipEnableFeaturesEXT<'a> { pub depth_clip_enable: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceDepthClipEnableFeaturesEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceDepthClipEnableFeaturesEXT<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceDepthClipEnableFeaturesEXT<'a> {} +impl<'a> Default for PhysicalDeviceDepthClipEnableFeaturesEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + depth_clip_enable: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceDepthClipEnableFeaturesEXT<'a> { + pub fn depth_clip_enable(mut self, depth_clip_enable: bool) -> Self { + self.depth_clip_enable = depth_clip_enable.into(); + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct PipelineRasterizationDepthClipStateCreateInfoEXT<'a> { @@ -18,6 +42,36 @@ pub struct PipelineRasterizationDepthClipStateCreateInfoEXT<'a> { pub depth_clip_enable: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PipelineRasterizationDepthClipStateCreateInfoEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT; +} +unsafe impl<'a> crate::Extends> +for PipelineRasterizationDepthClipStateCreateInfoEXT<'a> {} +impl<'a> Default for PipelineRasterizationDepthClipStateCreateInfoEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + flags: Default::default(), + depth_clip_enable: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PipelineRasterizationDepthClipStateCreateInfoEXT<'a> { + pub fn flags( + mut self, + flags: crate::vk::PipelineRasterizationDepthClipStateCreateFlagsEXT, + ) -> Self { + self.flags = flags; + self + } + pub fn depth_clip_enable(mut self, depth_clip_enable: bool) -> Self { + self.depth_clip_enable = depth_clip_enable.into(); + self + } +} ///Provided by [`ext::depth_clip_enable`](crate::ext::depth_clip_enable) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT: Self = Self(1000102000); diff --git a/ash-rewrite/src/generated/ext/descriptor_buffer.rs b/ash-rewrite/src/generated/ext/descriptor_buffer.rs index d3efb4765..60b4791b0 100644 --- a/ash-rewrite/src/generated/ext/descriptor_buffer.rs +++ b/ash-rewrite/src/generated/ext/descriptor_buffer.rs @@ -220,6 +220,57 @@ pub(crate) mod reexport { pub descriptor_buffer_push_descriptors: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceDescriptorBufferFeaturesEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceDescriptorBufferFeaturesEXT<'a> {} + unsafe impl<'a> crate::Extends> + for PhysicalDeviceDescriptorBufferFeaturesEXT<'a> {} + impl<'a> Default for PhysicalDeviceDescriptorBufferFeaturesEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + descriptor_buffer: Default::default(), + descriptor_buffer_capture_replay: Default::default(), + descriptor_buffer_image_layout_ignored: Default::default(), + descriptor_buffer_push_descriptors: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceDescriptorBufferFeaturesEXT<'a> { + pub fn descriptor_buffer(mut self, descriptor_buffer: bool) -> Self { + self.descriptor_buffer = descriptor_buffer.into(); + self + } + pub fn descriptor_buffer_capture_replay( + mut self, + descriptor_buffer_capture_replay: bool, + ) -> Self { + self.descriptor_buffer_capture_replay = descriptor_buffer_capture_replay + .into(); + self + } + pub fn descriptor_buffer_image_layout_ignored( + mut self, + descriptor_buffer_image_layout_ignored: bool, + ) -> Self { + self.descriptor_buffer_image_layout_ignored = descriptor_buffer_image_layout_ignored + .into(); + self + } + pub fn descriptor_buffer_push_descriptors( + mut self, + descriptor_buffer_push_descriptors: bool, + ) -> Self { + self.descriptor_buffer_push_descriptors = descriptor_buffer_push_descriptors + .into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceDescriptorBufferPropertiesEXT<'a> { @@ -260,6 +311,289 @@ pub(crate) mod reexport { pub descriptor_buffer_address_space_size: crate::vk::DeviceSize, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceDescriptorBufferPropertiesEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceDescriptorBufferPropertiesEXT<'a> {} + impl<'a> Default for PhysicalDeviceDescriptorBufferPropertiesEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + combined_image_sampler_descriptor_single_array: Default::default(), + bufferless_push_descriptors: Default::default(), + allow_sampler_image_view_post_submit_creation: Default::default(), + descriptor_buffer_offset_alignment: Default::default(), + max_descriptor_buffer_bindings: Default::default(), + max_resource_descriptor_buffer_bindings: Default::default(), + max_sampler_descriptor_buffer_bindings: Default::default(), + max_embedded_immutable_sampler_bindings: Default::default(), + max_embedded_immutable_samplers: Default::default(), + buffer_capture_replay_descriptor_data_size: Default::default(), + image_capture_replay_descriptor_data_size: Default::default(), + image_view_capture_replay_descriptor_data_size: Default::default(), + sampler_capture_replay_descriptor_data_size: Default::default(), + acceleration_structure_capture_replay_descriptor_data_size: Default::default(), + sampler_descriptor_size: Default::default(), + combined_image_sampler_descriptor_size: Default::default(), + sampled_image_descriptor_size: Default::default(), + storage_image_descriptor_size: Default::default(), + uniform_texel_buffer_descriptor_size: Default::default(), + robust_uniform_texel_buffer_descriptor_size: Default::default(), + storage_texel_buffer_descriptor_size: Default::default(), + robust_storage_texel_buffer_descriptor_size: Default::default(), + uniform_buffer_descriptor_size: Default::default(), + robust_uniform_buffer_descriptor_size: Default::default(), + storage_buffer_descriptor_size: Default::default(), + robust_storage_buffer_descriptor_size: Default::default(), + input_attachment_descriptor_size: Default::default(), + acceleration_structure_descriptor_size: Default::default(), + max_sampler_descriptor_buffer_range: Default::default(), + max_resource_descriptor_buffer_range: Default::default(), + sampler_descriptor_buffer_address_space_size: Default::default(), + resource_descriptor_buffer_address_space_size: Default::default(), + descriptor_buffer_address_space_size: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceDescriptorBufferPropertiesEXT<'a> { + pub fn combined_image_sampler_descriptor_single_array( + mut self, + combined_image_sampler_descriptor_single_array: bool, + ) -> Self { + self.combined_image_sampler_descriptor_single_array = combined_image_sampler_descriptor_single_array + .into(); + self + } + pub fn bufferless_push_descriptors( + mut self, + bufferless_push_descriptors: bool, + ) -> Self { + self.bufferless_push_descriptors = bufferless_push_descriptors.into(); + self + } + pub fn allow_sampler_image_view_post_submit_creation( + mut self, + allow_sampler_image_view_post_submit_creation: bool, + ) -> Self { + self.allow_sampler_image_view_post_submit_creation = allow_sampler_image_view_post_submit_creation + .into(); + self + } + pub fn descriptor_buffer_offset_alignment( + mut self, + descriptor_buffer_offset_alignment: crate::vk::DeviceSize, + ) -> Self { + self.descriptor_buffer_offset_alignment = descriptor_buffer_offset_alignment; + self + } + pub fn max_descriptor_buffer_bindings( + mut self, + max_descriptor_buffer_bindings: u32, + ) -> Self { + self.max_descriptor_buffer_bindings = max_descriptor_buffer_bindings; + self + } + pub fn max_resource_descriptor_buffer_bindings( + mut self, + max_resource_descriptor_buffer_bindings: u32, + ) -> Self { + self.max_resource_descriptor_buffer_bindings = max_resource_descriptor_buffer_bindings; + self + } + pub fn max_sampler_descriptor_buffer_bindings( + mut self, + max_sampler_descriptor_buffer_bindings: u32, + ) -> Self { + self.max_sampler_descriptor_buffer_bindings = max_sampler_descriptor_buffer_bindings; + self + } + pub fn max_embedded_immutable_sampler_bindings( + mut self, + max_embedded_immutable_sampler_bindings: u32, + ) -> Self { + self.max_embedded_immutable_sampler_bindings = max_embedded_immutable_sampler_bindings; + self + } + pub fn max_embedded_immutable_samplers( + mut self, + max_embedded_immutable_samplers: u32, + ) -> Self { + self.max_embedded_immutable_samplers = max_embedded_immutable_samplers; + self + } + pub fn buffer_capture_replay_descriptor_data_size( + mut self, + buffer_capture_replay_descriptor_data_size: usize, + ) -> Self { + self.buffer_capture_replay_descriptor_data_size = buffer_capture_replay_descriptor_data_size; + self + } + pub fn image_capture_replay_descriptor_data_size( + mut self, + image_capture_replay_descriptor_data_size: usize, + ) -> Self { + self.image_capture_replay_descriptor_data_size = image_capture_replay_descriptor_data_size; + self + } + pub fn image_view_capture_replay_descriptor_data_size( + mut self, + image_view_capture_replay_descriptor_data_size: usize, + ) -> Self { + self.image_view_capture_replay_descriptor_data_size = image_view_capture_replay_descriptor_data_size; + self + } + pub fn sampler_capture_replay_descriptor_data_size( + mut self, + sampler_capture_replay_descriptor_data_size: usize, + ) -> Self { + self.sampler_capture_replay_descriptor_data_size = sampler_capture_replay_descriptor_data_size; + self + } + pub fn acceleration_structure_capture_replay_descriptor_data_size( + mut self, + acceleration_structure_capture_replay_descriptor_data_size: usize, + ) -> Self { + self.acceleration_structure_capture_replay_descriptor_data_size = acceleration_structure_capture_replay_descriptor_data_size; + self + } + pub fn sampler_descriptor_size( + mut self, + sampler_descriptor_size: usize, + ) -> Self { + self.sampler_descriptor_size = sampler_descriptor_size; + self + } + pub fn combined_image_sampler_descriptor_size( + mut self, + combined_image_sampler_descriptor_size: usize, + ) -> Self { + self.combined_image_sampler_descriptor_size = combined_image_sampler_descriptor_size; + self + } + pub fn sampled_image_descriptor_size( + mut self, + sampled_image_descriptor_size: usize, + ) -> Self { + self.sampled_image_descriptor_size = sampled_image_descriptor_size; + self + } + pub fn storage_image_descriptor_size( + mut self, + storage_image_descriptor_size: usize, + ) -> Self { + self.storage_image_descriptor_size = storage_image_descriptor_size; + self + } + pub fn uniform_texel_buffer_descriptor_size( + mut self, + uniform_texel_buffer_descriptor_size: usize, + ) -> Self { + self.uniform_texel_buffer_descriptor_size = uniform_texel_buffer_descriptor_size; + self + } + pub fn robust_uniform_texel_buffer_descriptor_size( + mut self, + robust_uniform_texel_buffer_descriptor_size: usize, + ) -> Self { + self.robust_uniform_texel_buffer_descriptor_size = robust_uniform_texel_buffer_descriptor_size; + self + } + pub fn storage_texel_buffer_descriptor_size( + mut self, + storage_texel_buffer_descriptor_size: usize, + ) -> Self { + self.storage_texel_buffer_descriptor_size = storage_texel_buffer_descriptor_size; + self + } + pub fn robust_storage_texel_buffer_descriptor_size( + mut self, + robust_storage_texel_buffer_descriptor_size: usize, + ) -> Self { + self.robust_storage_texel_buffer_descriptor_size = robust_storage_texel_buffer_descriptor_size; + self + } + pub fn uniform_buffer_descriptor_size( + mut self, + uniform_buffer_descriptor_size: usize, + ) -> Self { + self.uniform_buffer_descriptor_size = uniform_buffer_descriptor_size; + self + } + pub fn robust_uniform_buffer_descriptor_size( + mut self, + robust_uniform_buffer_descriptor_size: usize, + ) -> Self { + self.robust_uniform_buffer_descriptor_size = robust_uniform_buffer_descriptor_size; + self + } + pub fn storage_buffer_descriptor_size( + mut self, + storage_buffer_descriptor_size: usize, + ) -> Self { + self.storage_buffer_descriptor_size = storage_buffer_descriptor_size; + self + } + pub fn robust_storage_buffer_descriptor_size( + mut self, + robust_storage_buffer_descriptor_size: usize, + ) -> Self { + self.robust_storage_buffer_descriptor_size = robust_storage_buffer_descriptor_size; + self + } + pub fn input_attachment_descriptor_size( + mut self, + input_attachment_descriptor_size: usize, + ) -> Self { + self.input_attachment_descriptor_size = input_attachment_descriptor_size; + self + } + pub fn acceleration_structure_descriptor_size( + mut self, + acceleration_structure_descriptor_size: usize, + ) -> Self { + self.acceleration_structure_descriptor_size = acceleration_structure_descriptor_size; + self + } + pub fn max_sampler_descriptor_buffer_range( + mut self, + max_sampler_descriptor_buffer_range: crate::vk::DeviceSize, + ) -> Self { + self.max_sampler_descriptor_buffer_range = max_sampler_descriptor_buffer_range; + self + } + pub fn max_resource_descriptor_buffer_range( + mut self, + max_resource_descriptor_buffer_range: crate::vk::DeviceSize, + ) -> Self { + self.max_resource_descriptor_buffer_range = max_resource_descriptor_buffer_range; + self + } + pub fn sampler_descriptor_buffer_address_space_size( + mut self, + sampler_descriptor_buffer_address_space_size: crate::vk::DeviceSize, + ) -> Self { + self.sampler_descriptor_buffer_address_space_size = sampler_descriptor_buffer_address_space_size; + self + } + pub fn resource_descriptor_buffer_address_space_size( + mut self, + resource_descriptor_buffer_address_space_size: crate::vk::DeviceSize, + ) -> Self { + self.resource_descriptor_buffer_address_space_size = resource_descriptor_buffer_address_space_size; + self + } + pub fn descriptor_buffer_address_space_size( + mut self, + descriptor_buffer_address_space_size: crate::vk::DeviceSize, + ) -> Self { + self.descriptor_buffer_address_space_size = descriptor_buffer_address_space_size; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT<'a> { @@ -268,6 +602,31 @@ pub(crate) mod reexport { pub combined_image_sampler_density_map_descriptor_size: usize, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT<'a> {} + impl<'a> Default for PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + combined_image_sampler_density_map_descriptor_size: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT<'a> { + pub fn combined_image_sampler_density_map_descriptor_size( + mut self, + combined_image_sampler_density_map_descriptor_size: usize, + ) -> Self { + self.combined_image_sampler_density_map_descriptor_size = combined_image_sampler_density_map_descriptor_size; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct DescriptorAddressInfoEXT<'a> { @@ -278,6 +637,35 @@ pub(crate) mod reexport { pub format: crate::vk::Format, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for DescriptorAddressInfoEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::DESCRIPTOR_ADDRESS_INFO_EXT; + } + impl<'a> Default for DescriptorAddressInfoEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + address: Default::default(), + range: Default::default(), + format: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> DescriptorAddressInfoEXT<'a> { + pub fn address(mut self, address: crate::vk::DeviceAddress) -> Self { + self.address = address; + self + } + pub fn range(mut self, range: crate::vk::DeviceSize) -> Self { + self.range = range; + self + } + pub fn format(mut self, format: crate::vk::Format) -> Self { + self.format = format; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct DescriptorBufferBindingInfoEXT<'a> { @@ -287,6 +675,30 @@ pub(crate) mod reexport { pub usage: crate::vk::BufferUsageFlags, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for DescriptorBufferBindingInfoEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::DESCRIPTOR_BUFFER_BINDING_INFO_EXT; + } + impl<'a> Default for DescriptorBufferBindingInfoEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + address: Default::default(), + usage: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> DescriptorBufferBindingInfoEXT<'a> { + pub fn address(mut self, address: crate::vk::DeviceAddress) -> Self { + self.address = address; + self + } + pub fn usage(mut self, usage: crate::vk::BufferUsageFlags) -> Self { + self.usage = usage; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct DescriptorBufferBindingPushDescriptorBufferHandleEXT<'a> { @@ -295,6 +707,28 @@ pub(crate) mod reexport { pub buffer: crate::vk::Buffer, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for DescriptorBufferBindingPushDescriptorBufferHandleEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::DESCRIPTOR_BUFFER_BINDING_PUSH_DESCRIPTOR_BUFFER_HANDLE_EXT; + } + unsafe impl<'a> crate::Extends> + for DescriptorBufferBindingPushDescriptorBufferHandleEXT<'a> {} + impl<'a> Default for DescriptorBufferBindingPushDescriptorBufferHandleEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + buffer: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> DescriptorBufferBindingPushDescriptorBufferHandleEXT<'a> { + pub fn buffer(mut self, buffer: crate::vk::Buffer) -> Self { + self.buffer = buffer; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct DescriptorGetInfoEXT<'a> { @@ -304,6 +738,30 @@ pub(crate) mod reexport { pub data: crate::vk::DescriptorDataEXT<'a>, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for DescriptorGetInfoEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::DESCRIPTOR_GET_INFO_EXT; + } + impl<'a> Default for DescriptorGetInfoEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + _type: Default::default(), + data: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> DescriptorGetInfoEXT<'a> { + pub fn _type(mut self, _type: crate::vk::DescriptorType) -> Self { + self._type = _type; + self + } + pub fn data(mut self, data: crate::vk::DescriptorDataEXT<'a>) -> Self { + self.data = data; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct BufferCaptureDescriptorDataInfoEXT<'a> { @@ -312,6 +770,26 @@ pub(crate) mod reexport { pub buffer: crate::vk::Buffer, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for BufferCaptureDescriptorDataInfoEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::BUFFER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT; + } + impl<'a> Default for BufferCaptureDescriptorDataInfoEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + buffer: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> BufferCaptureDescriptorDataInfoEXT<'a> { + pub fn buffer(mut self, buffer: crate::vk::Buffer) -> Self { + self.buffer = buffer; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct ImageCaptureDescriptorDataInfoEXT<'a> { @@ -320,6 +798,26 @@ pub(crate) mod reexport { pub image: crate::vk::Image, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for ImageCaptureDescriptorDataInfoEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::IMAGE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT; + } + impl<'a> Default for ImageCaptureDescriptorDataInfoEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + image: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> ImageCaptureDescriptorDataInfoEXT<'a> { + pub fn image(mut self, image: crate::vk::Image) -> Self { + self.image = image; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct ImageViewCaptureDescriptorDataInfoEXT<'a> { @@ -328,6 +826,26 @@ pub(crate) mod reexport { pub image_view: crate::vk::ImageView, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for ImageViewCaptureDescriptorDataInfoEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::IMAGE_VIEW_CAPTURE_DESCRIPTOR_DATA_INFO_EXT; + } + impl<'a> Default for ImageViewCaptureDescriptorDataInfoEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + image_view: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> ImageViewCaptureDescriptorDataInfoEXT<'a> { + pub fn image_view(mut self, image_view: crate::vk::ImageView) -> Self { + self.image_view = image_view; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct SamplerCaptureDescriptorDataInfoEXT<'a> { @@ -336,6 +854,26 @@ pub(crate) mod reexport { pub sampler: crate::vk::Sampler, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for SamplerCaptureDescriptorDataInfoEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::SAMPLER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT; + } + impl<'a> Default for SamplerCaptureDescriptorDataInfoEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + sampler: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> SamplerCaptureDescriptorDataInfoEXT<'a> { + pub fn sampler(mut self, sampler: crate::vk::Sampler) -> Self { + self.sampler = sampler; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct AccelerationStructureCaptureDescriptorDataInfoEXT<'a> { @@ -345,6 +883,37 @@ pub(crate) mod reexport { pub acceleration_structure_nv: crate::vk::AccelerationStructureNV, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for AccelerationStructureCaptureDescriptorDataInfoEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::ACCELERATION_STRUCTURE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT; + } + impl<'a> Default for AccelerationStructureCaptureDescriptorDataInfoEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + acceleration_structure: Default::default(), + acceleration_structure_nv: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> AccelerationStructureCaptureDescriptorDataInfoEXT<'a> { + pub fn acceleration_structure( + mut self, + acceleration_structure: crate::vk::AccelerationStructureKHR, + ) -> Self { + self.acceleration_structure = acceleration_structure; + self + } + pub fn acceleration_structure_nv( + mut self, + acceleration_structure_nv: crate::vk::AccelerationStructureNV, + ) -> Self { + self.acceleration_structure_nv = acceleration_structure_nv; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct OpaqueCaptureDescriptorDataCreateInfoEXT<'a> { @@ -353,6 +922,47 @@ pub(crate) mod reexport { pub opaque_capture_descriptor_data: *const core::ffi::c_void, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for OpaqueCaptureDescriptorDataCreateInfoEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT; + } + unsafe impl<'a> crate::Extends> + for OpaqueCaptureDescriptorDataCreateInfoEXT<'a> {} + unsafe impl<'a> crate::Extends> + for OpaqueCaptureDescriptorDataCreateInfoEXT<'a> {} + unsafe impl<'a> crate::Extends> + for OpaqueCaptureDescriptorDataCreateInfoEXT<'a> {} + unsafe impl<'a> crate::Extends> + for OpaqueCaptureDescriptorDataCreateInfoEXT<'a> {} + unsafe impl<'a> crate::Extends> + for OpaqueCaptureDescriptorDataCreateInfoEXT<'a> {} + unsafe impl<'a> crate::Extends> + for OpaqueCaptureDescriptorDataCreateInfoEXT<'a> {} + unsafe impl<'a> crate::Extends> + for OpaqueCaptureDescriptorDataCreateInfoEXT<'a> {} + unsafe impl<'a> crate::Extends> + for OpaqueCaptureDescriptorDataCreateInfoEXT<'a> {} + unsafe impl<'a> crate::Extends> + for OpaqueCaptureDescriptorDataCreateInfoEXT<'a> {} + impl<'a> Default for OpaqueCaptureDescriptorDataCreateInfoEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + opaque_capture_descriptor_data: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> OpaqueCaptureDescriptorDataCreateInfoEXT<'a> { + pub fn opaque_capture_descriptor_data( + mut self, + opaque_capture_descriptor_data: &'a core::ffi::c_void, + ) -> Self { + self.opaque_capture_descriptor_data = opaque_capture_descriptor_data; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub union DescriptorDataEXT<'a> { @@ -367,6 +977,11 @@ pub(crate) mod reexport { pub p_storage_buffer: *const crate::vk::DescriptorAddressInfoEXT<'a>, pub acceleration_structure: crate::vk::DeviceAddress, } + impl<'a> Default for DescriptorDataEXT<'a> { + fn default() -> Self { + unsafe { core::mem::zeroed() } + } + } ///Provided by [`ext::descriptor_buffer`](crate::ext::descriptor_buffer) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT: Self = Self( diff --git a/ash-rewrite/src/generated/ext/descriptor_heap.rs b/ash-rewrite/src/generated/ext/descriptor_heap.rs index eafda3078..f49f59995 100644 --- a/ash-rewrite/src/generated/ext/descriptor_heap.rs +++ b/ash-rewrite/src/generated/ext/descriptor_heap.rs @@ -208,20 +208,71 @@ pub(crate) mod reexport { pub format: crate::vk::Format, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for TensorViewCreateInfoARM<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::TENSOR_VIEW_CREATE_INFO_ARM; + } + impl<'a> Default for TensorViewCreateInfoARM<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + flags: Default::default(), + tensor: Default::default(), + format: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> TensorViewCreateInfoARM<'a> { + pub fn flags(mut self, flags: crate::vk::TensorViewCreateFlagsARM) -> Self { + self.flags = flags; + self + } + pub fn tensor(mut self, tensor: crate::vk::TensorARM) -> Self { + self.tensor = tensor; + self + } + pub fn format(mut self, format: crate::vk::Format) -> Self { + self.format = format; + self + } + } #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct HostAddressRangeEXT<'a> { pub address: *mut core::ffi::c_void, pub size: usize, pub _marker: ::core::marker::PhantomData<&'a ()>, } + impl<'a> HostAddressRangeEXT<'a> { + pub fn address(mut self, address: &'a mut [u8]) -> Self { + self.size = address.len() as _; + self.address = address.as_mut_ptr().cast(); + self + } + pub fn size(mut self, size: usize) -> Self { + self.size = size; + self + } + } #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct HostAddressRangeConstEXT<'a> { pub address: *const core::ffi::c_void, pub size: usize, pub _marker: ::core::marker::PhantomData<&'a ()>, } + impl<'a> HostAddressRangeConstEXT<'a> { + pub fn address(mut self, address: &'a [u8]) -> Self { + self.size = address.len() as _; + self.address = address.as_ptr().cast(); + self + } + pub fn size(mut self, size: usize) -> Self { + self.size = size; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct TexelBufferDescriptorInfoEXT<'a> { @@ -231,6 +282,33 @@ pub(crate) mod reexport { pub address_range: crate::vk::DeviceAddressRangeEXT, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for TexelBufferDescriptorInfoEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::TEXEL_BUFFER_DESCRIPTOR_INFO_EXT; + } + impl<'a> Default for TexelBufferDescriptorInfoEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + format: Default::default(), + address_range: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> TexelBufferDescriptorInfoEXT<'a> { + pub fn format(mut self, format: crate::vk::Format) -> Self { + self.format = format; + self + } + pub fn address_range( + mut self, + address_range: crate::vk::DeviceAddressRangeEXT, + ) -> Self { + self.address_range = address_range; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct ImageDescriptorInfoEXT<'a> { @@ -240,6 +318,30 @@ pub(crate) mod reexport { pub layout: crate::vk::ImageLayout, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for ImageDescriptorInfoEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::IMAGE_DESCRIPTOR_INFO_EXT; + } + impl<'a> Default for ImageDescriptorInfoEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + p_view: Default::default(), + layout: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> ImageDescriptorInfoEXT<'a> { + pub fn p_view(mut self, p_view: &'a crate::vk::ImageViewCreateInfo<'a>) -> Self { + self.p_view = p_view; + self + } + pub fn layout(mut self, layout: crate::vk::ImageLayout) -> Self { + self.layout = layout; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct ResourceDescriptorInfoEXT<'a> { @@ -249,6 +351,30 @@ pub(crate) mod reexport { pub data: crate::vk::ResourceDescriptorDataEXT<'a>, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for ResourceDescriptorInfoEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::RESOURCE_DESCRIPTOR_INFO_EXT; + } + impl<'a> Default for ResourceDescriptorInfoEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + _type: Default::default(), + data: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> ResourceDescriptorInfoEXT<'a> { + pub fn _type(mut self, _type: crate::vk::DescriptorType) -> Self { + self._type = _type; + self + } + pub fn data(mut self, data: crate::vk::ResourceDescriptorDataEXT<'a>) -> Self { + self.data = data; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct BindHeapInfoEXT<'a> { @@ -259,6 +385,44 @@ pub(crate) mod reexport { pub reserved_range_size: crate::vk::DeviceSize, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for BindHeapInfoEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::BIND_HEAP_INFO_EXT; + } + impl<'a> Default for BindHeapInfoEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + heap_range: Default::default(), + reserved_range_offset: Default::default(), + reserved_range_size: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> BindHeapInfoEXT<'a> { + pub fn heap_range( + mut self, + heap_range: crate::vk::DeviceAddressRangeEXT, + ) -> Self { + self.heap_range = heap_range; + self + } + pub fn reserved_range_offset( + mut self, + reserved_range_offset: crate::vk::DeviceSize, + ) -> Self { + self.reserved_range_offset = reserved_range_offset; + self + } + pub fn reserved_range_size( + mut self, + reserved_range_size: crate::vk::DeviceSize, + ) -> Self { + self.reserved_range_size = reserved_range_size; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PushDataInfoEXT<'a> { @@ -268,8 +432,32 @@ pub(crate) mod reexport { pub data: crate::vk::HostAddressRangeConstEXT<'a>, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for PushDataInfoEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PUSH_DATA_INFO_EXT; + } + impl<'a> Default for PushDataInfoEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + offset: Default::default(), + data: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PushDataInfoEXT<'a> { + pub fn offset(mut self, offset: u32) -> Self { + self.offset = offset; + self + } + pub fn data(mut self, data: crate::vk::HostAddressRangeConstEXT<'a>) -> Self { + self.data = data; + self + } + } #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct DescriptorMappingSourceConstantOffsetEXT<'a> { pub heap_offset: u32, pub heap_array_stride: u32, @@ -278,8 +466,36 @@ pub(crate) mod reexport { pub sampler_heap_array_stride: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + impl<'a> DescriptorMappingSourceConstantOffsetEXT<'a> { + pub fn heap_offset(mut self, heap_offset: u32) -> Self { + self.heap_offset = heap_offset; + self + } + pub fn heap_array_stride(mut self, heap_array_stride: u32) -> Self { + self.heap_array_stride = heap_array_stride; + self + } + pub fn p_embedded_sampler( + mut self, + p_embedded_sampler: &'a crate::vk::SamplerCreateInfo<'a>, + ) -> Self { + self.p_embedded_sampler = p_embedded_sampler; + self + } + pub fn sampler_heap_offset(mut self, sampler_heap_offset: u32) -> Self { + self.sampler_heap_offset = sampler_heap_offset; + self + } + pub fn sampler_heap_array_stride( + mut self, + sampler_heap_array_stride: u32, + ) -> Self { + self.sampler_heap_array_stride = sampler_heap_array_stride; + self + } + } #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct DescriptorMappingSourcePushIndexEXT<'a> { pub heap_offset: u32, pub push_offset: u32, @@ -293,8 +509,63 @@ pub(crate) mod reexport { pub sampler_heap_array_stride: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + impl<'a> DescriptorMappingSourcePushIndexEXT<'a> { + pub fn heap_offset(mut self, heap_offset: u32) -> Self { + self.heap_offset = heap_offset; + self + } + pub fn push_offset(mut self, push_offset: u32) -> Self { + self.push_offset = push_offset; + self + } + pub fn heap_index_stride(mut self, heap_index_stride: u32) -> Self { + self.heap_index_stride = heap_index_stride; + self + } + pub fn heap_array_stride(mut self, heap_array_stride: u32) -> Self { + self.heap_array_stride = heap_array_stride; + self + } + pub fn p_embedded_sampler( + mut self, + p_embedded_sampler: &'a crate::vk::SamplerCreateInfo<'a>, + ) -> Self { + self.p_embedded_sampler = p_embedded_sampler; + self + } + pub fn use_combined_image_sampler_index( + mut self, + use_combined_image_sampler_index: bool, + ) -> Self { + self.use_combined_image_sampler_index = use_combined_image_sampler_index + .into(); + self + } + pub fn sampler_heap_offset(mut self, sampler_heap_offset: u32) -> Self { + self.sampler_heap_offset = sampler_heap_offset; + self + } + pub fn sampler_push_offset(mut self, sampler_push_offset: u32) -> Self { + self.sampler_push_offset = sampler_push_offset; + self + } + pub fn sampler_heap_index_stride( + mut self, + sampler_heap_index_stride: u32, + ) -> Self { + self.sampler_heap_index_stride = sampler_heap_index_stride; + self + } + pub fn sampler_heap_array_stride( + mut self, + sampler_heap_array_stride: u32, + ) -> Self { + self.sampler_heap_array_stride = sampler_heap_array_stride; + self + } + } #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct DescriptorMappingSourceIndirectIndexEXT<'a> { pub heap_offset: u32, pub push_offset: u32, @@ -310,8 +581,71 @@ pub(crate) mod reexport { pub sampler_heap_array_stride: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + impl<'a> DescriptorMappingSourceIndirectIndexEXT<'a> { + pub fn heap_offset(mut self, heap_offset: u32) -> Self { + self.heap_offset = heap_offset; + self + } + pub fn push_offset(mut self, push_offset: u32) -> Self { + self.push_offset = push_offset; + self + } + pub fn address_offset(mut self, address_offset: u32) -> Self { + self.address_offset = address_offset; + self + } + pub fn heap_index_stride(mut self, heap_index_stride: u32) -> Self { + self.heap_index_stride = heap_index_stride; + self + } + pub fn heap_array_stride(mut self, heap_array_stride: u32) -> Self { + self.heap_array_stride = heap_array_stride; + self + } + pub fn p_embedded_sampler( + mut self, + p_embedded_sampler: &'a crate::vk::SamplerCreateInfo<'a>, + ) -> Self { + self.p_embedded_sampler = p_embedded_sampler; + self + } + pub fn use_combined_image_sampler_index( + mut self, + use_combined_image_sampler_index: bool, + ) -> Self { + self.use_combined_image_sampler_index = use_combined_image_sampler_index + .into(); + self + } + pub fn sampler_heap_offset(mut self, sampler_heap_offset: u32) -> Self { + self.sampler_heap_offset = sampler_heap_offset; + self + } + pub fn sampler_push_offset(mut self, sampler_push_offset: u32) -> Self { + self.sampler_push_offset = sampler_push_offset; + self + } + pub fn sampler_address_offset(mut self, sampler_address_offset: u32) -> Self { + self.sampler_address_offset = sampler_address_offset; + self + } + pub fn sampler_heap_index_stride( + mut self, + sampler_heap_index_stride: u32, + ) -> Self { + self.sampler_heap_index_stride = sampler_heap_index_stride; + self + } + pub fn sampler_heap_array_stride( + mut self, + sampler_heap_array_stride: u32, + ) -> Self { + self.sampler_heap_array_stride = sampler_heap_array_stride; + self + } + } #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct DescriptorMappingSourceIndirectIndexArrayEXT<'a> { pub heap_offset: u32, pub push_offset: u32, @@ -325,14 +659,76 @@ pub(crate) mod reexport { pub sampler_heap_index_stride: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + impl<'a> DescriptorMappingSourceIndirectIndexArrayEXT<'a> { + pub fn heap_offset(mut self, heap_offset: u32) -> Self { + self.heap_offset = heap_offset; + self + } + pub fn push_offset(mut self, push_offset: u32) -> Self { + self.push_offset = push_offset; + self + } + pub fn address_offset(mut self, address_offset: u32) -> Self { + self.address_offset = address_offset; + self + } + pub fn heap_index_stride(mut self, heap_index_stride: u32) -> Self { + self.heap_index_stride = heap_index_stride; + self + } + pub fn p_embedded_sampler( + mut self, + p_embedded_sampler: &'a crate::vk::SamplerCreateInfo<'a>, + ) -> Self { + self.p_embedded_sampler = p_embedded_sampler; + self + } + pub fn use_combined_image_sampler_index( + mut self, + use_combined_image_sampler_index: bool, + ) -> Self { + self.use_combined_image_sampler_index = use_combined_image_sampler_index + .into(); + self + } + pub fn sampler_heap_offset(mut self, sampler_heap_offset: u32) -> Self { + self.sampler_heap_offset = sampler_heap_offset; + self + } + pub fn sampler_push_offset(mut self, sampler_push_offset: u32) -> Self { + self.sampler_push_offset = sampler_push_offset; + self + } + pub fn sampler_address_offset(mut self, sampler_address_offset: u32) -> Self { + self.sampler_address_offset = sampler_address_offset; + self + } + pub fn sampler_heap_index_stride( + mut self, + sampler_heap_index_stride: u32, + ) -> Self { + self.sampler_heap_index_stride = sampler_heap_index_stride; + self + } + } #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct DescriptorMappingSourceHeapDataEXT { pub heap_offset: u32, pub push_offset: u32, } + impl DescriptorMappingSourceHeapDataEXT { + pub fn heap_offset(mut self, heap_offset: u32) -> Self { + self.heap_offset = heap_offset; + self + } + pub fn push_offset(mut self, push_offset: u32) -> Self { + self.push_offset = push_offset; + self + } + } #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct DescriptorMappingSourceShaderRecordIndexEXT<'a> { pub heap_offset: u32, pub shader_record_offset: u32, @@ -346,12 +742,80 @@ pub(crate) mod reexport { pub sampler_heap_array_stride: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + impl<'a> DescriptorMappingSourceShaderRecordIndexEXT<'a> { + pub fn heap_offset(mut self, heap_offset: u32) -> Self { + self.heap_offset = heap_offset; + self + } + pub fn shader_record_offset(mut self, shader_record_offset: u32) -> Self { + self.shader_record_offset = shader_record_offset; + self + } + pub fn heap_index_stride(mut self, heap_index_stride: u32) -> Self { + self.heap_index_stride = heap_index_stride; + self + } + pub fn heap_array_stride(mut self, heap_array_stride: u32) -> Self { + self.heap_array_stride = heap_array_stride; + self + } + pub fn p_embedded_sampler( + mut self, + p_embedded_sampler: &'a crate::vk::SamplerCreateInfo<'a>, + ) -> Self { + self.p_embedded_sampler = p_embedded_sampler; + self + } + pub fn use_combined_image_sampler_index( + mut self, + use_combined_image_sampler_index: bool, + ) -> Self { + self.use_combined_image_sampler_index = use_combined_image_sampler_index + .into(); + self + } + pub fn sampler_heap_offset(mut self, sampler_heap_offset: u32) -> Self { + self.sampler_heap_offset = sampler_heap_offset; + self + } + pub fn sampler_shader_record_offset( + mut self, + sampler_shader_record_offset: u32, + ) -> Self { + self.sampler_shader_record_offset = sampler_shader_record_offset; + self + } + pub fn sampler_heap_index_stride( + mut self, + sampler_heap_index_stride: u32, + ) -> Self { + self.sampler_heap_index_stride = sampler_heap_index_stride; + self + } + pub fn sampler_heap_array_stride( + mut self, + sampler_heap_array_stride: u32, + ) -> Self { + self.sampler_heap_array_stride = sampler_heap_array_stride; + self + } + } #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct DescriptorMappingSourceIndirectAddressEXT { pub push_offset: u32, pub address_offset: u32, } + impl DescriptorMappingSourceIndirectAddressEXT { + pub fn push_offset(mut self, push_offset: u32) -> Self { + self.push_offset = push_offset; + self + } + pub fn address_offset(mut self, address_offset: u32) -> Self { + self.address_offset = address_offset; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct DescriptorSetAndBindingMappingEXT<'a> { @@ -365,6 +829,57 @@ pub(crate) mod reexport { pub source_data: crate::vk::DescriptorMappingSourceDataEXT<'a>, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for DescriptorSetAndBindingMappingEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::DESCRIPTOR_SET_AND_BINDING_MAPPING_EXT; + } + impl<'a> Default for DescriptorSetAndBindingMappingEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + descriptor_set: Default::default(), + first_binding: Default::default(), + binding_count: Default::default(), + resource_mask: Default::default(), + source: Default::default(), + source_data: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> DescriptorSetAndBindingMappingEXT<'a> { + pub fn descriptor_set(mut self, descriptor_set: u32) -> Self { + self.descriptor_set = descriptor_set; + self + } + pub fn first_binding(mut self, first_binding: u32) -> Self { + self.first_binding = first_binding; + self + } + pub fn binding_count(mut self, binding_count: u32) -> Self { + self.binding_count = binding_count; + self + } + pub fn resource_mask( + mut self, + resource_mask: crate::vk::SpirvResourceTypeFlagsEXT, + ) -> Self { + self.resource_mask = resource_mask; + self + } + pub fn source(mut self, source: crate::vk::DescriptorMappingSourceEXT) -> Self { + self.source = source; + self + } + pub fn source_data( + mut self, + source_data: crate::vk::DescriptorMappingSourceDataEXT<'a>, + ) -> Self { + self.source_data = source_data; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct ShaderDescriptorSetAndBindingMappingInfoEXT<'a> { @@ -374,6 +889,39 @@ pub(crate) mod reexport { pub p_mappings: *const crate::vk::DescriptorSetAndBindingMappingEXT<'a>, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for ShaderDescriptorSetAndBindingMappingInfoEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::SHADER_DESCRIPTOR_SET_AND_BINDING_MAPPING_INFO_EXT; + } + unsafe impl<'a> crate::Extends> + for ShaderDescriptorSetAndBindingMappingInfoEXT<'a> {} + unsafe impl<'a> crate::Extends> + for ShaderDescriptorSetAndBindingMappingInfoEXT<'a> {} + impl<'a> Default for ShaderDescriptorSetAndBindingMappingInfoEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + mapping_count: Default::default(), + p_mappings: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> ShaderDescriptorSetAndBindingMappingInfoEXT<'a> { + pub fn mapping_count(mut self, mapping_count: u32) -> Self { + self.mapping_count = mapping_count; + self + } + pub fn p_mappings( + mut self, + p_mappings: &'a [crate::vk::DescriptorSetAndBindingMappingEXT<'a>], + ) -> Self { + self.mapping_count = p_mappings.len() as _; + self.p_mappings = p_mappings.as_ptr(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct SamplerCustomBorderColorIndexCreateInfoEXT<'a> { @@ -382,6 +930,28 @@ pub(crate) mod reexport { pub index: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for SamplerCustomBorderColorIndexCreateInfoEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::SAMPLER_CUSTOM_BORDER_COLOR_INDEX_CREATE_INFO_EXT; + } + unsafe impl<'a> crate::Extends> + for SamplerCustomBorderColorIndexCreateInfoEXT<'a> {} + impl<'a> Default for SamplerCustomBorderColorIndexCreateInfoEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + index: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> SamplerCustomBorderColorIndexCreateInfoEXT<'a> { + pub fn index(mut self, index: u32) -> Self { + self.index = index; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct OpaqueCaptureDataCreateInfoEXT<'a> { @@ -390,6 +960,32 @@ pub(crate) mod reexport { pub p_data: *const crate::vk::HostAddressRangeConstEXT<'a>, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for OpaqueCaptureDataCreateInfoEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::OPAQUE_CAPTURE_DATA_CREATE_INFO_EXT; + } + unsafe impl<'a> crate::Extends> + for OpaqueCaptureDataCreateInfoEXT<'a> {} + unsafe impl<'a> crate::Extends> + for OpaqueCaptureDataCreateInfoEXT<'a> {} + impl<'a> Default for OpaqueCaptureDataCreateInfoEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + p_data: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> OpaqueCaptureDataCreateInfoEXT<'a> { + pub fn p_data( + mut self, + p_data: &'a crate::vk::HostAddressRangeConstEXT<'a>, + ) -> Self { + self.p_data = p_data; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct IndirectCommandsLayoutPushDataTokenNV<'a> { @@ -399,6 +995,33 @@ pub(crate) mod reexport { pub push_data_size: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for IndirectCommandsLayoutPushDataTokenNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::INDIRECT_COMMANDS_LAYOUT_PUSH_DATA_TOKEN_NV; + } + unsafe impl<'a> crate::Extends> + for IndirectCommandsLayoutPushDataTokenNV<'a> {} + impl<'a> Default for IndirectCommandsLayoutPushDataTokenNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + push_data_offset: Default::default(), + push_data_size: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> IndirectCommandsLayoutPushDataTokenNV<'a> { + pub fn push_data_offset(mut self, push_data_offset: u32) -> Self { + self.push_data_offset = push_data_offset; + self + } + pub fn push_data_size(mut self, push_data_size: u32) -> Self { + self.push_data_size = push_data_size; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct SubsampledImageFormatPropertiesEXT<'a> { @@ -407,6 +1030,31 @@ pub(crate) mod reexport { pub subsampled_image_descriptor_count: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for SubsampledImageFormatPropertiesEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::SUBSAMPLED_IMAGE_FORMAT_PROPERTIES_EXT; + } + unsafe impl<'a> crate::Extends> + for SubsampledImageFormatPropertiesEXT<'a> {} + impl<'a> Default for SubsampledImageFormatPropertiesEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + subsampled_image_descriptor_count: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> SubsampledImageFormatPropertiesEXT<'a> { + pub fn subsampled_image_descriptor_count( + mut self, + subsampled_image_descriptor_count: u32, + ) -> Self { + self.subsampled_image_descriptor_count = subsampled_image_descriptor_count; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceDescriptorHeapFeaturesEXT<'a> { @@ -416,6 +1064,38 @@ pub(crate) mod reexport { pub descriptor_heap_capture_replay: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceDescriptorHeapFeaturesEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_DESCRIPTOR_HEAP_FEATURES_EXT; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceDescriptorHeapFeaturesEXT<'a> {} + unsafe impl<'a> crate::Extends> + for PhysicalDeviceDescriptorHeapFeaturesEXT<'a> {} + impl<'a> Default for PhysicalDeviceDescriptorHeapFeaturesEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + descriptor_heap: Default::default(), + descriptor_heap_capture_replay: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceDescriptorHeapFeaturesEXT<'a> { + pub fn descriptor_heap(mut self, descriptor_heap: bool) -> Self { + self.descriptor_heap = descriptor_heap.into(); + self + } + pub fn descriptor_heap_capture_replay( + mut self, + descriptor_heap_capture_replay: bool, + ) -> Self { + self.descriptor_heap_capture_replay = descriptor_heap_capture_replay.into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceDescriptorHeapPropertiesEXT<'a> { @@ -442,6 +1122,172 @@ pub(crate) mod reexport { pub protected_descriptor_heaps: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceDescriptorHeapPropertiesEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_DESCRIPTOR_HEAP_PROPERTIES_EXT; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceDescriptorHeapPropertiesEXT<'a> {} + impl<'a> Default for PhysicalDeviceDescriptorHeapPropertiesEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + sampler_heap_alignment: Default::default(), + resource_heap_alignment: Default::default(), + max_sampler_heap_size: Default::default(), + max_resource_heap_size: Default::default(), + min_sampler_heap_reserved_range: Default::default(), + min_sampler_heap_reserved_range_with_embedded: Default::default(), + min_resource_heap_reserved_range: Default::default(), + sampler_descriptor_size: Default::default(), + image_descriptor_size: Default::default(), + buffer_descriptor_size: Default::default(), + sampler_descriptor_alignment: Default::default(), + image_descriptor_alignment: Default::default(), + buffer_descriptor_alignment: Default::default(), + max_push_data_size: Default::default(), + image_capture_replay_opaque_data_size: Default::default(), + max_descriptor_heap_embedded_samplers: Default::default(), + sampler_ycbcr_conversion_count: Default::default(), + sparse_descriptor_heaps: Default::default(), + protected_descriptor_heaps: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceDescriptorHeapPropertiesEXT<'a> { + pub fn sampler_heap_alignment( + mut self, + sampler_heap_alignment: crate::vk::DeviceSize, + ) -> Self { + self.sampler_heap_alignment = sampler_heap_alignment; + self + } + pub fn resource_heap_alignment( + mut self, + resource_heap_alignment: crate::vk::DeviceSize, + ) -> Self { + self.resource_heap_alignment = resource_heap_alignment; + self + } + pub fn max_sampler_heap_size( + mut self, + max_sampler_heap_size: crate::vk::DeviceSize, + ) -> Self { + self.max_sampler_heap_size = max_sampler_heap_size; + self + } + pub fn max_resource_heap_size( + mut self, + max_resource_heap_size: crate::vk::DeviceSize, + ) -> Self { + self.max_resource_heap_size = max_resource_heap_size; + self + } + pub fn min_sampler_heap_reserved_range( + mut self, + min_sampler_heap_reserved_range: crate::vk::DeviceSize, + ) -> Self { + self.min_sampler_heap_reserved_range = min_sampler_heap_reserved_range; + self + } + pub fn min_sampler_heap_reserved_range_with_embedded( + mut self, + min_sampler_heap_reserved_range_with_embedded: crate::vk::DeviceSize, + ) -> Self { + self.min_sampler_heap_reserved_range_with_embedded = min_sampler_heap_reserved_range_with_embedded; + self + } + pub fn min_resource_heap_reserved_range( + mut self, + min_resource_heap_reserved_range: crate::vk::DeviceSize, + ) -> Self { + self.min_resource_heap_reserved_range = min_resource_heap_reserved_range; + self + } + pub fn sampler_descriptor_size( + mut self, + sampler_descriptor_size: crate::vk::DeviceSize, + ) -> Self { + self.sampler_descriptor_size = sampler_descriptor_size; + self + } + pub fn image_descriptor_size( + mut self, + image_descriptor_size: crate::vk::DeviceSize, + ) -> Self { + self.image_descriptor_size = image_descriptor_size; + self + } + pub fn buffer_descriptor_size( + mut self, + buffer_descriptor_size: crate::vk::DeviceSize, + ) -> Self { + self.buffer_descriptor_size = buffer_descriptor_size; + self + } + pub fn sampler_descriptor_alignment( + mut self, + sampler_descriptor_alignment: crate::vk::DeviceSize, + ) -> Self { + self.sampler_descriptor_alignment = sampler_descriptor_alignment; + self + } + pub fn image_descriptor_alignment( + mut self, + image_descriptor_alignment: crate::vk::DeviceSize, + ) -> Self { + self.image_descriptor_alignment = image_descriptor_alignment; + self + } + pub fn buffer_descriptor_alignment( + mut self, + buffer_descriptor_alignment: crate::vk::DeviceSize, + ) -> Self { + self.buffer_descriptor_alignment = buffer_descriptor_alignment; + self + } + pub fn max_push_data_size( + mut self, + max_push_data_size: crate::vk::DeviceSize, + ) -> Self { + self.max_push_data_size = max_push_data_size; + self + } + pub fn image_capture_replay_opaque_data_size( + mut self, + image_capture_replay_opaque_data_size: usize, + ) -> Self { + self.image_capture_replay_opaque_data_size = image_capture_replay_opaque_data_size; + self + } + pub fn max_descriptor_heap_embedded_samplers( + mut self, + max_descriptor_heap_embedded_samplers: u32, + ) -> Self { + self.max_descriptor_heap_embedded_samplers = max_descriptor_heap_embedded_samplers; + self + } + pub fn sampler_ycbcr_conversion_count( + mut self, + sampler_ycbcr_conversion_count: u32, + ) -> Self { + self.sampler_ycbcr_conversion_count = sampler_ycbcr_conversion_count; + self + } + pub fn sparse_descriptor_heaps(mut self, sparse_descriptor_heaps: bool) -> Self { + self.sparse_descriptor_heaps = sparse_descriptor_heaps.into(); + self + } + pub fn protected_descriptor_heaps( + mut self, + protected_descriptor_heaps: bool, + ) -> Self { + self.protected_descriptor_heaps = protected_descriptor_heaps.into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct CommandBufferInheritanceDescriptorHeapInfoEXT<'a> { @@ -451,6 +1297,39 @@ pub(crate) mod reexport { pub p_resource_heap_bind_info: *const crate::vk::BindHeapInfoEXT<'a>, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for CommandBufferInheritanceDescriptorHeapInfoEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::COMMAND_BUFFER_INHERITANCE_DESCRIPTOR_HEAP_INFO_EXT; + } + unsafe impl<'a> crate::Extends> + for CommandBufferInheritanceDescriptorHeapInfoEXT<'a> {} + impl<'a> Default for CommandBufferInheritanceDescriptorHeapInfoEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + p_sampler_heap_bind_info: Default::default(), + p_resource_heap_bind_info: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> CommandBufferInheritanceDescriptorHeapInfoEXT<'a> { + pub fn p_sampler_heap_bind_info( + mut self, + p_sampler_heap_bind_info: &'a crate::vk::BindHeapInfoEXT<'a>, + ) -> Self { + self.p_sampler_heap_bind_info = p_sampler_heap_bind_info; + self + } + pub fn p_resource_heap_bind_info( + mut self, + p_resource_heap_bind_info: &'a crate::vk::BindHeapInfoEXT<'a>, + ) -> Self { + self.p_resource_heap_bind_info = p_resource_heap_bind_info; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceDescriptorHeapTensorPropertiesARM<'a> { @@ -461,6 +1340,47 @@ pub(crate) mod reexport { pub tensor_capture_replay_opaque_data_size: usize, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceDescriptorHeapTensorPropertiesARM<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_DESCRIPTOR_HEAP_TENSOR_PROPERTIES_ARM; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceDescriptorHeapTensorPropertiesARM<'a> {} + impl<'a> Default for PhysicalDeviceDescriptorHeapTensorPropertiesARM<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + tensor_descriptor_size: Default::default(), + tensor_descriptor_alignment: Default::default(), + tensor_capture_replay_opaque_data_size: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceDescriptorHeapTensorPropertiesARM<'a> { + pub fn tensor_descriptor_size( + mut self, + tensor_descriptor_size: crate::vk::DeviceSize, + ) -> Self { + self.tensor_descriptor_size = tensor_descriptor_size; + self + } + pub fn tensor_descriptor_alignment( + mut self, + tensor_descriptor_alignment: crate::vk::DeviceSize, + ) -> Self { + self.tensor_descriptor_alignment = tensor_descriptor_alignment; + self + } + pub fn tensor_capture_replay_opaque_data_size( + mut self, + tensor_capture_replay_opaque_data_size: usize, + ) -> Self { + self.tensor_capture_replay_opaque_data_size = tensor_capture_replay_opaque_data_size; + self + } + } pub type DeviceAddressRangeEXT = crate::vk::DeviceAddressRangeKHR; #[repr(C)] #[derive(Clone, Copy)] @@ -470,6 +1390,11 @@ pub(crate) mod reexport { pub p_address_range: *const crate::vk::DeviceAddressRangeEXT, pub p_tensor_arm: *const crate::vk::TensorViewCreateInfoARM<'a>, } + impl<'a> Default for ResourceDescriptorDataEXT<'a> { + fn default() -> Self { + unsafe { core::mem::zeroed() } + } + } #[repr(C)] #[derive(Clone, Copy)] pub union DescriptorMappingSourceDataEXT<'a> { @@ -489,6 +1414,11 @@ pub(crate) mod reexport { pub shader_record_data_offset: u32, pub shader_record_address_offset: u32, } + impl<'a> Default for DescriptorMappingSourceDataEXT<'a> { + fn default() -> Self { + unsafe { core::mem::zeroed() } + } + } ///Provided by [`ext::descriptor_heap`](crate::ext::descriptor_heap) impl crate::vk::StructureType { pub const TEXEL_BUFFER_DESCRIPTOR_INFO_EXT: Self = Self(1000135000); @@ -648,7 +1578,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct TensorViewCreateFlagBitsARM(pub(crate) u64); #[repr(transparent)] #[derive(Clone, Copy)] @@ -745,7 +1675,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct SpirvResourceTypeFlagBitsEXT(pub(crate) u32); ///Provided by [`ext::descriptor_heap`](crate::ext::descriptor_heap) impl SpirvResourceTypeFlagBitsEXT { diff --git a/ash-rewrite/src/generated/ext/device_address_binding_report.rs b/ash-rewrite/src/generated/ext/device_address_binding_report.rs index 0acbc2ea7..a35786f36 100644 --- a/ash-rewrite/src/generated/ext/device_address_binding_report.rs +++ b/ash-rewrite/src/generated/ext/device_address_binding_report.rs @@ -9,6 +9,30 @@ pub struct PhysicalDeviceAddressBindingReportFeaturesEXT<'a> { pub report_address_binding: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceAddressBindingReportFeaturesEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceAddressBindingReportFeaturesEXT<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceAddressBindingReportFeaturesEXT<'a> {} +impl<'a> Default for PhysicalDeviceAddressBindingReportFeaturesEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + report_address_binding: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceAddressBindingReportFeaturesEXT<'a> { + pub fn report_address_binding(mut self, report_address_binding: bool) -> Self { + self.report_address_binding = report_address_binding.into(); + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct DeviceAddressBindingCallbackDataEXT<'a> { @@ -20,6 +44,45 @@ pub struct DeviceAddressBindingCallbackDataEXT<'a> { pub binding_type: crate::vk::DeviceAddressBindingTypeEXT, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> for DeviceAddressBindingCallbackDataEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::DEVICE_ADDRESS_BINDING_CALLBACK_DATA_EXT; +} +unsafe impl<'a> crate::Extends> +for DeviceAddressBindingCallbackDataEXT<'a> {} +impl<'a> Default for DeviceAddressBindingCallbackDataEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + flags: Default::default(), + base_address: Default::default(), + size: Default::default(), + binding_type: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> DeviceAddressBindingCallbackDataEXT<'a> { + pub fn flags(mut self, flags: crate::vk::DeviceAddressBindingFlagsEXT) -> Self { + self.flags = flags; + self + } + pub fn base_address(mut self, base_address: crate::vk::DeviceAddress) -> Self { + self.base_address = base_address; + self + } + pub fn size(mut self, size: crate::vk::DeviceSize) -> Self { + self.size = size; + self + } + pub fn binding_type( + mut self, + binding_type: crate::vk::DeviceAddressBindingTypeEXT, + ) -> Self { + self.binding_type = binding_type; + self + } +} ///Provided by [`ext::device_address_binding_report`](crate::ext::device_address_binding_report) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT: Self = Self( @@ -119,7 +182,7 @@ impl core::ops::Not for DeviceAddressBindingFlagsEXT { } } #[repr(transparent)] -#[derive(Clone, Copy)] +#[derive(Clone, Copy, Default)] pub struct DeviceAddressBindingFlagBitsEXT(pub(crate) u32); ///Provided by [`ext::device_address_binding_report`](crate::ext::device_address_binding_report) impl DeviceAddressBindingFlagBitsEXT { diff --git a/ash-rewrite/src/generated/ext/device_fault.rs b/ash-rewrite/src/generated/ext/device_fault.rs index d5f9b666e..054b7d9bd 100644 --- a/ash-rewrite/src/generated/ext/device_fault.rs +++ b/ash-rewrite/src/generated/ext/device_fault.rs @@ -45,6 +45,37 @@ pub(crate) mod reexport { pub device_fault_vendor_binary: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for PhysicalDeviceFaultFeaturesEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_FAULT_FEATURES_EXT; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceFaultFeaturesEXT<'a> {} + unsafe impl<'a> crate::Extends> + for PhysicalDeviceFaultFeaturesEXT<'a> {} + impl<'a> Default for PhysicalDeviceFaultFeaturesEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + device_fault: Default::default(), + device_fault_vendor_binary: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceFaultFeaturesEXT<'a> { + pub fn device_fault(mut self, device_fault: bool) -> Self { + self.device_fault = device_fault.into(); + self + } + pub fn device_fault_vendor_binary( + mut self, + device_fault_vendor_binary: bool, + ) -> Self { + self.device_fault_vendor_binary = device_fault_vendor_binary.into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct DeviceFaultCountsEXT<'a> { @@ -55,6 +86,38 @@ pub(crate) mod reexport { pub vendor_binary_size: crate::vk::DeviceSize, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for DeviceFaultCountsEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::DEVICE_FAULT_COUNTS_EXT; + } + impl<'a> Default for DeviceFaultCountsEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + address_info_count: Default::default(), + vendor_info_count: Default::default(), + vendor_binary_size: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> DeviceFaultCountsEXT<'a> { + pub fn address_info_count(mut self, address_info_count: u32) -> Self { + self.address_info_count = address_info_count; + self + } + pub fn vendor_info_count(mut self, vendor_info_count: u32) -> Self { + self.vendor_info_count = vendor_info_count; + self + } + pub fn vendor_binary_size( + mut self, + vendor_binary_size: crate::vk::DeviceSize, + ) -> Self { + self.vendor_binary_size = vendor_binary_size; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct DeviceFaultInfoEXT<'a> { @@ -66,6 +129,57 @@ pub(crate) mod reexport { pub p_vendor_binary_data: *mut core::ffi::c_void, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for DeviceFaultInfoEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::DEVICE_FAULT_INFO_EXT; + } + impl<'a> Default for DeviceFaultInfoEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + description: unsafe { core::mem::zeroed() }, + p_address_infos: Default::default(), + p_vendor_infos: Default::default(), + p_vendor_binary_data: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> DeviceFaultInfoEXT<'a> { + pub fn description( + mut self, + description: &core::ffi::CStr, + ) -> core::result::Result { + crate::write_c_str_slice_with_nul(&mut self.description, description) + .map(|_| self) + } + pub fn description_as_c_str( + &self, + ) -> core::result::Result<&core::ffi::CStr, core::ffi::FromBytesUntilNulError> { + crate::wrap_c_str_slice_until_nul(&self.description) + } + pub fn p_address_infos( + mut self, + p_address_infos: &'a mut crate::vk::DeviceFaultAddressInfoKHR, + ) -> Self { + self.p_address_infos = p_address_infos; + self + } + pub fn p_vendor_infos( + mut self, + p_vendor_infos: &'a mut crate::vk::DeviceFaultVendorInfoKHR, + ) -> Self { + self.p_vendor_infos = p_vendor_infos; + self + } + pub fn p_vendor_binary_data( + mut self, + p_vendor_binary_data: &'a mut core::ffi::c_void, + ) -> Self { + self.p_vendor_binary_data = p_vendor_binary_data; + self + } + } pub type DeviceFaultAddressInfoEXT = crate::vk::DeviceFaultAddressInfoKHR; pub type DeviceFaultVendorInfoEXT = crate::vk::DeviceFaultVendorInfoKHR; pub type DeviceFaultVendorBinaryHeaderVersionOneEXT = crate::vk::DeviceFaultVendorBinaryHeaderVersionOneKHR; diff --git a/ash-rewrite/src/generated/ext/device_generated_commands.rs b/ash-rewrite/src/generated/ext/device_generated_commands.rs index 4d93c2b56..e28911db4 100644 --- a/ash-rewrite/src/generated/ext/device_generated_commands.rs +++ b/ash-rewrite/src/generated/ext/device_generated_commands.rs @@ -177,6 +177,42 @@ pub(crate) mod reexport { pub dynamic_generated_pipeline_layout: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceDeviceGeneratedCommandsFeaturesEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceDeviceGeneratedCommandsFeaturesEXT<'a> {} + unsafe impl<'a> crate::Extends> + for PhysicalDeviceDeviceGeneratedCommandsFeaturesEXT<'a> {} + impl<'a> Default for PhysicalDeviceDeviceGeneratedCommandsFeaturesEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + device_generated_commands: Default::default(), + dynamic_generated_pipeline_layout: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceDeviceGeneratedCommandsFeaturesEXT<'a> { + pub fn device_generated_commands( + mut self, + device_generated_commands: bool, + ) -> Self { + self.device_generated_commands = device_generated_commands.into(); + self + } + pub fn dynamic_generated_pipeline_layout( + mut self, + dynamic_generated_pipeline_layout: bool, + ) -> Self { + self.dynamic_generated_pipeline_layout = dynamic_generated_pipeline_layout + .into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceDeviceGeneratedCommandsPropertiesEXT<'a> { @@ -196,6 +232,121 @@ pub(crate) mod reexport { pub device_generated_commands_multi_draw_indirect_count: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceDeviceGeneratedCommandsPropertiesEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_EXT; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceDeviceGeneratedCommandsPropertiesEXT<'a> {} + impl<'a> Default for PhysicalDeviceDeviceGeneratedCommandsPropertiesEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + max_indirect_pipeline_count: Default::default(), + max_indirect_shader_object_count: Default::default(), + max_indirect_sequence_count: Default::default(), + max_indirect_commands_token_count: Default::default(), + max_indirect_commands_token_offset: Default::default(), + max_indirect_commands_indirect_stride: Default::default(), + supported_indirect_commands_input_modes: Default::default(), + supported_indirect_commands_shader_stages: Default::default(), + supported_indirect_commands_shader_stages_pipeline_binding: Default::default(), + supported_indirect_commands_shader_stages_shader_binding: Default::default(), + device_generated_commands_transform_feedback: Default::default(), + device_generated_commands_multi_draw_indirect_count: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceDeviceGeneratedCommandsPropertiesEXT<'a> { + pub fn max_indirect_pipeline_count( + mut self, + max_indirect_pipeline_count: u32, + ) -> Self { + self.max_indirect_pipeline_count = max_indirect_pipeline_count; + self + } + pub fn max_indirect_shader_object_count( + mut self, + max_indirect_shader_object_count: u32, + ) -> Self { + self.max_indirect_shader_object_count = max_indirect_shader_object_count; + self + } + pub fn max_indirect_sequence_count( + mut self, + max_indirect_sequence_count: u32, + ) -> Self { + self.max_indirect_sequence_count = max_indirect_sequence_count; + self + } + pub fn max_indirect_commands_token_count( + mut self, + max_indirect_commands_token_count: u32, + ) -> Self { + self.max_indirect_commands_token_count = max_indirect_commands_token_count; + self + } + pub fn max_indirect_commands_token_offset( + mut self, + max_indirect_commands_token_offset: u32, + ) -> Self { + self.max_indirect_commands_token_offset = max_indirect_commands_token_offset; + self + } + pub fn max_indirect_commands_indirect_stride( + mut self, + max_indirect_commands_indirect_stride: u32, + ) -> Self { + self.max_indirect_commands_indirect_stride = max_indirect_commands_indirect_stride; + self + } + pub fn supported_indirect_commands_input_modes( + mut self, + supported_indirect_commands_input_modes: crate::vk::IndirectCommandsInputModeFlagsEXT, + ) -> Self { + self.supported_indirect_commands_input_modes = supported_indirect_commands_input_modes; + self + } + pub fn supported_indirect_commands_shader_stages( + mut self, + supported_indirect_commands_shader_stages: crate::vk::ShaderStageFlags, + ) -> Self { + self.supported_indirect_commands_shader_stages = supported_indirect_commands_shader_stages; + self + } + pub fn supported_indirect_commands_shader_stages_pipeline_binding( + mut self, + supported_indirect_commands_shader_stages_pipeline_binding: crate::vk::ShaderStageFlags, + ) -> Self { + self.supported_indirect_commands_shader_stages_pipeline_binding = supported_indirect_commands_shader_stages_pipeline_binding; + self + } + pub fn supported_indirect_commands_shader_stages_shader_binding( + mut self, + supported_indirect_commands_shader_stages_shader_binding: crate::vk::ShaderStageFlags, + ) -> Self { + self.supported_indirect_commands_shader_stages_shader_binding = supported_indirect_commands_shader_stages_shader_binding; + self + } + pub fn device_generated_commands_transform_feedback( + mut self, + device_generated_commands_transform_feedback: bool, + ) -> Self { + self.device_generated_commands_transform_feedback = device_generated_commands_transform_feedback + .into(); + self + } + pub fn device_generated_commands_multi_draw_indirect_count( + mut self, + device_generated_commands_multi_draw_indirect_count: bool, + ) -> Self { + self.device_generated_commands_multi_draw_indirect_count = device_generated_commands_multi_draw_indirect_count + .into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct GeneratedCommandsPipelineInfoEXT<'a> { @@ -204,6 +355,31 @@ pub(crate) mod reexport { pub pipeline: crate::vk::Pipeline, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for GeneratedCommandsPipelineInfoEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::GENERATED_COMMANDS_PIPELINE_INFO_EXT; + } + unsafe impl<'a> crate::Extends> + for GeneratedCommandsPipelineInfoEXT<'a> {} + unsafe impl< + 'a, + > crate::Extends> + for GeneratedCommandsPipelineInfoEXT<'a> {} + impl<'a> Default for GeneratedCommandsPipelineInfoEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + pipeline: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> GeneratedCommandsPipelineInfoEXT<'a> { + pub fn pipeline(mut self, pipeline: crate::vk::Pipeline) -> Self { + self.pipeline = pipeline; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct GeneratedCommandsShaderInfoEXT<'a> { @@ -213,6 +389,37 @@ pub(crate) mod reexport { pub p_shaders: *const crate::vk::ShaderEXT, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for GeneratedCommandsShaderInfoEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::GENERATED_COMMANDS_SHADER_INFO_EXT; + } + unsafe impl<'a> crate::Extends> + for GeneratedCommandsShaderInfoEXT<'a> {} + unsafe impl< + 'a, + > crate::Extends> + for GeneratedCommandsShaderInfoEXT<'a> {} + impl<'a> Default for GeneratedCommandsShaderInfoEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + shader_count: Default::default(), + p_shaders: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> GeneratedCommandsShaderInfoEXT<'a> { + pub fn shader_count(mut self, shader_count: u32) -> Self { + self.shader_count = shader_count; + self + } + pub fn p_shaders(mut self, p_shaders: &'a [crate::vk::ShaderEXT]) -> Self { + self.shader_count = p_shaders.len() as _; + self.p_shaders = p_shaders.as_ptr(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct GeneratedCommandsMemoryRequirementsInfoEXT<'a> { @@ -224,6 +431,47 @@ pub(crate) mod reexport { pub max_draw_count: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for GeneratedCommandsMemoryRequirementsInfoEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_EXT; + } + impl<'a> Default for GeneratedCommandsMemoryRequirementsInfoEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + indirect_execution_set: Default::default(), + indirect_commands_layout: Default::default(), + max_sequence_count: Default::default(), + max_draw_count: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> GeneratedCommandsMemoryRequirementsInfoEXT<'a> { + pub fn indirect_execution_set( + mut self, + indirect_execution_set: crate::vk::IndirectExecutionSetEXT, + ) -> Self { + self.indirect_execution_set = indirect_execution_set; + self + } + pub fn indirect_commands_layout( + mut self, + indirect_commands_layout: crate::vk::IndirectCommandsLayoutEXT, + ) -> Self { + self.indirect_commands_layout = indirect_commands_layout; + self + } + pub fn max_sequence_count(mut self, max_sequence_count: u32) -> Self { + self.max_sequence_count = max_sequence_count; + self + } + pub fn max_draw_count(mut self, max_draw_count: u32) -> Self { + self.max_draw_count = max_draw_count; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct IndirectExecutionSetPipelineInfoEXT<'a> { @@ -233,6 +481,34 @@ pub(crate) mod reexport { pub max_pipeline_count: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for IndirectExecutionSetPipelineInfoEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::INDIRECT_EXECUTION_SET_PIPELINE_INFO_EXT; + } + impl<'a> Default for IndirectExecutionSetPipelineInfoEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + initial_pipeline: Default::default(), + max_pipeline_count: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> IndirectExecutionSetPipelineInfoEXT<'a> { + pub fn initial_pipeline( + mut self, + initial_pipeline: crate::vk::Pipeline, + ) -> Self { + self.initial_pipeline = initial_pipeline; + self + } + pub fn max_pipeline_count(mut self, max_pipeline_count: u32) -> Self { + self.max_pipeline_count = max_pipeline_count; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct IndirectExecutionSetShaderLayoutInfoEXT<'a> { @@ -242,6 +518,35 @@ pub(crate) mod reexport { pub p_set_layouts: *const crate::vk::DescriptorSetLayout, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for IndirectExecutionSetShaderLayoutInfoEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::INDIRECT_EXECUTION_SET_SHADER_LAYOUT_INFO_EXT; + } + impl<'a> Default for IndirectExecutionSetShaderLayoutInfoEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + set_layout_count: Default::default(), + p_set_layouts: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> IndirectExecutionSetShaderLayoutInfoEXT<'a> { + pub fn set_layout_count(mut self, set_layout_count: u32) -> Self { + self.set_layout_count = set_layout_count; + self + } + pub fn p_set_layouts( + mut self, + p_set_layouts: &'a [crate::vk::DescriptorSetLayout], + ) -> Self { + self.set_layout_count = p_set_layouts.len() as _; + self.p_set_layouts = p_set_layouts.as_ptr(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct IndirectExecutionSetShaderInfoEXT<'a> { @@ -257,6 +562,68 @@ pub(crate) mod reexport { pub p_push_constant_ranges: *const crate::vk::PushConstantRange, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for IndirectExecutionSetShaderInfoEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::INDIRECT_EXECUTION_SET_SHADER_INFO_EXT; + } + impl<'a> Default for IndirectExecutionSetShaderInfoEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + shader_count: Default::default(), + p_initial_shaders: Default::default(), + p_set_layout_infos: Default::default(), + max_shader_count: Default::default(), + push_constant_range_count: Default::default(), + p_push_constant_ranges: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> IndirectExecutionSetShaderInfoEXT<'a> { + pub fn shader_count(mut self, shader_count: u32) -> Self { + self.shader_count = shader_count; + self + } + pub fn p_initial_shaders( + mut self, + p_initial_shaders: &'a [crate::vk::ShaderEXT], + ) -> Self { + self.shader_count = p_initial_shaders.len() as _; + self.p_initial_shaders = p_initial_shaders.as_ptr(); + self + } + pub fn p_set_layout_infos( + mut self, + p_set_layout_infos: &'a [crate::vk::IndirectExecutionSetShaderLayoutInfoEXT< + 'a, + >], + ) -> Self { + self.shader_count = p_set_layout_infos.len() as _; + self.p_set_layout_infos = p_set_layout_infos.as_ptr(); + self + } + pub fn max_shader_count(mut self, max_shader_count: u32) -> Self { + self.max_shader_count = max_shader_count; + self + } + pub fn push_constant_range_count( + mut self, + push_constant_range_count: u32, + ) -> Self { + self.push_constant_range_count = push_constant_range_count; + self + } + pub fn p_push_constant_ranges( + mut self, + p_push_constant_ranges: &'a [crate::vk::PushConstantRange], + ) -> Self { + self.push_constant_range_count = p_push_constant_ranges.len() as _; + self.p_push_constant_ranges = p_push_constant_ranges.as_ptr(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct IndirectExecutionSetCreateInfoEXT<'a> { @@ -266,6 +633,34 @@ pub(crate) mod reexport { pub info: crate::vk::IndirectExecutionSetInfoEXT<'a>, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for IndirectExecutionSetCreateInfoEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::INDIRECT_EXECUTION_SET_CREATE_INFO_EXT; + } + impl<'a> Default for IndirectExecutionSetCreateInfoEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + _type: Default::default(), + info: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> IndirectExecutionSetCreateInfoEXT<'a> { + pub fn _type( + mut self, + _type: crate::vk::IndirectExecutionSetInfoTypeEXT, + ) -> Self { + self._type = _type; + self + } + pub fn info(mut self, info: crate::vk::IndirectExecutionSetInfoEXT<'a>) -> Self { + self.info = info; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct GeneratedCommandsInfoEXT<'a> { @@ -283,6 +678,94 @@ pub(crate) mod reexport { pub max_draw_count: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for GeneratedCommandsInfoEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::GENERATED_COMMANDS_INFO_EXT; + } + impl<'a> Default for GeneratedCommandsInfoEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + shader_stages: Default::default(), + indirect_execution_set: Default::default(), + indirect_commands_layout: Default::default(), + indirect_address: Default::default(), + indirect_address_size: Default::default(), + preprocess_address: Default::default(), + preprocess_size: Default::default(), + max_sequence_count: Default::default(), + sequence_count_address: Default::default(), + max_draw_count: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> GeneratedCommandsInfoEXT<'a> { + pub fn shader_stages( + mut self, + shader_stages: crate::vk::ShaderStageFlags, + ) -> Self { + self.shader_stages = shader_stages; + self + } + pub fn indirect_execution_set( + mut self, + indirect_execution_set: crate::vk::IndirectExecutionSetEXT, + ) -> Self { + self.indirect_execution_set = indirect_execution_set; + self + } + pub fn indirect_commands_layout( + mut self, + indirect_commands_layout: crate::vk::IndirectCommandsLayoutEXT, + ) -> Self { + self.indirect_commands_layout = indirect_commands_layout; + self + } + pub fn indirect_address( + mut self, + indirect_address: crate::vk::DeviceAddress, + ) -> Self { + self.indirect_address = indirect_address; + self + } + pub fn indirect_address_size( + mut self, + indirect_address_size: crate::vk::DeviceSize, + ) -> Self { + self.indirect_address_size = indirect_address_size; + self + } + pub fn preprocess_address( + mut self, + preprocess_address: crate::vk::DeviceAddress, + ) -> Self { + self.preprocess_address = preprocess_address; + self + } + pub fn preprocess_size( + mut self, + preprocess_size: crate::vk::DeviceSize, + ) -> Self { + self.preprocess_size = preprocess_size; + self + } + pub fn max_sequence_count(mut self, max_sequence_count: u32) -> Self { + self.max_sequence_count = max_sequence_count; + self + } + pub fn sequence_count_address( + mut self, + sequence_count_address: crate::vk::DeviceAddress, + ) -> Self { + self.sequence_count_address = sequence_count_address; + self + } + pub fn max_draw_count(mut self, max_draw_count: u32) -> Self { + self.max_draw_count = max_draw_count; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct WriteIndirectExecutionSetPipelineEXT<'a> { @@ -292,6 +775,31 @@ pub(crate) mod reexport { pub pipeline: crate::vk::Pipeline, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for WriteIndirectExecutionSetPipelineEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::WRITE_INDIRECT_EXECUTION_SET_PIPELINE_EXT; + } + impl<'a> Default for WriteIndirectExecutionSetPipelineEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + index: Default::default(), + pipeline: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> WriteIndirectExecutionSetPipelineEXT<'a> { + pub fn index(mut self, index: u32) -> Self { + self.index = index; + self + } + pub fn pipeline(mut self, pipeline: crate::vk::Pipeline) -> Self { + self.pipeline = pipeline; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct WriteIndirectExecutionSetShaderEXT<'a> { @@ -301,6 +809,31 @@ pub(crate) mod reexport { pub shader: crate::vk::ShaderEXT, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for WriteIndirectExecutionSetShaderEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::WRITE_INDIRECT_EXECUTION_SET_SHADER_EXT; + } + impl<'a> Default for WriteIndirectExecutionSetShaderEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + index: Default::default(), + shader: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> WriteIndirectExecutionSetShaderEXT<'a> { + pub fn index(mut self, index: u32) -> Self { + self.index = index; + self + } + pub fn shader(mut self, shader: crate::vk::ShaderEXT) -> Self { + self.shader = shader; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct IndirectCommandsLayoutCreateInfoEXT<'a> { @@ -314,6 +847,64 @@ pub(crate) mod reexport { pub p_tokens: *const crate::vk::IndirectCommandsLayoutTokenEXT<'a>, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for IndirectCommandsLayoutCreateInfoEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_EXT; + } + impl<'a> Default for IndirectCommandsLayoutCreateInfoEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + flags: Default::default(), + shader_stages: Default::default(), + indirect_stride: Default::default(), + pipeline_layout: Default::default(), + token_count: Default::default(), + p_tokens: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> IndirectCommandsLayoutCreateInfoEXT<'a> { + pub fn flags( + mut self, + flags: crate::vk::IndirectCommandsLayoutUsageFlagsEXT, + ) -> Self { + self.flags = flags; + self + } + pub fn shader_stages( + mut self, + shader_stages: crate::vk::ShaderStageFlags, + ) -> Self { + self.shader_stages = shader_stages; + self + } + pub fn indirect_stride(mut self, indirect_stride: u32) -> Self { + self.indirect_stride = indirect_stride; + self + } + pub fn pipeline_layout( + mut self, + pipeline_layout: crate::vk::PipelineLayout, + ) -> Self { + self.pipeline_layout = pipeline_layout; + self + } + pub fn token_count(mut self, token_count: u32) -> Self { + self.token_count = token_count; + self + } + pub fn p_tokens( + mut self, + p_tokens: &'a [crate::vk::IndirectCommandsLayoutTokenEXT<'a>], + ) -> Self { + self.token_count = p_tokens.len() as _; + self.p_tokens = p_tokens.as_ptr(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct IndirectCommandsLayoutTokenEXT<'a> { @@ -324,54 +915,179 @@ pub(crate) mod reexport { pub offset: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for IndirectCommandsLayoutTokenEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::INDIRECT_COMMANDS_LAYOUT_TOKEN_EXT; + } + impl<'a> Default for IndirectCommandsLayoutTokenEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + _type: Default::default(), + data: Default::default(), + offset: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> IndirectCommandsLayoutTokenEXT<'a> { + pub fn _type(mut self, _type: crate::vk::IndirectCommandsTokenTypeEXT) -> Self { + self._type = _type; + self + } + pub fn data(mut self, data: crate::vk::IndirectCommandsTokenDataEXT) -> Self { + self.data = data; + self + } + pub fn offset(mut self, offset: u32) -> Self { + self.offset = offset; + self + } + } #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct DrawIndirectCountIndirectCommandEXT { pub buffer_address: crate::vk::DeviceAddress, pub stride: u32, pub command_count: u32, } + impl DrawIndirectCountIndirectCommandEXT { + pub fn buffer_address( + mut self, + buffer_address: crate::vk::DeviceAddress, + ) -> Self { + self.buffer_address = buffer_address; + self + } + pub fn stride(mut self, stride: u32) -> Self { + self.stride = stride; + self + } + pub fn command_count(mut self, command_count: u32) -> Self { + self.command_count = command_count; + self + } + } #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct IndirectCommandsVertexBufferTokenEXT { pub vertex_binding_unit: u32, } + impl IndirectCommandsVertexBufferTokenEXT { + pub fn vertex_binding_unit(mut self, vertex_binding_unit: u32) -> Self { + self.vertex_binding_unit = vertex_binding_unit; + self + } + } #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct BindVertexBufferIndirectCommandEXT { pub buffer_address: crate::vk::DeviceAddress, pub size: u32, pub stride: u32, } + impl BindVertexBufferIndirectCommandEXT { + pub fn buffer_address( + mut self, + buffer_address: crate::vk::DeviceAddress, + ) -> Self { + self.buffer_address = buffer_address; + self + } + pub fn size(mut self, size: u32) -> Self { + self.size = size; + self + } + pub fn stride(mut self, stride: u32) -> Self { + self.stride = stride; + self + } + } #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct IndirectCommandsIndexBufferTokenEXT { pub mode: crate::vk::IndirectCommandsInputModeFlagBitsEXT, } + impl IndirectCommandsIndexBufferTokenEXT { + pub fn mode( + mut self, + mode: crate::vk::IndirectCommandsInputModeFlagBitsEXT, + ) -> Self { + self.mode = mode; + self + } + } #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct BindIndexBufferIndirectCommandEXT { pub buffer_address: crate::vk::DeviceAddress, pub size: u32, pub index_type: crate::vk::IndexType, } + impl BindIndexBufferIndirectCommandEXT { + pub fn buffer_address( + mut self, + buffer_address: crate::vk::DeviceAddress, + ) -> Self { + self.buffer_address = buffer_address; + self + } + pub fn size(mut self, size: u32) -> Self { + self.size = size; + self + } + pub fn index_type(mut self, index_type: crate::vk::IndexType) -> Self { + self.index_type = index_type; + self + } + } #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct IndirectCommandsPushConstantTokenEXT { pub update_range: crate::vk::PushConstantRange, } + impl IndirectCommandsPushConstantTokenEXT { + pub fn update_range( + mut self, + update_range: crate::vk::PushConstantRange, + ) -> Self { + self.update_range = update_range; + self + } + } #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct IndirectCommandsExecutionSetTokenEXT { pub _type: crate::vk::IndirectExecutionSetInfoTypeEXT, pub shader_stages: crate::vk::ShaderStageFlags, } + impl IndirectCommandsExecutionSetTokenEXT { + pub fn _type( + mut self, + _type: crate::vk::IndirectExecutionSetInfoTypeEXT, + ) -> Self { + self._type = _type; + self + } + pub fn shader_stages( + mut self, + shader_stages: crate::vk::ShaderStageFlags, + ) -> Self { + self.shader_stages = shader_stages; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub union IndirectExecutionSetInfoEXT<'a> { pub p_pipeline_info: *const crate::vk::IndirectExecutionSetPipelineInfoEXT<'a>, pub p_shader_info: *const crate::vk::IndirectExecutionSetShaderInfoEXT<'a>, } + impl<'a> Default for IndirectExecutionSetInfoEXT<'a> { + fn default() -> Self { + unsafe { core::mem::zeroed() } + } + } #[repr(C)] #[derive(Clone, Copy)] pub union IndirectCommandsTokenDataEXT { @@ -380,6 +1096,11 @@ pub(crate) mod reexport { pub p_index_buffer: *const crate::vk::IndirectCommandsIndexBufferTokenEXT, pub p_execution_set: *const crate::vk::IndirectCommandsExecutionSetTokenEXT, } + impl Default for IndirectCommandsTokenDataEXT { + fn default() -> Self { + unsafe { core::mem::zeroed() } + } + } ///Provided by [`ext::device_generated_commands`](crate::ext::device_generated_commands) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT: Self = Self( @@ -533,7 +1254,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct IndirectCommandsLayoutUsageFlagBitsEXT(pub(crate) u32); ///Provided by [`ext::device_generated_commands`](crate::ext::device_generated_commands) impl IndirectCommandsLayoutUsageFlagBitsEXT { @@ -614,7 +1335,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct IndirectCommandsInputModeFlagBitsEXT(pub(crate) u32); ///Provided by [`ext::device_generated_commands`](crate::ext::device_generated_commands) impl IndirectCommandsInputModeFlagBitsEXT { diff --git a/ash-rewrite/src/generated/ext/device_memory_report.rs b/ash-rewrite/src/generated/ext/device_memory_report.rs index d7053fc2e..dd2321b2c 100644 --- a/ash-rewrite/src/generated/ext/device_memory_report.rs +++ b/ash-rewrite/src/generated/ext/device_memory_report.rs @@ -9,6 +9,30 @@ pub struct PhysicalDeviceDeviceMemoryReportFeaturesEXT<'a> { pub device_memory_report: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceDeviceMemoryReportFeaturesEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceDeviceMemoryReportFeaturesEXT<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceDeviceMemoryReportFeaturesEXT<'a> {} +impl<'a> Default for PhysicalDeviceDeviceMemoryReportFeaturesEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + device_memory_report: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceDeviceMemoryReportFeaturesEXT<'a> { + pub fn device_memory_report(mut self, device_memory_report: bool) -> Self { + self.device_memory_report = device_memory_report.into(); + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct DeviceDeviceMemoryReportCreateInfoEXT<'a> { @@ -19,6 +43,41 @@ pub struct DeviceDeviceMemoryReportCreateInfoEXT<'a> { pub p_user_data: *mut core::ffi::c_void, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for DeviceDeviceMemoryReportCreateInfoEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT; +} +unsafe impl<'a> crate::Extends> +for DeviceDeviceMemoryReportCreateInfoEXT<'a> {} +impl<'a> Default for DeviceDeviceMemoryReportCreateInfoEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + flags: Default::default(), + pfn_user_callback: Default::default(), + p_user_data: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> DeviceDeviceMemoryReportCreateInfoEXT<'a> { + pub fn flags(mut self, flags: crate::vk::DeviceMemoryReportFlagsEXT) -> Self { + self.flags = flags; + self + } + pub fn pfn_user_callback( + mut self, + pfn_user_callback: crate::vk::PFN_vkDeviceMemoryReportCallbackEXT, + ) -> Self { + self.pfn_user_callback = pfn_user_callback; + self + } + pub fn p_user_data(mut self, p_user_data: &'a mut core::ffi::c_void) -> Self { + self.p_user_data = p_user_data; + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct DeviceMemoryReportCallbackDataEXT<'a> { @@ -33,6 +92,55 @@ pub struct DeviceMemoryReportCallbackDataEXT<'a> { pub heap_index: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> for DeviceMemoryReportCallbackDataEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::DEVICE_MEMORY_REPORT_CALLBACK_DATA_EXT; +} +impl<'a> Default for DeviceMemoryReportCallbackDataEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + flags: Default::default(), + _type: Default::default(), + memory_object_id: Default::default(), + size: Default::default(), + object_type: Default::default(), + object_handle: Default::default(), + heap_index: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> DeviceMemoryReportCallbackDataEXT<'a> { + pub fn flags(mut self, flags: crate::vk::DeviceMemoryReportFlagsEXT) -> Self { + self.flags = flags; + self + } + pub fn _type(mut self, _type: crate::vk::DeviceMemoryReportEventTypeEXT) -> Self { + self._type = _type; + self + } + pub fn memory_object_id(mut self, memory_object_id: u64) -> Self { + self.memory_object_id = memory_object_id; + self + } + pub fn size(mut self, size: crate::vk::DeviceSize) -> Self { + self.size = size; + self + } + pub fn object_type(mut self, object_type: crate::vk::ObjectType) -> Self { + self.object_type = object_type; + self + } + pub fn object_handle(mut self, object_handle: u64) -> Self { + self.object_handle = object_handle; + self + } + pub fn heap_index(mut self, heap_index: u32) -> Self { + self.heap_index = heap_index; + self + } +} ///Provided by [`ext::device_memory_report`](crate::ext::device_memory_report) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT: Self = Self(1000284000); diff --git a/ash-rewrite/src/generated/ext/directfb_surface.rs b/ash-rewrite/src/generated/ext/directfb_surface.rs index 7c07cc61b..2652674a7 100644 --- a/ash-rewrite/src/generated/ext/directfb_surface.rs +++ b/ash-rewrite/src/generated/ext/directfb_surface.rs @@ -65,6 +65,38 @@ pub(crate) mod reexport { pub surface: *mut crate::platform_types::IDirectFBSurface, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for DirectFBSurfaceCreateInfoEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::DIRECTFB_SURFACE_CREATE_INFO_EXT; + } + impl<'a> Default for DirectFBSurfaceCreateInfoEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + flags: Default::default(), + dfb: Default::default(), + surface: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> DirectFBSurfaceCreateInfoEXT<'a> { + pub fn flags(mut self, flags: crate::vk::DirectFBSurfaceCreateFlagsEXT) -> Self { + self.flags = flags; + self + } + pub fn dfb(mut self, dfb: &'a mut crate::platform_types::IDirectFB) -> Self { + self.dfb = dfb; + self + } + pub fn surface( + mut self, + surface: &'a mut crate::platform_types::IDirectFBSurface, + ) -> Self { + self.surface = surface; + self + } + } ///Provided by [`ext::directfb_surface`](crate::ext::directfb_surface) impl crate::vk::StructureType { pub const DIRECTFB_SURFACE_CREATE_INFO_EXT: Self = Self(1000346000); diff --git a/ash-rewrite/src/generated/ext/discard_rectangles.rs b/ash-rewrite/src/generated/ext/discard_rectangles.rs index 0c90a9566..76271c84d 100644 --- a/ash-rewrite/src/generated/ext/discard_rectangles.rs +++ b/ash-rewrite/src/generated/ext/discard_rectangles.rs @@ -75,6 +75,28 @@ pub(crate) mod reexport { pub max_discard_rectangles: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceDiscardRectanglePropertiesEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceDiscardRectanglePropertiesEXT<'a> {} + impl<'a> Default for PhysicalDeviceDiscardRectanglePropertiesEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + max_discard_rectangles: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceDiscardRectanglePropertiesEXT<'a> { + pub fn max_discard_rectangles(mut self, max_discard_rectangles: u32) -> Self { + self.max_discard_rectangles = max_discard_rectangles; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PipelineDiscardRectangleStateCreateInfoEXT<'a> { @@ -86,6 +108,53 @@ pub(crate) mod reexport { pub p_discard_rectangles: *const crate::vk::Rect2D, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PipelineDiscardRectangleStateCreateInfoEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT; + } + unsafe impl<'a> crate::Extends> + for PipelineDiscardRectangleStateCreateInfoEXT<'a> {} + impl<'a> Default for PipelineDiscardRectangleStateCreateInfoEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + flags: Default::default(), + discard_rectangle_mode: Default::default(), + discard_rectangle_count: Default::default(), + p_discard_rectangles: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PipelineDiscardRectangleStateCreateInfoEXT<'a> { + pub fn flags( + mut self, + flags: crate::vk::PipelineDiscardRectangleStateCreateFlagsEXT, + ) -> Self { + self.flags = flags; + self + } + pub fn discard_rectangle_mode( + mut self, + discard_rectangle_mode: crate::vk::DiscardRectangleModeEXT, + ) -> Self { + self.discard_rectangle_mode = discard_rectangle_mode; + self + } + pub fn discard_rectangle_count(mut self, discard_rectangle_count: u32) -> Self { + self.discard_rectangle_count = discard_rectangle_count; + self + } + pub fn p_discard_rectangles( + mut self, + p_discard_rectangles: &'a [crate::vk::Rect2D], + ) -> Self { + self.discard_rectangle_count = p_discard_rectangles.len() as _; + self.p_discard_rectangles = p_discard_rectangles.as_ptr(); + self + } + } ///Provided by [`ext::discard_rectangles`](crate::ext::discard_rectangles) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT: Self = Self( diff --git a/ash-rewrite/src/generated/ext/display_control.rs b/ash-rewrite/src/generated/ext/display_control.rs index c57c006de..c135b8924 100644 --- a/ash-rewrite/src/generated/ext/display_control.rs +++ b/ash-rewrite/src/generated/ext/display_control.rs @@ -96,6 +96,28 @@ pub(crate) mod reexport { pub power_state: crate::vk::DisplayPowerStateEXT, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for DisplayPowerInfoEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::DISPLAY_POWER_INFO_EXT; + } + impl<'a> Default for DisplayPowerInfoEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + power_state: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> DisplayPowerInfoEXT<'a> { + pub fn power_state( + mut self, + power_state: crate::vk::DisplayPowerStateEXT, + ) -> Self { + self.power_state = power_state; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct DeviceEventInfoEXT<'a> { @@ -104,6 +126,28 @@ pub(crate) mod reexport { pub device_event: crate::vk::DeviceEventTypeEXT, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for DeviceEventInfoEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::DEVICE_EVENT_INFO_EXT; + } + impl<'a> Default for DeviceEventInfoEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + device_event: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> DeviceEventInfoEXT<'a> { + pub fn device_event( + mut self, + device_event: crate::vk::DeviceEventTypeEXT, + ) -> Self { + self.device_event = device_event; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct DisplayEventInfoEXT<'a> { @@ -112,6 +156,28 @@ pub(crate) mod reexport { pub display_event: crate::vk::DisplayEventTypeEXT, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for DisplayEventInfoEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::DISPLAY_EVENT_INFO_EXT; + } + impl<'a> Default for DisplayEventInfoEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + display_event: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> DisplayEventInfoEXT<'a> { + pub fn display_event( + mut self, + display_event: crate::vk::DisplayEventTypeEXT, + ) -> Self { + self.display_event = display_event; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct SwapchainCounterCreateInfoEXT<'a> { @@ -120,6 +186,30 @@ pub(crate) mod reexport { pub surface_counters: crate::vk::SurfaceCounterFlagsEXT, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for SwapchainCounterCreateInfoEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::SWAPCHAIN_COUNTER_CREATE_INFO_EXT; + } + unsafe impl<'a> crate::Extends> + for SwapchainCounterCreateInfoEXT<'a> {} + impl<'a> Default for SwapchainCounterCreateInfoEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + surface_counters: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> SwapchainCounterCreateInfoEXT<'a> { + pub fn surface_counters( + mut self, + surface_counters: crate::vk::SurfaceCounterFlagsEXT, + ) -> Self { + self.surface_counters = surface_counters; + self + } + } ///Provided by [`ext::display_control`](crate::ext::display_control) impl crate::vk::StructureType { pub const DISPLAY_POWER_INFO_EXT: Self = Self(1000091000); diff --git a/ash-rewrite/src/generated/ext/display_surface_counter.rs b/ash-rewrite/src/generated/ext/display_surface_counter.rs index 06105e200..a598e0c6f 100644 --- a/ash-rewrite/src/generated/ext/display_surface_counter.rs +++ b/ash-rewrite/src/generated/ext/display_surface_counter.rs @@ -54,6 +54,96 @@ pub(crate) mod reexport { pub supported_surface_counters: crate::vk::SurfaceCounterFlagsEXT, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for SurfaceCapabilities2EXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::SURFACE_CAPABILITIES_2_EXT; + } + impl<'a> Default for SurfaceCapabilities2EXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + min_image_count: Default::default(), + max_image_count: Default::default(), + current_extent: Default::default(), + min_image_extent: Default::default(), + max_image_extent: Default::default(), + max_image_array_layers: Default::default(), + supported_transforms: Default::default(), + current_transform: Default::default(), + supported_composite_alpha: Default::default(), + supported_usage_flags: Default::default(), + supported_surface_counters: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> SurfaceCapabilities2EXT<'a> { + pub fn min_image_count(mut self, min_image_count: u32) -> Self { + self.min_image_count = min_image_count; + self + } + pub fn max_image_count(mut self, max_image_count: u32) -> Self { + self.max_image_count = max_image_count; + self + } + pub fn current_extent(mut self, current_extent: crate::vk::Extent2D) -> Self { + self.current_extent = current_extent; + self + } + pub fn min_image_extent( + mut self, + min_image_extent: crate::vk::Extent2D, + ) -> Self { + self.min_image_extent = min_image_extent; + self + } + pub fn max_image_extent( + mut self, + max_image_extent: crate::vk::Extent2D, + ) -> Self { + self.max_image_extent = max_image_extent; + self + } + pub fn max_image_array_layers(mut self, max_image_array_layers: u32) -> Self { + self.max_image_array_layers = max_image_array_layers; + self + } + pub fn supported_transforms( + mut self, + supported_transforms: crate::vk::SurfaceTransformFlagsKHR, + ) -> Self { + self.supported_transforms = supported_transforms; + self + } + pub fn current_transform( + mut self, + current_transform: crate::vk::SurfaceTransformFlagBitsKHR, + ) -> Self { + self.current_transform = current_transform; + self + } + pub fn supported_composite_alpha( + mut self, + supported_composite_alpha: crate::vk::CompositeAlphaFlagsKHR, + ) -> Self { + self.supported_composite_alpha = supported_composite_alpha; + self + } + pub fn supported_usage_flags( + mut self, + supported_usage_flags: crate::vk::ImageUsageFlags, + ) -> Self { + self.supported_usage_flags = supported_usage_flags; + self + } + pub fn supported_surface_counters( + mut self, + supported_surface_counters: crate::vk::SurfaceCounterFlagsEXT, + ) -> Self { + self.supported_surface_counters = supported_surface_counters; + self + } + } ///Provided by [`ext::display_surface_counter`](crate::ext::display_surface_counter) impl crate::vk::StructureType { pub const SURFACE_CAPABILITIES_2_EXT: Self = Self(1000090000); @@ -127,7 +217,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct SurfaceCounterFlagBitsEXT(pub(crate) u32); ///Provided by [`ext::display_surface_counter`](crate::ext::display_surface_counter) impl SurfaceCounterFlagBitsEXT { diff --git a/ash-rewrite/src/generated/ext/dynamic_rendering_unused_attachments.rs b/ash-rewrite/src/generated/ext/dynamic_rendering_unused_attachments.rs index 528a03ced..13680aab0 100644 --- a/ash-rewrite/src/generated/ext/dynamic_rendering_unused_attachments.rs +++ b/ash-rewrite/src/generated/ext/dynamic_rendering_unused_attachments.rs @@ -9,6 +9,34 @@ pub struct PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT<'a> { pub dynamic_rendering_unused_attachments: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT<'a> {} +impl<'a> Default for PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + dynamic_rendering_unused_attachments: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT<'a> { + pub fn dynamic_rendering_unused_attachments( + mut self, + dynamic_rendering_unused_attachments: bool, + ) -> Self { + self.dynamic_rendering_unused_attachments = dynamic_rendering_unused_attachments + .into(); + self + } +} ///Provided by [`ext::dynamic_rendering_unused_attachments`](crate::ext::dynamic_rendering_unused_attachments) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT: Self = Self( diff --git a/ash-rewrite/src/generated/ext/extended_dynamic_state.rs b/ash-rewrite/src/generated/ext/extended_dynamic_state.rs index e35d363ec..eb4ff9009 100644 --- a/ash-rewrite/src/generated/ext/extended_dynamic_state.rs +++ b/ash-rewrite/src/generated/ext/extended_dynamic_state.rs @@ -219,6 +219,30 @@ pub(crate) mod reexport { pub extended_dynamic_state: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceExtendedDynamicStateFeaturesEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceExtendedDynamicStateFeaturesEXT<'a> {} + unsafe impl<'a> crate::Extends> + for PhysicalDeviceExtendedDynamicStateFeaturesEXT<'a> {} + impl<'a> Default for PhysicalDeviceExtendedDynamicStateFeaturesEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + extended_dynamic_state: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceExtendedDynamicStateFeaturesEXT<'a> { + pub fn extended_dynamic_state(mut self, extended_dynamic_state: bool) -> Self { + self.extended_dynamic_state = extended_dynamic_state.into(); + self + } + } ///Provided by [`ext::extended_dynamic_state`](crate::ext::extended_dynamic_state) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT: Self = Self( diff --git a/ash-rewrite/src/generated/ext/extended_dynamic_state2.rs b/ash-rewrite/src/generated/ext/extended_dynamic_state2.rs index 73088085a..723a34530 100644 --- a/ash-rewrite/src/generated/ext/extended_dynamic_state2.rs +++ b/ash-rewrite/src/generated/ext/extended_dynamic_state2.rs @@ -105,6 +105,48 @@ pub(crate) mod reexport { pub extended_dynamic_state2_patch_control_points: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceExtendedDynamicState2FeaturesEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceExtendedDynamicState2FeaturesEXT<'a> {} + unsafe impl<'a> crate::Extends> + for PhysicalDeviceExtendedDynamicState2FeaturesEXT<'a> {} + impl<'a> Default for PhysicalDeviceExtendedDynamicState2FeaturesEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + extended_dynamic_state2: Default::default(), + extended_dynamic_state2_logic_op: Default::default(), + extended_dynamic_state2_patch_control_points: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceExtendedDynamicState2FeaturesEXT<'a> { + pub fn extended_dynamic_state2(mut self, extended_dynamic_state2: bool) -> Self { + self.extended_dynamic_state2 = extended_dynamic_state2.into(); + self + } + pub fn extended_dynamic_state2_logic_op( + mut self, + extended_dynamic_state2_logic_op: bool, + ) -> Self { + self.extended_dynamic_state2_logic_op = extended_dynamic_state2_logic_op + .into(); + self + } + pub fn extended_dynamic_state2_patch_control_points( + mut self, + extended_dynamic_state2_patch_control_points: bool, + ) -> Self { + self.extended_dynamic_state2_patch_control_points = extended_dynamic_state2_patch_control_points + .into(); + self + } + } ///Provided by [`ext::extended_dynamic_state2`](crate::ext::extended_dynamic_state2) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT: Self = Self( diff --git a/ash-rewrite/src/generated/ext/extended_dynamic_state3.rs b/ash-rewrite/src/generated/ext/extended_dynamic_state3.rs index d8a9ce8f2..eff9a98eb 100644 --- a/ash-rewrite/src/generated/ext/extended_dynamic_state3.rs +++ b/ash-rewrite/src/generated/ext/extended_dynamic_state3.rs @@ -535,6 +535,304 @@ pub(crate) mod reexport { pub extended_dynamic_state3_shading_rate_image_enable: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceExtendedDynamicState3FeaturesEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceExtendedDynamicState3FeaturesEXT<'a> {} + unsafe impl<'a> crate::Extends> + for PhysicalDeviceExtendedDynamicState3FeaturesEXT<'a> {} + impl<'a> Default for PhysicalDeviceExtendedDynamicState3FeaturesEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + extended_dynamic_state3_tessellation_domain_origin: Default::default(), + extended_dynamic_state3_depth_clamp_enable: Default::default(), + extended_dynamic_state3_polygon_mode: Default::default(), + extended_dynamic_state3_rasterization_samples: Default::default(), + extended_dynamic_state3_sample_mask: Default::default(), + extended_dynamic_state3_alpha_to_coverage_enable: Default::default(), + extended_dynamic_state3_alpha_to_one_enable: Default::default(), + extended_dynamic_state3_logic_op_enable: Default::default(), + extended_dynamic_state3_color_blend_enable: Default::default(), + extended_dynamic_state3_color_blend_equation: Default::default(), + extended_dynamic_state3_color_write_mask: Default::default(), + extended_dynamic_state3_rasterization_stream: Default::default(), + extended_dynamic_state3_conservative_rasterization_mode: Default::default(), + extended_dynamic_state3_extra_primitive_overestimation_size: Default::default(), + extended_dynamic_state3_depth_clip_enable: Default::default(), + extended_dynamic_state3_sample_locations_enable: Default::default(), + extended_dynamic_state3_color_blend_advanced: Default::default(), + extended_dynamic_state3_provoking_vertex_mode: Default::default(), + extended_dynamic_state3_line_rasterization_mode: Default::default(), + extended_dynamic_state3_line_stipple_enable: Default::default(), + extended_dynamic_state3_depth_clip_negative_one_to_one: Default::default(), + extended_dynamic_state3_viewport_w_scaling_enable: Default::default(), + extended_dynamic_state3_viewport_swizzle: Default::default(), + extended_dynamic_state3_coverage_to_color_enable: Default::default(), + extended_dynamic_state3_coverage_to_color_location: Default::default(), + extended_dynamic_state3_coverage_modulation_mode: Default::default(), + extended_dynamic_state3_coverage_modulation_table_enable: Default::default(), + extended_dynamic_state3_coverage_modulation_table: Default::default(), + extended_dynamic_state3_coverage_reduction_mode: Default::default(), + extended_dynamic_state3_representative_fragment_test_enable: Default::default(), + extended_dynamic_state3_shading_rate_image_enable: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceExtendedDynamicState3FeaturesEXT<'a> { + pub fn extended_dynamic_state3_tessellation_domain_origin( + mut self, + extended_dynamic_state3_tessellation_domain_origin: bool, + ) -> Self { + self.extended_dynamic_state3_tessellation_domain_origin = extended_dynamic_state3_tessellation_domain_origin + .into(); + self + } + pub fn extended_dynamic_state3_depth_clamp_enable( + mut self, + extended_dynamic_state3_depth_clamp_enable: bool, + ) -> Self { + self.extended_dynamic_state3_depth_clamp_enable = extended_dynamic_state3_depth_clamp_enable + .into(); + self + } + pub fn extended_dynamic_state3_polygon_mode( + mut self, + extended_dynamic_state3_polygon_mode: bool, + ) -> Self { + self.extended_dynamic_state3_polygon_mode = extended_dynamic_state3_polygon_mode + .into(); + self + } + pub fn extended_dynamic_state3_rasterization_samples( + mut self, + extended_dynamic_state3_rasterization_samples: bool, + ) -> Self { + self.extended_dynamic_state3_rasterization_samples = extended_dynamic_state3_rasterization_samples + .into(); + self + } + pub fn extended_dynamic_state3_sample_mask( + mut self, + extended_dynamic_state3_sample_mask: bool, + ) -> Self { + self.extended_dynamic_state3_sample_mask = extended_dynamic_state3_sample_mask + .into(); + self + } + pub fn extended_dynamic_state3_alpha_to_coverage_enable( + mut self, + extended_dynamic_state3_alpha_to_coverage_enable: bool, + ) -> Self { + self.extended_dynamic_state3_alpha_to_coverage_enable = extended_dynamic_state3_alpha_to_coverage_enable + .into(); + self + } + pub fn extended_dynamic_state3_alpha_to_one_enable( + mut self, + extended_dynamic_state3_alpha_to_one_enable: bool, + ) -> Self { + self.extended_dynamic_state3_alpha_to_one_enable = extended_dynamic_state3_alpha_to_one_enable + .into(); + self + } + pub fn extended_dynamic_state3_logic_op_enable( + mut self, + extended_dynamic_state3_logic_op_enable: bool, + ) -> Self { + self.extended_dynamic_state3_logic_op_enable = extended_dynamic_state3_logic_op_enable + .into(); + self + } + pub fn extended_dynamic_state3_color_blend_enable( + mut self, + extended_dynamic_state3_color_blend_enable: bool, + ) -> Self { + self.extended_dynamic_state3_color_blend_enable = extended_dynamic_state3_color_blend_enable + .into(); + self + } + pub fn extended_dynamic_state3_color_blend_equation( + mut self, + extended_dynamic_state3_color_blend_equation: bool, + ) -> Self { + self.extended_dynamic_state3_color_blend_equation = extended_dynamic_state3_color_blend_equation + .into(); + self + } + pub fn extended_dynamic_state3_color_write_mask( + mut self, + extended_dynamic_state3_color_write_mask: bool, + ) -> Self { + self.extended_dynamic_state3_color_write_mask = extended_dynamic_state3_color_write_mask + .into(); + self + } + pub fn extended_dynamic_state3_rasterization_stream( + mut self, + extended_dynamic_state3_rasterization_stream: bool, + ) -> Self { + self.extended_dynamic_state3_rasterization_stream = extended_dynamic_state3_rasterization_stream + .into(); + self + } + pub fn extended_dynamic_state3_conservative_rasterization_mode( + mut self, + extended_dynamic_state3_conservative_rasterization_mode: bool, + ) -> Self { + self.extended_dynamic_state3_conservative_rasterization_mode = extended_dynamic_state3_conservative_rasterization_mode + .into(); + self + } + pub fn extended_dynamic_state3_extra_primitive_overestimation_size( + mut self, + extended_dynamic_state3_extra_primitive_overestimation_size: bool, + ) -> Self { + self.extended_dynamic_state3_extra_primitive_overestimation_size = extended_dynamic_state3_extra_primitive_overestimation_size + .into(); + self + } + pub fn extended_dynamic_state3_depth_clip_enable( + mut self, + extended_dynamic_state3_depth_clip_enable: bool, + ) -> Self { + self.extended_dynamic_state3_depth_clip_enable = extended_dynamic_state3_depth_clip_enable + .into(); + self + } + pub fn extended_dynamic_state3_sample_locations_enable( + mut self, + extended_dynamic_state3_sample_locations_enable: bool, + ) -> Self { + self.extended_dynamic_state3_sample_locations_enable = extended_dynamic_state3_sample_locations_enable + .into(); + self + } + pub fn extended_dynamic_state3_color_blend_advanced( + mut self, + extended_dynamic_state3_color_blend_advanced: bool, + ) -> Self { + self.extended_dynamic_state3_color_blend_advanced = extended_dynamic_state3_color_blend_advanced + .into(); + self + } + pub fn extended_dynamic_state3_provoking_vertex_mode( + mut self, + extended_dynamic_state3_provoking_vertex_mode: bool, + ) -> Self { + self.extended_dynamic_state3_provoking_vertex_mode = extended_dynamic_state3_provoking_vertex_mode + .into(); + self + } + pub fn extended_dynamic_state3_line_rasterization_mode( + mut self, + extended_dynamic_state3_line_rasterization_mode: bool, + ) -> Self { + self.extended_dynamic_state3_line_rasterization_mode = extended_dynamic_state3_line_rasterization_mode + .into(); + self + } + pub fn extended_dynamic_state3_line_stipple_enable( + mut self, + extended_dynamic_state3_line_stipple_enable: bool, + ) -> Self { + self.extended_dynamic_state3_line_stipple_enable = extended_dynamic_state3_line_stipple_enable + .into(); + self + } + pub fn extended_dynamic_state3_depth_clip_negative_one_to_one( + mut self, + extended_dynamic_state3_depth_clip_negative_one_to_one: bool, + ) -> Self { + self.extended_dynamic_state3_depth_clip_negative_one_to_one = extended_dynamic_state3_depth_clip_negative_one_to_one + .into(); + self + } + pub fn extended_dynamic_state3_viewport_w_scaling_enable( + mut self, + extended_dynamic_state3_viewport_w_scaling_enable: bool, + ) -> Self { + self.extended_dynamic_state3_viewport_w_scaling_enable = extended_dynamic_state3_viewport_w_scaling_enable + .into(); + self + } + pub fn extended_dynamic_state3_viewport_swizzle( + mut self, + extended_dynamic_state3_viewport_swizzle: bool, + ) -> Self { + self.extended_dynamic_state3_viewport_swizzle = extended_dynamic_state3_viewport_swizzle + .into(); + self + } + pub fn extended_dynamic_state3_coverage_to_color_enable( + mut self, + extended_dynamic_state3_coverage_to_color_enable: bool, + ) -> Self { + self.extended_dynamic_state3_coverage_to_color_enable = extended_dynamic_state3_coverage_to_color_enable + .into(); + self + } + pub fn extended_dynamic_state3_coverage_to_color_location( + mut self, + extended_dynamic_state3_coverage_to_color_location: bool, + ) -> Self { + self.extended_dynamic_state3_coverage_to_color_location = extended_dynamic_state3_coverage_to_color_location + .into(); + self + } + pub fn extended_dynamic_state3_coverage_modulation_mode( + mut self, + extended_dynamic_state3_coverage_modulation_mode: bool, + ) -> Self { + self.extended_dynamic_state3_coverage_modulation_mode = extended_dynamic_state3_coverage_modulation_mode + .into(); + self + } + pub fn extended_dynamic_state3_coverage_modulation_table_enable( + mut self, + extended_dynamic_state3_coverage_modulation_table_enable: bool, + ) -> Self { + self.extended_dynamic_state3_coverage_modulation_table_enable = extended_dynamic_state3_coverage_modulation_table_enable + .into(); + self + } + pub fn extended_dynamic_state3_coverage_modulation_table( + mut self, + extended_dynamic_state3_coverage_modulation_table: bool, + ) -> Self { + self.extended_dynamic_state3_coverage_modulation_table = extended_dynamic_state3_coverage_modulation_table + .into(); + self + } + pub fn extended_dynamic_state3_coverage_reduction_mode( + mut self, + extended_dynamic_state3_coverage_reduction_mode: bool, + ) -> Self { + self.extended_dynamic_state3_coverage_reduction_mode = extended_dynamic_state3_coverage_reduction_mode + .into(); + self + } + pub fn extended_dynamic_state3_representative_fragment_test_enable( + mut self, + extended_dynamic_state3_representative_fragment_test_enable: bool, + ) -> Self { + self.extended_dynamic_state3_representative_fragment_test_enable = extended_dynamic_state3_representative_fragment_test_enable + .into(); + self + } + pub fn extended_dynamic_state3_shading_rate_image_enable( + mut self, + extended_dynamic_state3_shading_rate_image_enable: bool, + ) -> Self { + self.extended_dynamic_state3_shading_rate_image_enable = extended_dynamic_state3_shading_rate_image_enable + .into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceExtendedDynamicState3PropertiesEXT<'a> { @@ -543,8 +841,34 @@ pub(crate) mod reexport { pub dynamic_primitive_topology_unrestricted: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceExtendedDynamicState3PropertiesEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceExtendedDynamicState3PropertiesEXT<'a> {} + impl<'a> Default for PhysicalDeviceExtendedDynamicState3PropertiesEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + dynamic_primitive_topology_unrestricted: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceExtendedDynamicState3PropertiesEXT<'a> { + pub fn dynamic_primitive_topology_unrestricted( + mut self, + dynamic_primitive_topology_unrestricted: bool, + ) -> Self { + self.dynamic_primitive_topology_unrestricted = dynamic_primitive_topology_unrestricted + .into(); + self + } + } #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct ColorBlendEquationEXT { pub src_color_blend_factor: crate::vk::BlendFactor, pub dst_color_blend_factor: crate::vk::BlendFactor, @@ -553,8 +877,46 @@ pub(crate) mod reexport { pub dst_alpha_blend_factor: crate::vk::BlendFactor, pub alpha_blend_op: crate::vk::BlendOp, } + impl ColorBlendEquationEXT { + pub fn src_color_blend_factor( + mut self, + src_color_blend_factor: crate::vk::BlendFactor, + ) -> Self { + self.src_color_blend_factor = src_color_blend_factor; + self + } + pub fn dst_color_blend_factor( + mut self, + dst_color_blend_factor: crate::vk::BlendFactor, + ) -> Self { + self.dst_color_blend_factor = dst_color_blend_factor; + self + } + pub fn color_blend_op(mut self, color_blend_op: crate::vk::BlendOp) -> Self { + self.color_blend_op = color_blend_op; + self + } + pub fn src_alpha_blend_factor( + mut self, + src_alpha_blend_factor: crate::vk::BlendFactor, + ) -> Self { + self.src_alpha_blend_factor = src_alpha_blend_factor; + self + } + pub fn dst_alpha_blend_factor( + mut self, + dst_alpha_blend_factor: crate::vk::BlendFactor, + ) -> Self { + self.dst_alpha_blend_factor = dst_alpha_blend_factor; + self + } + pub fn alpha_blend_op(mut self, alpha_blend_op: crate::vk::BlendOp) -> Self { + self.alpha_blend_op = alpha_blend_op; + self + } + } #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct ColorBlendAdvancedEXT { pub advanced_blend_op: crate::vk::BlendOp, pub src_premultiplied: crate::vk::Bool32, @@ -562,6 +924,34 @@ pub(crate) mod reexport { pub blend_overlap: crate::vk::BlendOverlapEXT, pub clamp_results: crate::vk::Bool32, } + impl ColorBlendAdvancedEXT { + pub fn advanced_blend_op( + mut self, + advanced_blend_op: crate::vk::BlendOp, + ) -> Self { + self.advanced_blend_op = advanced_blend_op; + self + } + pub fn src_premultiplied(mut self, src_premultiplied: bool) -> Self { + self.src_premultiplied = src_premultiplied.into(); + self + } + pub fn dst_premultiplied(mut self, dst_premultiplied: bool) -> Self { + self.dst_premultiplied = dst_premultiplied.into(); + self + } + pub fn blend_overlap( + mut self, + blend_overlap: crate::vk::BlendOverlapEXT, + ) -> Self { + self.blend_overlap = blend_overlap; + self + } + pub fn clamp_results(mut self, clamp_results: bool) -> Self { + self.clamp_results = clamp_results.into(); + self + } + } ///Provided by [`ext::extended_dynamic_state3`](crate::ext::extended_dynamic_state3) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT: Self = Self( diff --git a/ash-rewrite/src/generated/ext/external_memory_acquire_unmodified.rs b/ash-rewrite/src/generated/ext/external_memory_acquire_unmodified.rs index c934347eb..c22f40e1e 100644 --- a/ash-rewrite/src/generated/ext/external_memory_acquire_unmodified.rs +++ b/ash-rewrite/src/generated/ext/external_memory_acquire_unmodified.rs @@ -9,6 +9,33 @@ pub struct ExternalMemoryAcquireUnmodifiedEXT<'a> { pub acquire_unmodified_memory: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> for ExternalMemoryAcquireUnmodifiedEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXT; +} +unsafe impl<'a> crate::Extends> +for ExternalMemoryAcquireUnmodifiedEXT<'a> {} +unsafe impl<'a> crate::Extends> +for ExternalMemoryAcquireUnmodifiedEXT<'a> {} +unsafe impl<'a> crate::Extends> +for ExternalMemoryAcquireUnmodifiedEXT<'a> {} +unsafe impl<'a> crate::Extends> +for ExternalMemoryAcquireUnmodifiedEXT<'a> {} +impl<'a> Default for ExternalMemoryAcquireUnmodifiedEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + acquire_unmodified_memory: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> ExternalMemoryAcquireUnmodifiedEXT<'a> { + pub fn acquire_unmodified_memory(mut self, acquire_unmodified_memory: bool) -> Self { + self.acquire_unmodified_memory = acquire_unmodified_memory.into(); + self + } +} ///Provided by [`ext::external_memory_acquire_unmodified`](crate::ext::external_memory_acquire_unmodified) impl crate::vk::StructureType { pub const EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXT: Self = Self(1000453000); diff --git a/ash-rewrite/src/generated/ext/external_memory_host.rs b/ash-rewrite/src/generated/ext/external_memory_host.rs index 663d4b883..144249554 100644 --- a/ash-rewrite/src/generated/ext/external_memory_host.rs +++ b/ash-rewrite/src/generated/ext/external_memory_host.rs @@ -46,6 +46,38 @@ pub(crate) mod reexport { pub p_host_pointer: *mut core::ffi::c_void, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for ImportMemoryHostPointerInfoEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::IMPORT_MEMORY_HOST_POINTER_INFO_EXT; + } + unsafe impl<'a> crate::Extends> + for ImportMemoryHostPointerInfoEXT<'a> {} + impl<'a> Default for ImportMemoryHostPointerInfoEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + handle_type: Default::default(), + p_host_pointer: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> ImportMemoryHostPointerInfoEXT<'a> { + pub fn handle_type( + mut self, + handle_type: crate::vk::ExternalMemoryHandleTypeFlagBits, + ) -> Self { + self.handle_type = handle_type; + self + } + pub fn p_host_pointer( + mut self, + p_host_pointer: &'a mut core::ffi::c_void, + ) -> Self { + self.p_host_pointer = p_host_pointer; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct MemoryHostPointerPropertiesEXT<'a> { @@ -54,6 +86,25 @@ pub(crate) mod reexport { pub memory_type_bits: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for MemoryHostPointerPropertiesEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::MEMORY_HOST_POINTER_PROPERTIES_EXT; + } + impl<'a> Default for MemoryHostPointerPropertiesEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + memory_type_bits: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> MemoryHostPointerPropertiesEXT<'a> { + pub fn memory_type_bits(mut self, memory_type_bits: u32) -> Self { + self.memory_type_bits = memory_type_bits; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceExternalMemoryHostPropertiesEXT<'a> { @@ -62,6 +113,31 @@ pub(crate) mod reexport { pub min_imported_host_pointer_alignment: crate::vk::DeviceSize, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceExternalMemoryHostPropertiesEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceExternalMemoryHostPropertiesEXT<'a> {} + impl<'a> Default for PhysicalDeviceExternalMemoryHostPropertiesEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + min_imported_host_pointer_alignment: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceExternalMemoryHostPropertiesEXT<'a> { + pub fn min_imported_host_pointer_alignment( + mut self, + min_imported_host_pointer_alignment: crate::vk::DeviceSize, + ) -> Self { + self.min_imported_host_pointer_alignment = min_imported_host_pointer_alignment; + self + } + } ///Provided by [`ext::external_memory_host`](crate::ext::external_memory_host) impl crate::vk::StructureType { pub const IMPORT_MEMORY_HOST_POINTER_INFO_EXT: Self = Self(1000178000); diff --git a/ash-rewrite/src/generated/ext/external_memory_metal.rs b/ash-rewrite/src/generated/ext/external_memory_metal.rs index 922275494..a410fa1f8 100644 --- a/ash-rewrite/src/generated/ext/external_memory_metal.rs +++ b/ash-rewrite/src/generated/ext/external_memory_metal.rs @@ -62,6 +62,35 @@ pub(crate) mod reexport { pub handle: *mut core::ffi::c_void, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for ImportMemoryMetalHandleInfoEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::IMPORT_MEMORY_METAL_HANDLE_INFO_EXT; + } + unsafe impl<'a> crate::Extends> + for ImportMemoryMetalHandleInfoEXT<'a> {} + impl<'a> Default for ImportMemoryMetalHandleInfoEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + handle_type: Default::default(), + handle: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> ImportMemoryMetalHandleInfoEXT<'a> { + pub fn handle_type( + mut self, + handle_type: crate::vk::ExternalMemoryHandleTypeFlagBits, + ) -> Self { + self.handle_type = handle_type; + self + } + pub fn handle(mut self, handle: &'a mut core::ffi::c_void) -> Self { + self.handle = handle; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct MemoryMetalHandlePropertiesEXT<'a> { @@ -70,6 +99,25 @@ pub(crate) mod reexport { pub memory_type_bits: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for MemoryMetalHandlePropertiesEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::MEMORY_METAL_HANDLE_PROPERTIES_EXT; + } + impl<'a> Default for MemoryMetalHandlePropertiesEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + memory_type_bits: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> MemoryMetalHandlePropertiesEXT<'a> { + pub fn memory_type_bits(mut self, memory_type_bits: u32) -> Self { + self.memory_type_bits = memory_type_bits; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct MemoryGetMetalHandleInfoEXT<'a> { @@ -79,6 +127,33 @@ pub(crate) mod reexport { pub handle_type: crate::vk::ExternalMemoryHandleTypeFlagBits, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for MemoryGetMetalHandleInfoEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::MEMORY_GET_METAL_HANDLE_INFO_EXT; + } + impl<'a> Default for MemoryGetMetalHandleInfoEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + memory: Default::default(), + handle_type: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> MemoryGetMetalHandleInfoEXT<'a> { + pub fn memory(mut self, memory: crate::vk::DeviceMemory) -> Self { + self.memory = memory; + self + } + pub fn handle_type( + mut self, + handle_type: crate::vk::ExternalMemoryHandleTypeFlagBits, + ) -> Self { + self.handle_type = handle_type; + self + } + } ///Provided by [`ext::external_memory_metal`](crate::ext::external_memory_metal) impl crate::vk::StructureType { pub const IMPORT_MEMORY_METAL_HANDLE_INFO_EXT: Self = Self(1000602000); diff --git a/ash-rewrite/src/generated/ext/filter_cubic.rs b/ash-rewrite/src/generated/ext/filter_cubic.rs index 9f8987947..0532fd7be 100644 --- a/ash-rewrite/src/generated/ext/filter_cubic.rs +++ b/ash-rewrite/src/generated/ext/filter_cubic.rs @@ -9,6 +9,28 @@ pub struct PhysicalDeviceImageViewImageFormatInfoEXT<'a> { pub image_view_type: crate::vk::ImageViewType, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceImageViewImageFormatInfoEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceImageViewImageFormatInfoEXT<'a> {} +impl<'a> Default for PhysicalDeviceImageViewImageFormatInfoEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + image_view_type: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceImageViewImageFormatInfoEXT<'a> { + pub fn image_view_type(mut self, image_view_type: crate::vk::ImageViewType) -> Self { + self.image_view_type = image_view_type; + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct FilterCubicImageViewImageFormatPropertiesEXT<'a> { @@ -18,6 +40,33 @@ pub struct FilterCubicImageViewImageFormatPropertiesEXT<'a> { pub filter_cubic_minmax: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for FilterCubicImageViewImageFormatPropertiesEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT; +} +unsafe impl<'a> crate::Extends> +for FilterCubicImageViewImageFormatPropertiesEXT<'a> {} +impl<'a> Default for FilterCubicImageViewImageFormatPropertiesEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + filter_cubic: Default::default(), + filter_cubic_minmax: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> FilterCubicImageViewImageFormatPropertiesEXT<'a> { + pub fn filter_cubic(mut self, filter_cubic: bool) -> Self { + self.filter_cubic = filter_cubic.into(); + self + } + pub fn filter_cubic_minmax(mut self, filter_cubic_minmax: bool) -> Self { + self.filter_cubic_minmax = filter_cubic_minmax.into(); + self + } +} ///Provided by [`ext::filter_cubic`](crate::ext::filter_cubic) impl crate::vk::Filter { pub const CUBIC_EXT: Self = Self(1000015000); diff --git a/ash-rewrite/src/generated/ext/fragment_density_map.rs b/ash-rewrite/src/generated/ext/fragment_density_map.rs index ca72ca5bb..925619d10 100644 --- a/ash-rewrite/src/generated/ext/fragment_density_map.rs +++ b/ash-rewrite/src/generated/ext/fragment_density_map.rs @@ -11,6 +11,47 @@ pub struct PhysicalDeviceFragmentDensityMapFeaturesEXT<'a> { pub fragment_density_map_non_subsampled_images: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceFragmentDensityMapFeaturesEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceFragmentDensityMapFeaturesEXT<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceFragmentDensityMapFeaturesEXT<'a> {} +impl<'a> Default for PhysicalDeviceFragmentDensityMapFeaturesEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + fragment_density_map: Default::default(), + fragment_density_map_dynamic: Default::default(), + fragment_density_map_non_subsampled_images: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceFragmentDensityMapFeaturesEXT<'a> { + pub fn fragment_density_map(mut self, fragment_density_map: bool) -> Self { + self.fragment_density_map = fragment_density_map.into(); + self + } + pub fn fragment_density_map_dynamic( + mut self, + fragment_density_map_dynamic: bool, + ) -> Self { + self.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, + ) -> Self { + self.fragment_density_map_non_subsampled_images = fragment_density_map_non_subsampled_images + .into(); + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceFragmentDensityMapPropertiesEXT<'a> { @@ -21,6 +62,47 @@ pub struct PhysicalDeviceFragmentDensityMapPropertiesEXT<'a> { pub fragment_density_invocations: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceFragmentDensityMapPropertiesEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceFragmentDensityMapPropertiesEXT<'a> {} +impl<'a> Default for PhysicalDeviceFragmentDensityMapPropertiesEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + min_fragment_density_texel_size: Default::default(), + max_fragment_density_texel_size: Default::default(), + fragment_density_invocations: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceFragmentDensityMapPropertiesEXT<'a> { + pub fn min_fragment_density_texel_size( + mut self, + min_fragment_density_texel_size: crate::vk::Extent2D, + ) -> Self { + self.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: crate::vk::Extent2D, + ) -> Self { + self.max_fragment_density_texel_size = max_fragment_density_texel_size; + self + } + pub fn fragment_density_invocations( + mut self, + fragment_density_invocations: bool, + ) -> Self { + self.fragment_density_invocations = fragment_density_invocations.into(); + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct RenderPassFragmentDensityMapCreateInfoEXT<'a> { @@ -29,6 +111,33 @@ pub struct RenderPassFragmentDensityMapCreateInfoEXT<'a> { pub fragment_density_map_attachment: crate::vk::AttachmentReference, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for RenderPassFragmentDensityMapCreateInfoEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT; +} +unsafe impl<'a> crate::Extends> +for RenderPassFragmentDensityMapCreateInfoEXT<'a> {} +unsafe impl<'a> crate::Extends> +for RenderPassFragmentDensityMapCreateInfoEXT<'a> {} +impl<'a> Default for RenderPassFragmentDensityMapCreateInfoEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + fragment_density_map_attachment: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> RenderPassFragmentDensityMapCreateInfoEXT<'a> { + pub fn fragment_density_map_attachment( + mut self, + fragment_density_map_attachment: crate::vk::AttachmentReference, + ) -> Self { + self.fragment_density_map_attachment = fragment_density_map_attachment; + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct RenderingFragmentDensityMapAttachmentInfoEXT<'a> { @@ -38,6 +147,33 @@ pub struct RenderingFragmentDensityMapAttachmentInfoEXT<'a> { pub image_layout: crate::vk::ImageLayout, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for RenderingFragmentDensityMapAttachmentInfoEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT; +} +unsafe impl<'a> crate::Extends> +for RenderingFragmentDensityMapAttachmentInfoEXT<'a> {} +impl<'a> Default for RenderingFragmentDensityMapAttachmentInfoEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + image_view: Default::default(), + image_layout: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> RenderingFragmentDensityMapAttachmentInfoEXT<'a> { + pub fn image_view(mut self, image_view: crate::vk::ImageView) -> Self { + self.image_view = image_view; + self + } + pub fn image_layout(mut self, image_layout: crate::vk::ImageLayout) -> Self { + self.image_layout = image_layout; + self + } +} ///Provided by [`ext::fragment_density_map`](crate::ext::fragment_density_map) impl crate::vk::ImageLayout { pub const FRAGMENT_DENSITY_MAP_OPTIMAL_EXT: Self = Self(1000218000); diff --git a/ash-rewrite/src/generated/ext/fragment_density_map2.rs b/ash-rewrite/src/generated/ext/fragment_density_map2.rs index 532d077a8..47dd425f1 100644 --- a/ash-rewrite/src/generated/ext/fragment_density_map2.rs +++ b/ash-rewrite/src/generated/ext/fragment_density_map2.rs @@ -9,6 +9,33 @@ pub struct PhysicalDeviceFragmentDensityMap2FeaturesEXT<'a> { pub fragment_density_map_deferred: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceFragmentDensityMap2FeaturesEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceFragmentDensityMap2FeaturesEXT<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceFragmentDensityMap2FeaturesEXT<'a> {} +impl<'a> Default for PhysicalDeviceFragmentDensityMap2FeaturesEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + fragment_density_map_deferred: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceFragmentDensityMap2FeaturesEXT<'a> { + pub fn fragment_density_map_deferred( + mut self, + fragment_density_map_deferred: bool, + ) -> Self { + self.fragment_density_map_deferred = fragment_density_map_deferred.into(); + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceFragmentDensityMap2PropertiesEXT<'a> { @@ -20,6 +47,53 @@ pub struct PhysicalDeviceFragmentDensityMap2PropertiesEXT<'a> { pub max_descriptor_set_subsampled_samplers: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceFragmentDensityMap2PropertiesEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceFragmentDensityMap2PropertiesEXT<'a> {} +impl<'a> Default for PhysicalDeviceFragmentDensityMap2PropertiesEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + subsampled_loads: Default::default(), + subsampled_coarse_reconstruction_early_access: Default::default(), + max_subsampled_array_layers: Default::default(), + max_descriptor_set_subsampled_samplers: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceFragmentDensityMap2PropertiesEXT<'a> { + pub fn subsampled_loads(mut self, subsampled_loads: bool) -> Self { + self.subsampled_loads = subsampled_loads.into(); + self + } + pub fn subsampled_coarse_reconstruction_early_access( + mut self, + subsampled_coarse_reconstruction_early_access: bool, + ) -> Self { + self.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, + ) -> Self { + self.max_subsampled_array_layers = max_subsampled_array_layers; + self + } + pub fn max_descriptor_set_subsampled_samplers( + mut self, + max_descriptor_set_subsampled_samplers: u32, + ) -> Self { + self.max_descriptor_set_subsampled_samplers = max_descriptor_set_subsampled_samplers; + self + } +} ///Provided by [`ext::fragment_density_map2`](crate::ext::fragment_density_map2) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT: Self = Self( diff --git a/ash-rewrite/src/generated/ext/fragment_density_map_offset.rs b/ash-rewrite/src/generated/ext/fragment_density_map_offset.rs index 13cc86be3..771f85ebb 100644 --- a/ash-rewrite/src/generated/ext/fragment_density_map_offset.rs +++ b/ash-rewrite/src/generated/ext/fragment_density_map_offset.rs @@ -43,6 +43,33 @@ pub(crate) mod reexport { pub fragment_density_map_offset: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_EXT; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT<'a> {} + unsafe impl<'a> crate::Extends> + for PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT<'a> {} + impl<'a> Default for PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + fragment_density_map_offset: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT<'a> { + pub fn fragment_density_map_offset( + mut self, + fragment_density_map_offset: bool, + ) -> Self { + self.fragment_density_map_offset = fragment_density_map_offset.into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT<'a> { @@ -51,6 +78,31 @@ pub(crate) mod reexport { pub fragment_density_offset_granularity: crate::vk::Extent2D, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_EXT; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT<'a> {} + impl<'a> Default for PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + fragment_density_offset_granularity: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT<'a> { + pub fn fragment_density_offset_granularity( + mut self, + fragment_density_offset_granularity: crate::vk::Extent2D, + ) -> Self { + self.fragment_density_offset_granularity = fragment_density_offset_granularity; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct RenderPassFragmentDensityMapOffsetEndInfoEXT<'a> { @@ -60,6 +112,42 @@ pub(crate) mod reexport { pub p_fragment_density_offsets: *const crate::vk::Offset2D, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for RenderPassFragmentDensityMapOffsetEndInfoEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::RENDER_PASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_EXT; + } + unsafe impl<'a> crate::Extends> + for RenderPassFragmentDensityMapOffsetEndInfoEXT<'a> {} + unsafe impl<'a> crate::Extends> + for RenderPassFragmentDensityMapOffsetEndInfoEXT<'a> {} + impl<'a> Default for RenderPassFragmentDensityMapOffsetEndInfoEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + fragment_density_offset_count: Default::default(), + p_fragment_density_offsets: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> RenderPassFragmentDensityMapOffsetEndInfoEXT<'a> { + pub fn fragment_density_offset_count( + mut self, + fragment_density_offset_count: u32, + ) -> Self { + self.fragment_density_offset_count = fragment_density_offset_count; + self + } + pub fn p_fragment_density_offsets( + mut self, + p_fragment_density_offsets: &'a [crate::vk::Offset2D], + ) -> Self { + self.fragment_density_offset_count = p_fragment_density_offsets.len() as _; + self.p_fragment_density_offsets = p_fragment_density_offsets.as_ptr(); + self + } + } pub type RenderingEndInfoEXT<'a> = crate::vk::RenderingEndInfoKHR<'a>; ///Provided by [`ext::fragment_density_map_offset`](crate::ext::fragment_density_map_offset) impl crate::vk::StructureType { diff --git a/ash-rewrite/src/generated/ext/fragment_shader_interlock.rs b/ash-rewrite/src/generated/ext/fragment_shader_interlock.rs index 8b1c6965e..7f0777bae 100644 --- a/ash-rewrite/src/generated/ext/fragment_shader_interlock.rs +++ b/ash-rewrite/src/generated/ext/fragment_shader_interlock.rs @@ -11,6 +11,50 @@ pub struct PhysicalDeviceFragmentShaderInterlockFeaturesEXT<'a> { pub fragment_shader_shading_rate_interlock: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceFragmentShaderInterlockFeaturesEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceFragmentShaderInterlockFeaturesEXT<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceFragmentShaderInterlockFeaturesEXT<'a> {} +impl<'a> Default for PhysicalDeviceFragmentShaderInterlockFeaturesEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + fragment_shader_sample_interlock: Default::default(), + fragment_shader_pixel_interlock: Default::default(), + fragment_shader_shading_rate_interlock: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceFragmentShaderInterlockFeaturesEXT<'a> { + pub fn fragment_shader_sample_interlock( + mut self, + fragment_shader_sample_interlock: bool, + ) -> Self { + self.fragment_shader_sample_interlock = fragment_shader_sample_interlock.into(); + self + } + pub fn fragment_shader_pixel_interlock( + mut self, + fragment_shader_pixel_interlock: bool, + ) -> Self { + self.fragment_shader_pixel_interlock = fragment_shader_pixel_interlock.into(); + self + } + pub fn fragment_shader_shading_rate_interlock( + mut self, + fragment_shader_shading_rate_interlock: bool, + ) -> Self { + self.fragment_shader_shading_rate_interlock = fragment_shader_shading_rate_interlock + .into(); + self + } +} ///Provided by [`ext::fragment_shader_interlock`](crate::ext::fragment_shader_interlock) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT: Self = Self( diff --git a/ash-rewrite/src/generated/ext/frame_boundary.rs b/ash-rewrite/src/generated/ext/frame_boundary.rs index 190540181..6814f2387 100644 --- a/ash-rewrite/src/generated/ext/frame_boundary.rs +++ b/ash-rewrite/src/generated/ext/frame_boundary.rs @@ -17,6 +17,72 @@ pub struct FrameBoundaryEXT<'a> { pub p_tag: *const core::ffi::c_void, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> for FrameBoundaryEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::FRAME_BOUNDARY_EXT; +} +unsafe impl<'a> crate::Extends> for FrameBoundaryEXT<'a> {} +unsafe impl<'a> crate::Extends> for FrameBoundaryEXT<'a> {} +unsafe impl<'a> crate::Extends> for FrameBoundaryEXT<'a> {} +unsafe impl<'a> crate::Extends> for FrameBoundaryEXT<'a> {} +impl<'a> Default for FrameBoundaryEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + flags: Default::default(), + frame_id: Default::default(), + image_count: Default::default(), + p_images: Default::default(), + buffer_count: Default::default(), + p_buffers: Default::default(), + tag_name: Default::default(), + tag_size: Default::default(), + p_tag: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> FrameBoundaryEXT<'a> { + pub fn flags(mut self, flags: crate::vk::FrameBoundaryFlagsEXT) -> Self { + self.flags = flags; + self + } + pub fn frame_id(mut self, frame_id: u64) -> Self { + self.frame_id = frame_id; + self + } + pub fn image_count(mut self, image_count: u32) -> Self { + self.image_count = image_count; + self + } + pub fn p_images(mut self, p_images: &'a [crate::vk::Image]) -> Self { + self.image_count = p_images.len() as _; + self.p_images = p_images.as_ptr(); + self + } + pub fn buffer_count(mut self, buffer_count: u32) -> Self { + self.buffer_count = buffer_count; + self + } + pub fn p_buffers(mut self, p_buffers: &'a [crate::vk::Buffer]) -> Self { + self.buffer_count = p_buffers.len() as _; + self.p_buffers = p_buffers.as_ptr(); + self + } + pub fn tag_name(mut self, tag_name: u64) -> Self { + self.tag_name = tag_name; + self + } + pub fn tag_size(mut self, tag_size: usize) -> Self { + self.tag_size = tag_size; + self + } + pub fn p_tag(mut self, p_tag: &'a [u8]) -> Self { + self.tag_size = p_tag.len() as _; + self.p_tag = p_tag.as_ptr().cast(); + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceFrameBoundaryFeaturesEXT<'a> { @@ -25,6 +91,30 @@ pub struct PhysicalDeviceFrameBoundaryFeaturesEXT<'a> { pub frame_boundary: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceFrameBoundaryFeaturesEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES_EXT; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceFrameBoundaryFeaturesEXT<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceFrameBoundaryFeaturesEXT<'a> {} +impl<'a> Default for PhysicalDeviceFrameBoundaryFeaturesEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + frame_boundary: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceFrameBoundaryFeaturesEXT<'a> { + pub fn frame_boundary(mut self, frame_boundary: bool) -> Self { + self.frame_boundary = frame_boundary.into(); + self + } +} ///Provided by [`ext::frame_boundary`](crate::ext::frame_boundary) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES_EXT: Self = Self(1000375000); @@ -99,7 +189,7 @@ impl core::ops::Not for FrameBoundaryFlagsEXT { } } #[repr(transparent)] -#[derive(Clone, Copy)] +#[derive(Clone, Copy, Default)] pub struct FrameBoundaryFlagBitsEXT(pub(crate) u32); ///Provided by [`ext::frame_boundary`](crate::ext::frame_boundary) impl FrameBoundaryFlagBitsEXT { diff --git a/ash-rewrite/src/generated/ext/full_screen_exclusive.rs b/ash-rewrite/src/generated/ext/full_screen_exclusive.rs index 830ac7e72..327e4c4f9 100644 --- a/ash-rewrite/src/generated/ext/full_screen_exclusive.rs +++ b/ash-rewrite/src/generated/ext/full_screen_exclusive.rs @@ -109,6 +109,33 @@ pub(crate) mod reexport { pub full_screen_exclusive: crate::vk::FullScreenExclusiveEXT, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for SurfaceFullScreenExclusiveInfoEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT; + } + unsafe impl<'a> crate::Extends> + for SurfaceFullScreenExclusiveInfoEXT<'a> {} + unsafe impl<'a> crate::Extends> + for SurfaceFullScreenExclusiveInfoEXT<'a> {} + impl<'a> Default for SurfaceFullScreenExclusiveInfoEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + full_screen_exclusive: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> SurfaceFullScreenExclusiveInfoEXT<'a> { + pub fn full_screen_exclusive( + mut self, + full_screen_exclusive: crate::vk::FullScreenExclusiveEXT, + ) -> Self { + self.full_screen_exclusive = full_screen_exclusive; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct SurfaceFullScreenExclusiveWin32InfoEXT<'a> { @@ -117,6 +144,30 @@ pub(crate) mod reexport { pub hmonitor: crate::platform_types::HMONITOR, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for SurfaceFullScreenExclusiveWin32InfoEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT; + } + unsafe impl<'a> crate::Extends> + for SurfaceFullScreenExclusiveWin32InfoEXT<'a> {} + unsafe impl<'a> crate::Extends> + for SurfaceFullScreenExclusiveWin32InfoEXT<'a> {} + impl<'a> Default for SurfaceFullScreenExclusiveWin32InfoEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + hmonitor: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> SurfaceFullScreenExclusiveWin32InfoEXT<'a> { + pub fn hmonitor(mut self, hmonitor: crate::platform_types::HMONITOR) -> Self { + self.hmonitor = hmonitor; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct SurfaceCapabilitiesFullScreenExclusiveEXT<'a> { @@ -125,6 +176,32 @@ pub(crate) mod reexport { pub full_screen_exclusive_supported: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for SurfaceCapabilitiesFullScreenExclusiveEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT; + } + unsafe impl<'a> crate::Extends> + for SurfaceCapabilitiesFullScreenExclusiveEXT<'a> {} + impl<'a> Default for SurfaceCapabilitiesFullScreenExclusiveEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + full_screen_exclusive_supported: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> SurfaceCapabilitiesFullScreenExclusiveEXT<'a> { + pub fn full_screen_exclusive_supported( + mut self, + full_screen_exclusive_supported: bool, + ) -> Self { + self.full_screen_exclusive_supported = full_screen_exclusive_supported + .into(); + self + } + } ///Provided by [`ext::full_screen_exclusive`](crate::ext::full_screen_exclusive) impl crate::vk::StructureType { pub const SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT: Self = Self(1000255000); diff --git a/ash-rewrite/src/generated/ext/graphics_pipeline_library.rs b/ash-rewrite/src/generated/ext/graphics_pipeline_library.rs index 7ef3094ad..b1706c8e9 100644 --- a/ash-rewrite/src/generated/ext/graphics_pipeline_library.rs +++ b/ash-rewrite/src/generated/ext/graphics_pipeline_library.rs @@ -9,6 +9,30 @@ pub struct PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT<'a> { pub graphics_pipeline_library: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT<'a> {} +impl<'a> Default for PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + graphics_pipeline_library: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT<'a> { + pub fn graphics_pipeline_library(mut self, graphics_pipeline_library: bool) -> Self { + self.graphics_pipeline_library = graphics_pipeline_library.into(); + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT<'a> { @@ -18,6 +42,41 @@ pub struct PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT<'a> { pub graphics_pipeline_library_independent_interpolation_decoration: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT<'a> {} +impl<'a> Default for PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + graphics_pipeline_library_fast_linking: Default::default(), + graphics_pipeline_library_independent_interpolation_decoration: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT<'a> { + pub fn graphics_pipeline_library_fast_linking( + mut self, + graphics_pipeline_library_fast_linking: bool, + ) -> Self { + self.graphics_pipeline_library_fast_linking = graphics_pipeline_library_fast_linking + .into(); + self + } + pub fn graphics_pipeline_library_independent_interpolation_decoration( + mut self, + graphics_pipeline_library_independent_interpolation_decoration: bool, + ) -> Self { + self.graphics_pipeline_library_independent_interpolation_decoration = graphics_pipeline_library_independent_interpolation_decoration + .into(); + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct GraphicsPipelineLibraryCreateInfoEXT<'a> { @@ -26,6 +85,27 @@ pub struct GraphicsPipelineLibraryCreateInfoEXT<'a> { pub flags: crate::vk::GraphicsPipelineLibraryFlagsEXT, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> for GraphicsPipelineLibraryCreateInfoEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT; +} +unsafe impl<'a> crate::Extends> +for GraphicsPipelineLibraryCreateInfoEXT<'a> {} +impl<'a> Default for GraphicsPipelineLibraryCreateInfoEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + flags: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> GraphicsPipelineLibraryCreateInfoEXT<'a> { + pub fn flags(mut self, flags: crate::vk::GraphicsPipelineLibraryFlagsEXT) -> Self { + self.flags = flags; + self + } +} ///Provided by [`ext::graphics_pipeline_library`](crate::ext::graphics_pipeline_library) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT: Self = Self( @@ -125,7 +205,7 @@ impl core::ops::Not for GraphicsPipelineLibraryFlagsEXT { } } #[repr(transparent)] -#[derive(Clone, Copy)] +#[derive(Clone, Copy, Default)] pub struct GraphicsPipelineLibraryFlagBitsEXT(pub(crate) u32); ///Provided by [`ext::graphics_pipeline_library`](crate::ext::graphics_pipeline_library) impl GraphicsPipelineLibraryFlagBitsEXT { diff --git a/ash-rewrite/src/generated/ext/hdr_metadata.rs b/ash-rewrite/src/generated/ext/hdr_metadata.rs index 4423354b6..7864aabf8 100644 --- a/ash-rewrite/src/generated/ext/hdr_metadata.rs +++ b/ash-rewrite/src/generated/ext/hdr_metadata.rs @@ -38,11 +38,21 @@ impl DeviceFn { } pub(crate) mod reexport { #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct XYColorEXT { pub x: core::ffi::c_float, pub y: core::ffi::c_float, } + impl XYColorEXT { + pub fn x(mut self, x: core::ffi::c_float) -> Self { + self.x = x; + self + } + pub fn y(mut self, y: core::ffi::c_float) -> Self { + self.y = y; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct HdrMetadataEXT<'a> { @@ -58,6 +68,75 @@ pub(crate) mod reexport { pub max_frame_average_light_level: core::ffi::c_float, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for HdrMetadataEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::HDR_METADATA_EXT; + } + impl<'a> Default for HdrMetadataEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + display_primary_red: Default::default(), + display_primary_green: Default::default(), + display_primary_blue: Default::default(), + white_point: Default::default(), + max_luminance: Default::default(), + min_luminance: Default::default(), + max_content_light_level: Default::default(), + max_frame_average_light_level: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> HdrMetadataEXT<'a> { + pub fn display_primary_red( + mut self, + display_primary_red: crate::vk::XYColorEXT, + ) -> Self { + self.display_primary_red = display_primary_red; + self + } + pub fn display_primary_green( + mut self, + display_primary_green: crate::vk::XYColorEXT, + ) -> Self { + self.display_primary_green = display_primary_green; + self + } + pub fn display_primary_blue( + mut self, + display_primary_blue: crate::vk::XYColorEXT, + ) -> Self { + self.display_primary_blue = display_primary_blue; + self + } + pub fn white_point(mut self, white_point: crate::vk::XYColorEXT) -> Self { + self.white_point = white_point; + self + } + pub fn max_luminance(mut self, max_luminance: core::ffi::c_float) -> Self { + self.max_luminance = max_luminance; + self + } + pub fn min_luminance(mut self, min_luminance: core::ffi::c_float) -> Self { + self.min_luminance = min_luminance; + self + } + pub fn max_content_light_level( + mut self, + max_content_light_level: core::ffi::c_float, + ) -> Self { + self.max_content_light_level = max_content_light_level; + self + } + pub fn max_frame_average_light_level( + mut self, + max_frame_average_light_level: core::ffi::c_float, + ) -> Self { + self.max_frame_average_light_level = max_frame_average_light_level; + self + } + } ///Provided by [`ext::hdr_metadata`](crate::ext::hdr_metadata) impl crate::vk::StructureType { pub const HDR_METADATA_EXT: Self = Self(1000105000); diff --git a/ash-rewrite/src/generated/ext/headless_surface.rs b/ash-rewrite/src/generated/ext/headless_surface.rs index e5ea85be1..78ff2cc34 100644 --- a/ash-rewrite/src/generated/ext/headless_surface.rs +++ b/ash-rewrite/src/generated/ext/headless_surface.rs @@ -45,6 +45,25 @@ pub(crate) mod reexport { pub flags: crate::vk::HeadlessSurfaceCreateFlagsEXT, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for HeadlessSurfaceCreateInfoEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::HEADLESS_SURFACE_CREATE_INFO_EXT; + } + impl<'a> Default for HeadlessSurfaceCreateInfoEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + flags: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> HeadlessSurfaceCreateInfoEXT<'a> { + pub fn flags(mut self, flags: crate::vk::HeadlessSurfaceCreateFlagsEXT) -> Self { + self.flags = flags; + self + } + } ///Provided by [`ext::headless_surface`](crate::ext::headless_surface) impl crate::vk::StructureType { pub const HEADLESS_SURFACE_CREATE_INFO_EXT: Self = Self(1000256000); diff --git a/ash-rewrite/src/generated/ext/image_2d_view_of_3d.rs b/ash-rewrite/src/generated/ext/image_2d_view_of_3d.rs index b0d866e60..0300e926b 100644 --- a/ash-rewrite/src/generated/ext/image_2d_view_of_3d.rs +++ b/ash-rewrite/src/generated/ext/image_2d_view_of_3d.rs @@ -10,6 +10,35 @@ pub struct PhysicalDeviceImage2DViewOf3DFeaturesEXT<'a> { pub sampler2_d_view_of3_d: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceImage2DViewOf3DFeaturesEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceImage2DViewOf3DFeaturesEXT<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceImage2DViewOf3DFeaturesEXT<'a> {} +impl<'a> Default for PhysicalDeviceImage2DViewOf3DFeaturesEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + image2_d_view_of3_d: Default::default(), + sampler2_d_view_of3_d: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceImage2DViewOf3DFeaturesEXT<'a> { + pub fn image2_d_view_of3_d(mut self, image2_d_view_of3_d: bool) -> Self { + self.image2_d_view_of3_d = image2_d_view_of3_d.into(); + self + } + pub fn sampler2_d_view_of3_d(mut self, sampler2_d_view_of3_d: bool) -> Self { + self.sampler2_d_view_of3_d = sampler2_d_view_of3_d.into(); + self + } +} ///Provided by [`ext::image_2d_view_of_3d`](crate::ext::image_2d_view_of_3d) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT: Self = Self(1000393000); diff --git a/ash-rewrite/src/generated/ext/image_compression_control.rs b/ash-rewrite/src/generated/ext/image_compression_control.rs index e27ddc780..9e2e4ebcd 100644 --- a/ash-rewrite/src/generated/ext/image_compression_control.rs +++ b/ash-rewrite/src/generated/ext/image_compression_control.rs @@ -11,6 +11,48 @@ pub struct ImageCompressionControlEXT<'a> { pub p_fixed_rate_flags: *mut crate::vk::ImageCompressionFixedRateFlagsEXT, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> for ImageCompressionControlEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::IMAGE_COMPRESSION_CONTROL_EXT; +} +unsafe impl<'a> crate::Extends> +for ImageCompressionControlEXT<'a> {} +unsafe impl<'a> crate::Extends> +for ImageCompressionControlEXT<'a> {} +unsafe impl<'a> crate::Extends> +for ImageCompressionControlEXT<'a> {} +impl<'a> Default for ImageCompressionControlEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + flags: Default::default(), + compression_control_plane_count: Default::default(), + p_fixed_rate_flags: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> ImageCompressionControlEXT<'a> { + pub fn flags(mut self, flags: crate::vk::ImageCompressionFlagsEXT) -> Self { + self.flags = flags; + self + } + pub fn compression_control_plane_count( + mut self, + compression_control_plane_count: u32, + ) -> Self { + self.compression_control_plane_count = compression_control_plane_count; + self + } + pub fn p_fixed_rate_flags( + mut self, + p_fixed_rate_flags: &'a mut [crate::vk::ImageCompressionFixedRateFlagsEXT], + ) -> Self { + self.compression_control_plane_count = p_fixed_rate_flags.len() as _; + self.p_fixed_rate_flags = p_fixed_rate_flags.as_mut_ptr(); + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceImageCompressionControlFeaturesEXT<'a> { @@ -19,6 +61,30 @@ pub struct PhysicalDeviceImageCompressionControlFeaturesEXT<'a> { pub image_compression_control: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceImageCompressionControlFeaturesEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceImageCompressionControlFeaturesEXT<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceImageCompressionControlFeaturesEXT<'a> {} +impl<'a> Default for PhysicalDeviceImageCompressionControlFeaturesEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + image_compression_control: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceImageCompressionControlFeaturesEXT<'a> { + pub fn image_compression_control(mut self, image_compression_control: bool) -> Self { + self.image_compression_control = image_compression_control.into(); + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct ImageCompressionPropertiesEXT<'a> { @@ -28,6 +94,42 @@ pub struct ImageCompressionPropertiesEXT<'a> { pub image_compression_fixed_rate_flags: crate::vk::ImageCompressionFixedRateFlagsEXT, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> for ImageCompressionPropertiesEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::IMAGE_COMPRESSION_PROPERTIES_EXT; +} +unsafe impl<'a> crate::Extends> +for ImageCompressionPropertiesEXT<'a> {} +unsafe impl<'a> crate::Extends> +for ImageCompressionPropertiesEXT<'a> {} +unsafe impl<'a> crate::Extends> +for ImageCompressionPropertiesEXT<'a> {} +impl<'a> Default for ImageCompressionPropertiesEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + image_compression_flags: Default::default(), + image_compression_fixed_rate_flags: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> ImageCompressionPropertiesEXT<'a> { + pub fn image_compression_flags( + mut self, + image_compression_flags: crate::vk::ImageCompressionFlagsEXT, + ) -> Self { + self.image_compression_flags = image_compression_flags; + self + } + pub fn image_compression_fixed_rate_flags( + mut self, + image_compression_fixed_rate_flags: crate::vk::ImageCompressionFixedRateFlagsEXT, + ) -> Self { + self.image_compression_fixed_rate_flags = image_compression_fixed_rate_flags; + self + } +} ///Provided by [`ext::image_compression_control`](crate::ext::image_compression_control) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT: Self = Self( @@ -118,7 +220,7 @@ impl core::ops::Not for ImageCompressionFlagsEXT { } } #[repr(transparent)] -#[derive(Clone, Copy)] +#[derive(Clone, Copy, Default)] pub struct ImageCompressionFlagBitsEXT(pub(crate) u32); ///Provided by [`ext::image_compression_control`](crate::ext::image_compression_control) impl ImageCompressionFlagBitsEXT { @@ -250,7 +352,7 @@ impl core::ops::Not for ImageCompressionFixedRateFlagsEXT { } } #[repr(transparent)] -#[derive(Clone, Copy)] +#[derive(Clone, Copy, Default)] pub struct ImageCompressionFixedRateFlagBitsEXT(pub(crate) u32); ///Provided by [`ext::image_compression_control`](crate::ext::image_compression_control) impl ImageCompressionFixedRateFlagBitsEXT { diff --git a/ash-rewrite/src/generated/ext/image_compression_control_swapchain.rs b/ash-rewrite/src/generated/ext/image_compression_control_swapchain.rs index 78a0f086e..76835c48b 100644 --- a/ash-rewrite/src/generated/ext/image_compression_control_swapchain.rs +++ b/ash-rewrite/src/generated/ext/image_compression_control_swapchain.rs @@ -9,6 +9,34 @@ pub struct PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT<'a> { pub image_compression_control_swapchain: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT<'a> {} +impl<'a> Default for PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + image_compression_control_swapchain: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT<'a> { + pub fn image_compression_control_swapchain( + mut self, + image_compression_control_swapchain: bool, + ) -> Self { + self.image_compression_control_swapchain = image_compression_control_swapchain + .into(); + self + } +} ///Provided by [`ext::image_compression_control_swapchain`](crate::ext::image_compression_control_swapchain) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT: Self = Self( diff --git a/ash-rewrite/src/generated/ext/image_drm_format_modifier.rs b/ash-rewrite/src/generated/ext/image_drm_format_modifier.rs index fc9515478..a7526b85a 100644 --- a/ash-rewrite/src/generated/ext/image_drm_format_modifier.rs +++ b/ash-rewrite/src/generated/ext/image_drm_format_modifier.rs @@ -45,13 +45,68 @@ pub(crate) mod reexport { pub p_drm_format_modifier_properties: *mut crate::vk::DrmFormatModifierPropertiesEXT, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for DrmFormatModifierPropertiesListEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT; + } + unsafe impl<'a> crate::Extends> + for DrmFormatModifierPropertiesListEXT<'a> {} + impl<'a> Default for DrmFormatModifierPropertiesListEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + drm_format_modifier_count: Default::default(), + p_drm_format_modifier_properties: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> DrmFormatModifierPropertiesListEXT<'a> { + pub fn drm_format_modifier_count( + mut self, + drm_format_modifier_count: u32, + ) -> Self { + self.drm_format_modifier_count = drm_format_modifier_count; + self + } + pub fn p_drm_format_modifier_properties( + mut self, + p_drm_format_modifier_properties: &'a mut [crate::vk::DrmFormatModifierPropertiesEXT], + ) -> Self { + self.drm_format_modifier_count = p_drm_format_modifier_properties.len() as _; + self.p_drm_format_modifier_properties = p_drm_format_modifier_properties + .as_mut_ptr(); + self + } + } #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct DrmFormatModifierPropertiesEXT { pub drm_format_modifier: u64, pub drm_format_modifier_plane_count: u32, pub drm_format_modifier_tiling_features: crate::vk::FormatFeatureFlags, } + impl DrmFormatModifierPropertiesEXT { + pub fn drm_format_modifier(mut self, drm_format_modifier: u64) -> Self { + self.drm_format_modifier = drm_format_modifier; + self + } + pub fn drm_format_modifier_plane_count( + mut self, + drm_format_modifier_plane_count: u32, + ) -> Self { + self.drm_format_modifier_plane_count = drm_format_modifier_plane_count; + self + } + pub fn drm_format_modifier_tiling_features( + mut self, + drm_format_modifier_tiling_features: crate::vk::FormatFeatureFlags, + ) -> Self { + self.drm_format_modifier_tiling_features = drm_format_modifier_tiling_features; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceImageDrmFormatModifierInfoEXT<'a> { @@ -63,6 +118,50 @@ pub(crate) mod reexport { pub p_queue_family_indices: *const u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceImageDrmFormatModifierInfoEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceImageDrmFormatModifierInfoEXT<'a> {} + impl<'a> Default for PhysicalDeviceImageDrmFormatModifierInfoEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + drm_format_modifier: Default::default(), + sharing_mode: Default::default(), + queue_family_index_count: Default::default(), + p_queue_family_indices: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceImageDrmFormatModifierInfoEXT<'a> { + pub fn drm_format_modifier(mut self, drm_format_modifier: u64) -> Self { + self.drm_format_modifier = drm_format_modifier; + self + } + pub fn sharing_mode(mut self, sharing_mode: crate::vk::SharingMode) -> Self { + self.sharing_mode = sharing_mode; + self + } + pub fn queue_family_index_count( + mut self, + queue_family_index_count: u32, + ) -> Self { + self.queue_family_index_count = queue_family_index_count; + self + } + pub fn p_queue_family_indices( + mut self, + p_queue_family_indices: &'a [u32], + ) -> Self { + self.queue_family_index_count = p_queue_family_indices.len() as _; + self.p_queue_family_indices = p_queue_family_indices.as_ptr(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct ImageDrmFormatModifierListCreateInfoEXT<'a> { @@ -72,6 +171,40 @@ pub(crate) mod reexport { pub p_drm_format_modifiers: *const u64, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for ImageDrmFormatModifierListCreateInfoEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT; + } + unsafe impl<'a> crate::Extends> + for ImageDrmFormatModifierListCreateInfoEXT<'a> {} + impl<'a> Default for ImageDrmFormatModifierListCreateInfoEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + drm_format_modifier_count: Default::default(), + p_drm_format_modifiers: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> ImageDrmFormatModifierListCreateInfoEXT<'a> { + pub fn drm_format_modifier_count( + mut self, + drm_format_modifier_count: u32, + ) -> Self { + self.drm_format_modifier_count = drm_format_modifier_count; + self + } + pub fn p_drm_format_modifiers( + mut self, + p_drm_format_modifiers: &'a [u64], + ) -> Self { + self.drm_format_modifier_count = p_drm_format_modifiers.len() as _; + self.p_drm_format_modifiers = p_drm_format_modifiers.as_ptr(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct ImageDrmFormatModifierExplicitCreateInfoEXT<'a> { @@ -82,6 +215,45 @@ pub(crate) mod reexport { pub p_plane_layouts: *const crate::vk::SubresourceLayout, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for ImageDrmFormatModifierExplicitCreateInfoEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT; + } + unsafe impl<'a> crate::Extends> + for ImageDrmFormatModifierExplicitCreateInfoEXT<'a> {} + impl<'a> Default for ImageDrmFormatModifierExplicitCreateInfoEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + drm_format_modifier: Default::default(), + drm_format_modifier_plane_count: Default::default(), + p_plane_layouts: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> ImageDrmFormatModifierExplicitCreateInfoEXT<'a> { + pub fn drm_format_modifier(mut self, drm_format_modifier: u64) -> Self { + self.drm_format_modifier = drm_format_modifier; + self + } + pub fn drm_format_modifier_plane_count( + mut self, + drm_format_modifier_plane_count: u32, + ) -> Self { + self.drm_format_modifier_plane_count = drm_format_modifier_plane_count; + self + } + pub fn p_plane_layouts( + mut self, + p_plane_layouts: &'a [crate::vk::SubresourceLayout], + ) -> Self { + self.drm_format_modifier_plane_count = p_plane_layouts.len() as _; + self.p_plane_layouts = p_plane_layouts.as_ptr(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct ImageDrmFormatModifierPropertiesEXT<'a> { @@ -90,6 +262,26 @@ pub(crate) mod reexport { pub drm_format_modifier: u64, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for ImageDrmFormatModifierPropertiesEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT; + } + impl<'a> Default for ImageDrmFormatModifierPropertiesEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + drm_format_modifier: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> ImageDrmFormatModifierPropertiesEXT<'a> { + pub fn drm_format_modifier(mut self, drm_format_modifier: u64) -> Self { + self.drm_format_modifier = drm_format_modifier; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct DrmFormatModifierPropertiesList2EXT<'a> { @@ -99,13 +291,68 @@ pub(crate) mod reexport { pub p_drm_format_modifier_properties: *mut crate::vk::DrmFormatModifierProperties2EXT, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for DrmFormatModifierPropertiesList2EXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT; + } + unsafe impl<'a> crate::Extends> + for DrmFormatModifierPropertiesList2EXT<'a> {} + impl<'a> Default for DrmFormatModifierPropertiesList2EXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + drm_format_modifier_count: Default::default(), + p_drm_format_modifier_properties: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> DrmFormatModifierPropertiesList2EXT<'a> { + pub fn drm_format_modifier_count( + mut self, + drm_format_modifier_count: u32, + ) -> Self { + self.drm_format_modifier_count = drm_format_modifier_count; + self + } + pub fn p_drm_format_modifier_properties( + mut self, + p_drm_format_modifier_properties: &'a mut [crate::vk::DrmFormatModifierProperties2EXT], + ) -> Self { + self.drm_format_modifier_count = p_drm_format_modifier_properties.len() as _; + self.p_drm_format_modifier_properties = p_drm_format_modifier_properties + .as_mut_ptr(); + self + } + } #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct DrmFormatModifierProperties2EXT { pub drm_format_modifier: u64, pub drm_format_modifier_plane_count: u32, pub drm_format_modifier_tiling_features: crate::vk::FormatFeatureFlags2, } + impl DrmFormatModifierProperties2EXT { + pub fn drm_format_modifier(mut self, drm_format_modifier: u64) -> Self { + self.drm_format_modifier = drm_format_modifier; + self + } + pub fn drm_format_modifier_plane_count( + mut self, + drm_format_modifier_plane_count: u32, + ) -> Self { + self.drm_format_modifier_plane_count = drm_format_modifier_plane_count; + self + } + pub fn drm_format_modifier_tiling_features( + mut self, + drm_format_modifier_tiling_features: crate::vk::FormatFeatureFlags2, + ) -> Self { + self.drm_format_modifier_tiling_features = drm_format_modifier_tiling_features; + self + } + } ///Provided by [`ext::image_drm_format_modifier`](crate::ext::image_drm_format_modifier) impl crate::vk::ImageTiling { pub const DRM_FORMAT_MODIFIER_EXT: Self = Self(1000158000); diff --git a/ash-rewrite/src/generated/ext/image_sliced_view_of_3d.rs b/ash-rewrite/src/generated/ext/image_sliced_view_of_3d.rs index aba650b96..36c5c2706 100644 --- a/ash-rewrite/src/generated/ext/image_sliced_view_of_3d.rs +++ b/ash-rewrite/src/generated/ext/image_sliced_view_of_3d.rs @@ -10,6 +10,32 @@ pub struct ImageViewSlicedCreateInfoEXT<'a> { pub slice_count: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> for ImageViewSlicedCreateInfoEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::IMAGE_VIEW_SLICED_CREATE_INFO_EXT; +} +unsafe impl<'a> crate::Extends> +for ImageViewSlicedCreateInfoEXT<'a> {} +impl<'a> Default for ImageViewSlicedCreateInfoEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + slice_offset: Default::default(), + slice_count: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> ImageViewSlicedCreateInfoEXT<'a> { + pub fn slice_offset(mut self, slice_offset: u32) -> Self { + self.slice_offset = slice_offset; + self + } + pub fn slice_count(mut self, slice_count: u32) -> Self { + self.slice_count = slice_count; + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceImageSlicedViewOf3DFeaturesEXT<'a> { @@ -18,6 +44,30 @@ pub struct PhysicalDeviceImageSlicedViewOf3DFeaturesEXT<'a> { pub image_sliced_view_of3_d: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceImageSlicedViewOf3DFeaturesEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceImageSlicedViewOf3DFeaturesEXT<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceImageSlicedViewOf3DFeaturesEXT<'a> {} +impl<'a> Default for PhysicalDeviceImageSlicedViewOf3DFeaturesEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + image_sliced_view_of3_d: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceImageSlicedViewOf3DFeaturesEXT<'a> { + pub fn image_sliced_view_of3_d(mut self, image_sliced_view_of3_d: bool) -> Self { + self.image_sliced_view_of3_d = image_sliced_view_of3_d.into(); + self + } +} ///Provided by [`ext::image_sliced_view_of_3d`](crate::ext::image_sliced_view_of_3d) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT: Self = Self( diff --git a/ash-rewrite/src/generated/ext/image_view_min_lod.rs b/ash-rewrite/src/generated/ext/image_view_min_lod.rs index 0765c4b3f..99157f33f 100644 --- a/ash-rewrite/src/generated/ext/image_view_min_lod.rs +++ b/ash-rewrite/src/generated/ext/image_view_min_lod.rs @@ -9,6 +9,30 @@ pub struct PhysicalDeviceImageViewMinLodFeaturesEXT<'a> { pub min_lod: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceImageViewMinLodFeaturesEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceImageViewMinLodFeaturesEXT<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceImageViewMinLodFeaturesEXT<'a> {} +impl<'a> Default for PhysicalDeviceImageViewMinLodFeaturesEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + min_lod: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceImageViewMinLodFeaturesEXT<'a> { + pub fn min_lod(mut self, min_lod: bool) -> Self { + self.min_lod = min_lod.into(); + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct ImageViewMinLodCreateInfoEXT<'a> { @@ -17,6 +41,27 @@ pub struct ImageViewMinLodCreateInfoEXT<'a> { pub min_lod: core::ffi::c_float, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> for ImageViewMinLodCreateInfoEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT; +} +unsafe impl<'a> crate::Extends> +for ImageViewMinLodCreateInfoEXT<'a> {} +impl<'a> Default for ImageViewMinLodCreateInfoEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + min_lod: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> ImageViewMinLodCreateInfoEXT<'a> { + pub fn min_lod(mut self, min_lod: core::ffi::c_float) -> Self { + self.min_lod = min_lod; + self + } +} ///Provided by [`ext::image_view_min_lod`](crate::ext::image_view_min_lod) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT: Self = Self(1000391000); diff --git a/ash-rewrite/src/generated/ext/layer_settings.rs b/ash-rewrite/src/generated/ext/layer_settings.rs index 391db4a4f..53c1be0b5 100644 --- a/ash-rewrite/src/generated/ext/layer_settings.rs +++ b/ash-rewrite/src/generated/ext/layer_settings.rs @@ -10,8 +10,38 @@ pub struct LayerSettingsCreateInfoEXT<'a> { pub p_settings: *const crate::vk::LayerSettingEXT<'a>, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> for LayerSettingsCreateInfoEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::LAYER_SETTINGS_CREATE_INFO_EXT; +} +unsafe impl<'a> crate::Extends> +for LayerSettingsCreateInfoEXT<'a> {} +impl<'a> Default for LayerSettingsCreateInfoEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + setting_count: Default::default(), + p_settings: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> LayerSettingsCreateInfoEXT<'a> { + pub fn setting_count(mut self, setting_count: u32) -> Self { + self.setting_count = setting_count; + self + } + pub fn p_settings( + mut self, + p_settings: &'a [crate::vk::LayerSettingEXT<'a>], + ) -> Self { + self.setting_count = p_settings.len() as _; + self.p_settings = p_settings.as_ptr(); + self + } +} #[repr(C)] -#[derive(Clone, Copy)] +#[derive(Clone, Copy, Default)] pub struct LayerSettingEXT<'a> { pub p_layer_name: *const core::ffi::c_char, pub p_setting_name: *const core::ffi::c_char, @@ -20,6 +50,43 @@ pub struct LayerSettingEXT<'a> { pub p_values: *const core::ffi::c_void, pub _marker: ::core::marker::PhantomData<&'a ()>, } +impl<'a> LayerSettingEXT<'a> { + pub fn p_layer_name(mut self, p_layer_name: &'a core::ffi::CStr) -> Self { + self.p_layer_name = p_layer_name.as_ptr(); + self + } + pub unsafe fn p_layer_name_as_c_str(&self) -> Option<&core::ffi::CStr> { + if self.p_layer_name.is_null() { + None + } else { + Some(unsafe { core::ffi::CStr::from_ptr(self.p_layer_name) }) + } + } + pub fn p_setting_name(mut self, p_setting_name: &'a core::ffi::CStr) -> Self { + self.p_setting_name = p_setting_name.as_ptr(); + self + } + pub unsafe fn p_setting_name_as_c_str(&self) -> Option<&core::ffi::CStr> { + if self.p_setting_name.is_null() { + None + } else { + Some(unsafe { core::ffi::CStr::from_ptr(self.p_setting_name) }) + } + } + pub fn _type(mut self, _type: crate::vk::LayerSettingTypeEXT) -> Self { + self._type = _type; + self + } + pub fn value_count(mut self, value_count: u32) -> Self { + self.value_count = value_count; + self + } + pub fn p_values(mut self, p_values: &'a [u8]) -> Self { + self.value_count = p_values.len() as _; + self.p_values = p_values.as_ptr().cast(); + self + } +} ///Provided by [`ext::layer_settings`](crate::ext::layer_settings) impl crate::vk::StructureType { pub const LAYER_SETTINGS_CREATE_INFO_EXT: Self = Self(1000496000); diff --git a/ash-rewrite/src/generated/ext/legacy_dithering.rs b/ash-rewrite/src/generated/ext/legacy_dithering.rs index 256d2e2e0..aef284e32 100644 --- a/ash-rewrite/src/generated/ext/legacy_dithering.rs +++ b/ash-rewrite/src/generated/ext/legacy_dithering.rs @@ -9,6 +9,30 @@ pub struct PhysicalDeviceLegacyDitheringFeaturesEXT<'a> { pub legacy_dithering: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceLegacyDitheringFeaturesEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceLegacyDitheringFeaturesEXT<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceLegacyDitheringFeaturesEXT<'a> {} +impl<'a> Default for PhysicalDeviceLegacyDitheringFeaturesEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + legacy_dithering: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceLegacyDitheringFeaturesEXT<'a> { + pub fn legacy_dithering(mut self, legacy_dithering: bool) -> Self { + self.legacy_dithering = legacy_dithering.into(); + self + } +} ///Provided by [`ext::legacy_dithering`](crate::ext::legacy_dithering) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT: Self = Self(1000465000); diff --git a/ash-rewrite/src/generated/ext/legacy_vertex_attributes.rs b/ash-rewrite/src/generated/ext/legacy_vertex_attributes.rs index d0dacfe32..991a71eb0 100644 --- a/ash-rewrite/src/generated/ext/legacy_vertex_attributes.rs +++ b/ash-rewrite/src/generated/ext/legacy_vertex_attributes.rs @@ -9,6 +9,30 @@ pub struct PhysicalDeviceLegacyVertexAttributesFeaturesEXT<'a> { pub legacy_vertex_attributes: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceLegacyVertexAttributesFeaturesEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_FEATURES_EXT; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceLegacyVertexAttributesFeaturesEXT<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceLegacyVertexAttributesFeaturesEXT<'a> {} +impl<'a> Default for PhysicalDeviceLegacyVertexAttributesFeaturesEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + legacy_vertex_attributes: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceLegacyVertexAttributesFeaturesEXT<'a> { + pub fn legacy_vertex_attributes(mut self, legacy_vertex_attributes: bool) -> Self { + self.legacy_vertex_attributes = legacy_vertex_attributes.into(); + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceLegacyVertexAttributesPropertiesEXT<'a> { @@ -17,6 +41,31 @@ pub struct PhysicalDeviceLegacyVertexAttributesPropertiesEXT<'a> { pub native_unaligned_performance: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceLegacyVertexAttributesPropertiesEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_PROPERTIES_EXT; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceLegacyVertexAttributesPropertiesEXT<'a> {} +impl<'a> Default for PhysicalDeviceLegacyVertexAttributesPropertiesEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + native_unaligned_performance: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceLegacyVertexAttributesPropertiesEXT<'a> { + pub fn native_unaligned_performance( + mut self, + native_unaligned_performance: bool, + ) -> Self { + self.native_unaligned_performance = native_unaligned_performance.into(); + self + } +} ///Provided by [`ext::legacy_vertex_attributes`](crate::ext::legacy_vertex_attributes) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_FEATURES_EXT: Self = Self( diff --git a/ash-rewrite/src/generated/ext/map_memory_placed.rs b/ash-rewrite/src/generated/ext/map_memory_placed.rs index c66c41461..bc7d016b3 100644 --- a/ash-rewrite/src/generated/ext/map_memory_placed.rs +++ b/ash-rewrite/src/generated/ext/map_memory_placed.rs @@ -11,6 +11,40 @@ pub struct PhysicalDeviceMapMemoryPlacedFeaturesEXT<'a> { pub memory_unmap_reserve: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceMapMemoryPlacedFeaturesEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceMapMemoryPlacedFeaturesEXT<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceMapMemoryPlacedFeaturesEXT<'a> {} +impl<'a> Default for PhysicalDeviceMapMemoryPlacedFeaturesEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + memory_map_placed: Default::default(), + memory_map_range_placed: Default::default(), + memory_unmap_reserve: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceMapMemoryPlacedFeaturesEXT<'a> { + pub fn memory_map_placed(mut self, memory_map_placed: bool) -> Self { + self.memory_map_placed = memory_map_placed.into(); + self + } + pub fn memory_map_range_placed(mut self, memory_map_range_placed: bool) -> Self { + self.memory_map_range_placed = memory_map_range_placed.into(); + self + } + pub fn memory_unmap_reserve(mut self, memory_unmap_reserve: bool) -> Self { + self.memory_unmap_reserve = memory_unmap_reserve.into(); + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceMapMemoryPlacedPropertiesEXT<'a> { @@ -19,6 +53,31 @@ pub struct PhysicalDeviceMapMemoryPlacedPropertiesEXT<'a> { pub min_placed_memory_map_alignment: crate::vk::DeviceSize, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceMapMemoryPlacedPropertiesEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_MAP_MEMORY_PLACED_PROPERTIES_EXT; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceMapMemoryPlacedPropertiesEXT<'a> {} +impl<'a> Default for PhysicalDeviceMapMemoryPlacedPropertiesEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + min_placed_memory_map_alignment: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceMapMemoryPlacedPropertiesEXT<'a> { + pub fn min_placed_memory_map_alignment( + mut self, + min_placed_memory_map_alignment: crate::vk::DeviceSize, + ) -> Self { + self.min_placed_memory_map_alignment = min_placed_memory_map_alignment; + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct MemoryMapPlacedInfoEXT<'a> { @@ -27,6 +86,30 @@ pub struct MemoryMapPlacedInfoEXT<'a> { pub p_placed_address: *mut core::ffi::c_void, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> for MemoryMapPlacedInfoEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::MEMORY_MAP_PLACED_INFO_EXT; +} +unsafe impl<'a> crate::Extends> +for MemoryMapPlacedInfoEXT<'a> {} +impl<'a> Default for MemoryMapPlacedInfoEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + p_placed_address: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> MemoryMapPlacedInfoEXT<'a> { + pub fn p_placed_address( + mut self, + p_placed_address: &'a mut core::ffi::c_void, + ) -> Self { + self.p_placed_address = p_placed_address; + self + } +} ///Provided by [`ext::map_memory_placed`](crate::ext::map_memory_placed) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT: Self = Self(1000272000); diff --git a/ash-rewrite/src/generated/ext/memory_budget.rs b/ash-rewrite/src/generated/ext/memory_budget.rs index c7bfbd0fc..4f493b8dd 100644 --- a/ash-rewrite/src/generated/ext/memory_budget.rs +++ b/ash-rewrite/src/generated/ext/memory_budget.rs @@ -10,6 +10,39 @@ pub struct PhysicalDeviceMemoryBudgetPropertiesEXT<'a> { pub heap_usage: [crate::vk::DeviceSize; crate::vk::MAX_MEMORY_HEAPS as _], pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceMemoryBudgetPropertiesEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceMemoryBudgetPropertiesEXT<'a> {} +impl<'a> Default for PhysicalDeviceMemoryBudgetPropertiesEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + heap_budget: unsafe { core::mem::zeroed() }, + heap_usage: unsafe { core::mem::zeroed() }, + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceMemoryBudgetPropertiesEXT<'a> { + pub fn heap_budget( + mut self, + heap_budget: [crate::vk::DeviceSize; crate::vk::MAX_MEMORY_HEAPS as _], + ) -> Self { + self.heap_budget = heap_budget; + self + } + pub fn heap_usage( + mut self, + heap_usage: [crate::vk::DeviceSize; crate::vk::MAX_MEMORY_HEAPS as _], + ) -> Self { + self.heap_usage = heap_usage; + self + } +} ///Provided by [`ext::memory_budget`](crate::ext::memory_budget) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT: Self = Self(1000237000); diff --git a/ash-rewrite/src/generated/ext/memory_decompression.rs b/ash-rewrite/src/generated/ext/memory_decompression.rs index 2938795e5..435bddd8f 100644 --- a/ash-rewrite/src/generated/ext/memory_decompression.rs +++ b/ash-rewrite/src/generated/ext/memory_decompression.rs @@ -62,6 +62,30 @@ pub(crate) mod reexport { pub memory_decompression: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceMemoryDecompressionFeaturesEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_EXT; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceMemoryDecompressionFeaturesEXT<'a> {} + unsafe impl<'a> crate::Extends> + for PhysicalDeviceMemoryDecompressionFeaturesEXT<'a> {} + impl<'a> Default for PhysicalDeviceMemoryDecompressionFeaturesEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + memory_decompression: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceMemoryDecompressionFeaturesEXT<'a> { + pub fn memory_decompression(mut self, memory_decompression: bool) -> Self { + self.memory_decompression = memory_decompression.into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceMemoryDecompressionPropertiesEXT<'a> { @@ -71,14 +95,71 @@ pub(crate) mod reexport { pub max_decompression_indirect_count: u64, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceMemoryDecompressionPropertiesEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_EXT; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceMemoryDecompressionPropertiesEXT<'a> {} + impl<'a> Default for PhysicalDeviceMemoryDecompressionPropertiesEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + decompression_methods: Default::default(), + max_decompression_indirect_count: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceMemoryDecompressionPropertiesEXT<'a> { + pub fn decompression_methods( + mut self, + decompression_methods: crate::vk::MemoryDecompressionMethodFlagsEXT, + ) -> Self { + self.decompression_methods = decompression_methods; + self + } + pub fn max_decompression_indirect_count( + mut self, + max_decompression_indirect_count: u64, + ) -> Self { + self.max_decompression_indirect_count = max_decompression_indirect_count; + self + } + } #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct DecompressMemoryRegionEXT { pub src_address: crate::vk::DeviceAddress, pub dst_address: crate::vk::DeviceAddress, pub compressed_size: crate::vk::DeviceSize, pub decompressed_size: crate::vk::DeviceSize, } + impl DecompressMemoryRegionEXT { + pub fn src_address(mut self, src_address: crate::vk::DeviceAddress) -> Self { + self.src_address = src_address; + self + } + pub fn dst_address(mut self, dst_address: crate::vk::DeviceAddress) -> Self { + self.dst_address = dst_address; + self + } + pub fn compressed_size( + mut self, + compressed_size: crate::vk::DeviceSize, + ) -> Self { + self.compressed_size = compressed_size; + self + } + pub fn decompressed_size( + mut self, + decompressed_size: crate::vk::DeviceSize, + ) -> Self { + self.decompressed_size = decompressed_size; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct DecompressMemoryInfoEXT<'a> { @@ -89,6 +170,42 @@ pub(crate) mod reexport { pub p_regions: *const crate::vk::DecompressMemoryRegionEXT, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for DecompressMemoryInfoEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::DECOMPRESS_MEMORY_INFO_EXT; + } + impl<'a> Default for DecompressMemoryInfoEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + decompression_method: Default::default(), + region_count: Default::default(), + p_regions: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> DecompressMemoryInfoEXT<'a> { + pub fn decompression_method( + mut self, + decompression_method: crate::vk::MemoryDecompressionMethodFlagsEXT, + ) -> Self { + self.decompression_method = decompression_method; + self + } + pub fn region_count(mut self, region_count: u32) -> Self { + self.region_count = region_count; + self + } + pub fn p_regions( + mut self, + p_regions: &'a [crate::vk::DecompressMemoryRegionEXT], + ) -> Self { + self.region_count = p_regions.len() as _; + self.p_regions = p_regions.as_ptr(); + self + } + } ///Provided by [`ext::memory_decompression`](crate::ext::memory_decompression) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_EXT: Self = Self( @@ -182,7 +299,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct MemoryDecompressionMethodFlagBitsEXT(pub(crate) u64); ///Provided by [`ext::memory_decompression`](crate::ext::memory_decompression) impl MemoryDecompressionMethodFlagBitsEXT { diff --git a/ash-rewrite/src/generated/ext/memory_priority.rs b/ash-rewrite/src/generated/ext/memory_priority.rs index 2b8b339d0..de96a929a 100644 --- a/ash-rewrite/src/generated/ext/memory_priority.rs +++ b/ash-rewrite/src/generated/ext/memory_priority.rs @@ -9,6 +9,30 @@ pub struct PhysicalDeviceMemoryPriorityFeaturesEXT<'a> { pub memory_priority: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceMemoryPriorityFeaturesEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceMemoryPriorityFeaturesEXT<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceMemoryPriorityFeaturesEXT<'a> {} +impl<'a> Default for PhysicalDeviceMemoryPriorityFeaturesEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + memory_priority: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceMemoryPriorityFeaturesEXT<'a> { + pub fn memory_priority(mut self, memory_priority: bool) -> Self { + self.memory_priority = memory_priority.into(); + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct MemoryPriorityAllocateInfoEXT<'a> { @@ -17,6 +41,27 @@ pub struct MemoryPriorityAllocateInfoEXT<'a> { pub priority: core::ffi::c_float, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> for MemoryPriorityAllocateInfoEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::MEMORY_PRIORITY_ALLOCATE_INFO_EXT; +} +unsafe impl<'a> crate::Extends> +for MemoryPriorityAllocateInfoEXT<'a> {} +impl<'a> Default for MemoryPriorityAllocateInfoEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + priority: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> MemoryPriorityAllocateInfoEXT<'a> { + pub fn priority(mut self, priority: core::ffi::c_float) -> Self { + self.priority = priority; + self + } +} ///Provided by [`ext::memory_priority`](crate::ext::memory_priority) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT: Self = Self(1000238000); diff --git a/ash-rewrite/src/generated/ext/mesh_shader.rs b/ash-rewrite/src/generated/ext/mesh_shader.rs index 522eb7e27..bd1d08876 100644 --- a/ash-rewrite/src/generated/ext/mesh_shader.rs +++ b/ash-rewrite/src/generated/ext/mesh_shader.rs @@ -87,6 +87,54 @@ pub(crate) mod reexport { pub mesh_shader_queries: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceMeshShaderFeaturesEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceMeshShaderFeaturesEXT<'a> {} + unsafe impl<'a> crate::Extends> + for PhysicalDeviceMeshShaderFeaturesEXT<'a> {} + impl<'a> Default for PhysicalDeviceMeshShaderFeaturesEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + task_shader: Default::default(), + mesh_shader: Default::default(), + multiview_mesh_shader: Default::default(), + primitive_fragment_shading_rate_mesh_shader: Default::default(), + mesh_shader_queries: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceMeshShaderFeaturesEXT<'a> { + pub fn task_shader(mut self, task_shader: bool) -> Self { + self.task_shader = task_shader.into(); + self + } + pub fn mesh_shader(mut self, mesh_shader: bool) -> Self { + self.mesh_shader = mesh_shader.into(); + self + } + pub fn multiview_mesh_shader(mut self, multiview_mesh_shader: bool) -> Self { + self.multiview_mesh_shader = multiview_mesh_shader.into(); + self + } + pub fn primitive_fragment_shading_rate_mesh_shader( + mut self, + primitive_fragment_shading_rate_mesh_shader: bool, + ) -> Self { + self.primitive_fragment_shading_rate_mesh_shader = primitive_fragment_shading_rate_mesh_shader + .into(); + self + } + pub fn mesh_shader_queries(mut self, mesh_shader_queries: bool) -> Self { + self.mesh_shader_queries = mesh_shader_queries.into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceMeshShaderPropertiesEXT<'a> { @@ -122,13 +170,265 @@ pub(crate) mod reexport { pub prefers_compact_primitive_output: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceMeshShaderPropertiesEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceMeshShaderPropertiesEXT<'a> {} + impl<'a> Default for PhysicalDeviceMeshShaderPropertiesEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + max_task_work_group_total_count: Default::default(), + max_task_work_group_count: unsafe { core::mem::zeroed() }, + max_task_work_group_invocations: Default::default(), + max_task_work_group_size: unsafe { core::mem::zeroed() }, + max_task_payload_size: Default::default(), + max_task_shared_memory_size: Default::default(), + max_task_payload_and_shared_memory_size: Default::default(), + max_mesh_work_group_total_count: Default::default(), + max_mesh_work_group_count: unsafe { core::mem::zeroed() }, + max_mesh_work_group_invocations: Default::default(), + max_mesh_work_group_size: unsafe { core::mem::zeroed() }, + max_mesh_shared_memory_size: Default::default(), + max_mesh_payload_and_shared_memory_size: Default::default(), + max_mesh_output_memory_size: Default::default(), + max_mesh_payload_and_output_memory_size: Default::default(), + max_mesh_output_components: Default::default(), + max_mesh_output_vertices: Default::default(), + max_mesh_output_primitives: Default::default(), + max_mesh_output_layers: Default::default(), + max_mesh_multiview_view_count: Default::default(), + mesh_output_per_vertex_granularity: Default::default(), + mesh_output_per_primitive_granularity: Default::default(), + max_preferred_task_work_group_invocations: Default::default(), + max_preferred_mesh_work_group_invocations: Default::default(), + prefers_local_invocation_vertex_output: Default::default(), + prefers_local_invocation_primitive_output: Default::default(), + prefers_compact_vertex_output: Default::default(), + prefers_compact_primitive_output: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceMeshShaderPropertiesEXT<'a> { + pub fn max_task_work_group_total_count( + mut self, + max_task_work_group_total_count: u32, + ) -> Self { + self.max_task_work_group_total_count = max_task_work_group_total_count; + self + } + pub fn max_task_work_group_count( + mut self, + max_task_work_group_count: [u32; 3 as _], + ) -> Self { + self.max_task_work_group_count = max_task_work_group_count; + self + } + pub fn max_task_work_group_invocations( + mut self, + max_task_work_group_invocations: u32, + ) -> Self { + self.max_task_work_group_invocations = max_task_work_group_invocations; + self + } + pub fn max_task_work_group_size( + mut self, + max_task_work_group_size: [u32; 3 as _], + ) -> Self { + self.max_task_work_group_size = max_task_work_group_size; + self + } + pub fn max_task_payload_size(mut self, max_task_payload_size: u32) -> Self { + self.max_task_payload_size = max_task_payload_size; + self + } + pub fn max_task_shared_memory_size( + mut self, + max_task_shared_memory_size: u32, + ) -> Self { + self.max_task_shared_memory_size = max_task_shared_memory_size; + self + } + pub fn max_task_payload_and_shared_memory_size( + mut self, + max_task_payload_and_shared_memory_size: u32, + ) -> Self { + self.max_task_payload_and_shared_memory_size = max_task_payload_and_shared_memory_size; + self + } + pub fn max_mesh_work_group_total_count( + mut self, + max_mesh_work_group_total_count: u32, + ) -> Self { + self.max_mesh_work_group_total_count = max_mesh_work_group_total_count; + self + } + pub fn max_mesh_work_group_count( + mut self, + max_mesh_work_group_count: [u32; 3 as _], + ) -> Self { + self.max_mesh_work_group_count = max_mesh_work_group_count; + self + } + pub fn max_mesh_work_group_invocations( + mut self, + max_mesh_work_group_invocations: u32, + ) -> Self { + self.max_mesh_work_group_invocations = max_mesh_work_group_invocations; + self + } + pub fn max_mesh_work_group_size( + mut self, + max_mesh_work_group_size: [u32; 3 as _], + ) -> Self { + self.max_mesh_work_group_size = max_mesh_work_group_size; + self + } + pub fn max_mesh_shared_memory_size( + mut self, + max_mesh_shared_memory_size: u32, + ) -> Self { + self.max_mesh_shared_memory_size = max_mesh_shared_memory_size; + self + } + pub fn max_mesh_payload_and_shared_memory_size( + mut self, + max_mesh_payload_and_shared_memory_size: u32, + ) -> Self { + self.max_mesh_payload_and_shared_memory_size = max_mesh_payload_and_shared_memory_size; + self + } + pub fn max_mesh_output_memory_size( + mut self, + max_mesh_output_memory_size: u32, + ) -> Self { + self.max_mesh_output_memory_size = max_mesh_output_memory_size; + self + } + pub fn max_mesh_payload_and_output_memory_size( + mut self, + max_mesh_payload_and_output_memory_size: u32, + ) -> Self { + self.max_mesh_payload_and_output_memory_size = max_mesh_payload_and_output_memory_size; + self + } + pub fn max_mesh_output_components( + mut self, + max_mesh_output_components: u32, + ) -> Self { + self.max_mesh_output_components = max_mesh_output_components; + self + } + pub fn max_mesh_output_vertices( + mut self, + max_mesh_output_vertices: u32, + ) -> Self { + self.max_mesh_output_vertices = max_mesh_output_vertices; + self + } + pub fn max_mesh_output_primitives( + mut self, + max_mesh_output_primitives: u32, + ) -> Self { + self.max_mesh_output_primitives = max_mesh_output_primitives; + self + } + pub fn max_mesh_output_layers(mut self, max_mesh_output_layers: u32) -> Self { + self.max_mesh_output_layers = max_mesh_output_layers; + self + } + pub fn max_mesh_multiview_view_count( + mut self, + max_mesh_multiview_view_count: u32, + ) -> Self { + self.max_mesh_multiview_view_count = max_mesh_multiview_view_count; + self + } + pub fn mesh_output_per_vertex_granularity( + mut self, + mesh_output_per_vertex_granularity: u32, + ) -> Self { + self.mesh_output_per_vertex_granularity = mesh_output_per_vertex_granularity; + self + } + pub fn mesh_output_per_primitive_granularity( + mut self, + mesh_output_per_primitive_granularity: u32, + ) -> Self { + self.mesh_output_per_primitive_granularity = mesh_output_per_primitive_granularity; + self + } + pub fn max_preferred_task_work_group_invocations( + mut self, + max_preferred_task_work_group_invocations: u32, + ) -> Self { + self.max_preferred_task_work_group_invocations = max_preferred_task_work_group_invocations; + self + } + pub fn max_preferred_mesh_work_group_invocations( + mut self, + max_preferred_mesh_work_group_invocations: u32, + ) -> Self { + self.max_preferred_mesh_work_group_invocations = max_preferred_mesh_work_group_invocations; + self + } + pub fn prefers_local_invocation_vertex_output( + mut self, + prefers_local_invocation_vertex_output: bool, + ) -> Self { + self.prefers_local_invocation_vertex_output = prefers_local_invocation_vertex_output + .into(); + self + } + pub fn prefers_local_invocation_primitive_output( + mut self, + prefers_local_invocation_primitive_output: bool, + ) -> Self { + self.prefers_local_invocation_primitive_output = prefers_local_invocation_primitive_output + .into(); + self + } + pub fn prefers_compact_vertex_output( + mut self, + prefers_compact_vertex_output: bool, + ) -> Self { + self.prefers_compact_vertex_output = prefers_compact_vertex_output.into(); + self + } + pub fn prefers_compact_primitive_output( + mut self, + prefers_compact_primitive_output: bool, + ) -> Self { + self.prefers_compact_primitive_output = prefers_compact_primitive_output + .into(); + self + } + } #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct DrawMeshTasksIndirectCommandEXT { pub group_count_x: u32, pub group_count_y: u32, pub group_count_z: u32, } + impl DrawMeshTasksIndirectCommandEXT { + pub fn group_count_x(mut self, group_count_x: u32) -> Self { + self.group_count_x = group_count_x; + self + } + pub fn group_count_y(mut self, group_count_y: u32) -> Self { + self.group_count_y = group_count_y; + self + } + pub fn group_count_z(mut self, group_count_z: u32) -> Self { + self.group_count_z = group_count_z; + self + } + } ///Provided by [`ext::mesh_shader`](crate::ext::mesh_shader) impl crate::vk::QueryType { pub const MESH_PRIMITIVES_GENERATED_EXT: Self = Self(1000328000); diff --git a/ash-rewrite/src/generated/ext/metal_objects.rs b/ash-rewrite/src/generated/ext/metal_objects.rs index f5d104c7e..984435aea 100644 --- a/ash-rewrite/src/generated/ext/metal_objects.rs +++ b/ash-rewrite/src/generated/ext/metal_objects.rs @@ -43,6 +43,42 @@ pub(crate) mod reexport { pub export_object_type: crate::vk::ExportMetalObjectTypeFlagBitsEXT, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for ExportMetalObjectCreateInfoEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::EXPORT_METAL_OBJECT_CREATE_INFO_EXT; + } + unsafe impl<'a> crate::Extends> + for ExportMetalObjectCreateInfoEXT<'a> {} + unsafe impl<'a> crate::Extends> + for ExportMetalObjectCreateInfoEXT<'a> {} + unsafe impl<'a> crate::Extends> + for ExportMetalObjectCreateInfoEXT<'a> {} + unsafe impl<'a> crate::Extends> + for ExportMetalObjectCreateInfoEXT<'a> {} + unsafe impl<'a> crate::Extends> + for ExportMetalObjectCreateInfoEXT<'a> {} + unsafe impl<'a> crate::Extends> + for ExportMetalObjectCreateInfoEXT<'a> {} + unsafe impl<'a> crate::Extends> + for ExportMetalObjectCreateInfoEXT<'a> {} + impl<'a> Default for ExportMetalObjectCreateInfoEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + export_object_type: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> ExportMetalObjectCreateInfoEXT<'a> { + pub fn export_object_type( + mut self, + export_object_type: crate::vk::ExportMetalObjectTypeFlagBitsEXT, + ) -> Self { + self.export_object_type = export_object_type; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct ExportMetalObjectsInfoEXT<'a> { @@ -50,6 +86,19 @@ pub(crate) mod reexport { pub p_next: *const core::ffi::c_void, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for ExportMetalObjectsInfoEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::EXPORT_METAL_OBJECTS_INFO_EXT; + } + impl<'a> Default for ExportMetalObjectsInfoEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> ExportMetalObjectsInfoEXT<'a> {} #[repr(C)] #[derive(Clone, Copy)] pub struct ExportMetalDeviceInfoEXT<'a> { @@ -58,6 +107,30 @@ pub(crate) mod reexport { pub mtl_device: crate::platform_types::MTLDevice_id, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for ExportMetalDeviceInfoEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::EXPORT_METAL_DEVICE_INFO_EXT; + } + unsafe impl<'a> crate::Extends> + for ExportMetalDeviceInfoEXT<'a> {} + impl<'a> Default for ExportMetalDeviceInfoEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + mtl_device: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> ExportMetalDeviceInfoEXT<'a> { + pub fn mtl_device( + mut self, + mtl_device: crate::platform_types::MTLDevice_id, + ) -> Self { + self.mtl_device = mtl_device; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct ExportMetalCommandQueueInfoEXT<'a> { @@ -67,6 +140,35 @@ pub(crate) mod reexport { pub mtl_command_queue: crate::platform_types::MTLCommandQueue_id, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for ExportMetalCommandQueueInfoEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::EXPORT_METAL_COMMAND_QUEUE_INFO_EXT; + } + unsafe impl<'a> crate::Extends> + for ExportMetalCommandQueueInfoEXT<'a> {} + impl<'a> Default for ExportMetalCommandQueueInfoEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + queue: Default::default(), + mtl_command_queue: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> ExportMetalCommandQueueInfoEXT<'a> { + pub fn queue(mut self, queue: crate::vk::Queue) -> Self { + self.queue = queue; + self + } + pub fn mtl_command_queue( + mut self, + mtl_command_queue: crate::platform_types::MTLCommandQueue_id, + ) -> Self { + self.mtl_command_queue = mtl_command_queue; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct ExportMetalBufferInfoEXT<'a> { @@ -76,6 +178,35 @@ pub(crate) mod reexport { pub mtl_buffer: crate::platform_types::MTLBuffer_id, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for ExportMetalBufferInfoEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::EXPORT_METAL_BUFFER_INFO_EXT; + } + unsafe impl<'a> crate::Extends> + for ExportMetalBufferInfoEXT<'a> {} + impl<'a> Default for ExportMetalBufferInfoEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + memory: Default::default(), + mtl_buffer: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> ExportMetalBufferInfoEXT<'a> { + pub fn memory(mut self, memory: crate::vk::DeviceMemory) -> Self { + self.memory = memory; + self + } + pub fn mtl_buffer( + mut self, + mtl_buffer: crate::platform_types::MTLBuffer_id, + ) -> Self { + self.mtl_buffer = mtl_buffer; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct ImportMetalBufferInfoEXT<'a> { @@ -84,6 +215,30 @@ pub(crate) mod reexport { pub mtl_buffer: crate::platform_types::MTLBuffer_id, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for ImportMetalBufferInfoEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::IMPORT_METAL_BUFFER_INFO_EXT; + } + unsafe impl<'a> crate::Extends> + for ImportMetalBufferInfoEXT<'a> {} + impl<'a> Default for ImportMetalBufferInfoEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + mtl_buffer: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> ImportMetalBufferInfoEXT<'a> { + pub fn mtl_buffer( + mut self, + mtl_buffer: crate::platform_types::MTLBuffer_id, + ) -> Self { + self.mtl_buffer = mtl_buffer; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct ExportMetalTextureInfoEXT<'a> { @@ -96,6 +251,50 @@ pub(crate) mod reexport { pub mtl_texture: crate::platform_types::MTLTexture_id, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for ExportMetalTextureInfoEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::EXPORT_METAL_TEXTURE_INFO_EXT; + } + unsafe impl<'a> crate::Extends> + for ExportMetalTextureInfoEXT<'a> {} + impl<'a> Default for ExportMetalTextureInfoEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + image: Default::default(), + image_view: Default::default(), + buffer_view: Default::default(), + plane: Default::default(), + mtl_texture: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> ExportMetalTextureInfoEXT<'a> { + pub fn image(mut self, image: crate::vk::Image) -> Self { + self.image = image; + self + } + pub fn image_view(mut self, image_view: crate::vk::ImageView) -> Self { + self.image_view = image_view; + self + } + pub fn buffer_view(mut self, buffer_view: crate::vk::BufferView) -> Self { + self.buffer_view = buffer_view; + self + } + pub fn plane(mut self, plane: crate::vk::ImageAspectFlagBits) -> Self { + self.plane = plane; + self + } + pub fn mtl_texture( + mut self, + mtl_texture: crate::platform_types::MTLTexture_id, + ) -> Self { + self.mtl_texture = mtl_texture; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct ImportMetalTextureInfoEXT<'a> { @@ -105,6 +304,35 @@ pub(crate) mod reexport { pub mtl_texture: crate::platform_types::MTLTexture_id, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for ImportMetalTextureInfoEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::IMPORT_METAL_TEXTURE_INFO_EXT; + } + unsafe impl<'a> crate::Extends> + for ImportMetalTextureInfoEXT<'a> {} + impl<'a> Default for ImportMetalTextureInfoEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + plane: Default::default(), + mtl_texture: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> ImportMetalTextureInfoEXT<'a> { + pub fn plane(mut self, plane: crate::vk::ImageAspectFlagBits) -> Self { + self.plane = plane; + self + } + pub fn mtl_texture( + mut self, + mtl_texture: crate::platform_types::MTLTexture_id, + ) -> Self { + self.mtl_texture = mtl_texture; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct ExportMetalIOSurfaceInfoEXT<'a> { @@ -114,6 +342,35 @@ pub(crate) mod reexport { pub io_surface: crate::platform_types::IOSurfaceRef, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for ExportMetalIOSurfaceInfoEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::EXPORT_METAL_IO_SURFACE_INFO_EXT; + } + unsafe impl<'a> crate::Extends> + for ExportMetalIOSurfaceInfoEXT<'a> {} + impl<'a> Default for ExportMetalIOSurfaceInfoEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + image: Default::default(), + io_surface: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> ExportMetalIOSurfaceInfoEXT<'a> { + pub fn image(mut self, image: crate::vk::Image) -> Self { + self.image = image; + self + } + pub fn io_surface( + mut self, + io_surface: crate::platform_types::IOSurfaceRef, + ) -> Self { + self.io_surface = io_surface; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct ImportMetalIOSurfaceInfoEXT<'a> { @@ -122,6 +379,30 @@ pub(crate) mod reexport { pub io_surface: crate::platform_types::IOSurfaceRef, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for ImportMetalIOSurfaceInfoEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::IMPORT_METAL_IO_SURFACE_INFO_EXT; + } + unsafe impl<'a> crate::Extends> + for ImportMetalIOSurfaceInfoEXT<'a> {} + impl<'a> Default for ImportMetalIOSurfaceInfoEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + io_surface: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> ImportMetalIOSurfaceInfoEXT<'a> { + pub fn io_surface( + mut self, + io_surface: crate::platform_types::IOSurfaceRef, + ) -> Self { + self.io_surface = io_surface; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct ExportMetalSharedEventInfoEXT<'a> { @@ -132,6 +413,40 @@ pub(crate) mod reexport { pub mtl_shared_event: crate::platform_types::MTLSharedEvent_id, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for ExportMetalSharedEventInfoEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::EXPORT_METAL_SHARED_EVENT_INFO_EXT; + } + unsafe impl<'a> crate::Extends> + for ExportMetalSharedEventInfoEXT<'a> {} + impl<'a> Default for ExportMetalSharedEventInfoEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + semaphore: Default::default(), + event: Default::default(), + mtl_shared_event: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> ExportMetalSharedEventInfoEXT<'a> { + pub fn semaphore(mut self, semaphore: crate::vk::Semaphore) -> Self { + self.semaphore = semaphore; + self + } + pub fn event(mut self, event: crate::vk::Event) -> Self { + self.event = event; + self + } + pub fn mtl_shared_event( + mut self, + mtl_shared_event: crate::platform_types::MTLSharedEvent_id, + ) -> Self { + self.mtl_shared_event = mtl_shared_event; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct ImportMetalSharedEventInfoEXT<'a> { @@ -140,6 +455,32 @@ pub(crate) mod reexport { pub mtl_shared_event: crate::platform_types::MTLSharedEvent_id, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for ImportMetalSharedEventInfoEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::IMPORT_METAL_SHARED_EVENT_INFO_EXT; + } + unsafe impl<'a> crate::Extends> + for ImportMetalSharedEventInfoEXT<'a> {} + unsafe impl<'a> crate::Extends> + for ImportMetalSharedEventInfoEXT<'a> {} + impl<'a> Default for ImportMetalSharedEventInfoEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + mtl_shared_event: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> ImportMetalSharedEventInfoEXT<'a> { + pub fn mtl_shared_event( + mut self, + mtl_shared_event: crate::platform_types::MTLSharedEvent_id, + ) -> Self { + self.mtl_shared_event = mtl_shared_event; + self + } + } ///Provided by [`ext::metal_objects`](crate::ext::metal_objects) impl crate::vk::StructureType { pub const EXPORT_METAL_OBJECT_CREATE_INFO_EXT: Self = Self(1000311000); @@ -241,7 +582,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct ExportMetalObjectTypeFlagBitsEXT(pub(crate) u32); ///Provided by [`ext::metal_objects`](crate::ext::metal_objects) impl ExportMetalObjectTypeFlagBitsEXT { diff --git a/ash-rewrite/src/generated/ext/metal_surface.rs b/ash-rewrite/src/generated/ext/metal_surface.rs index b977c8de4..814a763cb 100644 --- a/ash-rewrite/src/generated/ext/metal_surface.rs +++ b/ash-rewrite/src/generated/ext/metal_surface.rs @@ -46,6 +46,33 @@ pub(crate) mod reexport { pub p_layer: *const crate::platform_types::CAMetalLayer, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for MetalSurfaceCreateInfoEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::METAL_SURFACE_CREATE_INFO_EXT; + } + impl<'a> Default for MetalSurfaceCreateInfoEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + flags: Default::default(), + p_layer: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> MetalSurfaceCreateInfoEXT<'a> { + pub fn flags(mut self, flags: crate::vk::MetalSurfaceCreateFlagsEXT) -> Self { + self.flags = flags; + self + } + pub fn p_layer( + mut self, + p_layer: &'a crate::platform_types::CAMetalLayer, + ) -> Self { + self.p_layer = p_layer; + self + } + } ///Provided by [`ext::metal_surface`](crate::ext::metal_surface) impl crate::vk::StructureType { pub const METAL_SURFACE_CREATE_INFO_EXT: Self = Self(1000217000); diff --git a/ash-rewrite/src/generated/ext/multi_draw.rs b/ash-rewrite/src/generated/ext/multi_draw.rs index 9aa6f90bf..f6d221f67 100644 --- a/ash-rewrite/src/generated/ext/multi_draw.rs +++ b/ash-rewrite/src/generated/ext/multi_draw.rs @@ -60,18 +60,42 @@ impl DeviceFn { } pub(crate) mod reexport { #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct MultiDrawInfoEXT { pub first_vertex: u32, pub vertex_count: u32, } + impl MultiDrawInfoEXT { + pub fn first_vertex(mut self, first_vertex: u32) -> Self { + self.first_vertex = first_vertex; + self + } + pub fn vertex_count(mut self, vertex_count: u32) -> Self { + self.vertex_count = vertex_count; + self + } + } #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct MultiDrawIndexedInfoEXT { pub first_index: u32, pub index_count: u32, pub vertex_offset: i32, } + impl MultiDrawIndexedInfoEXT { + pub fn first_index(mut self, first_index: u32) -> Self { + self.first_index = first_index; + self + } + pub fn index_count(mut self, index_count: u32) -> Self { + self.index_count = index_count; + self + } + pub fn vertex_offset(mut self, vertex_offset: i32) -> Self { + self.vertex_offset = vertex_offset; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceMultiDrawPropertiesEXT<'a> { @@ -80,6 +104,28 @@ pub(crate) mod reexport { pub max_multi_draw_count: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceMultiDrawPropertiesEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceMultiDrawPropertiesEXT<'a> {} + impl<'a> Default for PhysicalDeviceMultiDrawPropertiesEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + max_multi_draw_count: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceMultiDrawPropertiesEXT<'a> { + pub fn max_multi_draw_count(mut self, max_multi_draw_count: u32) -> Self { + self.max_multi_draw_count = max_multi_draw_count; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceMultiDrawFeaturesEXT<'a> { @@ -88,6 +134,30 @@ pub(crate) mod reexport { pub multi_draw: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceMultiDrawFeaturesEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceMultiDrawFeaturesEXT<'a> {} + unsafe impl<'a> crate::Extends> + for PhysicalDeviceMultiDrawFeaturesEXT<'a> {} + impl<'a> Default for PhysicalDeviceMultiDrawFeaturesEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + multi_draw: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceMultiDrawFeaturesEXT<'a> { + pub fn multi_draw(mut self, multi_draw: bool) -> Self { + self.multi_draw = multi_draw.into(); + self + } + } ///Provided by [`ext::multi_draw`](crate::ext::multi_draw) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT: Self = Self(1000392000); diff --git a/ash-rewrite/src/generated/ext/multisampled_render_to_single_sampled.rs b/ash-rewrite/src/generated/ext/multisampled_render_to_single_sampled.rs index 97b984a01..fbd5da123 100644 --- a/ash-rewrite/src/generated/ext/multisampled_render_to_single_sampled.rs +++ b/ash-rewrite/src/generated/ext/multisampled_render_to_single_sampled.rs @@ -9,6 +9,34 @@ pub struct PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT<'a> { pub multisampled_render_to_single_sampled: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT<'a> {} +impl<'a> Default for PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + multisampled_render_to_single_sampled: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT<'a> { + pub fn multisampled_render_to_single_sampled( + mut self, + multisampled_render_to_single_sampled: bool, + ) -> Self { + self.multisampled_render_to_single_sampled = multisampled_render_to_single_sampled + .into(); + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct SubpassResolvePerformanceQueryEXT<'a> { @@ -17,6 +45,27 @@ pub struct SubpassResolvePerformanceQueryEXT<'a> { pub optimal: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> for SubpassResolvePerformanceQueryEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT; +} +unsafe impl<'a> crate::Extends> +for SubpassResolvePerformanceQueryEXT<'a> {} +impl<'a> Default for SubpassResolvePerformanceQueryEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + optimal: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> SubpassResolvePerformanceQueryEXT<'a> { + pub fn optimal(mut self, optimal: bool) -> Self { + self.optimal = optimal.into(); + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct MultisampledRenderToSingleSampledInfoEXT<'a> { @@ -26,6 +75,42 @@ pub struct MultisampledRenderToSingleSampledInfoEXT<'a> { pub rasterization_samples: crate::vk::SampleCountFlagBits, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for MultisampledRenderToSingleSampledInfoEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT; +} +unsafe impl<'a> crate::Extends> +for MultisampledRenderToSingleSampledInfoEXT<'a> {} +unsafe impl<'a> crate::Extends> +for MultisampledRenderToSingleSampledInfoEXT<'a> {} +impl<'a> Default for MultisampledRenderToSingleSampledInfoEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + multisampled_render_to_single_sampled_enable: Default::default(), + rasterization_samples: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> MultisampledRenderToSingleSampledInfoEXT<'a> { + pub fn multisampled_render_to_single_sampled_enable( + mut self, + multisampled_render_to_single_sampled_enable: bool, + ) -> Self { + self.multisampled_render_to_single_sampled_enable = multisampled_render_to_single_sampled_enable + .into(); + self + } + pub fn rasterization_samples( + mut self, + rasterization_samples: crate::vk::SampleCountFlagBits, + ) -> Self { + self.rasterization_samples = rasterization_samples; + self + } +} ///Provided by [`ext::multisampled_render_to_single_sampled`](crate::ext::multisampled_render_to_single_sampled) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT: Self = Self( diff --git a/ash-rewrite/src/generated/ext/mutable_descriptor_type.rs b/ash-rewrite/src/generated/ext/mutable_descriptor_type.rs index 1b15c5d90..ceac8930a 100644 --- a/ash-rewrite/src/generated/ext/mutable_descriptor_type.rs +++ b/ash-rewrite/src/generated/ext/mutable_descriptor_type.rs @@ -9,13 +9,51 @@ pub struct PhysicalDeviceMutableDescriptorTypeFeaturesEXT<'a> { pub mutable_descriptor_type: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceMutableDescriptorTypeFeaturesEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceMutableDescriptorTypeFeaturesEXT<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceMutableDescriptorTypeFeaturesEXT<'a> {} +impl<'a> Default for PhysicalDeviceMutableDescriptorTypeFeaturesEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + mutable_descriptor_type: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceMutableDescriptorTypeFeaturesEXT<'a> { + pub fn mutable_descriptor_type(mut self, mutable_descriptor_type: bool) -> Self { + self.mutable_descriptor_type = mutable_descriptor_type.into(); + self + } +} #[repr(C)] -#[derive(Clone, Copy)] +#[derive(Clone, Copy, Default)] pub struct MutableDescriptorTypeListEXT<'a> { pub descriptor_type_count: u32, pub p_descriptor_types: *const crate::vk::DescriptorType, pub _marker: ::core::marker::PhantomData<&'a ()>, } +impl<'a> MutableDescriptorTypeListEXT<'a> { + pub fn descriptor_type_count(mut self, descriptor_type_count: u32) -> Self { + self.descriptor_type_count = descriptor_type_count; + self + } + pub fn p_descriptor_types( + mut self, + p_descriptor_types: &'a [crate::vk::DescriptorType], + ) -> Self { + self.descriptor_type_count = p_descriptor_types.len() as _; + self.p_descriptor_types = p_descriptor_types.as_ptr(); + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct MutableDescriptorTypeCreateInfoEXT<'a> { @@ -27,6 +65,44 @@ pub struct MutableDescriptorTypeCreateInfoEXT<'a> { >, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> for MutableDescriptorTypeCreateInfoEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT; +} +unsafe impl<'a> crate::Extends> +for MutableDescriptorTypeCreateInfoEXT<'a> {} +unsafe impl<'a> crate::Extends> +for MutableDescriptorTypeCreateInfoEXT<'a> {} +impl<'a> Default for MutableDescriptorTypeCreateInfoEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + mutable_descriptor_type_list_count: Default::default(), + p_mutable_descriptor_type_lists: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> MutableDescriptorTypeCreateInfoEXT<'a> { + pub fn mutable_descriptor_type_list_count( + mut self, + mutable_descriptor_type_list_count: u32, + ) -> Self { + self.mutable_descriptor_type_list_count = mutable_descriptor_type_list_count; + self + } + pub fn p_mutable_descriptor_type_lists( + mut self, + p_mutable_descriptor_type_lists: &'a [crate::vk::MutableDescriptorTypeListEXT< + 'a, + >], + ) -> Self { + self.mutable_descriptor_type_list_count = p_mutable_descriptor_type_lists.len() + as _; + self.p_mutable_descriptor_type_lists = p_mutable_descriptor_type_lists.as_ptr(); + self + } +} ///Provided by [`ext::mutable_descriptor_type`](crate::ext::mutable_descriptor_type) impl crate::vk::DescriptorType { pub const MUTABLE_EXT: Self = Self(1000351000); diff --git a/ash-rewrite/src/generated/ext/nested_command_buffer.rs b/ash-rewrite/src/generated/ext/nested_command_buffer.rs index 7116e18c2..f0a3685ca 100644 --- a/ash-rewrite/src/generated/ext/nested_command_buffer.rs +++ b/ash-rewrite/src/generated/ext/nested_command_buffer.rs @@ -11,6 +11,47 @@ pub struct PhysicalDeviceNestedCommandBufferFeaturesEXT<'a> { pub nested_command_buffer_simultaneous_use: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceNestedCommandBufferFeaturesEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_FEATURES_EXT; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceNestedCommandBufferFeaturesEXT<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceNestedCommandBufferFeaturesEXT<'a> {} +impl<'a> Default for PhysicalDeviceNestedCommandBufferFeaturesEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + nested_command_buffer: Default::default(), + nested_command_buffer_rendering: Default::default(), + nested_command_buffer_simultaneous_use: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceNestedCommandBufferFeaturesEXT<'a> { + pub fn nested_command_buffer(mut self, nested_command_buffer: bool) -> Self { + self.nested_command_buffer = nested_command_buffer.into(); + self + } + pub fn nested_command_buffer_rendering( + mut self, + nested_command_buffer_rendering: bool, + ) -> Self { + self.nested_command_buffer_rendering = nested_command_buffer_rendering.into(); + self + } + pub fn nested_command_buffer_simultaneous_use( + mut self, + nested_command_buffer_simultaneous_use: bool, + ) -> Self { + self.nested_command_buffer_simultaneous_use = nested_command_buffer_simultaneous_use + .into(); + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceNestedCommandBufferPropertiesEXT<'a> { @@ -19,6 +60,31 @@ pub struct PhysicalDeviceNestedCommandBufferPropertiesEXT<'a> { pub max_command_buffer_nesting_level: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceNestedCommandBufferPropertiesEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_PROPERTIES_EXT; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceNestedCommandBufferPropertiesEXT<'a> {} +impl<'a> Default for PhysicalDeviceNestedCommandBufferPropertiesEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + max_command_buffer_nesting_level: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceNestedCommandBufferPropertiesEXT<'a> { + pub fn max_command_buffer_nesting_level( + mut self, + max_command_buffer_nesting_level: u32, + ) -> Self { + self.max_command_buffer_nesting_level = max_command_buffer_nesting_level; + self + } +} ///Provided by [`ext::nested_command_buffer`](crate::ext::nested_command_buffer) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_FEATURES_EXT: Self = Self( diff --git a/ash-rewrite/src/generated/ext/non_seamless_cube_map.rs b/ash-rewrite/src/generated/ext/non_seamless_cube_map.rs index 6a4e53d9a..80ab6704c 100644 --- a/ash-rewrite/src/generated/ext/non_seamless_cube_map.rs +++ b/ash-rewrite/src/generated/ext/non_seamless_cube_map.rs @@ -9,6 +9,30 @@ pub struct PhysicalDeviceNonSeamlessCubeMapFeaturesEXT<'a> { pub non_seamless_cube_map: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceNonSeamlessCubeMapFeaturesEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceNonSeamlessCubeMapFeaturesEXT<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceNonSeamlessCubeMapFeaturesEXT<'a> {} +impl<'a> Default for PhysicalDeviceNonSeamlessCubeMapFeaturesEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + non_seamless_cube_map: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceNonSeamlessCubeMapFeaturesEXT<'a> { + pub fn non_seamless_cube_map(mut self, non_seamless_cube_map: bool) -> Self { + self.non_seamless_cube_map = non_seamless_cube_map.into(); + self + } +} ///Provided by [`ext::non_seamless_cube_map`](crate::ext::non_seamless_cube_map) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT: Self = Self( diff --git a/ash-rewrite/src/generated/ext/opacity_micromap.rs b/ash-rewrite/src/generated/ext/opacity_micromap.rs index 5239921ff..7ff13a987 100644 --- a/ash-rewrite/src/generated/ext/opacity_micromap.rs +++ b/ash-rewrite/src/generated/ext/opacity_micromap.rs @@ -269,6 +269,92 @@ pub(crate) mod reexport { pub triangle_array_stride: crate::vk::DeviceSize, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for MicromapBuildInfoEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::MICROMAP_BUILD_INFO_EXT; + } + impl<'a> Default for MicromapBuildInfoEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + _type: Default::default(), + flags: Default::default(), + mode: Default::default(), + dst_micromap: Default::default(), + usage_counts_count: Default::default(), + p_usage_counts: Default::default(), + pp_usage_counts: Default::default(), + data: Default::default(), + scratch_data: Default::default(), + triangle_array: Default::default(), + triangle_array_stride: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> MicromapBuildInfoEXT<'a> { + pub fn _type(mut self, _type: crate::vk::MicromapTypeEXT) -> Self { + self._type = _type; + self + } + pub fn flags(mut self, flags: crate::vk::BuildMicromapFlagsEXT) -> Self { + self.flags = flags; + self + } + pub fn mode(mut self, mode: crate::vk::BuildMicromapModeEXT) -> Self { + self.mode = mode; + self + } + pub fn dst_micromap(mut self, dst_micromap: crate::vk::MicromapEXT) -> Self { + self.dst_micromap = dst_micromap; + self + } + pub fn usage_counts_count(mut self, usage_counts_count: u32) -> Self { + self.usage_counts_count = usage_counts_count; + self + } + pub fn p_usage_counts( + mut self, + p_usage_counts: &'a [crate::vk::MicromapUsageEXT], + ) -> Self { + self.usage_counts_count = p_usage_counts.len() as _; + self.p_usage_counts = p_usage_counts.as_ptr(); + self + } + pub fn pp_usage_counts( + mut self, + pp_usage_counts: &'a [&'a crate::vk::MicromapUsageEXT], + ) -> Self { + self.usage_counts_count = pp_usage_counts.len() as _; + self.pp_usage_counts = pp_usage_counts.as_ptr().cast(); + self + } + pub fn data(mut self, data: crate::vk::DeviceOrHostAddressConstKHR) -> Self { + self.data = data; + self + } + pub fn scratch_data( + mut self, + scratch_data: crate::vk::DeviceOrHostAddressKHR, + ) -> Self { + self.scratch_data = scratch_data; + self + } + pub fn triangle_array( + mut self, + triangle_array: crate::vk::DeviceOrHostAddressConstKHR, + ) -> Self { + self.triangle_array = triangle_array; + self + } + pub fn triangle_array_stride( + mut self, + triangle_array_stride: crate::vk::DeviceSize, + ) -> Self { + self.triangle_array_stride = triangle_array_stride; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct MicromapCreateInfoEXT<'a> { @@ -282,6 +368,56 @@ pub(crate) mod reexport { pub device_address: crate::vk::DeviceAddress, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for MicromapCreateInfoEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::MICROMAP_CREATE_INFO_EXT; + } + impl<'a> Default for MicromapCreateInfoEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + create_flags: Default::default(), + buffer: Default::default(), + offset: Default::default(), + size: Default::default(), + _type: Default::default(), + device_address: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> MicromapCreateInfoEXT<'a> { + pub fn create_flags( + mut self, + create_flags: crate::vk::MicromapCreateFlagsEXT, + ) -> Self { + self.create_flags = create_flags; + self + } + pub fn buffer(mut self, buffer: crate::vk::Buffer) -> Self { + self.buffer = buffer; + self + } + pub fn offset(mut self, offset: crate::vk::DeviceSize) -> Self { + self.offset = offset; + self + } + pub fn size(mut self, size: crate::vk::DeviceSize) -> Self { + self.size = size; + self + } + pub fn _type(mut self, _type: crate::vk::MicromapTypeEXT) -> Self { + self._type = _type; + self + } + pub fn device_address( + mut self, + device_address: crate::vk::DeviceAddress, + ) -> Self { + self.device_address = device_address; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct MicromapVersionInfoEXT<'a> { @@ -290,6 +426,25 @@ pub(crate) mod reexport { pub p_version_data: *const u8, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for MicromapVersionInfoEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::MICROMAP_VERSION_INFO_EXT; + } + impl<'a> Default for MicromapVersionInfoEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + p_version_data: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> MicromapVersionInfoEXT<'a> { + pub fn p_version_data(mut self, p_version_data: *const u8) -> Self { + self.p_version_data = p_version_data; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct CopyMicromapInfoEXT<'a> { @@ -300,6 +455,35 @@ pub(crate) mod reexport { pub mode: crate::vk::CopyMicromapModeEXT, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for CopyMicromapInfoEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::COPY_MICROMAP_INFO_EXT; + } + impl<'a> Default for CopyMicromapInfoEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + src: Default::default(), + dst: Default::default(), + mode: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> CopyMicromapInfoEXT<'a> { + pub fn src(mut self, src: crate::vk::MicromapEXT) -> Self { + self.src = src; + self + } + pub fn dst(mut self, dst: crate::vk::MicromapEXT) -> Self { + self.dst = dst; + self + } + pub fn mode(mut self, mode: crate::vk::CopyMicromapModeEXT) -> Self { + self.mode = mode; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct CopyMicromapToMemoryInfoEXT<'a> { @@ -310,6 +494,35 @@ pub(crate) mod reexport { pub mode: crate::vk::CopyMicromapModeEXT, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for CopyMicromapToMemoryInfoEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::COPY_MICROMAP_TO_MEMORY_INFO_EXT; + } + impl<'a> Default for CopyMicromapToMemoryInfoEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + src: Default::default(), + dst: Default::default(), + mode: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> CopyMicromapToMemoryInfoEXT<'a> { + pub fn src(mut self, src: crate::vk::MicromapEXT) -> Self { + self.src = src; + self + } + pub fn dst(mut self, dst: crate::vk::DeviceOrHostAddressKHR) -> Self { + self.dst = dst; + self + } + pub fn mode(mut self, mode: crate::vk::CopyMicromapModeEXT) -> Self { + self.mode = mode; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct CopyMemoryToMicromapInfoEXT<'a> { @@ -320,6 +533,35 @@ pub(crate) mod reexport { pub mode: crate::vk::CopyMicromapModeEXT, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for CopyMemoryToMicromapInfoEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::COPY_MEMORY_TO_MICROMAP_INFO_EXT; + } + impl<'a> Default for CopyMemoryToMicromapInfoEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + src: Default::default(), + dst: Default::default(), + mode: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> CopyMemoryToMicromapInfoEXT<'a> { + pub fn src(mut self, src: crate::vk::DeviceOrHostAddressConstKHR) -> Self { + self.src = src; + self + } + pub fn dst(mut self, dst: crate::vk::MicromapEXT) -> Self { + self.dst = dst; + self + } + pub fn mode(mut self, mode: crate::vk::CopyMicromapModeEXT) -> Self { + self.mode = mode; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct MicromapBuildSizesInfoEXT<'a> { @@ -330,20 +572,80 @@ pub(crate) mod reexport { pub discardable: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for MicromapBuildSizesInfoEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::MICROMAP_BUILD_SIZES_INFO_EXT; + } + impl<'a> Default for MicromapBuildSizesInfoEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + micromap_size: Default::default(), + build_scratch_size: Default::default(), + discardable: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> MicromapBuildSizesInfoEXT<'a> { + pub fn micromap_size(mut self, micromap_size: crate::vk::DeviceSize) -> Self { + self.micromap_size = micromap_size; + self + } + pub fn build_scratch_size( + mut self, + build_scratch_size: crate::vk::DeviceSize, + ) -> Self { + self.build_scratch_size = build_scratch_size; + self + } + pub fn discardable(mut self, discardable: bool) -> Self { + self.discardable = discardable.into(); + self + } + } #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct MicromapUsageEXT { pub count: u32, pub subdivision_level: u32, pub format: u32, } + impl MicromapUsageEXT { + pub fn count(mut self, count: u32) -> Self { + self.count = count; + self + } + pub fn subdivision_level(mut self, subdivision_level: u32) -> Self { + self.subdivision_level = subdivision_level; + self + } + pub fn format(mut self, format: u32) -> Self { + self.format = format; + self + } + } #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct MicromapTriangleEXT { pub data_offset: u32, pub subdivision_level: u16, pub format: u16, } + impl MicromapTriangleEXT { + pub fn data_offset(mut self, data_offset: u32) -> Self { + self.data_offset = data_offset; + self + } + pub fn subdivision_level(mut self, subdivision_level: u16) -> Self { + self.subdivision_level = subdivision_level; + self + } + pub fn format(mut self, format: u16) -> Self { + self.format = format; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceOpacityMicromapFeaturesEXT<'a> { @@ -354,6 +656,40 @@ pub(crate) mod reexport { pub micromap_host_commands: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceOpacityMicromapFeaturesEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceOpacityMicromapFeaturesEXT<'a> {} + unsafe impl<'a> crate::Extends> + for PhysicalDeviceOpacityMicromapFeaturesEXT<'a> {} + impl<'a> Default for PhysicalDeviceOpacityMicromapFeaturesEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + micromap: Default::default(), + micromap_capture_replay: Default::default(), + micromap_host_commands: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceOpacityMicromapFeaturesEXT<'a> { + pub fn micromap(mut self, micromap: bool) -> Self { + self.micromap = micromap.into(); + self + } + pub fn micromap_capture_replay(mut self, micromap_capture_replay: bool) -> Self { + self.micromap_capture_replay = micromap_capture_replay.into(); + self + } + pub fn micromap_host_commands(mut self, micromap_host_commands: bool) -> Self { + self.micromap_host_commands = micromap_host_commands.into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceOpacityMicromapPropertiesEXT<'a> { @@ -363,6 +699,39 @@ pub(crate) mod reexport { pub max_opacity4_state_subdivision_level: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceOpacityMicromapPropertiesEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceOpacityMicromapPropertiesEXT<'a> {} + impl<'a> Default for PhysicalDeviceOpacityMicromapPropertiesEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + max_opacity2_state_subdivision_level: Default::default(), + max_opacity4_state_subdivision_level: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceOpacityMicromapPropertiesEXT<'a> { + pub fn max_opacity2_state_subdivision_level( + mut self, + max_opacity2_state_subdivision_level: u32, + ) -> Self { + self.max_opacity2_state_subdivision_level = max_opacity2_state_subdivision_level; + self + } + pub fn max_opacity4_state_subdivision_level( + mut self, + max_opacity4_state_subdivision_level: u32, + ) -> Self { + self.max_opacity4_state_subdivision_level = max_opacity4_state_subdivision_level; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct AccelerationStructureTrianglesOpacityMicromapEXT<'a> { @@ -378,6 +747,81 @@ pub(crate) mod reexport { pub micromap: crate::vk::MicromapEXT, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for AccelerationStructureTrianglesOpacityMicromapEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_EXT; + } + unsafe impl< + 'a, + > crate::Extends> + for AccelerationStructureTrianglesOpacityMicromapEXT<'a> {} + unsafe impl< + 'a, + > crate::Extends< + crate::vk::AccelerationStructureDenseGeometryFormatTrianglesDataAMDX<'_>, + > for AccelerationStructureTrianglesOpacityMicromapEXT<'a> {} + impl<'a> Default for AccelerationStructureTrianglesOpacityMicromapEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + index_type: Default::default(), + index_buffer: Default::default(), + index_stride: Default::default(), + base_triangle: Default::default(), + usage_counts_count: Default::default(), + p_usage_counts: Default::default(), + pp_usage_counts: Default::default(), + micromap: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> AccelerationStructureTrianglesOpacityMicromapEXT<'a> { + pub fn index_type(mut self, index_type: crate::vk::IndexType) -> Self { + self.index_type = index_type; + self + } + pub fn index_buffer( + mut self, + index_buffer: crate::vk::DeviceOrHostAddressConstKHR, + ) -> Self { + self.index_buffer = index_buffer; + self + } + pub fn index_stride(mut self, index_stride: crate::vk::DeviceSize) -> Self { + self.index_stride = index_stride; + self + } + pub fn base_triangle(mut self, base_triangle: u32) -> Self { + self.base_triangle = base_triangle; + self + } + pub fn usage_counts_count(mut self, usage_counts_count: u32) -> Self { + self.usage_counts_count = usage_counts_count; + self + } + pub fn p_usage_counts( + mut self, + p_usage_counts: &'a [crate::vk::MicromapUsageEXT], + ) -> Self { + self.usage_counts_count = p_usage_counts.len() as _; + self.p_usage_counts = p_usage_counts.as_ptr(); + self + } + pub fn pp_usage_counts( + mut self, + pp_usage_counts: &'a [&'a crate::vk::MicromapUsageEXT], + ) -> Self { + self.usage_counts_count = pp_usage_counts.len() as _; + self.pp_usage_counts = pp_usage_counts.as_ptr().cast(); + self + } + pub fn micromap(mut self, micromap: crate::vk::MicromapEXT) -> Self { + self.micromap = micromap; + self + } + } ///Provided by [`ext::opacity_micromap`](crate::ext::opacity_micromap) impl crate::vk::QueryType { pub const MICROMAP_SERIALIZATION_SIZE_EXT: Self = Self(1000396000); @@ -597,7 +1041,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct BuildMicromapFlagBitsEXT(pub(crate) u32); ///Provided by [`ext::opacity_micromap`](crate::ext::opacity_micromap) impl BuildMicromapFlagBitsEXT { @@ -676,7 +1120,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct MicromapCreateFlagBitsEXT(pub(crate) u32); ///Provided by [`ext::opacity_micromap`](crate::ext::opacity_micromap) impl MicromapCreateFlagBitsEXT { diff --git a/ash-rewrite/src/generated/ext/pageable_device_local_memory.rs b/ash-rewrite/src/generated/ext/pageable_device_local_memory.rs index 10809774d..3533e4923 100644 --- a/ash-rewrite/src/generated/ext/pageable_device_local_memory.rs +++ b/ash-rewrite/src/generated/ext/pageable_device_local_memory.rs @@ -44,6 +44,33 @@ pub(crate) mod reexport { pub pageable_device_local_memory: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT; + } + unsafe impl<'a> crate::Extends> + for PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT<'a> {} + unsafe impl<'a> crate::Extends> + for PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT<'a> {} + impl<'a> Default for PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + pageable_device_local_memory: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT<'a> { + pub fn pageable_device_local_memory( + mut self, + pageable_device_local_memory: bool, + ) -> Self { + self.pageable_device_local_memory = pageable_device_local_memory.into(); + self + } + } ///Provided by [`ext::pageable_device_local_memory`](crate::ext::pageable_device_local_memory) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT: Self = Self( diff --git a/ash-rewrite/src/generated/ext/pci_bus_info.rs b/ash-rewrite/src/generated/ext/pci_bus_info.rs index 82548d22e..07a018a13 100644 --- a/ash-rewrite/src/generated/ext/pci_bus_info.rs +++ b/ash-rewrite/src/generated/ext/pci_bus_info.rs @@ -12,6 +12,43 @@ pub struct PhysicalDevicePCIBusInfoPropertiesEXT<'a> { pub pci_function: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDevicePCIBusInfoPropertiesEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT; +} +unsafe impl<'a> crate::Extends> +for PhysicalDevicePCIBusInfoPropertiesEXT<'a> {} +impl<'a> Default for PhysicalDevicePCIBusInfoPropertiesEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + pci_domain: Default::default(), + pci_bus: Default::default(), + pci_device: Default::default(), + pci_function: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDevicePCIBusInfoPropertiesEXT<'a> { + pub fn pci_domain(mut self, pci_domain: u32) -> Self { + self.pci_domain = pci_domain; + self + } + pub fn pci_bus(mut self, pci_bus: u32) -> Self { + self.pci_bus = pci_bus; + self + } + pub fn pci_device(mut self, pci_device: u32) -> Self { + self.pci_device = pci_device; + self + } + pub fn pci_function(mut self, pci_function: u32) -> Self { + self.pci_function = pci_function; + self + } +} ///Provided by [`ext::pci_bus_info`](crate::ext::pci_bus_info) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT: Self = Self(1000212000); diff --git a/ash-rewrite/src/generated/ext/physical_device_drm.rs b/ash-rewrite/src/generated/ext/physical_device_drm.rs index 98ede2e4e..a2ec3da98 100644 --- a/ash-rewrite/src/generated/ext/physical_device_drm.rs +++ b/ash-rewrite/src/generated/ext/physical_device_drm.rs @@ -14,6 +14,52 @@ pub struct PhysicalDeviceDrmPropertiesEXT<'a> { pub render_minor: i64, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> for PhysicalDeviceDrmPropertiesEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_DRM_PROPERTIES_EXT; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceDrmPropertiesEXT<'a> {} +impl<'a> Default for PhysicalDeviceDrmPropertiesEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + has_primary: Default::default(), + has_render: Default::default(), + primary_major: Default::default(), + primary_minor: Default::default(), + render_major: Default::default(), + render_minor: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceDrmPropertiesEXT<'a> { + pub fn has_primary(mut self, has_primary: bool) -> Self { + self.has_primary = has_primary.into(); + self + } + pub fn has_render(mut self, has_render: bool) -> Self { + self.has_render = has_render.into(); + self + } + pub fn primary_major(mut self, primary_major: i64) -> Self { + self.primary_major = primary_major; + self + } + pub fn primary_minor(mut self, primary_minor: i64) -> Self { + self.primary_minor = primary_minor; + self + } + pub fn render_major(mut self, render_major: i64) -> Self { + self.render_major = render_major; + self + } + pub fn render_minor(mut self, render_minor: i64) -> Self { + self.render_minor = render_minor; + self + } +} ///Provided by [`ext::physical_device_drm`](crate::ext::physical_device_drm) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_DRM_PROPERTIES_EXT: Self = Self(1000353000); diff --git a/ash-rewrite/src/generated/ext/pipeline_library_group_handles.rs b/ash-rewrite/src/generated/ext/pipeline_library_group_handles.rs index cb04fa74e..9e613fc02 100644 --- a/ash-rewrite/src/generated/ext/pipeline_library_group_handles.rs +++ b/ash-rewrite/src/generated/ext/pipeline_library_group_handles.rs @@ -9,6 +9,33 @@ pub struct PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT<'a> { pub pipeline_library_group_handles: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT; +} +unsafe impl<'a> crate::Extends> +for PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT<'a> {} +impl<'a> Default for PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + pipeline_library_group_handles: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT<'a> { + pub fn pipeline_library_group_handles( + mut self, + pipeline_library_group_handles: bool, + ) -> Self { + self.pipeline_library_group_handles = pipeline_library_group_handles.into(); + self + } +} ///Provided by [`ext::pipeline_library_group_handles`](crate::ext::pipeline_library_group_handles) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT: Self = Self( diff --git a/ash-rewrite/src/generated/ext/pipeline_properties.rs b/ash-rewrite/src/generated/ext/pipeline_properties.rs index 90d0e92f1..aa932340b 100644 --- a/ash-rewrite/src/generated/ext/pipeline_properties.rs +++ b/ash-rewrite/src/generated/ext/pipeline_properties.rs @@ -44,6 +44,28 @@ pub(crate) mod reexport { pub pipeline_identifier: [u8; crate::vk::UUID_SIZE as _], pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for PipelinePropertiesIdentifierEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PIPELINE_PROPERTIES_IDENTIFIER_EXT; + } + impl<'a> Default for PipelinePropertiesIdentifierEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + pipeline_identifier: unsafe { core::mem::zeroed() }, + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PipelinePropertiesIdentifierEXT<'a> { + pub fn pipeline_identifier( + mut self, + pipeline_identifier: [u8; crate::vk::UUID_SIZE as _], + ) -> Self { + self.pipeline_identifier = pipeline_identifier; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDevicePipelinePropertiesFeaturesEXT<'a> { @@ -52,6 +74,33 @@ pub(crate) mod reexport { pub pipeline_properties_identifier: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDevicePipelinePropertiesFeaturesEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT; + } + unsafe impl<'a> crate::Extends> + for PhysicalDevicePipelinePropertiesFeaturesEXT<'a> {} + unsafe impl<'a> crate::Extends> + for PhysicalDevicePipelinePropertiesFeaturesEXT<'a> {} + impl<'a> Default for PhysicalDevicePipelinePropertiesFeaturesEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + pipeline_properties_identifier: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDevicePipelinePropertiesFeaturesEXT<'a> { + pub fn pipeline_properties_identifier( + mut self, + pipeline_properties_identifier: bool, + ) -> Self { + self.pipeline_properties_identifier = pipeline_properties_identifier.into(); + self + } + } pub type PipelineInfoEXT<'a> = crate::vk::PipelineInfoKHR<'a>; ///Provided by [`ext::pipeline_properties`](crate::ext::pipeline_properties) impl crate::vk::StructureType { diff --git a/ash-rewrite/src/generated/ext/present_timing.rs b/ash-rewrite/src/generated/ext/present_timing.rs index d637795d7..ef451c869 100644 --- a/ash-rewrite/src/generated/ext/present_timing.rs +++ b/ash-rewrite/src/generated/ext/present_timing.rs @@ -96,6 +96,46 @@ pub(crate) mod reexport { pub present_at_relative_time: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDevicePresentTimingFeaturesEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_PRESENT_TIMING_FEATURES_EXT; + } + unsafe impl<'a> crate::Extends> + for PhysicalDevicePresentTimingFeaturesEXT<'a> {} + unsafe impl<'a> crate::Extends> + for PhysicalDevicePresentTimingFeaturesEXT<'a> {} + impl<'a> Default for PhysicalDevicePresentTimingFeaturesEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + present_timing: Default::default(), + present_at_absolute_time: Default::default(), + present_at_relative_time: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDevicePresentTimingFeaturesEXT<'a> { + pub fn present_timing(mut self, present_timing: bool) -> Self { + self.present_timing = present_timing.into(); + self + } + pub fn present_at_absolute_time( + mut self, + present_at_absolute_time: bool, + ) -> Self { + self.present_at_absolute_time = present_at_absolute_time.into(); + self + } + pub fn present_at_relative_time( + mut self, + present_at_relative_time: bool, + ) -> Self { + self.present_at_relative_time = present_at_relative_time.into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PresentTimingSurfaceCapabilitiesEXT<'a> { @@ -107,6 +147,57 @@ pub(crate) mod reexport { pub present_stage_queries: crate::vk::PresentStageFlagsEXT, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PresentTimingSurfaceCapabilitiesEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PRESENT_TIMING_SURFACE_CAPABILITIES_EXT; + } + unsafe impl<'a> crate::Extends> + for PresentTimingSurfaceCapabilitiesEXT<'a> {} + impl<'a> Default for PresentTimingSurfaceCapabilitiesEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + present_timing_supported: Default::default(), + present_at_absolute_time_supported: Default::default(), + present_at_relative_time_supported: Default::default(), + present_stage_queries: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PresentTimingSurfaceCapabilitiesEXT<'a> { + pub fn present_timing_supported( + mut self, + present_timing_supported: bool, + ) -> Self { + self.present_timing_supported = present_timing_supported.into(); + self + } + pub fn present_at_absolute_time_supported( + mut self, + present_at_absolute_time_supported: bool, + ) -> Self { + self.present_at_absolute_time_supported = present_at_absolute_time_supported + .into(); + self + } + pub fn present_at_relative_time_supported( + mut self, + present_at_relative_time_supported: bool, + ) -> Self { + self.present_at_relative_time_supported = present_at_relative_time_supported + .into(); + self + } + pub fn present_stage_queries( + mut self, + present_stage_queries: crate::vk::PresentStageFlagsEXT, + ) -> Self { + self.present_stage_queries = present_stage_queries; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct SwapchainTimingPropertiesEXT<'a> { @@ -116,6 +207,30 @@ pub(crate) mod reexport { pub refresh_interval: u64, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for SwapchainTimingPropertiesEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::SWAPCHAIN_TIMING_PROPERTIES_EXT; + } + impl<'a> Default for SwapchainTimingPropertiesEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + refresh_duration: Default::default(), + refresh_interval: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> SwapchainTimingPropertiesEXT<'a> { + pub fn refresh_duration(mut self, refresh_duration: u64) -> Self { + self.refresh_duration = refresh_duration; + self + } + pub fn refresh_interval(mut self, refresh_interval: u64) -> Self { + self.refresh_interval = refresh_interval; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct SwapchainTimeDomainPropertiesEXT<'a> { @@ -126,12 +241,56 @@ pub(crate) mod reexport { pub p_time_domain_ids: *mut u64, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for SwapchainTimeDomainPropertiesEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::SWAPCHAIN_TIME_DOMAIN_PROPERTIES_EXT; + } + impl<'a> Default for SwapchainTimeDomainPropertiesEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + time_domain_count: Default::default(), + p_time_domains: Default::default(), + p_time_domain_ids: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> SwapchainTimeDomainPropertiesEXT<'a> { + pub fn time_domain_count(mut self, time_domain_count: u32) -> Self { + self.time_domain_count = time_domain_count; + self + } + pub fn p_time_domains( + mut self, + p_time_domains: &'a mut [crate::vk::TimeDomainKHR], + ) -> Self { + self.time_domain_count = p_time_domains.len() as _; + self.p_time_domains = p_time_domains.as_mut_ptr(); + self + } + pub fn p_time_domain_ids(mut self, p_time_domain_ids: &'a mut [u64]) -> Self { + self.time_domain_count = p_time_domain_ids.len() as _; + self.p_time_domain_ids = p_time_domain_ids.as_mut_ptr(); + self + } + } #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct PresentStageTimeEXT { pub stage: crate::vk::PresentStageFlagsEXT, pub time: u64, } + impl PresentStageTimeEXT { + pub fn stage(mut self, stage: crate::vk::PresentStageFlagsEXT) -> Self { + self.stage = stage; + self + } + pub fn time(mut self, time: u64) -> Self { + self.time = time; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PastPresentationTimingInfoEXT<'a> { @@ -141,6 +300,33 @@ pub(crate) mod reexport { pub swapchain: crate::vk::SwapchainKHR, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for PastPresentationTimingInfoEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PAST_PRESENTATION_TIMING_INFO_EXT; + } + impl<'a> Default for PastPresentationTimingInfoEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + flags: Default::default(), + swapchain: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PastPresentationTimingInfoEXT<'a> { + pub fn flags( + mut self, + flags: crate::vk::PastPresentationTimingFlagsEXT, + ) -> Self { + self.flags = flags; + self + } + pub fn swapchain(mut self, swapchain: crate::vk::SwapchainKHR) -> Self { + self.swapchain = swapchain; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PastPresentationTimingPropertiesEXT<'a> { @@ -152,6 +338,51 @@ pub(crate) mod reexport { pub p_presentation_timings: *mut crate::vk::PastPresentationTimingEXT<'a>, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PastPresentationTimingPropertiesEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PAST_PRESENTATION_TIMING_PROPERTIES_EXT; + } + impl<'a> Default for PastPresentationTimingPropertiesEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + timing_properties_counter: Default::default(), + time_domains_counter: Default::default(), + presentation_timing_count: Default::default(), + p_presentation_timings: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PastPresentationTimingPropertiesEXT<'a> { + pub fn timing_properties_counter( + mut self, + timing_properties_counter: u64, + ) -> Self { + self.timing_properties_counter = timing_properties_counter; + self + } + pub fn time_domains_counter(mut self, time_domains_counter: u64) -> Self { + self.time_domains_counter = time_domains_counter; + self + } + pub fn presentation_timing_count( + mut self, + presentation_timing_count: u32, + ) -> Self { + self.presentation_timing_count = presentation_timing_count; + self + } + pub fn p_presentation_timings( + mut self, + p_presentation_timings: &'a mut [crate::vk::PastPresentationTimingEXT<'a>], + ) -> Self { + self.presentation_timing_count = p_presentation_timings.len() as _; + self.p_presentation_timings = p_presentation_timings.as_mut_ptr(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PastPresentationTimingEXT<'a> { @@ -166,6 +397,59 @@ pub(crate) mod reexport { pub report_complete: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for PastPresentationTimingEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PAST_PRESENTATION_TIMING_EXT; + } + impl<'a> Default for PastPresentationTimingEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + present_id: Default::default(), + target_time: Default::default(), + present_stage_count: Default::default(), + p_present_stages: Default::default(), + time_domain: Default::default(), + time_domain_id: Default::default(), + report_complete: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PastPresentationTimingEXT<'a> { + pub fn present_id(mut self, present_id: u64) -> Self { + self.present_id = present_id; + self + } + pub fn target_time(mut self, target_time: u64) -> Self { + self.target_time = target_time; + self + } + pub fn present_stage_count(mut self, present_stage_count: u32) -> Self { + self.present_stage_count = present_stage_count; + self + } + pub fn p_present_stages( + mut self, + p_present_stages: &'a mut [crate::vk::PresentStageTimeEXT], + ) -> Self { + self.present_stage_count = p_present_stages.len() as _; + self.p_present_stages = p_present_stages.as_mut_ptr(); + self + } + pub fn time_domain(mut self, time_domain: crate::vk::TimeDomainKHR) -> Self { + self.time_domain = time_domain; + self + } + pub fn time_domain_id(mut self, time_domain_id: u64) -> Self { + self.time_domain_id = time_domain_id; + self + } + pub fn report_complete(mut self, report_complete: bool) -> Self { + self.report_complete = report_complete.into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PresentTimingsInfoEXT<'a> { @@ -175,6 +459,36 @@ pub(crate) mod reexport { pub p_timing_infos: *const crate::vk::PresentTimingInfoEXT<'a>, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for PresentTimingsInfoEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PRESENT_TIMINGS_INFO_EXT; + } + unsafe impl<'a> crate::Extends> + for PresentTimingsInfoEXT<'a> {} + impl<'a> Default for PresentTimingsInfoEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + swapchain_count: Default::default(), + p_timing_infos: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PresentTimingsInfoEXT<'a> { + pub fn swapchain_count(mut self, swapchain_count: u32) -> Self { + self.swapchain_count = swapchain_count; + self + } + pub fn p_timing_infos( + mut self, + p_timing_infos: &'a [crate::vk::PresentTimingInfoEXT<'a>], + ) -> Self { + self.swapchain_count = p_timing_infos.len() as _; + self.p_timing_infos = p_timing_infos.as_ptr(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PresentTimingInfoEXT<'a> { @@ -187,6 +501,51 @@ pub(crate) mod reexport { pub target_time_domain_present_stage: crate::vk::PresentStageFlagsEXT, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for PresentTimingInfoEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PRESENT_TIMING_INFO_EXT; + } + impl<'a> Default for PresentTimingInfoEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + flags: Default::default(), + target_time: Default::default(), + time_domain_id: Default::default(), + present_stage_queries: Default::default(), + target_time_domain_present_stage: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PresentTimingInfoEXT<'a> { + pub fn flags(mut self, flags: crate::vk::PresentTimingInfoFlagsEXT) -> Self { + self.flags = flags; + self + } + pub fn target_time(mut self, target_time: u64) -> Self { + self.target_time = target_time; + self + } + pub fn time_domain_id(mut self, time_domain_id: u64) -> Self { + self.time_domain_id = time_domain_id; + self + } + pub fn present_stage_queries( + mut self, + present_stage_queries: crate::vk::PresentStageFlagsEXT, + ) -> Self { + self.present_stage_queries = present_stage_queries; + self + } + pub fn target_time_domain_present_stage( + mut self, + target_time_domain_present_stage: crate::vk::PresentStageFlagsEXT, + ) -> Self { + self.target_time_domain_present_stage = target_time_domain_present_stage; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct SwapchainCalibratedTimestampInfoEXT<'a> { @@ -197,6 +556,41 @@ pub(crate) mod reexport { pub time_domain_id: u64, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for SwapchainCalibratedTimestampInfoEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::SWAPCHAIN_CALIBRATED_TIMESTAMP_INFO_EXT; + } + unsafe impl<'a> crate::Extends> + for SwapchainCalibratedTimestampInfoEXT<'a> {} + impl<'a> Default for SwapchainCalibratedTimestampInfoEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + swapchain: Default::default(), + present_stage: Default::default(), + time_domain_id: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> SwapchainCalibratedTimestampInfoEXT<'a> { + pub fn swapchain(mut self, swapchain: crate::vk::SwapchainKHR) -> Self { + self.swapchain = swapchain; + self + } + pub fn present_stage( + mut self, + present_stage: crate::vk::PresentStageFlagsEXT, + ) -> Self { + self.present_stage = present_stage; + self + } + pub fn time_domain_id(mut self, time_domain_id: u64) -> Self { + self.time_domain_id = time_domain_id; + self + } + } ///Provided by [`ext::present_timing`](crate::ext::present_timing) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_PRESENT_TIMING_FEATURES_EXT: Self = Self(1000208000); @@ -303,7 +697,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct PresentStageFlagBitsEXT(pub(crate) u32); ///Provided by [`ext::present_timing`](crate::ext::present_timing) impl PresentStageFlagBitsEXT { @@ -386,7 +780,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct PastPresentationTimingFlagBitsEXT(pub(crate) u32); ///Provided by [`ext::present_timing`](crate::ext::present_timing) impl PastPresentationTimingFlagBitsEXT { @@ -467,7 +861,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct PresentTimingInfoFlagBitsEXT(pub(crate) u32); ///Provided by [`ext::present_timing`](crate::ext::present_timing) impl PresentTimingInfoFlagBitsEXT { diff --git a/ash-rewrite/src/generated/ext/primitive_restart_index.rs b/ash-rewrite/src/generated/ext/primitive_restart_index.rs index 561c9f3ac..f9e1436e2 100644 --- a/ash-rewrite/src/generated/ext/primitive_restart_index.rs +++ b/ash-rewrite/src/generated/ext/primitive_restart_index.rs @@ -43,6 +43,30 @@ pub(crate) mod reexport { pub primitive_restart_index: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDevicePrimitiveRestartIndexFeaturesEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_PRIMITIVE_RESTART_INDEX_FEATURES_EXT; + } + unsafe impl<'a> crate::Extends> + for PhysicalDevicePrimitiveRestartIndexFeaturesEXT<'a> {} + unsafe impl<'a> crate::Extends> + for PhysicalDevicePrimitiveRestartIndexFeaturesEXT<'a> {} + impl<'a> Default for PhysicalDevicePrimitiveRestartIndexFeaturesEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + primitive_restart_index: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDevicePrimitiveRestartIndexFeaturesEXT<'a> { + pub fn primitive_restart_index(mut self, primitive_restart_index: bool) -> Self { + self.primitive_restart_index = primitive_restart_index.into(); + self + } + } ///Provided by [`ext::primitive_restart_index`](crate::ext::primitive_restart_index) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_PRIMITIVE_RESTART_INDEX_FEATURES_EXT: Self = Self( diff --git a/ash-rewrite/src/generated/ext/primitive_topology_list_restart.rs b/ash-rewrite/src/generated/ext/primitive_topology_list_restart.rs index 419a9cd56..6d3d872eb 100644 --- a/ash-rewrite/src/generated/ext/primitive_topology_list_restart.rs +++ b/ash-rewrite/src/generated/ext/primitive_topology_list_restart.rs @@ -10,6 +10,42 @@ pub struct PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT<'a> { pub primitive_topology_patch_list_restart: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT; +} +unsafe impl<'a> crate::Extends> +for PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT<'a> {} +impl<'a> Default for PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + primitive_topology_list_restart: Default::default(), + primitive_topology_patch_list_restart: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT<'a> { + pub fn primitive_topology_list_restart( + mut self, + primitive_topology_list_restart: bool, + ) -> Self { + self.primitive_topology_list_restart = primitive_topology_list_restart.into(); + self + } + pub fn primitive_topology_patch_list_restart( + mut self, + primitive_topology_patch_list_restart: bool, + ) -> Self { + self.primitive_topology_patch_list_restart = primitive_topology_patch_list_restart + .into(); + self + } +} ///Provided by [`ext::primitive_topology_list_restart`](crate::ext::primitive_topology_list_restart) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT: Self = Self( diff --git a/ash-rewrite/src/generated/ext/primitives_generated_query.rs b/ash-rewrite/src/generated/ext/primitives_generated_query.rs index eaf25b191..671f7503b 100644 --- a/ash-rewrite/src/generated/ext/primitives_generated_query.rs +++ b/ash-rewrite/src/generated/ext/primitives_generated_query.rs @@ -11,6 +11,51 @@ pub struct PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT<'a> { pub primitives_generated_query_with_non_zero_streams: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT; +} +unsafe impl<'a> crate::Extends> +for PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT<'a> {} +impl<'a> Default for PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + primitives_generated_query: Default::default(), + primitives_generated_query_with_rasterizer_discard: Default::default(), + primitives_generated_query_with_non_zero_streams: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT<'a> { + pub fn primitives_generated_query( + mut self, + primitives_generated_query: bool, + ) -> Self { + self.primitives_generated_query = primitives_generated_query.into(); + self + } + pub fn primitives_generated_query_with_rasterizer_discard( + mut self, + primitives_generated_query_with_rasterizer_discard: bool, + ) -> Self { + self.primitives_generated_query_with_rasterizer_discard = primitives_generated_query_with_rasterizer_discard + .into(); + self + } + pub fn primitives_generated_query_with_non_zero_streams( + mut self, + primitives_generated_query_with_non_zero_streams: bool, + ) -> Self { + self.primitives_generated_query_with_non_zero_streams = primitives_generated_query_with_non_zero_streams + .into(); + self + } +} ///Provided by [`ext::primitives_generated_query`](crate::ext::primitives_generated_query) impl crate::vk::QueryType { pub const PRIMITIVES_GENERATED_EXT: Self = Self(1000382000); diff --git a/ash-rewrite/src/generated/ext/provoking_vertex.rs b/ash-rewrite/src/generated/ext/provoking_vertex.rs index 3b6e967df..6bd56cf9a 100644 --- a/ash-rewrite/src/generated/ext/provoking_vertex.rs +++ b/ash-rewrite/src/generated/ext/provoking_vertex.rs @@ -10,6 +10,39 @@ pub struct PhysicalDeviceProvokingVertexFeaturesEXT<'a> { pub transform_feedback_preserves_provoking_vertex: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceProvokingVertexFeaturesEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceProvokingVertexFeaturesEXT<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceProvokingVertexFeaturesEXT<'a> {} +impl<'a> Default for PhysicalDeviceProvokingVertexFeaturesEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + provoking_vertex_last: Default::default(), + transform_feedback_preserves_provoking_vertex: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceProvokingVertexFeaturesEXT<'a> { + pub fn provoking_vertex_last(mut self, provoking_vertex_last: bool) -> Self { + self.provoking_vertex_last = provoking_vertex_last.into(); + self + } + pub fn transform_feedback_preserves_provoking_vertex( + mut self, + transform_feedback_preserves_provoking_vertex: bool, + ) -> Self { + self.transform_feedback_preserves_provoking_vertex = transform_feedback_preserves_provoking_vertex + .into(); + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceProvokingVertexPropertiesEXT<'a> { @@ -19,6 +52,41 @@ pub struct PhysicalDeviceProvokingVertexPropertiesEXT<'a> { pub transform_feedback_preserves_triangle_fan_provoking_vertex: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceProvokingVertexPropertiesEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceProvokingVertexPropertiesEXT<'a> {} +impl<'a> Default for PhysicalDeviceProvokingVertexPropertiesEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + provoking_vertex_mode_per_pipeline: Default::default(), + transform_feedback_preserves_triangle_fan_provoking_vertex: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceProvokingVertexPropertiesEXT<'a> { + pub fn provoking_vertex_mode_per_pipeline( + mut self, + provoking_vertex_mode_per_pipeline: bool, + ) -> Self { + self.provoking_vertex_mode_per_pipeline = provoking_vertex_mode_per_pipeline + .into(); + self + } + pub fn transform_feedback_preserves_triangle_fan_provoking_vertex( + mut self, + transform_feedback_preserves_triangle_fan_provoking_vertex: bool, + ) -> Self { + self.transform_feedback_preserves_triangle_fan_provoking_vertex = transform_feedback_preserves_triangle_fan_provoking_vertex + .into(); + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct PipelineRasterizationProvokingVertexStateCreateInfoEXT<'a> { @@ -27,6 +95,31 @@ pub struct PipelineRasterizationProvokingVertexStateCreateInfoEXT<'a> { pub provoking_vertex_mode: crate::vk::ProvokingVertexModeEXT, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PipelineRasterizationProvokingVertexStateCreateInfoEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT; +} +unsafe impl<'a> crate::Extends> +for PipelineRasterizationProvokingVertexStateCreateInfoEXT<'a> {} +impl<'a> Default for PipelineRasterizationProvokingVertexStateCreateInfoEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + provoking_vertex_mode: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PipelineRasterizationProvokingVertexStateCreateInfoEXT<'a> { + pub fn provoking_vertex_mode( + mut self, + provoking_vertex_mode: crate::vk::ProvokingVertexModeEXT, + ) -> Self { + self.provoking_vertex_mode = provoking_vertex_mode; + self + } +} ///Provided by [`ext::provoking_vertex`](crate::ext::provoking_vertex) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT: Self = Self(1000254000); diff --git a/ash-rewrite/src/generated/ext/rasterization_order_attachment_access.rs b/ash-rewrite/src/generated/ext/rasterization_order_attachment_access.rs index b94ad2ac6..24177414b 100644 --- a/ash-rewrite/src/generated/ext/rasterization_order_attachment_access.rs +++ b/ash-rewrite/src/generated/ext/rasterization_order_attachment_access.rs @@ -11,6 +11,52 @@ pub struct PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT<'a> { pub rasterization_order_stencil_attachment_access: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT<'a> {} +impl<'a> Default for PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + rasterization_order_color_attachment_access: Default::default(), + rasterization_order_depth_attachment_access: Default::default(), + rasterization_order_stencil_attachment_access: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT<'a> { + pub fn rasterization_order_color_attachment_access( + mut self, + rasterization_order_color_attachment_access: bool, + ) -> Self { + self.rasterization_order_color_attachment_access = rasterization_order_color_attachment_access + .into(); + self + } + pub fn rasterization_order_depth_attachment_access( + mut self, + rasterization_order_depth_attachment_access: bool, + ) -> Self { + self.rasterization_order_depth_attachment_access = rasterization_order_depth_attachment_access + .into(); + self + } + pub fn rasterization_order_stencil_attachment_access( + mut self, + rasterization_order_stencil_attachment_access: bool, + ) -> Self { + self.rasterization_order_stencil_attachment_access = rasterization_order_stencil_attachment_access + .into(); + self + } +} ///Provided by [`ext::rasterization_order_attachment_access`](crate::ext::rasterization_order_attachment_access) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT: Self = Self( diff --git a/ash-rewrite/src/generated/ext/ray_tracing_invocation_reorder.rs b/ash-rewrite/src/generated/ext/ray_tracing_invocation_reorder.rs index e01a1b43d..9ff1e8291 100644 --- a/ash-rewrite/src/generated/ext/ray_tracing_invocation_reorder.rs +++ b/ash-rewrite/src/generated/ext/ray_tracing_invocation_reorder.rs @@ -9,6 +9,33 @@ pub struct PhysicalDeviceRayTracingInvocationReorderFeaturesEXT<'a> { pub ray_tracing_invocation_reorder: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceRayTracingInvocationReorderFeaturesEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_EXT; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceRayTracingInvocationReorderFeaturesEXT<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceRayTracingInvocationReorderFeaturesEXT<'a> {} +impl<'a> Default for PhysicalDeviceRayTracingInvocationReorderFeaturesEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + ray_tracing_invocation_reorder: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceRayTracingInvocationReorderFeaturesEXT<'a> { + pub fn ray_tracing_invocation_reorder( + mut self, + ray_tracing_invocation_reorder: bool, + ) -> Self { + self.ray_tracing_invocation_reorder = ray_tracing_invocation_reorder.into(); + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceRayTracingInvocationReorderPropertiesEXT<'a> { @@ -18,6 +45,39 @@ pub struct PhysicalDeviceRayTracingInvocationReorderPropertiesEXT<'a> { pub max_shader_binding_table_record_index: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceRayTracingInvocationReorderPropertiesEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_EXT; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceRayTracingInvocationReorderPropertiesEXT<'a> {} +impl<'a> Default for PhysicalDeviceRayTracingInvocationReorderPropertiesEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + ray_tracing_invocation_reorder_reordering_hint: Default::default(), + max_shader_binding_table_record_index: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceRayTracingInvocationReorderPropertiesEXT<'a> { + pub fn ray_tracing_invocation_reorder_reordering_hint( + mut self, + ray_tracing_invocation_reorder_reordering_hint: crate::vk::RayTracingInvocationReorderModeEXT, + ) -> Self { + self.ray_tracing_invocation_reorder_reordering_hint = ray_tracing_invocation_reorder_reordering_hint; + self + } + pub fn max_shader_binding_table_record_index( + mut self, + max_shader_binding_table_record_index: u32, + ) -> Self { + self.max_shader_binding_table_record_index = max_shader_binding_table_record_index; + self + } +} ///Provided by [`ext::ray_tracing_invocation_reorder`](crate::ext::ray_tracing_invocation_reorder) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_EXT: Self = Self( diff --git a/ash-rewrite/src/generated/ext/rgba10x6_formats.rs b/ash-rewrite/src/generated/ext/rgba10x6_formats.rs index d5ee19d87..56186a62c 100644 --- a/ash-rewrite/src/generated/ext/rgba10x6_formats.rs +++ b/ash-rewrite/src/generated/ext/rgba10x6_formats.rs @@ -9,6 +9,34 @@ pub struct PhysicalDeviceRGBA10X6FormatsFeaturesEXT<'a> { pub format_rgba10x6_without_y_cb_cr_sampler: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceRGBA10X6FormatsFeaturesEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceRGBA10X6FormatsFeaturesEXT<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceRGBA10X6FormatsFeaturesEXT<'a> {} +impl<'a> Default for PhysicalDeviceRGBA10X6FormatsFeaturesEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + format_rgba10x6_without_y_cb_cr_sampler: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceRGBA10X6FormatsFeaturesEXT<'a> { + pub fn format_rgba10x6_without_y_cb_cr_sampler( + mut self, + format_rgba10x6_without_y_cb_cr_sampler: bool, + ) -> Self { + self.format_rgba10x6_without_y_cb_cr_sampler = format_rgba10x6_without_y_cb_cr_sampler + .into(); + self + } +} ///Provided by [`ext::rgba10x6_formats`](crate::ext::rgba10x6_formats) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT: Self = Self(1000344000); diff --git a/ash-rewrite/src/generated/ext/sample_locations.rs b/ash-rewrite/src/generated/ext/sample_locations.rs index 452984794..178ea98ca 100644 --- a/ash-rewrite/src/generated/ext/sample_locations.rs +++ b/ash-rewrite/src/generated/ext/sample_locations.rs @@ -70,11 +70,21 @@ impl InstanceFn { } pub(crate) mod reexport { #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct SampleLocationEXT { pub x: core::ffi::c_float, pub y: core::ffi::c_float, } + impl SampleLocationEXT { + pub fn x(mut self, x: core::ffi::c_float) -> Self { + self.x = x; + self + } + pub fn y(mut self, y: core::ffi::c_float) -> Self { + self.y = y; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct SampleLocationsInfoEXT<'a> { @@ -86,20 +96,94 @@ pub(crate) mod reexport { pub p_sample_locations: *const crate::vk::SampleLocationEXT, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for SampleLocationsInfoEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::SAMPLE_LOCATIONS_INFO_EXT; + } + unsafe impl<'a> crate::Extends> + for SampleLocationsInfoEXT<'a> {} + unsafe impl<'a> crate::Extends> + for SampleLocationsInfoEXT<'a> {} + impl<'a> Default for SampleLocationsInfoEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + sample_locations_per_pixel: Default::default(), + sample_location_grid_size: Default::default(), + sample_locations_count: Default::default(), + p_sample_locations: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> SampleLocationsInfoEXT<'a> { + pub fn sample_locations_per_pixel( + mut self, + sample_locations_per_pixel: crate::vk::SampleCountFlagBits, + ) -> Self { + self.sample_locations_per_pixel = sample_locations_per_pixel; + self + } + pub fn sample_location_grid_size( + mut self, + sample_location_grid_size: crate::vk::Extent2D, + ) -> Self { + self.sample_location_grid_size = sample_location_grid_size; + self + } + pub fn sample_locations_count(mut self, sample_locations_count: u32) -> Self { + self.sample_locations_count = sample_locations_count; + self + } + pub fn p_sample_locations( + mut self, + p_sample_locations: &'a [crate::vk::SampleLocationEXT], + ) -> Self { + self.sample_locations_count = p_sample_locations.len() as _; + self.p_sample_locations = p_sample_locations.as_ptr(); + self + } + } #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct AttachmentSampleLocationsEXT<'a> { pub attachment_index: u32, pub sample_locations_info: crate::vk::SampleLocationsInfoEXT<'a>, pub _marker: ::core::marker::PhantomData<&'a ()>, } + impl<'a> AttachmentSampleLocationsEXT<'a> { + pub fn attachment_index(mut self, attachment_index: u32) -> Self { + self.attachment_index = attachment_index; + self + } + pub fn sample_locations_info( + mut self, + sample_locations_info: crate::vk::SampleLocationsInfoEXT<'a>, + ) -> Self { + self.sample_locations_info = sample_locations_info; + self + } + } #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct SubpassSampleLocationsEXT<'a> { pub subpass_index: u32, pub sample_locations_info: crate::vk::SampleLocationsInfoEXT<'a>, pub _marker: ::core::marker::PhantomData<&'a ()>, } + impl<'a> SubpassSampleLocationsEXT<'a> { + pub fn subpass_index(mut self, subpass_index: u32) -> Self { + self.subpass_index = subpass_index; + self + } + pub fn sample_locations_info( + mut self, + sample_locations_info: crate::vk::SampleLocationsInfoEXT<'a>, + ) -> Self { + self.sample_locations_info = sample_locations_info; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct RenderPassSampleLocationsBeginInfoEXT<'a> { @@ -115,6 +199,65 @@ pub(crate) mod reexport { >, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for RenderPassSampleLocationsBeginInfoEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT; + } + unsafe impl<'a> crate::Extends> + for RenderPassSampleLocationsBeginInfoEXT<'a> {} + impl<'a> Default for RenderPassSampleLocationsBeginInfoEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + attachment_initial_sample_locations_count: Default::default(), + p_attachment_initial_sample_locations: Default::default(), + post_subpass_sample_locations_count: Default::default(), + p_post_subpass_sample_locations: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> RenderPassSampleLocationsBeginInfoEXT<'a> { + pub fn attachment_initial_sample_locations_count( + mut self, + attachment_initial_sample_locations_count: u32, + ) -> Self { + self.attachment_initial_sample_locations_count = attachment_initial_sample_locations_count; + self + } + pub fn p_attachment_initial_sample_locations( + mut self, + p_attachment_initial_sample_locations: &'a [crate::vk::AttachmentSampleLocationsEXT< + 'a, + >], + ) -> Self { + self.attachment_initial_sample_locations_count = p_attachment_initial_sample_locations + .len() as _; + self.p_attachment_initial_sample_locations = p_attachment_initial_sample_locations + .as_ptr(); + self + } + pub fn post_subpass_sample_locations_count( + mut self, + post_subpass_sample_locations_count: u32, + ) -> Self { + self.post_subpass_sample_locations_count = post_subpass_sample_locations_count; + self + } + pub fn p_post_subpass_sample_locations( + mut self, + p_post_subpass_sample_locations: &'a [crate::vk::SubpassSampleLocationsEXT< + 'a, + >], + ) -> Self { + self.post_subpass_sample_locations_count = p_post_subpass_sample_locations + .len() as _; + self.p_post_subpass_sample_locations = p_post_subpass_sample_locations + .as_ptr(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PipelineSampleLocationsStateCreateInfoEXT<'a> { @@ -124,6 +267,36 @@ pub(crate) mod reexport { pub sample_locations_info: crate::vk::SampleLocationsInfoEXT<'a>, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PipelineSampleLocationsStateCreateInfoEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT; + } + unsafe impl<'a> crate::Extends> + for PipelineSampleLocationsStateCreateInfoEXT<'a> {} + impl<'a> Default for PipelineSampleLocationsStateCreateInfoEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + sample_locations_enable: Default::default(), + sample_locations_info: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PipelineSampleLocationsStateCreateInfoEXT<'a> { + pub fn sample_locations_enable(mut self, sample_locations_enable: bool) -> Self { + self.sample_locations_enable = sample_locations_enable.into(); + self + } + pub fn sample_locations_info( + mut self, + sample_locations_info: crate::vk::SampleLocationsInfoEXT<'a>, + ) -> Self { + self.sample_locations_info = sample_locations_info; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceSampleLocationsPropertiesEXT<'a> { @@ -136,6 +309,63 @@ pub(crate) mod reexport { pub variable_sample_locations: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceSampleLocationsPropertiesEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceSampleLocationsPropertiesEXT<'a> {} + impl<'a> Default for PhysicalDeviceSampleLocationsPropertiesEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + sample_location_sample_counts: Default::default(), + max_sample_location_grid_size: Default::default(), + sample_location_coordinate_range: unsafe { core::mem::zeroed() }, + sample_location_sub_pixel_bits: Default::default(), + variable_sample_locations: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceSampleLocationsPropertiesEXT<'a> { + pub fn sample_location_sample_counts( + mut self, + sample_location_sample_counts: crate::vk::SampleCountFlags, + ) -> Self { + self.sample_location_sample_counts = sample_location_sample_counts; + self + } + pub fn max_sample_location_grid_size( + mut self, + max_sample_location_grid_size: crate::vk::Extent2D, + ) -> Self { + self.max_sample_location_grid_size = max_sample_location_grid_size; + self + } + pub fn sample_location_coordinate_range( + mut self, + sample_location_coordinate_range: [core::ffi::c_float; 2 as _], + ) -> Self { + self.sample_location_coordinate_range = sample_location_coordinate_range; + self + } + pub fn sample_location_sub_pixel_bits( + mut self, + sample_location_sub_pixel_bits: u32, + ) -> Self { + self.sample_location_sub_pixel_bits = sample_location_sub_pixel_bits; + self + } + pub fn variable_sample_locations( + mut self, + variable_sample_locations: bool, + ) -> Self { + self.variable_sample_locations = variable_sample_locations.into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct MultisamplePropertiesEXT<'a> { @@ -144,6 +374,28 @@ pub(crate) mod reexport { pub max_sample_location_grid_size: crate::vk::Extent2D, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for MultisamplePropertiesEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::MULTISAMPLE_PROPERTIES_EXT; + } + impl<'a> Default for MultisamplePropertiesEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + max_sample_location_grid_size: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> MultisamplePropertiesEXT<'a> { + pub fn max_sample_location_grid_size( + mut self, + max_sample_location_grid_size: crate::vk::Extent2D, + ) -> Self { + self.max_sample_location_grid_size = max_sample_location_grid_size; + self + } + } ///Provided by [`ext::sample_locations`](crate::ext::sample_locations) impl crate::vk::StructureType { pub const SAMPLE_LOCATIONS_INFO_EXT: Self = Self(1000143000); diff --git a/ash-rewrite/src/generated/ext/shader_64bit_indexing.rs b/ash-rewrite/src/generated/ext/shader_64bit_indexing.rs index 711a555ee..6824715d9 100644 --- a/ash-rewrite/src/generated/ext/shader_64bit_indexing.rs +++ b/ash-rewrite/src/generated/ext/shader_64bit_indexing.rs @@ -9,6 +9,30 @@ pub struct PhysicalDeviceShader64BitIndexingFeaturesEXT<'a> { pub shader64_bit_indexing: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceShader64BitIndexingFeaturesEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_SHADER_64_INDEXING_FEATURES_EXT; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceShader64BitIndexingFeaturesEXT<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceShader64BitIndexingFeaturesEXT<'a> {} +impl<'a> Default for PhysicalDeviceShader64BitIndexingFeaturesEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + shader64_bit_indexing: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceShader64BitIndexingFeaturesEXT<'a> { + pub fn shader64_bit_indexing(mut self, shader64_bit_indexing: bool) -> Self { + self.shader64_bit_indexing = shader64_bit_indexing.into(); + self + } +} ///Provided by [`ext::shader_64bit_indexing`](crate::ext::shader_64bit_indexing) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_SHADER_64_INDEXING_FEATURES_EXT: Self = Self(1000627000); diff --git a/ash-rewrite/src/generated/ext/shader_atomic_float.rs b/ash-rewrite/src/generated/ext/shader_atomic_float.rs index ef91344b8..defb392ee 100644 --- a/ash-rewrite/src/generated/ext/shader_atomic_float.rs +++ b/ash-rewrite/src/generated/ext/shader_atomic_float.rs @@ -20,6 +20,121 @@ pub struct PhysicalDeviceShaderAtomicFloatFeaturesEXT<'a> { pub sparse_image_float32_atomic_add: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceShaderAtomicFloatFeaturesEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceShaderAtomicFloatFeaturesEXT<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceShaderAtomicFloatFeaturesEXT<'a> {} +impl<'a> Default for PhysicalDeviceShaderAtomicFloatFeaturesEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + shader_buffer_float32_atomics: Default::default(), + shader_buffer_float32_atomic_add: Default::default(), + shader_buffer_float64_atomics: Default::default(), + shader_buffer_float64_atomic_add: Default::default(), + shader_shared_float32_atomics: Default::default(), + shader_shared_float32_atomic_add: Default::default(), + shader_shared_float64_atomics: Default::default(), + shader_shared_float64_atomic_add: Default::default(), + shader_image_float32_atomics: Default::default(), + shader_image_float32_atomic_add: Default::default(), + sparse_image_float32_atomics: Default::default(), + sparse_image_float32_atomic_add: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceShaderAtomicFloatFeaturesEXT<'a> { + pub fn shader_buffer_float32_atomics( + mut self, + shader_buffer_float32_atomics: bool, + ) -> Self { + self.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, + ) -> Self { + self.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, + ) -> Self { + self.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, + ) -> Self { + self.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, + ) -> Self { + self.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, + ) -> Self { + self.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, + ) -> Self { + self.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, + ) -> Self { + self.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, + ) -> Self { + self.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, + ) -> Self { + self.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, + ) -> Self { + self.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, + ) -> Self { + self.sparse_image_float32_atomic_add = sparse_image_float32_atomic_add.into(); + self + } +} ///Provided by [`ext::shader_atomic_float`](crate::ext::shader_atomic_float) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT: Self = Self(1000260000); diff --git a/ash-rewrite/src/generated/ext/shader_atomic_float2.rs b/ash-rewrite/src/generated/ext/shader_atomic_float2.rs index 1e91e12a6..dd9e7dcbc 100644 --- a/ash-rewrite/src/generated/ext/shader_atomic_float2.rs +++ b/ash-rewrite/src/generated/ext/shader_atomic_float2.rs @@ -20,6 +20,129 @@ pub struct PhysicalDeviceShaderAtomicFloat2FeaturesEXT<'a> { pub sparse_image_float32_atomic_min_max: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceShaderAtomicFloat2FeaturesEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceShaderAtomicFloat2FeaturesEXT<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceShaderAtomicFloat2FeaturesEXT<'a> {} +impl<'a> Default for PhysicalDeviceShaderAtomicFloat2FeaturesEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + shader_buffer_float16_atomics: Default::default(), + shader_buffer_float16_atomic_add: Default::default(), + shader_buffer_float16_atomic_min_max: Default::default(), + shader_buffer_float32_atomic_min_max: Default::default(), + shader_buffer_float64_atomic_min_max: Default::default(), + shader_shared_float16_atomics: Default::default(), + shader_shared_float16_atomic_add: Default::default(), + shader_shared_float16_atomic_min_max: Default::default(), + shader_shared_float32_atomic_min_max: Default::default(), + shader_shared_float64_atomic_min_max: Default::default(), + shader_image_float32_atomic_min_max: Default::default(), + sparse_image_float32_atomic_min_max: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceShaderAtomicFloat2FeaturesEXT<'a> { + pub fn shader_buffer_float16_atomics( + mut self, + shader_buffer_float16_atomics: bool, + ) -> Self { + self.shader_buffer_float16_atomics = shader_buffer_float16_atomics.into(); + self + } + pub fn shader_buffer_float16_atomic_add( + mut self, + shader_buffer_float16_atomic_add: bool, + ) -> Self { + self.shader_buffer_float16_atomic_add = shader_buffer_float16_atomic_add.into(); + self + } + pub fn shader_buffer_float16_atomic_min_max( + mut self, + shader_buffer_float16_atomic_min_max: bool, + ) -> Self { + self.shader_buffer_float16_atomic_min_max = shader_buffer_float16_atomic_min_max + .into(); + self + } + pub fn shader_buffer_float32_atomic_min_max( + mut self, + shader_buffer_float32_atomic_min_max: bool, + ) -> Self { + self.shader_buffer_float32_atomic_min_max = shader_buffer_float32_atomic_min_max + .into(); + self + } + pub fn shader_buffer_float64_atomic_min_max( + mut self, + shader_buffer_float64_atomic_min_max: bool, + ) -> Self { + self.shader_buffer_float64_atomic_min_max = shader_buffer_float64_atomic_min_max + .into(); + self + } + pub fn shader_shared_float16_atomics( + mut self, + shader_shared_float16_atomics: bool, + ) -> Self { + self.shader_shared_float16_atomics = shader_shared_float16_atomics.into(); + self + } + pub fn shader_shared_float16_atomic_add( + mut self, + shader_shared_float16_atomic_add: bool, + ) -> Self { + self.shader_shared_float16_atomic_add = shader_shared_float16_atomic_add.into(); + self + } + pub fn shader_shared_float16_atomic_min_max( + mut self, + shader_shared_float16_atomic_min_max: bool, + ) -> Self { + self.shader_shared_float16_atomic_min_max = shader_shared_float16_atomic_min_max + .into(); + self + } + pub fn shader_shared_float32_atomic_min_max( + mut self, + shader_shared_float32_atomic_min_max: bool, + ) -> Self { + self.shader_shared_float32_atomic_min_max = shader_shared_float32_atomic_min_max + .into(); + self + } + pub fn shader_shared_float64_atomic_min_max( + mut self, + shader_shared_float64_atomic_min_max: bool, + ) -> Self { + self.shader_shared_float64_atomic_min_max = shader_shared_float64_atomic_min_max + .into(); + self + } + pub fn shader_image_float32_atomic_min_max( + mut self, + shader_image_float32_atomic_min_max: bool, + ) -> Self { + self.shader_image_float32_atomic_min_max = shader_image_float32_atomic_min_max + .into(); + self + } + pub fn sparse_image_float32_atomic_min_max( + mut self, + sparse_image_float32_atomic_min_max: bool, + ) -> Self { + self.sparse_image_float32_atomic_min_max = sparse_image_float32_atomic_min_max + .into(); + self + } +} ///Provided by [`ext::shader_atomic_float2`](crate::ext::shader_atomic_float2) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT: Self = Self( diff --git a/ash-rewrite/src/generated/ext/shader_float8.rs b/ash-rewrite/src/generated/ext/shader_float8.rs index 9c584a9d1..1dbc2be10 100644 --- a/ash-rewrite/src/generated/ext/shader_float8.rs +++ b/ash-rewrite/src/generated/ext/shader_float8.rs @@ -10,6 +10,38 @@ pub struct PhysicalDeviceShaderFloat8FeaturesEXT<'a> { pub shader_float8_cooperative_matrix: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceShaderFloat8FeaturesEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_SHADER_FLOAT8_FEATURES_EXT; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceShaderFloat8FeaturesEXT<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceShaderFloat8FeaturesEXT<'a> {} +impl<'a> Default for PhysicalDeviceShaderFloat8FeaturesEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + shader_float8: Default::default(), + shader_float8_cooperative_matrix: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceShaderFloat8FeaturesEXT<'a> { + pub fn shader_float8(mut self, shader_float8: bool) -> Self { + self.shader_float8 = shader_float8.into(); + self + } + pub fn shader_float8_cooperative_matrix( + mut self, + shader_float8_cooperative_matrix: bool, + ) -> Self { + self.shader_float8_cooperative_matrix = shader_float8_cooperative_matrix.into(); + self + } +} ///Provided by [`ext::shader_float8`](crate::ext::shader_float8) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_SHADER_FLOAT8_FEATURES_EXT: Self = Self(1000567000); diff --git a/ash-rewrite/src/generated/ext/shader_image_atomic_int64.rs b/ash-rewrite/src/generated/ext/shader_image_atomic_int64.rs index 42cf28e72..f3671735a 100644 --- a/ash-rewrite/src/generated/ext/shader_image_atomic_int64.rs +++ b/ash-rewrite/src/generated/ext/shader_image_atomic_int64.rs @@ -10,6 +10,41 @@ pub struct PhysicalDeviceShaderImageAtomicInt64FeaturesEXT<'a> { pub sparse_image_int64_atomics: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceShaderImageAtomicInt64FeaturesEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceShaderImageAtomicInt64FeaturesEXT<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceShaderImageAtomicInt64FeaturesEXT<'a> {} +impl<'a> Default for PhysicalDeviceShaderImageAtomicInt64FeaturesEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + shader_image_int64_atomics: Default::default(), + sparse_image_int64_atomics: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceShaderImageAtomicInt64FeaturesEXT<'a> { + pub fn shader_image_int64_atomics( + mut self, + shader_image_int64_atomics: bool, + ) -> Self { + self.shader_image_int64_atomics = shader_image_int64_atomics.into(); + self + } + pub fn sparse_image_int64_atomics( + mut self, + sparse_image_int64_atomics: bool, + ) -> Self { + self.sparse_image_int64_atomics = sparse_image_int64_atomics.into(); + self + } +} ///Provided by [`ext::shader_image_atomic_int64`](crate::ext::shader_image_atomic_int64) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT: Self = Self( diff --git a/ash-rewrite/src/generated/ext/shader_long_vector.rs b/ash-rewrite/src/generated/ext/shader_long_vector.rs index f998b8055..7ac509bef 100644 --- a/ash-rewrite/src/generated/ext/shader_long_vector.rs +++ b/ash-rewrite/src/generated/ext/shader_long_vector.rs @@ -9,6 +9,30 @@ pub struct PhysicalDeviceShaderLongVectorFeaturesEXT<'a> { pub long_vector: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceShaderLongVectorFeaturesEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_SHADER_LONG_VECTOR_FEATURES_EXT; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceShaderLongVectorFeaturesEXT<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceShaderLongVectorFeaturesEXT<'a> {} +impl<'a> Default for PhysicalDeviceShaderLongVectorFeaturesEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + long_vector: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceShaderLongVectorFeaturesEXT<'a> { + pub fn long_vector(mut self, long_vector: bool) -> Self { + self.long_vector = long_vector.into(); + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceShaderLongVectorPropertiesEXT<'a> { @@ -17,6 +41,28 @@ pub struct PhysicalDeviceShaderLongVectorPropertiesEXT<'a> { pub max_vector_components: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceShaderLongVectorPropertiesEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_SHADER_LONG_VECTOR_PROPERTIES_EXT; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceShaderLongVectorPropertiesEXT<'a> {} +impl<'a> Default for PhysicalDeviceShaderLongVectorPropertiesEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + max_vector_components: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceShaderLongVectorPropertiesEXT<'a> { + pub fn max_vector_components(mut self, max_vector_components: u32) -> Self { + self.max_vector_components = max_vector_components; + self + } +} ///Provided by [`ext::shader_long_vector`](crate::ext::shader_long_vector) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_SHADER_LONG_VECTOR_FEATURES_EXT: Self = Self(1000635000); diff --git a/ash-rewrite/src/generated/ext/shader_module_identifier.rs b/ash-rewrite/src/generated/ext/shader_module_identifier.rs index c6320ceed..1ff002794 100644 --- a/ash-rewrite/src/generated/ext/shader_module_identifier.rs +++ b/ash-rewrite/src/generated/ext/shader_module_identifier.rs @@ -60,6 +60,33 @@ pub(crate) mod reexport { pub shader_module_identifier: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceShaderModuleIdentifierFeaturesEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceShaderModuleIdentifierFeaturesEXT<'a> {} + unsafe impl<'a> crate::Extends> + for PhysicalDeviceShaderModuleIdentifierFeaturesEXT<'a> {} + impl<'a> Default for PhysicalDeviceShaderModuleIdentifierFeaturesEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + shader_module_identifier: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceShaderModuleIdentifierFeaturesEXT<'a> { + pub fn shader_module_identifier( + mut self, + shader_module_identifier: bool, + ) -> Self { + self.shader_module_identifier = shader_module_identifier.into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceShaderModuleIdentifierPropertiesEXT<'a> { @@ -68,6 +95,31 @@ pub(crate) mod reexport { pub shader_module_identifier_algorithm_uuid: [u8; crate::vk::UUID_SIZE as _], pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceShaderModuleIdentifierPropertiesEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceShaderModuleIdentifierPropertiesEXT<'a> {} + impl<'a> Default for PhysicalDeviceShaderModuleIdentifierPropertiesEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + shader_module_identifier_algorithm_uuid: unsafe { core::mem::zeroed() }, + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceShaderModuleIdentifierPropertiesEXT<'a> { + pub fn shader_module_identifier_algorithm_uuid( + mut self, + shader_module_identifier_algorithm_uuid: [u8; crate::vk::UUID_SIZE as _], + ) -> Self { + self.shader_module_identifier_algorithm_uuid = shader_module_identifier_algorithm_uuid; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PipelineShaderStageModuleIdentifierCreateInfoEXT<'a> { @@ -77,6 +129,34 @@ pub(crate) mod reexport { pub p_identifier: *const u8, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PipelineShaderStageModuleIdentifierCreateInfoEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT; + } + unsafe impl<'a> crate::Extends> + for PipelineShaderStageModuleIdentifierCreateInfoEXT<'a> {} + impl<'a> Default for PipelineShaderStageModuleIdentifierCreateInfoEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + identifier_size: Default::default(), + p_identifier: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PipelineShaderStageModuleIdentifierCreateInfoEXT<'a> { + pub fn identifier_size(mut self, identifier_size: u32) -> Self { + self.identifier_size = identifier_size; + self + } + pub fn p_identifier(mut self, p_identifier: &'a [u8]) -> Self { + self.identifier_size = p_identifier.len() as _; + self.p_identifier = p_identifier.as_ptr(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct ShaderModuleIdentifierEXT<'a> { @@ -86,6 +166,34 @@ pub(crate) mod reexport { pub identifier: [u8; crate::vk::MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT as _], pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for ShaderModuleIdentifierEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::SHADER_MODULE_IDENTIFIER_EXT; + } + impl<'a> Default for ShaderModuleIdentifierEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + identifier_size: Default::default(), + identifier: unsafe { core::mem::zeroed() }, + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> ShaderModuleIdentifierEXT<'a> { + pub fn identifier_size(mut self, identifier_size: u32) -> Self { + self.identifier_size = identifier_size; + self + } + pub fn identifier(mut self, identifier: &[u8]) -> Self { + self.identifier_size = identifier.len() as _; + self.identifier[..identifier.len()].copy_from_slice(identifier); + self + } + pub fn identifier_as_slice(&self) -> &[u8] { + &self.identifier[..self.identifier_size as _] + } + } ///Provided by [`ext::shader_module_identifier`](crate::ext::shader_module_identifier) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT: Self = Self( diff --git a/ash-rewrite/src/generated/ext/shader_object.rs b/ash-rewrite/src/generated/ext/shader_object.rs index 672f5b947..7fce6bdc0 100644 --- a/ash-rewrite/src/generated/ext/shader_object.rs +++ b/ash-rewrite/src/generated/ext/shader_object.rs @@ -112,6 +112,30 @@ pub(crate) mod reexport { pub shader_object: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceShaderObjectFeaturesEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceShaderObjectFeaturesEXT<'a> {} + unsafe impl<'a> crate::Extends> + for PhysicalDeviceShaderObjectFeaturesEXT<'a> {} + impl<'a> Default for PhysicalDeviceShaderObjectFeaturesEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + shader_object: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceShaderObjectFeaturesEXT<'a> { + pub fn shader_object(mut self, shader_object: bool) -> Self { + self.shader_object = shader_object.into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceShaderObjectPropertiesEXT<'a> { @@ -121,6 +145,36 @@ pub(crate) mod reexport { pub shader_binary_version: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceShaderObjectPropertiesEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceShaderObjectPropertiesEXT<'a> {} + impl<'a> Default for PhysicalDeviceShaderObjectPropertiesEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + shader_binary_uuid: unsafe { core::mem::zeroed() }, + shader_binary_version: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceShaderObjectPropertiesEXT<'a> { + pub fn shader_binary_uuid( + mut self, + shader_binary_uuid: [u8; crate::vk::UUID_SIZE as _], + ) -> Self { + self.shader_binary_uuid = shader_binary_uuid; + self + } + pub fn shader_binary_version(mut self, shader_binary_version: u32) -> Self { + self.shader_binary_version = shader_binary_version; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct ShaderCreateInfoEXT<'a> { @@ -140,6 +194,102 @@ pub(crate) mod reexport { pub p_specialization_info: *const crate::vk::SpecializationInfo<'a>, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for ShaderCreateInfoEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::SHADER_CREATE_INFO_EXT; + } + impl<'a> Default for ShaderCreateInfoEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + flags: Default::default(), + stage: Default::default(), + next_stage: Default::default(), + code_type: Default::default(), + code_size: Default::default(), + p_code: Default::default(), + p_name: Default::default(), + set_layout_count: Default::default(), + p_set_layouts: Default::default(), + push_constant_range_count: Default::default(), + p_push_constant_ranges: Default::default(), + p_specialization_info: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> ShaderCreateInfoEXT<'a> { + pub fn flags(mut self, flags: crate::vk::ShaderCreateFlagsEXT) -> Self { + self.flags = flags; + self + } + pub fn stage(mut self, stage: crate::vk::ShaderStageFlagBits) -> Self { + self.stage = stage; + self + } + pub fn next_stage(mut self, next_stage: crate::vk::ShaderStageFlags) -> Self { + self.next_stage = next_stage; + self + } + pub fn code_type(mut self, code_type: crate::vk::ShaderCodeTypeEXT) -> Self { + self.code_type = code_type; + self + } + pub fn code_size(mut self, code_size: usize) -> Self { + self.code_size = code_size; + self + } + pub fn p_code(mut self, p_code: &'a [u8]) -> Self { + self.code_size = p_code.len() as _; + self.p_code = p_code.as_ptr().cast(); + self + } + pub fn p_name(mut self, p_name: &'a core::ffi::CStr) -> Self { + self.p_name = p_name.as_ptr(); + self + } + pub unsafe fn p_name_as_c_str(&self) -> Option<&core::ffi::CStr> { + if self.p_name.is_null() { + None + } else { + Some(unsafe { core::ffi::CStr::from_ptr(self.p_name) }) + } + } + pub fn set_layout_count(mut self, set_layout_count: u32) -> Self { + self.set_layout_count = set_layout_count; + self + } + pub fn p_set_layouts( + mut self, + p_set_layouts: &'a [crate::vk::DescriptorSetLayout], + ) -> Self { + self.set_layout_count = p_set_layouts.len() as _; + self.p_set_layouts = p_set_layouts.as_ptr(); + self + } + pub fn push_constant_range_count( + mut self, + push_constant_range_count: u32, + ) -> Self { + self.push_constant_range_count = push_constant_range_count; + self + } + pub fn p_push_constant_ranges( + mut self, + p_push_constant_ranges: &'a [crate::vk::PushConstantRange], + ) -> Self { + self.push_constant_range_count = p_push_constant_ranges.len() as _; + self.p_push_constant_ranges = p_push_constant_ranges.as_ptr(); + self + } + pub fn p_specialization_info( + mut self, + p_specialization_info: &'a crate::vk::SpecializationInfo<'a>, + ) -> Self { + self.p_specialization_info = p_specialization_info; + self + } + } pub type ShaderRequiredSubgroupSizeCreateInfoEXT<'a> = crate::vk::PipelineShaderStageRequiredSubgroupSizeCreateInfo< 'a, >; @@ -277,7 +427,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct ShaderCreateFlagBitsEXT(pub(crate) u32); ///Provided by [`ext::shader_object`](crate::ext::shader_object) impl ShaderCreateFlagBitsEXT { diff --git a/ash-rewrite/src/generated/ext/shader_replicated_composites.rs b/ash-rewrite/src/generated/ext/shader_replicated_composites.rs index 9b291e29d..1d9981da2 100644 --- a/ash-rewrite/src/generated/ext/shader_replicated_composites.rs +++ b/ash-rewrite/src/generated/ext/shader_replicated_composites.rs @@ -9,6 +9,33 @@ pub struct PhysicalDeviceShaderReplicatedCompositesFeaturesEXT<'a> { pub shader_replicated_composites: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceShaderReplicatedCompositesFeaturesEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceShaderReplicatedCompositesFeaturesEXT<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceShaderReplicatedCompositesFeaturesEXT<'a> {} +impl<'a> Default for PhysicalDeviceShaderReplicatedCompositesFeaturesEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + shader_replicated_composites: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceShaderReplicatedCompositesFeaturesEXT<'a> { + pub fn shader_replicated_composites( + mut self, + shader_replicated_composites: bool, + ) -> Self { + self.shader_replicated_composites = shader_replicated_composites.into(); + self + } +} ///Provided by [`ext::shader_replicated_composites`](crate::ext::shader_replicated_composites) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT: Self = Self( diff --git a/ash-rewrite/src/generated/ext/shader_subgroup_partitioned.rs b/ash-rewrite/src/generated/ext/shader_subgroup_partitioned.rs index 189c79315..e205c9526 100644 --- a/ash-rewrite/src/generated/ext/shader_subgroup_partitioned.rs +++ b/ash-rewrite/src/generated/ext/shader_subgroup_partitioned.rs @@ -9,6 +9,33 @@ pub struct PhysicalDeviceShaderSubgroupPartitionedFeaturesEXT<'a> { pub shader_subgroup_partitioned: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceShaderSubgroupPartitionedFeaturesEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_SHADER_SUBGROUP_PARTITIONED_FEATURES_EXT; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceShaderSubgroupPartitionedFeaturesEXT<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceShaderSubgroupPartitionedFeaturesEXT<'a> {} +impl<'a> Default for PhysicalDeviceShaderSubgroupPartitionedFeaturesEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + shader_subgroup_partitioned: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceShaderSubgroupPartitionedFeaturesEXT<'a> { + pub fn shader_subgroup_partitioned( + mut self, + shader_subgroup_partitioned: bool, + ) -> Self { + self.shader_subgroup_partitioned = shader_subgroup_partitioned.into(); + self + } +} ///Provided by [`ext::shader_subgroup_partitioned`](crate::ext::shader_subgroup_partitioned) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_SHADER_SUBGROUP_PARTITIONED_FEATURES_EXT: Self = Self( diff --git a/ash-rewrite/src/generated/ext/shader_tile_image.rs b/ash-rewrite/src/generated/ext/shader_tile_image.rs index 0d87e6d16..5c666133a 100644 --- a/ash-rewrite/src/generated/ext/shader_tile_image.rs +++ b/ash-rewrite/src/generated/ext/shader_tile_image.rs @@ -11,6 +11,52 @@ pub struct PhysicalDeviceShaderTileImageFeaturesEXT<'a> { pub shader_tile_image_stencil_read_access: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceShaderTileImageFeaturesEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceShaderTileImageFeaturesEXT<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceShaderTileImageFeaturesEXT<'a> {} +impl<'a> Default for PhysicalDeviceShaderTileImageFeaturesEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + shader_tile_image_color_read_access: Default::default(), + shader_tile_image_depth_read_access: Default::default(), + shader_tile_image_stencil_read_access: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceShaderTileImageFeaturesEXT<'a> { + pub fn shader_tile_image_color_read_access( + mut self, + shader_tile_image_color_read_access: bool, + ) -> Self { + self.shader_tile_image_color_read_access = shader_tile_image_color_read_access + .into(); + self + } + pub fn shader_tile_image_depth_read_access( + mut self, + shader_tile_image_depth_read_access: bool, + ) -> Self { + self.shader_tile_image_depth_read_access = shader_tile_image_depth_read_access + .into(); + self + } + pub fn shader_tile_image_stencil_read_access( + mut self, + shader_tile_image_stencil_read_access: bool, + ) -> Self { + self.shader_tile_image_stencil_read_access = shader_tile_image_stencil_read_access + .into(); + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceShaderTileImagePropertiesEXT<'a> { @@ -21,6 +67,50 @@ pub struct PhysicalDeviceShaderTileImagePropertiesEXT<'a> { pub shader_tile_image_read_from_helper_invocation: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceShaderTileImagePropertiesEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceShaderTileImagePropertiesEXT<'a> {} +impl<'a> Default for PhysicalDeviceShaderTileImagePropertiesEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + shader_tile_image_coherent_read_accelerated: Default::default(), + shader_tile_image_read_sample_from_pixel_rate_invocation: Default::default(), + shader_tile_image_read_from_helper_invocation: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceShaderTileImagePropertiesEXT<'a> { + pub fn shader_tile_image_coherent_read_accelerated( + mut self, + shader_tile_image_coherent_read_accelerated: bool, + ) -> Self { + self.shader_tile_image_coherent_read_accelerated = shader_tile_image_coherent_read_accelerated + .into(); + self + } + pub fn shader_tile_image_read_sample_from_pixel_rate_invocation( + mut self, + shader_tile_image_read_sample_from_pixel_rate_invocation: bool, + ) -> Self { + self.shader_tile_image_read_sample_from_pixel_rate_invocation = shader_tile_image_read_sample_from_pixel_rate_invocation + .into(); + self + } + pub fn shader_tile_image_read_from_helper_invocation( + mut self, + shader_tile_image_read_from_helper_invocation: bool, + ) -> Self { + self.shader_tile_image_read_from_helper_invocation = shader_tile_image_read_from_helper_invocation + .into(); + self + } +} ///Provided by [`ext::shader_tile_image`](crate::ext::shader_tile_image) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT: Self = Self(1000395000); diff --git a/ash-rewrite/src/generated/ext/shader_uniform_buffer_unsized_array.rs b/ash-rewrite/src/generated/ext/shader_uniform_buffer_unsized_array.rs index 6a6a9f1e7..eea8b0f52 100644 --- a/ash-rewrite/src/generated/ext/shader_uniform_buffer_unsized_array.rs +++ b/ash-rewrite/src/generated/ext/shader_uniform_buffer_unsized_array.rs @@ -9,6 +9,34 @@ pub struct PhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT<'a> { pub shader_uniform_buffer_unsized_array: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_SHADER_UNIFORM_BUFFER_UNSIZED_ARRAY_FEATURES_EXT; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT<'a> {} +impl<'a> Default for PhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + shader_uniform_buffer_unsized_array: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT<'a> { + pub fn shader_uniform_buffer_unsized_array( + mut self, + shader_uniform_buffer_unsized_array: bool, + ) -> Self { + self.shader_uniform_buffer_unsized_array = shader_uniform_buffer_unsized_array + .into(); + self + } +} ///Provided by [`ext::shader_uniform_buffer_unsized_array`](crate::ext::shader_uniform_buffer_unsized_array) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_SHADER_UNIFORM_BUFFER_UNSIZED_ARRAY_FEATURES_EXT: Self = Self( diff --git a/ash-rewrite/src/generated/ext/subpass_merge_feedback.rs b/ash-rewrite/src/generated/ext/subpass_merge_feedback.rs index b68edf91a..96a4afecb 100644 --- a/ash-rewrite/src/generated/ext/subpass_merge_feedback.rs +++ b/ash-rewrite/src/generated/ext/subpass_merge_feedback.rs @@ -9,11 +9,40 @@ pub struct RenderPassCreationControlEXT<'a> { pub disallow_merging: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> for RenderPassCreationControlEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::RENDER_PASS_CREATION_CONTROL_EXT; +} +unsafe impl<'a> crate::Extends> +for RenderPassCreationControlEXT<'a> {} +unsafe impl<'a> crate::Extends> +for RenderPassCreationControlEXT<'a> {} +impl<'a> Default for RenderPassCreationControlEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + disallow_merging: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> RenderPassCreationControlEXT<'a> { + pub fn disallow_merging(mut self, disallow_merging: bool) -> Self { + self.disallow_merging = disallow_merging.into(); + self + } +} #[repr(C)] -#[derive(Clone, Copy)] +#[derive(Clone, Copy, Default)] pub struct RenderPassCreationFeedbackInfoEXT { pub post_merge_subpass_count: u32, } +impl RenderPassCreationFeedbackInfoEXT { + pub fn post_merge_subpass_count(mut self, post_merge_subpass_count: u32) -> Self { + self.post_merge_subpass_count = post_merge_subpass_count; + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct RenderPassCreationFeedbackCreateInfoEXT<'a> { @@ -22,6 +51,31 @@ pub struct RenderPassCreationFeedbackCreateInfoEXT<'a> { pub p_render_pass_feedback: *mut crate::vk::RenderPassCreationFeedbackInfoEXT, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for RenderPassCreationFeedbackCreateInfoEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::RENDER_PASS_CREATION_FEEDBACK_CREATE_INFO_EXT; +} +unsafe impl<'a> crate::Extends> +for RenderPassCreationFeedbackCreateInfoEXT<'a> {} +impl<'a> Default for RenderPassCreationFeedbackCreateInfoEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + p_render_pass_feedback: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> RenderPassCreationFeedbackCreateInfoEXT<'a> { + pub fn p_render_pass_feedback( + mut self, + p_render_pass_feedback: &'a mut crate::vk::RenderPassCreationFeedbackInfoEXT, + ) -> Self { + self.p_render_pass_feedback = p_render_pass_feedback; + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct RenderPassSubpassFeedbackInfoEXT { @@ -29,6 +83,40 @@ pub struct RenderPassSubpassFeedbackInfoEXT { pub description: [core::ffi::c_char; crate::vk::MAX_DESCRIPTION_SIZE as _], pub post_merge_index: u32, } +impl Default for RenderPassSubpassFeedbackInfoEXT { + fn default() -> Self { + Self { + subpass_merge_status: Default::default(), + description: unsafe { core::mem::zeroed() }, + post_merge_index: Default::default(), + } + } +} +impl RenderPassSubpassFeedbackInfoEXT { + pub fn subpass_merge_status( + mut self, + subpass_merge_status: crate::vk::SubpassMergeStatusEXT, + ) -> Self { + self.subpass_merge_status = subpass_merge_status; + self + } + pub fn description( + mut self, + description: &core::ffi::CStr, + ) -> core::result::Result { + crate::write_c_str_slice_with_nul(&mut self.description, description) + .map(|_| self) + } + pub fn description_as_c_str( + &self, + ) -> core::result::Result<&core::ffi::CStr, core::ffi::FromBytesUntilNulError> { + crate::wrap_c_str_slice_until_nul(&self.description) + } + pub fn post_merge_index(mut self, post_merge_index: u32) -> Self { + self.post_merge_index = post_merge_index; + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct RenderPassSubpassFeedbackCreateInfoEXT<'a> { @@ -37,6 +125,31 @@ pub struct RenderPassSubpassFeedbackCreateInfoEXT<'a> { pub p_subpass_feedback: *mut crate::vk::RenderPassSubpassFeedbackInfoEXT, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for RenderPassSubpassFeedbackCreateInfoEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::RENDER_PASS_SUBPASS_FEEDBACK_CREATE_INFO_EXT; +} +unsafe impl<'a> crate::Extends> +for RenderPassSubpassFeedbackCreateInfoEXT<'a> {} +impl<'a> Default for RenderPassSubpassFeedbackCreateInfoEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + p_subpass_feedback: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> RenderPassSubpassFeedbackCreateInfoEXT<'a> { + pub fn p_subpass_feedback( + mut self, + p_subpass_feedback: &'a mut crate::vk::RenderPassSubpassFeedbackInfoEXT, + ) -> Self { + self.p_subpass_feedback = p_subpass_feedback; + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceSubpassMergeFeedbackFeaturesEXT<'a> { @@ -45,6 +158,30 @@ pub struct PhysicalDeviceSubpassMergeFeedbackFeaturesEXT<'a> { pub subpass_merge_feedback: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceSubpassMergeFeedbackFeaturesEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceSubpassMergeFeedbackFeaturesEXT<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceSubpassMergeFeedbackFeaturesEXT<'a> {} +impl<'a> Default for PhysicalDeviceSubpassMergeFeedbackFeaturesEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + subpass_merge_feedback: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceSubpassMergeFeedbackFeaturesEXT<'a> { + pub fn subpass_merge_feedback(mut self, subpass_merge_feedback: bool) -> Self { + self.subpass_merge_feedback = subpass_merge_feedback.into(); + self + } +} ///Provided by [`ext::subpass_merge_feedback`](crate::ext::subpass_merge_feedback) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT: Self = Self( diff --git a/ash-rewrite/src/generated/ext/texel_buffer_alignment.rs b/ash-rewrite/src/generated/ext/texel_buffer_alignment.rs index 93ff314f4..a077fe03e 100644 --- a/ash-rewrite/src/generated/ext/texel_buffer_alignment.rs +++ b/ash-rewrite/src/generated/ext/texel_buffer_alignment.rs @@ -9,6 +9,30 @@ pub struct PhysicalDeviceTexelBufferAlignmentFeaturesEXT<'a> { pub texel_buffer_alignment: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceTexelBufferAlignmentFeaturesEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceTexelBufferAlignmentFeaturesEXT<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceTexelBufferAlignmentFeaturesEXT<'a> {} +impl<'a> Default for PhysicalDeviceTexelBufferAlignmentFeaturesEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + texel_buffer_alignment: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceTexelBufferAlignmentFeaturesEXT<'a> { + pub fn texel_buffer_alignment(mut self, texel_buffer_alignment: bool) -> Self { + self.texel_buffer_alignment = texel_buffer_alignment.into(); + self + } +} pub type PhysicalDeviceTexelBufferAlignmentPropertiesEXT<'a> = crate::vk::PhysicalDeviceTexelBufferAlignmentProperties< 'a, >; diff --git a/ash-rewrite/src/generated/ext/texture_compression_astc_3d.rs b/ash-rewrite/src/generated/ext/texture_compression_astc_3d.rs index c5224ee54..3af511f21 100644 --- a/ash-rewrite/src/generated/ext/texture_compression_astc_3d.rs +++ b/ash-rewrite/src/generated/ext/texture_compression_astc_3d.rs @@ -9,6 +9,33 @@ pub struct PhysicalDeviceTextureCompressionASTC3DFeaturesEXT<'a> { pub texture_compression_astc_3d: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceTextureCompressionASTC3DFeaturesEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_3D_FEATURES_EXT; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceTextureCompressionASTC3DFeaturesEXT<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceTextureCompressionASTC3DFeaturesEXT<'a> {} +impl<'a> Default for PhysicalDeviceTextureCompressionASTC3DFeaturesEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + texture_compression_astc_3d: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceTextureCompressionASTC3DFeaturesEXT<'a> { + pub fn texture_compression_astc_3d( + mut self, + texture_compression_astc_3d: bool, + ) -> Self { + self.texture_compression_astc_3d = texture_compression_astc_3d.into(); + self + } +} ///Provided by [`ext::texture_compression_astc_3d`](crate::ext::texture_compression_astc_3d) impl crate::vk::Format { pub const ASTC_3X3X3_UNORM_BLOCK_EXT: Self = Self(1000288000); diff --git a/ash-rewrite/src/generated/ext/transform_feedback.rs b/ash-rewrite/src/generated/ext/transform_feedback.rs index 8f2e81e2b..75382add0 100644 --- a/ash-rewrite/src/generated/ext/transform_feedback.rs +++ b/ash-rewrite/src/generated/ext/transform_feedback.rs @@ -139,6 +139,35 @@ pub(crate) mod reexport { pub geometry_streams: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceTransformFeedbackFeaturesEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceTransformFeedbackFeaturesEXT<'a> {} + unsafe impl<'a> crate::Extends> + for PhysicalDeviceTransformFeedbackFeaturesEXT<'a> {} + impl<'a> Default for PhysicalDeviceTransformFeedbackFeaturesEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + transform_feedback: Default::default(), + geometry_streams: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceTransformFeedbackFeaturesEXT<'a> { + pub fn transform_feedback(mut self, transform_feedback: bool) -> Self { + self.transform_feedback = transform_feedback.into(); + self + } + pub fn geometry_streams(mut self, geometry_streams: bool) -> Self { + self.geometry_streams = geometry_streams.into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceTransformFeedbackPropertiesEXT<'a> { @@ -156,6 +185,102 @@ pub(crate) mod reexport { pub transform_feedback_draw: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceTransformFeedbackPropertiesEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceTransformFeedbackPropertiesEXT<'a> {} + impl<'a> Default for PhysicalDeviceTransformFeedbackPropertiesEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + max_transform_feedback_streams: Default::default(), + max_transform_feedback_buffers: Default::default(), + max_transform_feedback_buffer_size: Default::default(), + max_transform_feedback_stream_data_size: Default::default(), + max_transform_feedback_buffer_data_size: Default::default(), + max_transform_feedback_buffer_data_stride: Default::default(), + transform_feedback_queries: Default::default(), + transform_feedback_streams_lines_triangles: Default::default(), + transform_feedback_rasterization_stream_select: Default::default(), + transform_feedback_draw: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceTransformFeedbackPropertiesEXT<'a> { + pub fn max_transform_feedback_streams( + mut self, + max_transform_feedback_streams: u32, + ) -> Self { + self.max_transform_feedback_streams = max_transform_feedback_streams; + self + } + pub fn max_transform_feedback_buffers( + mut self, + max_transform_feedback_buffers: u32, + ) -> Self { + self.max_transform_feedback_buffers = max_transform_feedback_buffers; + self + } + pub fn max_transform_feedback_buffer_size( + mut self, + max_transform_feedback_buffer_size: crate::vk::DeviceSize, + ) -> Self { + self.max_transform_feedback_buffer_size = max_transform_feedback_buffer_size; + self + } + pub fn max_transform_feedback_stream_data_size( + mut self, + max_transform_feedback_stream_data_size: u32, + ) -> Self { + self.max_transform_feedback_stream_data_size = max_transform_feedback_stream_data_size; + self + } + pub fn max_transform_feedback_buffer_data_size( + mut self, + max_transform_feedback_buffer_data_size: u32, + ) -> Self { + self.max_transform_feedback_buffer_data_size = max_transform_feedback_buffer_data_size; + self + } + pub fn max_transform_feedback_buffer_data_stride( + mut self, + max_transform_feedback_buffer_data_stride: u32, + ) -> Self { + self.max_transform_feedback_buffer_data_stride = max_transform_feedback_buffer_data_stride; + self + } + pub fn transform_feedback_queries( + mut self, + transform_feedback_queries: bool, + ) -> Self { + self.transform_feedback_queries = transform_feedback_queries.into(); + self + } + pub fn transform_feedback_streams_lines_triangles( + mut self, + transform_feedback_streams_lines_triangles: bool, + ) -> Self { + self.transform_feedback_streams_lines_triangles = transform_feedback_streams_lines_triangles + .into(); + self + } + pub fn transform_feedback_rasterization_stream_select( + mut self, + transform_feedback_rasterization_stream_select: bool, + ) -> Self { + self.transform_feedback_rasterization_stream_select = transform_feedback_rasterization_stream_select + .into(); + self + } + pub fn transform_feedback_draw(mut self, transform_feedback_draw: bool) -> Self { + self.transform_feedback_draw = transform_feedback_draw.into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PipelineRasterizationStateStreamCreateInfoEXT<'a> { @@ -165,6 +290,36 @@ pub(crate) mod reexport { pub rasterization_stream: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PipelineRasterizationStateStreamCreateInfoEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT; + } + unsafe impl<'a> crate::Extends> + for PipelineRasterizationStateStreamCreateInfoEXT<'a> {} + impl<'a> Default for PipelineRasterizationStateStreamCreateInfoEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + flags: Default::default(), + rasterization_stream: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PipelineRasterizationStateStreamCreateInfoEXT<'a> { + pub fn flags( + mut self, + flags: crate::vk::PipelineRasterizationStateStreamCreateFlagsEXT, + ) -> Self { + self.flags = flags; + self + } + pub fn rasterization_stream(mut self, rasterization_stream: u32) -> Self { + self.rasterization_stream = rasterization_stream; + self + } + } ///Provided by [`ext::transform_feedback`](crate::ext::transform_feedback) impl crate::vk::QueryType { pub const TRANSFORM_FEEDBACK_STREAM_EXT: Self = Self(1000028004); diff --git a/ash-rewrite/src/generated/ext/validation_cache.rs b/ash-rewrite/src/generated/ext/validation_cache.rs index c71d3762d..c6c9278ce 100644 --- a/ash-rewrite/src/generated/ext/validation_cache.rs +++ b/ash-rewrite/src/generated/ext/validation_cache.rs @@ -97,6 +97,36 @@ pub(crate) mod reexport { pub p_initial_data: *const core::ffi::c_void, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for ValidationCacheCreateInfoEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::VALIDATION_CACHE_CREATE_INFO_EXT; + } + impl<'a> Default for ValidationCacheCreateInfoEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + flags: Default::default(), + initial_data_size: Default::default(), + p_initial_data: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> ValidationCacheCreateInfoEXT<'a> { + pub fn flags(mut self, flags: crate::vk::ValidationCacheCreateFlagsEXT) -> Self { + self.flags = flags; + self + } + pub fn initial_data_size(mut self, initial_data_size: usize) -> Self { + self.initial_data_size = initial_data_size; + self + } + pub fn p_initial_data(mut self, p_initial_data: &'a [u8]) -> Self { + self.initial_data_size = p_initial_data.len() as _; + self.p_initial_data = p_initial_data.as_ptr().cast(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct ShaderModuleValidationCacheCreateInfoEXT<'a> { @@ -105,6 +135,33 @@ pub(crate) mod reexport { pub validation_cache: crate::vk::ValidationCacheEXT, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for ShaderModuleValidationCacheCreateInfoEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT; + } + unsafe impl<'a> crate::Extends> + for ShaderModuleValidationCacheCreateInfoEXT<'a> {} + unsafe impl<'a> crate::Extends> + for ShaderModuleValidationCacheCreateInfoEXT<'a> {} + impl<'a> Default for ShaderModuleValidationCacheCreateInfoEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + validation_cache: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> ShaderModuleValidationCacheCreateInfoEXT<'a> { + pub fn validation_cache( + mut self, + validation_cache: crate::vk::ValidationCacheEXT, + ) -> Self { + self.validation_cache = validation_cache; + self + } + } ///Provided by [`ext::validation_cache`](crate::ext::validation_cache) impl crate::vk::StructureType { pub const VALIDATION_CACHE_CREATE_INFO_EXT: Self = Self(1000160000); diff --git a/ash-rewrite/src/generated/ext/validation_features.rs b/ash-rewrite/src/generated/ext/validation_features.rs index 9ea143bf8..6692a3015 100644 --- a/ash-rewrite/src/generated/ext/validation_features.rs +++ b/ash-rewrite/src/generated/ext/validation_features.rs @@ -12,6 +12,61 @@ pub struct ValidationFeaturesEXT<'a> { pub p_disabled_validation_features: *const crate::vk::ValidationFeatureDisableEXT, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> for ValidationFeaturesEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::VALIDATION_FEATURES_EXT; +} +unsafe impl<'a> crate::Extends> +for ValidationFeaturesEXT<'a> {} +unsafe impl<'a> crate::Extends> +for ValidationFeaturesEXT<'a> {} +unsafe impl<'a> crate::Extends> +for ValidationFeaturesEXT<'a> {} +impl<'a> Default for ValidationFeaturesEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + enabled_validation_feature_count: Default::default(), + p_enabled_validation_features: Default::default(), + disabled_validation_feature_count: Default::default(), + p_disabled_validation_features: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> ValidationFeaturesEXT<'a> { + pub fn enabled_validation_feature_count( + mut self, + enabled_validation_feature_count: u32, + ) -> Self { + self.enabled_validation_feature_count = enabled_validation_feature_count; + self + } + pub fn p_enabled_validation_features( + mut self, + p_enabled_validation_features: &'a [crate::vk::ValidationFeatureEnableEXT], + ) -> Self { + self.enabled_validation_feature_count = p_enabled_validation_features.len() as _; + self.p_enabled_validation_features = p_enabled_validation_features.as_ptr(); + self + } + pub fn disabled_validation_feature_count( + mut self, + disabled_validation_feature_count: u32, + ) -> Self { + self.disabled_validation_feature_count = disabled_validation_feature_count; + self + } + pub fn p_disabled_validation_features( + mut self, + p_disabled_validation_features: &'a [crate::vk::ValidationFeatureDisableEXT], + ) -> Self { + self.disabled_validation_feature_count = p_disabled_validation_features.len() + as _; + self.p_disabled_validation_features = p_disabled_validation_features.as_ptr(); + self + } +} ///Provided by [`ext::validation_features`](crate::ext::validation_features) impl crate::vk::StructureType { pub const VALIDATION_FEATURES_EXT: Self = Self(1000247000); diff --git a/ash-rewrite/src/generated/ext/validation_flags.rs b/ash-rewrite/src/generated/ext/validation_flags.rs index 09c695c2e..ef0ddc700 100644 --- a/ash-rewrite/src/generated/ext/validation_flags.rs +++ b/ash-rewrite/src/generated/ext/validation_flags.rs @@ -10,6 +10,39 @@ pub struct ValidationFlagsEXT<'a> { pub p_disabled_validation_checks: *const crate::vk::ValidationCheckEXT, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> for ValidationFlagsEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::VALIDATION_FLAGS_EXT; +} +unsafe impl<'a> crate::Extends> +for ValidationFlagsEXT<'a> {} +impl<'a> Default for ValidationFlagsEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + disabled_validation_check_count: Default::default(), + p_disabled_validation_checks: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> ValidationFlagsEXT<'a> { + pub fn disabled_validation_check_count( + mut self, + disabled_validation_check_count: u32, + ) -> Self { + self.disabled_validation_check_count = disabled_validation_check_count; + self + } + pub fn p_disabled_validation_checks( + mut self, + p_disabled_validation_checks: &'a [crate::vk::ValidationCheckEXT], + ) -> Self { + self.disabled_validation_check_count = p_disabled_validation_checks.len() as _; + self.p_disabled_validation_checks = p_disabled_validation_checks.as_ptr(); + self + } +} ///Provided by [`ext::validation_flags`](crate::ext::validation_flags) impl crate::vk::StructureType { pub const VALIDATION_FLAGS_EXT: Self = Self(1000061000); diff --git a/ash-rewrite/src/generated/ext/vertex_attribute_divisor.rs b/ash-rewrite/src/generated/ext/vertex_attribute_divisor.rs index c4fe85e3d..2486ad2b6 100644 --- a/ash-rewrite/src/generated/ext/vertex_attribute_divisor.rs +++ b/ash-rewrite/src/generated/ext/vertex_attribute_divisor.rs @@ -9,6 +9,28 @@ pub struct PhysicalDeviceVertexAttributeDivisorPropertiesEXT<'a> { pub max_vertex_attrib_divisor: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceVertexAttributeDivisorPropertiesEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceVertexAttributeDivisorPropertiesEXT<'a> {} +impl<'a> Default for PhysicalDeviceVertexAttributeDivisorPropertiesEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + max_vertex_attrib_divisor: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceVertexAttributeDivisorPropertiesEXT<'a> { + pub fn max_vertex_attrib_divisor(mut self, max_vertex_attrib_divisor: u32) -> Self { + self.max_vertex_attrib_divisor = max_vertex_attrib_divisor; + self + } +} pub type VertexInputBindingDivisorDescriptionEXT = crate::vk::VertexInputBindingDivisorDescription; pub type PipelineVertexInputDivisorStateCreateInfoEXT<'a> = crate::vk::PipelineVertexInputDivisorStateCreateInfo< 'a, diff --git a/ash-rewrite/src/generated/ext/vertex_attribute_robustness.rs b/ash-rewrite/src/generated/ext/vertex_attribute_robustness.rs index 7ebaecda0..a19922496 100644 --- a/ash-rewrite/src/generated/ext/vertex_attribute_robustness.rs +++ b/ash-rewrite/src/generated/ext/vertex_attribute_robustness.rs @@ -9,6 +9,33 @@ pub struct PhysicalDeviceVertexAttributeRobustnessFeaturesEXT<'a> { pub vertex_attribute_robustness: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceVertexAttributeRobustnessFeaturesEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceVertexAttributeRobustnessFeaturesEXT<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceVertexAttributeRobustnessFeaturesEXT<'a> {} +impl<'a> Default for PhysicalDeviceVertexAttributeRobustnessFeaturesEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + vertex_attribute_robustness: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceVertexAttributeRobustnessFeaturesEXT<'a> { + pub fn vertex_attribute_robustness( + mut self, + vertex_attribute_robustness: bool, + ) -> Self { + self.vertex_attribute_robustness = vertex_attribute_robustness.into(); + self + } +} ///Provided by [`ext::vertex_attribute_robustness`](crate::ext::vertex_attribute_robustness) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT: Self = Self( diff --git a/ash-rewrite/src/generated/ext/vertex_input_dynamic_state.rs b/ash-rewrite/src/generated/ext/vertex_input_dynamic_state.rs index 527b44cff..4aa4d3472 100644 --- a/ash-rewrite/src/generated/ext/vertex_input_dynamic_state.rs +++ b/ash-rewrite/src/generated/ext/vertex_input_dynamic_state.rs @@ -46,6 +46,33 @@ pub(crate) mod reexport { pub vertex_input_dynamic_state: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceVertexInputDynamicStateFeaturesEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceVertexInputDynamicStateFeaturesEXT<'a> {} + unsafe impl<'a> crate::Extends> + for PhysicalDeviceVertexInputDynamicStateFeaturesEXT<'a> {} + impl<'a> Default for PhysicalDeviceVertexInputDynamicStateFeaturesEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + vertex_input_dynamic_state: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceVertexInputDynamicStateFeaturesEXT<'a> { + pub fn vertex_input_dynamic_state( + mut self, + vertex_input_dynamic_state: bool, + ) -> Self { + self.vertex_input_dynamic_state = vertex_input_dynamic_state.into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct VertexInputBindingDescription2EXT<'a> { @@ -57,6 +84,41 @@ pub(crate) mod reexport { pub divisor: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for VertexInputBindingDescription2EXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::VERTEX_INPUT_BINDING_DESCRIPTION_2_EXT; + } + impl<'a> Default for VertexInputBindingDescription2EXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + binding: Default::default(), + stride: Default::default(), + input_rate: Default::default(), + divisor: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> VertexInputBindingDescription2EXT<'a> { + pub fn binding(mut self, binding: u32) -> Self { + self.binding = binding; + self + } + pub fn stride(mut self, stride: u32) -> Self { + self.stride = stride; + self + } + pub fn input_rate(mut self, input_rate: crate::vk::VertexInputRate) -> Self { + self.input_rate = input_rate; + self + } + pub fn divisor(mut self, divisor: u32) -> Self { + self.divisor = divisor; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct VertexInputAttributeDescription2EXT<'a> { @@ -68,6 +130,41 @@ pub(crate) mod reexport { pub offset: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for VertexInputAttributeDescription2EXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::VERTEX_INPUT_ATTRIBUTE_DESCRIPTION_2_EXT; + } + impl<'a> Default for VertexInputAttributeDescription2EXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + location: Default::default(), + binding: Default::default(), + format: Default::default(), + offset: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> VertexInputAttributeDescription2EXT<'a> { + pub fn location(mut self, location: u32) -> Self { + self.location = location; + self + } + pub fn binding(mut self, binding: u32) -> Self { + self.binding = binding; + self + } + pub fn format(mut self, format: crate::vk::Format) -> Self { + self.format = format; + self + } + pub fn offset(mut self, offset: u32) -> Self { + self.offset = offset; + self + } + } ///Provided by [`ext::vertex_input_dynamic_state`](crate::ext::vertex_input_dynamic_state) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT: Self = Self( diff --git a/ash-rewrite/src/generated/ext/ycbcr_2plane_444_formats.rs b/ash-rewrite/src/generated/ext/ycbcr_2plane_444_formats.rs index 8de1db815..65a8ee7a1 100644 --- a/ash-rewrite/src/generated/ext/ycbcr_2plane_444_formats.rs +++ b/ash-rewrite/src/generated/ext/ycbcr_2plane_444_formats.rs @@ -9,6 +9,30 @@ pub struct PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT<'a> { pub ycbcr2plane444_formats: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT<'a> {} +impl<'a> Default for PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + ycbcr2plane444_formats: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT<'a> { + pub fn ycbcr2plane444_formats(mut self, ycbcr2plane444_formats: bool) -> Self { + self.ycbcr2plane444_formats = ycbcr2plane444_formats.into(); + self + } +} ///Provided by [`ext::ycbcr_2plane_444_formats`](crate::ext::ycbcr_2plane_444_formats) impl crate::vk::Format { pub const G8_B8R8_2PLANE_444_UNORM_EXT: Self = Self::G8_B8R8_2PLANE_444_UNORM; diff --git a/ash-rewrite/src/generated/ext/ycbcr_image_arrays.rs b/ash-rewrite/src/generated/ext/ycbcr_image_arrays.rs index b94b69beb..da2fe066d 100644 --- a/ash-rewrite/src/generated/ext/ycbcr_image_arrays.rs +++ b/ash-rewrite/src/generated/ext/ycbcr_image_arrays.rs @@ -9,6 +9,30 @@ pub struct PhysicalDeviceYcbcrImageArraysFeaturesEXT<'a> { pub ycbcr_image_arrays: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceYcbcrImageArraysFeaturesEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceYcbcrImageArraysFeaturesEXT<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceYcbcrImageArraysFeaturesEXT<'a> {} +impl<'a> Default for PhysicalDeviceYcbcrImageArraysFeaturesEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + ycbcr_image_arrays: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceYcbcrImageArraysFeaturesEXT<'a> { + pub fn ycbcr_image_arrays(mut self, ycbcr_image_arrays: bool) -> Self { + self.ycbcr_image_arrays = ycbcr_image_arrays.into(); + self + } +} ///Provided by [`ext::ycbcr_image_arrays`](crate::ext::ycbcr_image_arrays) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT: Self = Self(1000252000); diff --git a/ash-rewrite/src/generated/ext/zero_initialize_device_memory.rs b/ash-rewrite/src/generated/ext/zero_initialize_device_memory.rs index 5e3ad60e8..9f48a0de7 100644 --- a/ash-rewrite/src/generated/ext/zero_initialize_device_memory.rs +++ b/ash-rewrite/src/generated/ext/zero_initialize_device_memory.rs @@ -9,6 +9,33 @@ pub struct PhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT<'a> { pub zero_initialize_device_memory: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_ZERO_INITIALIZE_DEVICE_MEMORY_FEATURES_EXT; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT<'a> {} +impl<'a> Default for PhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + zero_initialize_device_memory: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT<'a> { + pub fn zero_initialize_device_memory( + mut self, + zero_initialize_device_memory: bool, + ) -> Self { + self.zero_initialize_device_memory = zero_initialize_device_memory.into(); + self + } +} ///Provided by [`ext::zero_initialize_device_memory`](crate::ext::zero_initialize_device_memory) impl crate::vk::ImageLayout { pub const ZERO_INITIALIZED_EXT: Self = Self(1000620000); diff --git a/ash-rewrite/src/generated/fuchsia/buffer_collection.rs b/ash-rewrite/src/generated/fuchsia/buffer_collection.rs index d5c78d721..962c74255 100644 --- a/ash-rewrite/src/generated/fuchsia/buffer_collection.rs +++ b/ash-rewrite/src/generated/fuchsia/buffer_collection.rs @@ -112,6 +112,36 @@ pub(crate) mod reexport { pub index: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for ImportMemoryBufferCollectionFUCHSIA<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA; + } + unsafe impl<'a> crate::Extends> + for ImportMemoryBufferCollectionFUCHSIA<'a> {} + impl<'a> Default for ImportMemoryBufferCollectionFUCHSIA<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + collection: Default::default(), + index: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> ImportMemoryBufferCollectionFUCHSIA<'a> { + pub fn collection( + mut self, + collection: crate::vk::BufferCollectionFUCHSIA, + ) -> Self { + self.collection = collection; + self + } + pub fn index(mut self, index: u32) -> Self { + self.index = index; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct BufferCollectionImageCreateInfoFUCHSIA<'a> { @@ -121,6 +151,36 @@ pub(crate) mod reexport { pub index: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for BufferCollectionImageCreateInfoFUCHSIA<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA; + } + unsafe impl<'a> crate::Extends> + for BufferCollectionImageCreateInfoFUCHSIA<'a> {} + impl<'a> Default for BufferCollectionImageCreateInfoFUCHSIA<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + collection: Default::default(), + index: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> BufferCollectionImageCreateInfoFUCHSIA<'a> { + pub fn collection( + mut self, + collection: crate::vk::BufferCollectionFUCHSIA, + ) -> Self { + self.collection = collection; + self + } + pub fn index(mut self, index: u32) -> Self { + self.index = index; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct BufferCollectionBufferCreateInfoFUCHSIA<'a> { @@ -130,6 +190,36 @@ pub(crate) mod reexport { pub index: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for BufferCollectionBufferCreateInfoFUCHSIA<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA; + } + unsafe impl<'a> crate::Extends> + for BufferCollectionBufferCreateInfoFUCHSIA<'a> {} + impl<'a> Default for BufferCollectionBufferCreateInfoFUCHSIA<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + collection: Default::default(), + index: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> BufferCollectionBufferCreateInfoFUCHSIA<'a> { + pub fn collection( + mut self, + collection: crate::vk::BufferCollectionFUCHSIA, + ) -> Self { + self.collection = collection; + self + } + pub fn index(mut self, index: u32) -> Self { + self.index = index; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct BufferCollectionCreateInfoFUCHSIA<'a> { @@ -138,6 +228,29 @@ pub(crate) mod reexport { pub collection_token: crate::platform_types::zx_handle_t, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for BufferCollectionCreateInfoFUCHSIA<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::BUFFER_COLLECTION_CREATE_INFO_FUCHSIA; + } + impl<'a> Default for BufferCollectionCreateInfoFUCHSIA<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + collection_token: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> BufferCollectionCreateInfoFUCHSIA<'a> { + pub fn collection_token( + mut self, + collection_token: crate::platform_types::zx_handle_t, + ) -> Self { + self.collection_token = collection_token; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct BufferCollectionPropertiesFUCHSIA<'a> { @@ -156,6 +269,97 @@ pub(crate) mod reexport { pub suggested_y_chroma_offset: crate::vk::ChromaLocation, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for BufferCollectionPropertiesFUCHSIA<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::BUFFER_COLLECTION_PROPERTIES_FUCHSIA; + } + impl<'a> Default for BufferCollectionPropertiesFUCHSIA<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + memory_type_bits: Default::default(), + buffer_count: Default::default(), + create_info_index: Default::default(), + sysmem_pixel_format: Default::default(), + format_features: Default::default(), + sysmem_color_space_index: Default::default(), + sampler_ycbcr_conversion_components: Default::default(), + suggested_ycbcr_model: Default::default(), + suggested_ycbcr_range: Default::default(), + suggested_x_chroma_offset: Default::default(), + suggested_y_chroma_offset: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> BufferCollectionPropertiesFUCHSIA<'a> { + pub fn memory_type_bits(mut self, memory_type_bits: u32) -> Self { + self.memory_type_bits = memory_type_bits; + self + } + pub fn buffer_count(mut self, buffer_count: u32) -> Self { + self.buffer_count = buffer_count; + self + } + pub fn create_info_index(mut self, create_info_index: u32) -> Self { + self.create_info_index = create_info_index; + self + } + pub fn sysmem_pixel_format(mut self, sysmem_pixel_format: u64) -> Self { + self.sysmem_pixel_format = sysmem_pixel_format; + self + } + pub fn format_features( + mut self, + format_features: crate::vk::FormatFeatureFlags, + ) -> Self { + self.format_features = format_features; + self + } + pub fn sysmem_color_space_index( + mut self, + sysmem_color_space_index: crate::vk::SysmemColorSpaceFUCHSIA<'a>, + ) -> Self { + self.sysmem_color_space_index = sysmem_color_space_index; + self + } + pub fn sampler_ycbcr_conversion_components( + mut self, + sampler_ycbcr_conversion_components: crate::vk::ComponentMapping, + ) -> Self { + self.sampler_ycbcr_conversion_components = sampler_ycbcr_conversion_components; + self + } + pub fn suggested_ycbcr_model( + mut self, + suggested_ycbcr_model: crate::vk::SamplerYcbcrModelConversion, + ) -> Self { + self.suggested_ycbcr_model = suggested_ycbcr_model; + self + } + pub fn suggested_ycbcr_range( + mut self, + suggested_ycbcr_range: crate::vk::SamplerYcbcrRange, + ) -> Self { + self.suggested_ycbcr_range = suggested_ycbcr_range; + self + } + pub fn suggested_x_chroma_offset( + mut self, + suggested_x_chroma_offset: crate::vk::ChromaLocation, + ) -> Self { + self.suggested_x_chroma_offset = suggested_x_chroma_offset; + self + } + pub fn suggested_y_chroma_offset( + mut self, + suggested_y_chroma_offset: crate::vk::ChromaLocation, + ) -> Self { + self.suggested_y_chroma_offset = suggested_y_chroma_offset; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct BufferConstraintsInfoFUCHSIA<'a> { @@ -168,6 +372,46 @@ pub(crate) mod reexport { >, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for BufferConstraintsInfoFUCHSIA<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::BUFFER_CONSTRAINTS_INFO_FUCHSIA; + } + impl<'a> Default for BufferConstraintsInfoFUCHSIA<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + create_info: Default::default(), + required_format_features: Default::default(), + buffer_collection_constraints: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> BufferConstraintsInfoFUCHSIA<'a> { + pub fn create_info( + mut self, + create_info: crate::vk::BufferCreateInfo<'a>, + ) -> Self { + self.create_info = create_info; + self + } + pub fn required_format_features( + mut self, + required_format_features: crate::vk::FormatFeatureFlags, + ) -> Self { + self.required_format_features = required_format_features; + self + } + pub fn buffer_collection_constraints( + mut self, + buffer_collection_constraints: crate::vk::BufferCollectionConstraintsInfoFUCHSIA< + 'a, + >, + ) -> Self { + self.buffer_collection_constraints = buffer_collection_constraints; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct SysmemColorSpaceFUCHSIA<'a> { @@ -176,6 +420,25 @@ pub(crate) mod reexport { pub color_space: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for SysmemColorSpaceFUCHSIA<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::SYSMEM_COLOR_SPACE_FUCHSIA; + } + impl<'a> Default for SysmemColorSpaceFUCHSIA<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + color_space: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> SysmemColorSpaceFUCHSIA<'a> { + pub fn color_space(mut self, color_space: u32) -> Self { + self.color_space = color_space; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct ImageFormatConstraintsInfoFUCHSIA<'a> { @@ -189,6 +452,64 @@ pub(crate) mod reexport { pub p_color_spaces: *const crate::vk::SysmemColorSpaceFUCHSIA<'a>, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for ImageFormatConstraintsInfoFUCHSIA<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::IMAGE_FORMAT_CONSTRAINTS_INFO_FUCHSIA; + } + impl<'a> Default for ImageFormatConstraintsInfoFUCHSIA<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + image_create_info: Default::default(), + required_format_features: Default::default(), + flags: Default::default(), + sysmem_pixel_format: Default::default(), + color_space_count: Default::default(), + p_color_spaces: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> ImageFormatConstraintsInfoFUCHSIA<'a> { + pub fn image_create_info( + mut self, + image_create_info: crate::vk::ImageCreateInfo<'a>, + ) -> Self { + self.image_create_info = image_create_info; + self + } + pub fn required_format_features( + mut self, + required_format_features: crate::vk::FormatFeatureFlags, + ) -> Self { + self.required_format_features = required_format_features; + self + } + pub fn flags( + mut self, + flags: crate::vk::ImageFormatConstraintsFlagsFUCHSIA, + ) -> Self { + self.flags = flags; + self + } + pub fn sysmem_pixel_format(mut self, sysmem_pixel_format: u64) -> Self { + self.sysmem_pixel_format = sysmem_pixel_format; + self + } + pub fn color_space_count(mut self, color_space_count: u32) -> Self { + self.color_space_count = color_space_count; + self + } + pub fn p_color_spaces( + mut self, + p_color_spaces: &'a [crate::vk::SysmemColorSpaceFUCHSIA<'a>], + ) -> Self { + self.color_space_count = p_color_spaces.len() as _; + self.p_color_spaces = p_color_spaces.as_ptr(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct ImageConstraintsInfoFUCHSIA<'a> { @@ -204,6 +525,55 @@ pub(crate) mod reexport { pub flags: crate::vk::ImageConstraintsInfoFlagsFUCHSIA, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for ImageConstraintsInfoFUCHSIA<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::IMAGE_CONSTRAINTS_INFO_FUCHSIA; + } + impl<'a> Default for ImageConstraintsInfoFUCHSIA<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + format_constraints_count: Default::default(), + p_format_constraints: Default::default(), + buffer_collection_constraints: Default::default(), + flags: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> ImageConstraintsInfoFUCHSIA<'a> { + pub fn format_constraints_count( + mut self, + format_constraints_count: u32, + ) -> Self { + self.format_constraints_count = format_constraints_count; + self + } + pub fn p_format_constraints( + mut self, + p_format_constraints: &'a [crate::vk::ImageFormatConstraintsInfoFUCHSIA<'a>], + ) -> Self { + self.format_constraints_count = p_format_constraints.len() as _; + self.p_format_constraints = p_format_constraints.as_ptr(); + self + } + pub fn buffer_collection_constraints( + mut self, + buffer_collection_constraints: crate::vk::BufferCollectionConstraintsInfoFUCHSIA< + 'a, + >, + ) -> Self { + self.buffer_collection_constraints = buffer_collection_constraints; + self + } + pub fn flags( + mut self, + flags: crate::vk::ImageConstraintsInfoFlagsFUCHSIA, + ) -> Self { + self.flags = flags; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct BufferCollectionConstraintsInfoFUCHSIA<'a> { @@ -216,6 +586,55 @@ pub(crate) mod reexport { pub min_buffer_count_for_shared_slack: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for BufferCollectionConstraintsInfoFUCHSIA<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::BUFFER_COLLECTION_CONSTRAINTS_INFO_FUCHSIA; + } + impl<'a> Default for BufferCollectionConstraintsInfoFUCHSIA<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + min_buffer_count: Default::default(), + max_buffer_count: Default::default(), + min_buffer_count_for_camping: Default::default(), + min_buffer_count_for_dedicated_slack: Default::default(), + min_buffer_count_for_shared_slack: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> BufferCollectionConstraintsInfoFUCHSIA<'a> { + pub fn min_buffer_count(mut self, min_buffer_count: u32) -> Self { + self.min_buffer_count = min_buffer_count; + self + } + pub fn max_buffer_count(mut self, max_buffer_count: u32) -> Self { + self.max_buffer_count = max_buffer_count; + self + } + pub fn min_buffer_count_for_camping( + mut self, + min_buffer_count_for_camping: u32, + ) -> Self { + self.min_buffer_count_for_camping = min_buffer_count_for_camping; + self + } + pub fn min_buffer_count_for_dedicated_slack( + mut self, + min_buffer_count_for_dedicated_slack: u32, + ) -> Self { + self.min_buffer_count_for_dedicated_slack = min_buffer_count_for_dedicated_slack; + self + } + pub fn min_buffer_count_for_shared_slack( + mut self, + min_buffer_count_for_shared_slack: u32, + ) -> Self { + self.min_buffer_count_for_shared_slack = min_buffer_count_for_shared_slack; + self + } + } ///Provided by [`fuchsia::buffer_collection`](crate::fuchsia::buffer_collection) impl crate::vk::StructureType { pub const BUFFER_COLLECTION_CREATE_INFO_FUCHSIA: Self = Self(1000366000); @@ -387,7 +806,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct ImageConstraintsInfoFlagBitsFUCHSIA(pub(crate) u32); ///Provided by [`fuchsia::buffer_collection`](crate::fuchsia::buffer_collection) impl ImageConstraintsInfoFlagBitsFUCHSIA { diff --git a/ash-rewrite/src/generated/fuchsia/external_memory.rs b/ash-rewrite/src/generated/fuchsia/external_memory.rs index a26741f9a..3c18c13de 100644 --- a/ash-rewrite/src/generated/fuchsia/external_memory.rs +++ b/ash-rewrite/src/generated/fuchsia/external_memory.rs @@ -62,6 +62,36 @@ pub(crate) mod reexport { pub handle: crate::platform_types::zx_handle_t, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for ImportMemoryZirconHandleInfoFUCHSIA<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA; + } + unsafe impl<'a> crate::Extends> + for ImportMemoryZirconHandleInfoFUCHSIA<'a> {} + impl<'a> Default for ImportMemoryZirconHandleInfoFUCHSIA<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + handle_type: Default::default(), + handle: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> ImportMemoryZirconHandleInfoFUCHSIA<'a> { + pub fn handle_type( + mut self, + handle_type: crate::vk::ExternalMemoryHandleTypeFlagBits, + ) -> Self { + self.handle_type = handle_type; + self + } + pub fn handle(mut self, handle: crate::platform_types::zx_handle_t) -> Self { + self.handle = handle; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct MemoryZirconHandlePropertiesFUCHSIA<'a> { @@ -70,6 +100,26 @@ pub(crate) mod reexport { pub memory_type_bits: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for MemoryZirconHandlePropertiesFUCHSIA<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::MEMORY_ZIRCON_HANDLE_PROPERTIES_FUCHSIA; + } + impl<'a> Default for MemoryZirconHandlePropertiesFUCHSIA<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + memory_type_bits: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> MemoryZirconHandlePropertiesFUCHSIA<'a> { + pub fn memory_type_bits(mut self, memory_type_bits: u32) -> Self { + self.memory_type_bits = memory_type_bits; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct MemoryGetZirconHandleInfoFUCHSIA<'a> { @@ -79,6 +129,33 @@ pub(crate) mod reexport { pub handle_type: crate::vk::ExternalMemoryHandleTypeFlagBits, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for MemoryGetZirconHandleInfoFUCHSIA<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::MEMORY_GET_ZIRCON_HANDLE_INFO_FUCHSIA; + } + impl<'a> Default for MemoryGetZirconHandleInfoFUCHSIA<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + memory: Default::default(), + handle_type: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> MemoryGetZirconHandleInfoFUCHSIA<'a> { + pub fn memory(mut self, memory: crate::vk::DeviceMemory) -> Self { + self.memory = memory; + self + } + pub fn handle_type( + mut self, + handle_type: crate::vk::ExternalMemoryHandleTypeFlagBits, + ) -> Self { + self.handle_type = handle_type; + self + } + } ///Provided by [`fuchsia::external_memory`](crate::fuchsia::external_memory) impl crate::vk::StructureType { pub const IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA: Self = Self(1000364000); diff --git a/ash-rewrite/src/generated/fuchsia/external_semaphore.rs b/ash-rewrite/src/generated/fuchsia/external_semaphore.rs index d2743aee4..5dc6a2ece 100644 --- a/ash-rewrite/src/generated/fuchsia/external_semaphore.rs +++ b/ash-rewrite/src/generated/fuchsia/external_semaphore.rs @@ -62,6 +62,47 @@ pub(crate) mod reexport { pub zircon_handle: crate::platform_types::zx_handle_t, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for ImportSemaphoreZirconHandleInfoFUCHSIA<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::IMPORT_SEMAPHORE_ZIRCON_HANDLE_INFO_FUCHSIA; + } + impl<'a> Default for ImportSemaphoreZirconHandleInfoFUCHSIA<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + semaphore: Default::default(), + flags: Default::default(), + handle_type: Default::default(), + zircon_handle: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> ImportSemaphoreZirconHandleInfoFUCHSIA<'a> { + pub fn semaphore(mut self, semaphore: crate::vk::Semaphore) -> Self { + self.semaphore = semaphore; + self + } + pub fn flags(mut self, flags: crate::vk::SemaphoreImportFlags) -> Self { + self.flags = flags; + self + } + pub fn handle_type( + mut self, + handle_type: crate::vk::ExternalSemaphoreHandleTypeFlagBits, + ) -> Self { + self.handle_type = handle_type; + self + } + pub fn zircon_handle( + mut self, + zircon_handle: crate::platform_types::zx_handle_t, + ) -> Self { + self.zircon_handle = zircon_handle; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct SemaphoreGetZirconHandleInfoFUCHSIA<'a> { @@ -71,6 +112,34 @@ pub(crate) mod reexport { pub handle_type: crate::vk::ExternalSemaphoreHandleTypeFlagBits, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for SemaphoreGetZirconHandleInfoFUCHSIA<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::SEMAPHORE_GET_ZIRCON_HANDLE_INFO_FUCHSIA; + } + impl<'a> Default for SemaphoreGetZirconHandleInfoFUCHSIA<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + semaphore: Default::default(), + handle_type: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> SemaphoreGetZirconHandleInfoFUCHSIA<'a> { + pub fn semaphore(mut self, semaphore: crate::vk::Semaphore) -> Self { + self.semaphore = semaphore; + self + } + pub fn handle_type( + mut self, + handle_type: crate::vk::ExternalSemaphoreHandleTypeFlagBits, + ) -> Self { + self.handle_type = handle_type; + self + } + } ///Provided by [`fuchsia::external_semaphore`](crate::fuchsia::external_semaphore) impl crate::vk::StructureType { pub const IMPORT_SEMAPHORE_ZIRCON_HANDLE_INFO_FUCHSIA: Self = Self(1000365000); diff --git a/ash-rewrite/src/generated/fuchsia/imagepipe_surface.rs b/ash-rewrite/src/generated/fuchsia/imagepipe_surface.rs index cc7fd272e..5e3e33c5c 100644 --- a/ash-rewrite/src/generated/fuchsia/imagepipe_surface.rs +++ b/ash-rewrite/src/generated/fuchsia/imagepipe_surface.rs @@ -46,6 +46,37 @@ pub(crate) mod reexport { pub image_pipe_handle: crate::platform_types::zx_handle_t, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for ImagePipeSurfaceCreateInfoFUCHSIA<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA; + } + impl<'a> Default for ImagePipeSurfaceCreateInfoFUCHSIA<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + flags: Default::default(), + image_pipe_handle: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> ImagePipeSurfaceCreateInfoFUCHSIA<'a> { + pub fn flags( + mut self, + flags: crate::vk::ImagePipeSurfaceCreateFlagsFUCHSIA, + ) -> Self { + self.flags = flags; + self + } + pub fn image_pipe_handle( + mut self, + image_pipe_handle: crate::platform_types::zx_handle_t, + ) -> Self { + self.image_pipe_handle = image_pipe_handle; + self + } + } ///Provided by [`fuchsia::imagepipe_surface`](crate::fuchsia::imagepipe_surface) impl crate::vk::StructureType { pub const IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA: Self = Self(1000214000); diff --git a/ash-rewrite/src/generated/ggp/frame_token.rs b/ash-rewrite/src/generated/ggp/frame_token.rs index 2d2476cde..21e2db2f4 100644 --- a/ash-rewrite/src/generated/ggp/frame_token.rs +++ b/ash-rewrite/src/generated/ggp/frame_token.rs @@ -9,6 +9,30 @@ pub struct PresentFrameTokenGGP<'a> { pub frame_token: crate::platform_types::GgpFrameToken, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> for PresentFrameTokenGGP<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PRESENT_FRAME_TOKEN_GGP; +} +unsafe impl<'a> crate::Extends> +for PresentFrameTokenGGP<'a> {} +impl<'a> Default for PresentFrameTokenGGP<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + frame_token: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PresentFrameTokenGGP<'a> { + pub fn frame_token( + mut self, + frame_token: crate::platform_types::GgpFrameToken, + ) -> Self { + self.frame_token = frame_token; + self + } +} ///Provided by [`ggp::frame_token`](crate::ggp::frame_token) impl crate::vk::StructureType { pub const PRESENT_FRAME_TOKEN_GGP: Self = Self(1000191000); diff --git a/ash-rewrite/src/generated/ggp/stream_descriptor_surface.rs b/ash-rewrite/src/generated/ggp/stream_descriptor_surface.rs index 47f1ece02..946cff039 100644 --- a/ash-rewrite/src/generated/ggp/stream_descriptor_surface.rs +++ b/ash-rewrite/src/generated/ggp/stream_descriptor_surface.rs @@ -46,6 +46,37 @@ pub(crate) mod reexport { pub stream_descriptor: crate::platform_types::GgpStreamDescriptor, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for StreamDescriptorSurfaceCreateInfoGGP<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::STREAM_DESCRIPTOR_SURFACE_CREATE_INFO_GGP; + } + impl<'a> Default for StreamDescriptorSurfaceCreateInfoGGP<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + flags: Default::default(), + stream_descriptor: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> StreamDescriptorSurfaceCreateInfoGGP<'a> { + pub fn flags( + mut self, + flags: crate::vk::StreamDescriptorSurfaceCreateFlagsGGP, + ) -> Self { + self.flags = flags; + self + } + pub fn stream_descriptor( + mut self, + stream_descriptor: crate::platform_types::GgpStreamDescriptor, + ) -> Self { + self.stream_descriptor = stream_descriptor; + self + } + } ///Provided by [`ggp::stream_descriptor_surface`](crate::ggp::stream_descriptor_surface) impl crate::vk::StructureType { pub const STREAM_DESCRIPTOR_SURFACE_CREATE_INFO_GGP: Self = Self(1000049000); diff --git a/ash-rewrite/src/generated/google/display_timing.rs b/ash-rewrite/src/generated/google/display_timing.rs index 3d6756d0b..e30072ac3 100644 --- a/ash-rewrite/src/generated/google/display_timing.rs +++ b/ash-rewrite/src/generated/google/display_timing.rs @@ -54,12 +54,18 @@ impl DeviceFn { } pub(crate) mod reexport { #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct RefreshCycleDurationGOOGLE { pub refresh_duration: u64, } + impl RefreshCycleDurationGOOGLE { + pub fn refresh_duration(mut self, refresh_duration: u64) -> Self { + self.refresh_duration = refresh_duration; + self + } + } #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct PastPresentationTimingGOOGLE { pub present_id: u32, pub desired_present_time: u64, @@ -67,6 +73,28 @@ pub(crate) mod reexport { pub earliest_present_time: u64, pub present_margin: u64, } + impl PastPresentationTimingGOOGLE { + pub fn present_id(mut self, present_id: u32) -> Self { + self.present_id = present_id; + self + } + pub fn desired_present_time(mut self, desired_present_time: u64) -> Self { + self.desired_present_time = desired_present_time; + self + } + pub fn actual_present_time(mut self, actual_present_time: u64) -> Self { + self.actual_present_time = actual_present_time; + self + } + pub fn earliest_present_time(mut self, earliest_present_time: u64) -> Self { + self.earliest_present_time = earliest_present_time; + self + } + pub fn present_margin(mut self, present_margin: u64) -> Self { + self.present_margin = present_margin; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PresentTimesInfoGOOGLE<'a> { @@ -76,12 +104,49 @@ pub(crate) mod reexport { pub p_times: *const crate::vk::PresentTimeGOOGLE, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for PresentTimesInfoGOOGLE<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PRESENT_TIMES_INFO_GOOGLE; + } + unsafe impl<'a> crate::Extends> + for PresentTimesInfoGOOGLE<'a> {} + impl<'a> Default for PresentTimesInfoGOOGLE<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + swapchain_count: Default::default(), + p_times: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PresentTimesInfoGOOGLE<'a> { + pub fn swapchain_count(mut self, swapchain_count: u32) -> Self { + self.swapchain_count = swapchain_count; + self + } + pub fn p_times(mut self, p_times: &'a [crate::vk::PresentTimeGOOGLE]) -> Self { + self.swapchain_count = p_times.len() as _; + self.p_times = p_times.as_ptr(); + self + } + } #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct PresentTimeGOOGLE { pub present_id: u32, pub desired_present_time: u64, } + impl PresentTimeGOOGLE { + pub fn present_id(mut self, present_id: u32) -> Self { + self.present_id = present_id; + self + } + pub fn desired_present_time(mut self, desired_present_time: u64) -> Self { + self.desired_present_time = desired_present_time; + self + } + } ///Provided by [`google::display_timing`](crate::google::display_timing) impl crate::vk::StructureType { pub const PRESENT_TIMES_INFO_GOOGLE: Self = Self(1000092000); diff --git a/ash-rewrite/src/generated/huawei/cluster_culling_shader.rs b/ash-rewrite/src/generated/huawei/cluster_culling_shader.rs index 3162cf30c..4e6b599b8 100644 --- a/ash-rewrite/src/generated/huawei/cluster_culling_shader.rs +++ b/ash-rewrite/src/generated/huawei/cluster_culling_shader.rs @@ -64,6 +64,55 @@ pub(crate) mod reexport { pub indirect_buffer_offset_alignment: crate::vk::DeviceSize, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceClusterCullingShaderPropertiesHUAWEI<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_PROPERTIES_HUAWEI; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceClusterCullingShaderPropertiesHUAWEI<'a> {} + impl<'a> Default for PhysicalDeviceClusterCullingShaderPropertiesHUAWEI<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + max_work_group_count: unsafe { core::mem::zeroed() }, + max_work_group_size: unsafe { core::mem::zeroed() }, + max_output_cluster_count: Default::default(), + indirect_buffer_offset_alignment: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceClusterCullingShaderPropertiesHUAWEI<'a> { + pub fn max_work_group_count( + mut self, + max_work_group_count: [u32; 3 as _], + ) -> Self { + self.max_work_group_count = max_work_group_count; + self + } + pub fn max_work_group_size( + mut self, + max_work_group_size: [u32; 3 as _], + ) -> Self { + self.max_work_group_size = max_work_group_size; + self + } + pub fn max_output_cluster_count( + mut self, + max_output_cluster_count: u32, + ) -> Self { + self.max_output_cluster_count = max_output_cluster_count; + self + } + pub fn indirect_buffer_offset_alignment( + mut self, + indirect_buffer_offset_alignment: crate::vk::DeviceSize, + ) -> Self { + self.indirect_buffer_offset_alignment = indirect_buffer_offset_alignment; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceClusterCullingShaderFeaturesHUAWEI<'a> { @@ -73,6 +122,39 @@ pub(crate) mod reexport { pub multiview_cluster_culling_shader: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceClusterCullingShaderFeaturesHUAWEI<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceClusterCullingShaderFeaturesHUAWEI<'a> {} + unsafe impl<'a> crate::Extends> + for PhysicalDeviceClusterCullingShaderFeaturesHUAWEI<'a> {} + impl<'a> Default for PhysicalDeviceClusterCullingShaderFeaturesHUAWEI<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + clusterculling_shader: Default::default(), + multiview_cluster_culling_shader: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceClusterCullingShaderFeaturesHUAWEI<'a> { + pub fn clusterculling_shader(mut self, clusterculling_shader: bool) -> Self { + self.clusterculling_shader = clusterculling_shader.into(); + self + } + pub fn multiview_cluster_culling_shader( + mut self, + multiview_cluster_culling_shader: bool, + ) -> Self { + self.multiview_cluster_culling_shader = multiview_cluster_culling_shader + .into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI<'a> { @@ -81,6 +163,30 @@ pub(crate) mod reexport { pub cluster_shading_rate: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_VRS_FEATURES_HUAWEI; + } + unsafe impl< + 'a, + > crate::Extends> + for PhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI<'a> {} + impl<'a> Default for PhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + cluster_shading_rate: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI<'a> { + pub fn cluster_shading_rate(mut self, cluster_shading_rate: bool) -> Self { + self.cluster_shading_rate = cluster_shading_rate.into(); + self + } + } ///Provided by [`huawei::cluster_culling_shader`](crate::huawei::cluster_culling_shader) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI: Self = Self( diff --git a/ash-rewrite/src/generated/huawei/hdr_vivid.rs b/ash-rewrite/src/generated/huawei/hdr_vivid.rs index 0386f8a5b..4324c6040 100644 --- a/ash-rewrite/src/generated/huawei/hdr_vivid.rs +++ b/ash-rewrite/src/generated/huawei/hdr_vivid.rs @@ -10,6 +10,33 @@ pub struct HdrVividDynamicMetadataHUAWEI<'a> { pub p_dynamic_metadata: *const core::ffi::c_void, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> for HdrVividDynamicMetadataHUAWEI<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::HDR_VIVID_DYNAMIC_METADATA_HUAWEI; +} +unsafe impl<'a> crate::Extends> +for HdrVividDynamicMetadataHUAWEI<'a> {} +impl<'a> Default for HdrVividDynamicMetadataHUAWEI<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + dynamic_metadata_size: Default::default(), + p_dynamic_metadata: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> HdrVividDynamicMetadataHUAWEI<'a> { + pub fn dynamic_metadata_size(mut self, dynamic_metadata_size: usize) -> Self { + self.dynamic_metadata_size = dynamic_metadata_size; + self + } + pub fn p_dynamic_metadata(mut self, p_dynamic_metadata: &'a [u8]) -> Self { + self.dynamic_metadata_size = p_dynamic_metadata.len() as _; + self.p_dynamic_metadata = p_dynamic_metadata.as_ptr().cast(); + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceHdrVividFeaturesHUAWEI<'a> { @@ -18,6 +45,29 @@ pub struct PhysicalDeviceHdrVividFeaturesHUAWEI<'a> { pub hdr_vivid: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> for PhysicalDeviceHdrVividFeaturesHUAWEI<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_HDR_VIVID_FEATURES_HUAWEI; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceHdrVividFeaturesHUAWEI<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceHdrVividFeaturesHUAWEI<'a> {} +impl<'a> Default for PhysicalDeviceHdrVividFeaturesHUAWEI<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + hdr_vivid: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceHdrVividFeaturesHUAWEI<'a> { + pub fn hdr_vivid(mut self, hdr_vivid: bool) -> Self { + self.hdr_vivid = hdr_vivid.into(); + self + } +} ///Provided by [`huawei::hdr_vivid`](crate::huawei::hdr_vivid) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_HDR_VIVID_FEATURES_HUAWEI: Self = Self(1000590000); diff --git a/ash-rewrite/src/generated/huawei/invocation_mask.rs b/ash-rewrite/src/generated/huawei/invocation_mask.rs index 63397300f..92b5fef78 100644 --- a/ash-rewrite/src/generated/huawei/invocation_mask.rs +++ b/ash-rewrite/src/generated/huawei/invocation_mask.rs @@ -44,6 +44,30 @@ pub(crate) mod reexport { pub invocation_mask: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceInvocationMaskFeaturesHUAWEI<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceInvocationMaskFeaturesHUAWEI<'a> {} + unsafe impl<'a> crate::Extends> + for PhysicalDeviceInvocationMaskFeaturesHUAWEI<'a> {} + impl<'a> Default for PhysicalDeviceInvocationMaskFeaturesHUAWEI<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + invocation_mask: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceInvocationMaskFeaturesHUAWEI<'a> { + pub fn invocation_mask(mut self, invocation_mask: bool) -> Self { + self.invocation_mask = invocation_mask.into(); + self + } + } ///Provided by [`huawei::invocation_mask`](crate::huawei::invocation_mask) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI: Self = Self( diff --git a/ash-rewrite/src/generated/huawei/subpass_shading.rs b/ash-rewrite/src/generated/huawei/subpass_shading.rs index 01c71f7b6..d51888cf3 100644 --- a/ash-rewrite/src/generated/huawei/subpass_shading.rs +++ b/ash-rewrite/src/generated/huawei/subpass_shading.rs @@ -61,6 +61,33 @@ pub(crate) mod reexport { pub subpass: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for SubpassShadingPipelineCreateInfoHUAWEI<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI; + } + unsafe impl<'a> crate::Extends> + for SubpassShadingPipelineCreateInfoHUAWEI<'a> {} + impl<'a> Default for SubpassShadingPipelineCreateInfoHUAWEI<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + render_pass: Default::default(), + subpass: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> SubpassShadingPipelineCreateInfoHUAWEI<'a> { + pub fn render_pass(mut self, render_pass: crate::vk::RenderPass) -> Self { + self.render_pass = render_pass; + self + } + pub fn subpass(mut self, subpass: u32) -> Self { + self.subpass = subpass; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceSubpassShadingPropertiesHUAWEI<'a> { @@ -69,6 +96,31 @@ pub(crate) mod reexport { pub max_subpass_shading_workgroup_size_aspect_ratio: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceSubpassShadingPropertiesHUAWEI<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceSubpassShadingPropertiesHUAWEI<'a> {} + impl<'a> Default for PhysicalDeviceSubpassShadingPropertiesHUAWEI<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + max_subpass_shading_workgroup_size_aspect_ratio: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceSubpassShadingPropertiesHUAWEI<'a> { + pub fn max_subpass_shading_workgroup_size_aspect_ratio( + mut self, + max_subpass_shading_workgroup_size_aspect_ratio: u32, + ) -> Self { + self.max_subpass_shading_workgroup_size_aspect_ratio = max_subpass_shading_workgroup_size_aspect_ratio; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceSubpassShadingFeaturesHUAWEI<'a> { @@ -77,6 +129,30 @@ pub(crate) mod reexport { pub subpass_shading: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceSubpassShadingFeaturesHUAWEI<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceSubpassShadingFeaturesHUAWEI<'a> {} + unsafe impl<'a> crate::Extends> + for PhysicalDeviceSubpassShadingFeaturesHUAWEI<'a> {} + impl<'a> Default for PhysicalDeviceSubpassShadingFeaturesHUAWEI<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + subpass_shading: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceSubpassShadingFeaturesHUAWEI<'a> { + pub fn subpass_shading(mut self, subpass_shading: bool) -> Self { + self.subpass_shading = subpass_shading.into(); + self + } + } ///Provided by [`huawei::subpass_shading`](crate::huawei::subpass_shading) impl crate::vk::PipelineBindPoint { pub const SUBPASS_SHADING_HUAWEI: Self = Self(1000369003); diff --git a/ash-rewrite/src/generated/img/relaxed_line_rasterization.rs b/ash-rewrite/src/generated/img/relaxed_line_rasterization.rs index 03486608a..251098db2 100644 --- a/ash-rewrite/src/generated/img/relaxed_line_rasterization.rs +++ b/ash-rewrite/src/generated/img/relaxed_line_rasterization.rs @@ -9,6 +9,33 @@ pub struct PhysicalDeviceRelaxedLineRasterizationFeaturesIMG<'a> { pub relaxed_line_rasterization: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceRelaxedLineRasterizationFeaturesIMG<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceRelaxedLineRasterizationFeaturesIMG<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceRelaxedLineRasterizationFeaturesIMG<'a> {} +impl<'a> Default for PhysicalDeviceRelaxedLineRasterizationFeaturesIMG<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + relaxed_line_rasterization: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceRelaxedLineRasterizationFeaturesIMG<'a> { + pub fn relaxed_line_rasterization( + mut self, + relaxed_line_rasterization: bool, + ) -> Self { + self.relaxed_line_rasterization = relaxed_line_rasterization.into(); + self + } +} ///Provided by [`img::relaxed_line_rasterization`](crate::img::relaxed_line_rasterization) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG: Self = Self( diff --git a/ash-rewrite/src/generated/intel/performance_query.rs b/ash-rewrite/src/generated/intel/performance_query.rs index f4c728e65..7e7b93653 100644 --- a/ash-rewrite/src/generated/intel/performance_query.rs +++ b/ash-rewrite/src/generated/intel/performance_query.rs @@ -157,11 +157,21 @@ impl DeviceFn { } pub(crate) mod reexport { #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct PerformanceValueINTEL { pub _type: crate::vk::PerformanceValueTypeINTEL, pub data: crate::vk::PerformanceValueDataINTEL, } + impl PerformanceValueINTEL { + pub fn _type(mut self, _type: crate::vk::PerformanceValueTypeINTEL) -> Self { + self._type = _type; + self + } + pub fn data(mut self, data: crate::vk::PerformanceValueDataINTEL) -> Self { + self.data = data; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct InitializePerformanceApiInfoINTEL<'a> { @@ -170,6 +180,26 @@ pub(crate) mod reexport { pub p_user_data: *mut core::ffi::c_void, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for InitializePerformanceApiInfoINTEL<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::INITIALIZE_PERFORMANCE_API_INFO_INTEL; + } + impl<'a> Default for InitializePerformanceApiInfoINTEL<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + p_user_data: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> InitializePerformanceApiInfoINTEL<'a> { + pub fn p_user_data(mut self, p_user_data: &'a mut core::ffi::c_void) -> Self { + self.p_user_data = p_user_data; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct QueryPoolPerformanceQueryCreateInfoINTEL<'a> { @@ -178,6 +208,31 @@ pub(crate) mod reexport { pub performance_counters_sampling: crate::vk::QueryPoolSamplingModeINTEL, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for QueryPoolPerformanceQueryCreateInfoINTEL<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL; + } + unsafe impl<'a> crate::Extends> + for QueryPoolPerformanceQueryCreateInfoINTEL<'a> {} + impl<'a> Default for QueryPoolPerformanceQueryCreateInfoINTEL<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + performance_counters_sampling: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> QueryPoolPerformanceQueryCreateInfoINTEL<'a> { + pub fn performance_counters_sampling( + mut self, + performance_counters_sampling: crate::vk::QueryPoolSamplingModeINTEL, + ) -> Self { + self.performance_counters_sampling = performance_counters_sampling; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PerformanceMarkerInfoINTEL<'a> { @@ -186,6 +241,25 @@ pub(crate) mod reexport { pub marker: u64, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for PerformanceMarkerInfoINTEL<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PERFORMANCE_MARKER_INFO_INTEL; + } + impl<'a> Default for PerformanceMarkerInfoINTEL<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + marker: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PerformanceMarkerInfoINTEL<'a> { + pub fn marker(mut self, marker: u64) -> Self { + self.marker = marker; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PerformanceStreamMarkerInfoINTEL<'a> { @@ -194,6 +268,25 @@ pub(crate) mod reexport { pub marker: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for PerformanceStreamMarkerInfoINTEL<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PERFORMANCE_STREAM_MARKER_INFO_INTEL; + } + impl<'a> Default for PerformanceStreamMarkerInfoINTEL<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + marker: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PerformanceStreamMarkerInfoINTEL<'a> { + pub fn marker(mut self, marker: u32) -> Self { + self.marker = marker; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PerformanceOverrideInfoINTEL<'a> { @@ -204,6 +297,35 @@ pub(crate) mod reexport { pub parameter: u64, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for PerformanceOverrideInfoINTEL<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PERFORMANCE_OVERRIDE_INFO_INTEL; + } + impl<'a> Default for PerformanceOverrideInfoINTEL<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + _type: Default::default(), + enable: Default::default(), + parameter: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PerformanceOverrideInfoINTEL<'a> { + pub fn _type(mut self, _type: crate::vk::PerformanceOverrideTypeINTEL) -> Self { + self._type = _type; + self + } + pub fn enable(mut self, enable: bool) -> Self { + self.enable = enable.into(); + self + } + pub fn parameter(mut self, parameter: u64) -> Self { + self.parameter = parameter; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PerformanceConfigurationAcquireInfoINTEL<'a> { @@ -212,6 +334,29 @@ pub(crate) mod reexport { pub _type: crate::vk::PerformanceConfigurationTypeINTEL, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PerformanceConfigurationAcquireInfoINTEL<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PERFORMANCE_CONFIGURATION_ACQUIRE_INFO_INTEL; + } + impl<'a> Default for PerformanceConfigurationAcquireInfoINTEL<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + _type: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PerformanceConfigurationAcquireInfoINTEL<'a> { + pub fn _type( + mut self, + _type: crate::vk::PerformanceConfigurationTypeINTEL, + ) -> Self { + self._type = _type; + self + } + } pub type QueryPoolCreateInfoINTEL<'a> = crate::vk::QueryPoolPerformanceQueryCreateInfoINTEL< 'a, >; @@ -224,6 +369,11 @@ pub(crate) mod reexport { pub value_bool: crate::vk::Bool32, pub value_string: *const core::ffi::c_char, } + impl Default for PerformanceValueDataINTEL { + fn default() -> Self { + unsafe { core::mem::zeroed() } + } + } ///Provided by [`intel::performance_query`](crate::intel::performance_query) impl crate::vk::QueryType { pub const PERFORMANCE_QUERY_INTEL: Self = Self(1000210000); diff --git a/ash-rewrite/src/generated/intel/shader_integer_functions2.rs b/ash-rewrite/src/generated/intel/shader_integer_functions2.rs index 2b6b22343..8dd3eb769 100644 --- a/ash-rewrite/src/generated/intel/shader_integer_functions2.rs +++ b/ash-rewrite/src/generated/intel/shader_integer_functions2.rs @@ -9,6 +9,30 @@ pub struct PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL<'a> { pub shader_integer_functions2: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL<'a> {} +impl<'a> Default for PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + shader_integer_functions2: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL<'a> { + pub fn shader_integer_functions2(mut self, shader_integer_functions2: bool) -> Self { + self.shader_integer_functions2 = shader_integer_functions2.into(); + self + } +} ///Provided by [`intel::shader_integer_functions2`](crate::intel::shader_integer_functions2) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL: Self = Self( diff --git a/ash-rewrite/src/generated/khr/acceleration_structure.rs b/ash-rewrite/src/generated/khr/acceleration_structure.rs index 67029f5bf..24054133d 100644 --- a/ash-rewrite/src/generated/khr/acceleration_structure.rs +++ b/ash-rewrite/src/generated/khr/acceleration_structure.rs @@ -301,6 +301,40 @@ pub(crate) mod reexport { pub p_acceleration_structures: *const crate::vk::AccelerationStructureKHR, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for WriteDescriptorSetAccelerationStructureKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR; + } + unsafe impl<'a> crate::Extends> + for WriteDescriptorSetAccelerationStructureKHR<'a> {} + impl<'a> Default for WriteDescriptorSetAccelerationStructureKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + acceleration_structure_count: Default::default(), + p_acceleration_structures: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> WriteDescriptorSetAccelerationStructureKHR<'a> { + pub fn acceleration_structure_count( + mut self, + acceleration_structure_count: u32, + ) -> Self { + self.acceleration_structure_count = acceleration_structure_count; + self + } + pub fn p_acceleration_structures( + mut self, + p_acceleration_structures: &'a [crate::vk::AccelerationStructureKHR], + ) -> Self { + self.acceleration_structure_count = p_acceleration_structures.len() as _; + self.p_acceleration_structures = p_acceleration_structures.as_ptr(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceAccelerationStructureFeaturesKHR<'a> { @@ -313,6 +347,66 @@ pub(crate) mod reexport { pub descriptor_binding_acceleration_structure_update_after_bind: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceAccelerationStructureFeaturesKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceAccelerationStructureFeaturesKHR<'a> {} + unsafe impl<'a> crate::Extends> + for PhysicalDeviceAccelerationStructureFeaturesKHR<'a> {} + impl<'a> Default for PhysicalDeviceAccelerationStructureFeaturesKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + acceleration_structure: Default::default(), + acceleration_structure_capture_replay: Default::default(), + acceleration_structure_indirect_build: Default::default(), + acceleration_structure_host_commands: Default::default(), + descriptor_binding_acceleration_structure_update_after_bind: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceAccelerationStructureFeaturesKHR<'a> { + pub fn acceleration_structure(mut self, acceleration_structure: bool) -> Self { + self.acceleration_structure = acceleration_structure.into(); + self + } + pub fn acceleration_structure_capture_replay( + mut self, + acceleration_structure_capture_replay: bool, + ) -> Self { + self.acceleration_structure_capture_replay = acceleration_structure_capture_replay + .into(); + self + } + pub fn acceleration_structure_indirect_build( + mut self, + acceleration_structure_indirect_build: bool, + ) -> Self { + self.acceleration_structure_indirect_build = acceleration_structure_indirect_build + .into(); + self + } + pub fn acceleration_structure_host_commands( + mut self, + acceleration_structure_host_commands: bool, + ) -> Self { + self.acceleration_structure_host_commands = acceleration_structure_host_commands + .into(); + self + } + pub fn descriptor_binding_acceleration_structure_update_after_bind( + mut self, + descriptor_binding_acceleration_structure_update_after_bind: bool, + ) -> Self { + self.descriptor_binding_acceleration_structure_update_after_bind = descriptor_binding_acceleration_structure_update_after_bind + .into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceAccelerationStructurePropertiesKHR<'a> { @@ -328,6 +422,78 @@ pub(crate) mod reexport { pub min_acceleration_structure_scratch_offset_alignment: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceAccelerationStructurePropertiesKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceAccelerationStructurePropertiesKHR<'a> {} + impl<'a> Default for PhysicalDeviceAccelerationStructurePropertiesKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + max_geometry_count: Default::default(), + max_instance_count: Default::default(), + max_primitive_count: Default::default(), + max_per_stage_descriptor_acceleration_structures: Default::default(), + max_per_stage_descriptor_update_after_bind_acceleration_structures: Default::default(), + max_descriptor_set_acceleration_structures: Default::default(), + max_descriptor_set_update_after_bind_acceleration_structures: Default::default(), + min_acceleration_structure_scratch_offset_alignment: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceAccelerationStructurePropertiesKHR<'a> { + pub fn max_geometry_count(mut self, max_geometry_count: u64) -> Self { + self.max_geometry_count = max_geometry_count; + self + } + pub fn max_instance_count(mut self, max_instance_count: u64) -> Self { + self.max_instance_count = max_instance_count; + self + } + pub fn max_primitive_count(mut self, max_primitive_count: u64) -> Self { + self.max_primitive_count = max_primitive_count; + self + } + pub fn max_per_stage_descriptor_acceleration_structures( + mut self, + max_per_stage_descriptor_acceleration_structures: u32, + ) -> Self { + self.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, + ) -> Self { + self.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, + ) -> Self { + self.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, + ) -> Self { + self.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, + ) -> Self { + self.min_acceleration_structure_scratch_offset_alignment = min_acceleration_structure_scratch_offset_alignment; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct AccelerationStructureGeometryTrianglesDataKHR<'a> { @@ -342,6 +508,65 @@ pub(crate) mod reexport { pub transform_data: crate::vk::DeviceOrHostAddressConstKHR, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for AccelerationStructureGeometryTrianglesDataKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR; + } + impl<'a> Default for AccelerationStructureGeometryTrianglesDataKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + vertex_format: Default::default(), + vertex_data: Default::default(), + vertex_stride: Default::default(), + max_vertex: Default::default(), + index_type: Default::default(), + index_data: Default::default(), + transform_data: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> AccelerationStructureGeometryTrianglesDataKHR<'a> { + pub fn vertex_format(mut self, vertex_format: crate::vk::Format) -> Self { + self.vertex_format = vertex_format; + self + } + pub fn vertex_data( + mut self, + vertex_data: crate::vk::DeviceOrHostAddressConstKHR, + ) -> Self { + self.vertex_data = vertex_data; + self + } + pub fn vertex_stride(mut self, vertex_stride: crate::vk::DeviceSize) -> Self { + self.vertex_stride = vertex_stride; + self + } + pub fn max_vertex(mut self, max_vertex: u32) -> Self { + self.max_vertex = max_vertex; + self + } + pub fn index_type(mut self, index_type: crate::vk::IndexType) -> Self { + self.index_type = index_type; + self + } + pub fn index_data( + mut self, + index_data: crate::vk::DeviceOrHostAddressConstKHR, + ) -> Self { + self.index_data = index_data; + self + } + pub fn transform_data( + mut self, + transform_data: crate::vk::DeviceOrHostAddressConstKHR, + ) -> Self { + self.transform_data = transform_data; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct AccelerationStructureGeometryAabbsDataKHR<'a> { @@ -351,6 +576,31 @@ pub(crate) mod reexport { pub stride: crate::vk::DeviceSize, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for AccelerationStructureGeometryAabbsDataKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA_KHR; + } + impl<'a> Default for AccelerationStructureGeometryAabbsDataKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + data: Default::default(), + stride: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> AccelerationStructureGeometryAabbsDataKHR<'a> { + pub fn data(mut self, data: crate::vk::DeviceOrHostAddressConstKHR) -> Self { + self.data = data; + self + } + pub fn stride(mut self, stride: crate::vk::DeviceSize) -> Self { + self.stride = stride; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct AccelerationStructureGeometryInstancesDataKHR<'a> { @@ -360,6 +610,31 @@ pub(crate) mod reexport { pub data: crate::vk::DeviceOrHostAddressConstKHR, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for AccelerationStructureGeometryInstancesDataKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR; + } + impl<'a> Default for AccelerationStructureGeometryInstancesDataKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + array_of_pointers: Default::default(), + data: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> AccelerationStructureGeometryInstancesDataKHR<'a> { + pub fn array_of_pointers(mut self, array_of_pointers: bool) -> Self { + self.array_of_pointers = array_of_pointers.into(); + self + } + pub fn data(mut self, data: crate::vk::DeviceOrHostAddressConstKHR) -> Self { + self.data = data; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct AccelerationStructureGeometryKHR<'a> { @@ -370,6 +645,41 @@ pub(crate) mod reexport { pub flags: crate::vk::GeometryFlagsKHR, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for AccelerationStructureGeometryKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::ACCELERATION_STRUCTURE_GEOMETRY_KHR; + } + impl<'a> Default for AccelerationStructureGeometryKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + geometry_type: Default::default(), + geometry: Default::default(), + flags: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> AccelerationStructureGeometryKHR<'a> { + pub fn geometry_type( + mut self, + geometry_type: crate::vk::GeometryTypeKHR, + ) -> Self { + self.geometry_type = geometry_type; + self + } + pub fn geometry( + mut self, + geometry: crate::vk::AccelerationStructureGeometryDataKHR<'a>, + ) -> Self { + self.geometry = geometry; + self + } + pub fn flags(mut self, flags: crate::vk::GeometryFlagsKHR) -> Self { + self.flags = flags; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct AccelerationStructureBuildGeometryInfoKHR<'a> { @@ -386,14 +696,115 @@ pub(crate) mod reexport { pub scratch_data: crate::vk::DeviceOrHostAddressKHR, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for AccelerationStructureBuildGeometryInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::ACCELERATION_STRUCTURE_BUILD_GEOMETRY_INFO_KHR; + } + impl<'a> Default for AccelerationStructureBuildGeometryInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + _type: Default::default(), + flags: Default::default(), + mode: Default::default(), + src_acceleration_structure: Default::default(), + dst_acceleration_structure: Default::default(), + geometry_count: Default::default(), + p_geometries: Default::default(), + pp_geometries: Default::default(), + scratch_data: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> AccelerationStructureBuildGeometryInfoKHR<'a> { + pub fn _type(mut self, _type: crate::vk::AccelerationStructureTypeKHR) -> Self { + self._type = _type; + self + } + pub fn flags( + mut self, + flags: crate::vk::BuildAccelerationStructureFlagsKHR, + ) -> Self { + self.flags = flags; + self + } + pub fn mode( + mut self, + mode: crate::vk::BuildAccelerationStructureModeKHR, + ) -> Self { + self.mode = mode; + self + } + pub fn src_acceleration_structure( + mut self, + src_acceleration_structure: crate::vk::AccelerationStructureKHR, + ) -> Self { + self.src_acceleration_structure = src_acceleration_structure; + self + } + pub fn dst_acceleration_structure( + mut self, + dst_acceleration_structure: crate::vk::AccelerationStructureKHR, + ) -> Self { + self.dst_acceleration_structure = dst_acceleration_structure; + self + } + pub fn geometry_count(mut self, geometry_count: u32) -> Self { + self.geometry_count = geometry_count; + self + } + pub fn p_geometries( + mut self, + p_geometries: &'a [crate::vk::AccelerationStructureGeometryKHR<'a>], + ) -> Self { + self.geometry_count = p_geometries.len() as _; + self.p_geometries = p_geometries.as_ptr(); + self + } + pub fn pp_geometries( + mut self, + pp_geometries: &'a [&'a crate::vk::AccelerationStructureGeometryKHR<'a>], + ) -> Self { + self.geometry_count = pp_geometries.len() as _; + self.pp_geometries = pp_geometries.as_ptr().cast(); + self + } + pub fn scratch_data( + mut self, + scratch_data: crate::vk::DeviceOrHostAddressKHR, + ) -> Self { + self.scratch_data = scratch_data; + self + } + } #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct AccelerationStructureBuildRangeInfoKHR { pub primitive_count: u32, pub primitive_offset: u32, pub first_vertex: u32, pub transform_offset: u32, } + impl AccelerationStructureBuildRangeInfoKHR { + pub fn primitive_count(mut self, primitive_count: u32) -> Self { + self.primitive_count = primitive_count; + self + } + pub fn primitive_offset(mut self, primitive_offset: u32) -> Self { + self.primitive_offset = primitive_offset; + self + } + pub fn first_vertex(mut self, first_vertex: u32) -> Self { + self.first_vertex = first_vertex; + self + } + pub fn transform_offset(mut self, transform_offset: u32) -> Self { + self.transform_offset = transform_offset; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct AccelerationStructureCreateInfoKHR<'a> { @@ -407,8 +818,59 @@ pub(crate) mod reexport { pub device_address: crate::vk::DeviceAddress, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for AccelerationStructureCreateInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::ACCELERATION_STRUCTURE_CREATE_INFO_KHR; + } + impl<'a> Default for AccelerationStructureCreateInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + create_flags: Default::default(), + buffer: Default::default(), + offset: Default::default(), + size: Default::default(), + _type: Default::default(), + device_address: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> AccelerationStructureCreateInfoKHR<'a> { + pub fn create_flags( + mut self, + create_flags: crate::vk::AccelerationStructureCreateFlagsKHR, + ) -> Self { + self.create_flags = create_flags; + self + } + pub fn buffer(mut self, buffer: crate::vk::Buffer) -> Self { + self.buffer = buffer; + self + } + pub fn offset(mut self, offset: crate::vk::DeviceSize) -> Self { + self.offset = offset; + self + } + pub fn size(mut self, size: crate::vk::DeviceSize) -> Self { + self.size = size; + self + } + pub fn _type(mut self, _type: crate::vk::AccelerationStructureTypeKHR) -> Self { + self._type = _type; + self + } + pub fn device_address( + mut self, + device_address: crate::vk::DeviceAddress, + ) -> Self { + self.device_address = device_address; + self + } + } #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct AabbPositionsKHR { pub min_x: core::ffi::c_float, pub min_y: core::ffi::c_float, @@ -417,13 +879,52 @@ pub(crate) mod reexport { pub max_y: core::ffi::c_float, pub max_z: core::ffi::c_float, } + impl AabbPositionsKHR { + pub fn min_x(mut self, min_x: core::ffi::c_float) -> Self { + self.min_x = min_x; + self + } + pub fn min_y(mut self, min_y: core::ffi::c_float) -> Self { + self.min_y = min_y; + self + } + pub fn min_z(mut self, min_z: core::ffi::c_float) -> Self { + self.min_z = min_z; + self + } + pub fn max_x(mut self, max_x: core::ffi::c_float) -> Self { + self.max_x = max_x; + self + } + pub fn max_y(mut self, max_y: core::ffi::c_float) -> Self { + self.max_y = max_y; + self + } + pub fn max_z(mut self, max_z: core::ffi::c_float) -> Self { + self.max_z = max_z; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct TransformMatrixKHR { pub matrix: [[core::ffi::c_float; 4 as _]; 3 as _], } + impl Default for TransformMatrixKHR { + fn default() -> Self { + Self { + matrix: unsafe { core::mem::zeroed() }, + } + } + } + impl TransformMatrixKHR { + pub fn matrix(mut self, matrix: [[core::ffi::c_float; 4 as _]; 3 as _]) -> Self { + self.matrix = matrix; + self + } + } #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct AccelerationStructureInstanceKHR { pub transform: crate::vk::TransformMatrixKHR, /**- `instanceCustomIndex` @ `0..24` @@ -434,6 +935,43 @@ pub(crate) mod reexport { pub bitfield1: u32, pub acceleration_structure_reference: u64, } + impl AccelerationStructureInstanceKHR { + pub fn transform(mut self, transform: crate::vk::TransformMatrixKHR) -> Self { + self.transform = transform; + self + } + pub fn instance_custom_index(mut self, instance_custom_index: u32) -> Self { + let rest = self.bitfield0 & 0xFF000000; + self.bitfield0 = (instance_custom_index & 0x00FFFFFF) | rest; + self + } + pub fn mask(mut self, mask: u32) -> Self { + let rest = self.bitfield0 & 0x00FFFFFF; + self.bitfield0 = ((mask << 24u32) & 0xFF000000) | rest; + self + } + pub fn instance_shader_binding_table_record_offset( + mut self, + instance_shader_binding_table_record_offset: u32, + ) -> Self { + let rest = self.bitfield1 & 0xFF000000; + self.bitfield1 = (instance_shader_binding_table_record_offset & 0x00FFFFFF) + | rest; + self + } + pub fn flags(mut self, flags: u32) -> Self { + let rest = self.bitfield1 & 0x00FFFFFF; + self.bitfield1 = ((flags << 24u32) & 0xFF000000) | rest; + self + } + pub fn acceleration_structure_reference( + mut self, + acceleration_structure_reference: u64, + ) -> Self { + self.acceleration_structure_reference = acceleration_structure_reference; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct AccelerationStructureDeviceAddressInfoKHR<'a> { @@ -442,6 +980,29 @@ pub(crate) mod reexport { pub acceleration_structure: crate::vk::AccelerationStructureKHR, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for AccelerationStructureDeviceAddressInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::ACCELERATION_STRUCTURE_DEVICE_ADDRESS_INFO_KHR; + } + impl<'a> Default for AccelerationStructureDeviceAddressInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + acceleration_structure: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> AccelerationStructureDeviceAddressInfoKHR<'a> { + pub fn acceleration_structure( + mut self, + acceleration_structure: crate::vk::AccelerationStructureKHR, + ) -> Self { + self.acceleration_structure = acceleration_structure; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct AccelerationStructureVersionInfoKHR<'a> { @@ -450,6 +1011,26 @@ pub(crate) mod reexport { pub p_version_data: *const u8, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for AccelerationStructureVersionInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::ACCELERATION_STRUCTURE_VERSION_INFO_KHR; + } + impl<'a> Default for AccelerationStructureVersionInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + p_version_data: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> AccelerationStructureVersionInfoKHR<'a> { + pub fn p_version_data(mut self, p_version_data: *const u8) -> Self { + self.p_version_data = p_version_data; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct CopyAccelerationStructureInfoKHR<'a> { @@ -460,6 +1041,38 @@ pub(crate) mod reexport { pub mode: crate::vk::CopyAccelerationStructureModeKHR, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for CopyAccelerationStructureInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::COPY_ACCELERATION_STRUCTURE_INFO_KHR; + } + impl<'a> Default for CopyAccelerationStructureInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + src: Default::default(), + dst: Default::default(), + mode: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> CopyAccelerationStructureInfoKHR<'a> { + pub fn src(mut self, src: crate::vk::AccelerationStructureKHR) -> Self { + self.src = src; + self + } + pub fn dst(mut self, dst: crate::vk::AccelerationStructureKHR) -> Self { + self.dst = dst; + self + } + pub fn mode( + mut self, + mode: crate::vk::CopyAccelerationStructureModeKHR, + ) -> Self { + self.mode = mode; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct CopyAccelerationStructureToMemoryInfoKHR<'a> { @@ -470,6 +1083,39 @@ pub(crate) mod reexport { pub mode: crate::vk::CopyAccelerationStructureModeKHR, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for CopyAccelerationStructureToMemoryInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::COPY_ACCELERATION_STRUCTURE_TO_MEMORY_INFO_KHR; + } + impl<'a> Default for CopyAccelerationStructureToMemoryInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + src: Default::default(), + dst: Default::default(), + mode: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> CopyAccelerationStructureToMemoryInfoKHR<'a> { + pub fn src(mut self, src: crate::vk::AccelerationStructureKHR) -> Self { + self.src = src; + self + } + pub fn dst(mut self, dst: crate::vk::DeviceOrHostAddressKHR) -> Self { + self.dst = dst; + self + } + pub fn mode( + mut self, + mode: crate::vk::CopyAccelerationStructureModeKHR, + ) -> Self { + self.mode = mode; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct CopyMemoryToAccelerationStructureInfoKHR<'a> { @@ -480,6 +1126,39 @@ pub(crate) mod reexport { pub mode: crate::vk::CopyAccelerationStructureModeKHR, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for CopyMemoryToAccelerationStructureInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::COPY_MEMORY_TO_ACCELERATION_STRUCTURE_INFO_KHR; + } + impl<'a> Default for CopyMemoryToAccelerationStructureInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + src: Default::default(), + dst: Default::default(), + mode: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> CopyMemoryToAccelerationStructureInfoKHR<'a> { + pub fn src(mut self, src: crate::vk::DeviceOrHostAddressConstKHR) -> Self { + self.src = src; + self + } + pub fn dst(mut self, dst: crate::vk::AccelerationStructureKHR) -> Self { + self.dst = dst; + self + } + pub fn mode( + mut self, + mode: crate::vk::CopyAccelerationStructureModeKHR, + ) -> Self { + self.mode = mode; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct AccelerationStructureBuildSizesInfoKHR<'a> { @@ -490,18 +1169,67 @@ pub(crate) mod reexport { pub build_scratch_size: crate::vk::DeviceSize, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for AccelerationStructureBuildSizesInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR; + } + impl<'a> Default for AccelerationStructureBuildSizesInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + acceleration_structure_size: Default::default(), + update_scratch_size: Default::default(), + build_scratch_size: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> AccelerationStructureBuildSizesInfoKHR<'a> { + pub fn acceleration_structure_size( + mut self, + acceleration_structure_size: crate::vk::DeviceSize, + ) -> Self { + self.acceleration_structure_size = acceleration_structure_size; + self + } + pub fn update_scratch_size( + mut self, + update_scratch_size: crate::vk::DeviceSize, + ) -> Self { + self.update_scratch_size = update_scratch_size; + self + } + pub fn build_scratch_size( + mut self, + build_scratch_size: crate::vk::DeviceSize, + ) -> Self { + self.build_scratch_size = build_scratch_size; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub union DeviceOrHostAddressKHR { pub device_address: crate::vk::DeviceAddress, pub host_address: *mut core::ffi::c_void, } + impl Default for DeviceOrHostAddressKHR { + fn default() -> Self { + unsafe { core::mem::zeroed() } + } + } #[repr(C)] #[derive(Clone, Copy)] pub union DeviceOrHostAddressConstKHR { pub device_address: crate::vk::DeviceAddress, pub host_address: *const core::ffi::c_void, } + impl Default for DeviceOrHostAddressConstKHR { + fn default() -> Self { + unsafe { core::mem::zeroed() } + } + } #[repr(C)] #[derive(Clone, Copy)] pub union AccelerationStructureGeometryDataKHR<'a> { @@ -509,6 +1237,11 @@ pub(crate) mod reexport { pub aabbs: crate::vk::AccelerationStructureGeometryAabbsDataKHR<'a>, pub instances: crate::vk::AccelerationStructureGeometryInstancesDataKHR<'a>, } + impl<'a> Default for AccelerationStructureGeometryDataKHR<'a> { + fn default() -> Self { + unsafe { core::mem::zeroed() } + } + } ///Provided by [`khr::acceleration_structure`](crate::khr::acceleration_structure) impl crate::vk::DescriptorType { pub const ACCELERATION_STRUCTURE_KHR: Self = Self(1000150000); @@ -769,7 +1502,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct GeometryFlagBitsKHR(pub(crate) u32); ///Provided by [`khr::acceleration_structure`](crate::khr::acceleration_structure) impl GeometryFlagBitsKHR { @@ -877,7 +1610,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct GeometryInstanceFlagBitsKHR(pub(crate) u32); ///Provided by [`khr::acceleration_structure`](crate::khr::acceleration_structure) impl GeometryInstanceFlagBitsKHR { @@ -1008,7 +1741,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct BuildAccelerationStructureFlagBitsKHR(pub(crate) u32); ///Provided by [`khr::acceleration_structure`](crate::khr::acceleration_structure) impl BuildAccelerationStructureFlagBitsKHR { @@ -1096,7 +1829,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct AccelerationStructureCreateFlagBitsKHR(pub(crate) u32); ///Provided by [`khr::acceleration_structure`](crate::khr::acceleration_structure) impl AccelerationStructureCreateFlagBitsKHR { diff --git a/ash-rewrite/src/generated/khr/android_surface.rs b/ash-rewrite/src/generated/khr/android_surface.rs index f273246ea..4d11f95f1 100644 --- a/ash-rewrite/src/generated/khr/android_surface.rs +++ b/ash-rewrite/src/generated/khr/android_surface.rs @@ -46,6 +46,33 @@ pub(crate) mod reexport { pub window: *mut crate::platform_types::ANativeWindow, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for AndroidSurfaceCreateInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::ANDROID_SURFACE_CREATE_INFO_KHR; + } + impl<'a> Default for AndroidSurfaceCreateInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + flags: Default::default(), + window: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> AndroidSurfaceCreateInfoKHR<'a> { + pub fn flags(mut self, flags: crate::vk::AndroidSurfaceCreateFlagsKHR) -> Self { + self.flags = flags; + self + } + pub fn window( + mut self, + window: &'a mut crate::platform_types::ANativeWindow, + ) -> Self { + self.window = window; + self + } + } ///Provided by [`khr::android_surface`](crate::khr::android_surface) impl crate::vk::StructureType { pub const ANDROID_SURFACE_CREATE_INFO_KHR: Self = Self(1000008000); diff --git a/ash-rewrite/src/generated/khr/calibrated_timestamps.rs b/ash-rewrite/src/generated/khr/calibrated_timestamps.rs index 483efa6a6..f9f90f345 100644 --- a/ash-rewrite/src/generated/khr/calibrated_timestamps.rs +++ b/ash-rewrite/src/generated/khr/calibrated_timestamps.rs @@ -82,6 +82,25 @@ pub(crate) mod reexport { pub time_domain: crate::vk::TimeDomainKHR, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for CalibratedTimestampInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::CALIBRATED_TIMESTAMP_INFO_KHR; + } + impl<'a> Default for CalibratedTimestampInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + time_domain: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> CalibratedTimestampInfoKHR<'a> { + pub fn time_domain(mut self, time_domain: crate::vk::TimeDomainKHR) -> Self { + self.time_domain = time_domain; + self + } + } ///Provided by [`khr::calibrated_timestamps`](crate::khr::calibrated_timestamps) impl crate::vk::StructureType { pub const CALIBRATED_TIMESTAMP_INFO_KHR: Self = Self(1000184000); diff --git a/ash-rewrite/src/generated/khr/compute_shader_derivatives.rs b/ash-rewrite/src/generated/khr/compute_shader_derivatives.rs index 41c6addfc..3a859acd1 100644 --- a/ash-rewrite/src/generated/khr/compute_shader_derivatives.rs +++ b/ash-rewrite/src/generated/khr/compute_shader_derivatives.rs @@ -10,6 +10,41 @@ pub struct PhysicalDeviceComputeShaderDerivativesFeaturesKHR<'a> { pub compute_derivative_group_linear: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceComputeShaderDerivativesFeaturesKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_KHR; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceComputeShaderDerivativesFeaturesKHR<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceComputeShaderDerivativesFeaturesKHR<'a> {} +impl<'a> Default for PhysicalDeviceComputeShaderDerivativesFeaturesKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + compute_derivative_group_quads: Default::default(), + compute_derivative_group_linear: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceComputeShaderDerivativesFeaturesKHR<'a> { + pub fn compute_derivative_group_quads( + mut self, + compute_derivative_group_quads: bool, + ) -> Self { + self.compute_derivative_group_quads = compute_derivative_group_quads.into(); + self + } + pub fn compute_derivative_group_linear( + mut self, + compute_derivative_group_linear: bool, + ) -> Self { + self.compute_derivative_group_linear = compute_derivative_group_linear.into(); + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceComputeShaderDerivativesPropertiesKHR<'a> { @@ -18,6 +53,31 @@ pub struct PhysicalDeviceComputeShaderDerivativesPropertiesKHR<'a> { pub mesh_and_task_shader_derivatives: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceComputeShaderDerivativesPropertiesKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_PROPERTIES_KHR; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceComputeShaderDerivativesPropertiesKHR<'a> {} +impl<'a> Default for PhysicalDeviceComputeShaderDerivativesPropertiesKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + mesh_and_task_shader_derivatives: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceComputeShaderDerivativesPropertiesKHR<'a> { + pub fn mesh_and_task_shader_derivatives( + mut self, + mesh_and_task_shader_derivatives: bool, + ) -> Self { + self.mesh_and_task_shader_derivatives = mesh_and_task_shader_derivatives.into(); + self + } +} ///Provided by [`khr::compute_shader_derivatives`](crate::khr::compute_shader_derivatives) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_KHR: Self = Self( diff --git a/ash-rewrite/src/generated/khr/cooperative_matrix.rs b/ash-rewrite/src/generated/khr/cooperative_matrix.rs index 04b0f6a22..47c399086 100644 --- a/ash-rewrite/src/generated/khr/cooperative_matrix.rs +++ b/ash-rewrite/src/generated/khr/cooperative_matrix.rs @@ -47,6 +47,39 @@ pub(crate) mod reexport { pub cooperative_matrix_robust_buffer_access: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceCooperativeMatrixFeaturesKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceCooperativeMatrixFeaturesKHR<'a> {} + unsafe impl<'a> crate::Extends> + for PhysicalDeviceCooperativeMatrixFeaturesKHR<'a> {} + impl<'a> Default for PhysicalDeviceCooperativeMatrixFeaturesKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + cooperative_matrix: Default::default(), + cooperative_matrix_robust_buffer_access: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceCooperativeMatrixFeaturesKHR<'a> { + pub fn cooperative_matrix(mut self, cooperative_matrix: bool) -> Self { + self.cooperative_matrix = cooperative_matrix.into(); + self + } + pub fn cooperative_matrix_robust_buffer_access( + mut self, + cooperative_matrix_robust_buffer_access: bool, + ) -> Self { + self.cooperative_matrix_robust_buffer_access = cooperative_matrix_robust_buffer_access + .into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct CooperativeMatrixPropertiesKHR<'a> { @@ -63,6 +96,65 @@ pub(crate) mod reexport { pub scope: crate::vk::ScopeKHR, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for CooperativeMatrixPropertiesKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::COOPERATIVE_MATRIX_PROPERTIES_KHR; + } + impl<'a> Default for CooperativeMatrixPropertiesKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + m_size: Default::default(), + n_size: Default::default(), + k_size: Default::default(), + a_type: Default::default(), + b_type: Default::default(), + c_type: Default::default(), + result_type: Default::default(), + saturating_accumulation: Default::default(), + scope: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> CooperativeMatrixPropertiesKHR<'a> { + pub fn m_size(mut self, m_size: u32) -> Self { + self.m_size = m_size; + self + } + pub fn n_size(mut self, n_size: u32) -> Self { + self.n_size = n_size; + self + } + pub fn k_size(mut self, k_size: u32) -> Self { + self.k_size = k_size; + self + } + pub fn a_type(mut self, a_type: crate::vk::ComponentTypeKHR) -> Self { + self.a_type = a_type; + self + } + pub fn b_type(mut self, b_type: crate::vk::ComponentTypeKHR) -> Self { + self.b_type = b_type; + self + } + pub fn c_type(mut self, c_type: crate::vk::ComponentTypeKHR) -> Self { + self.c_type = c_type; + self + } + pub fn result_type(mut self, result_type: crate::vk::ComponentTypeKHR) -> Self { + self.result_type = result_type; + self + } + pub fn saturating_accumulation(mut self, saturating_accumulation: bool) -> Self { + self.saturating_accumulation = saturating_accumulation.into(); + self + } + pub fn scope(mut self, scope: crate::vk::ScopeKHR) -> Self { + self.scope = scope; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceCooperativeMatrixPropertiesKHR<'a> { @@ -71,6 +163,31 @@ pub(crate) mod reexport { pub cooperative_matrix_supported_stages: crate::vk::ShaderStageFlags, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceCooperativeMatrixPropertiesKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceCooperativeMatrixPropertiesKHR<'a> {} + impl<'a> Default for PhysicalDeviceCooperativeMatrixPropertiesKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + cooperative_matrix_supported_stages: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceCooperativeMatrixPropertiesKHR<'a> { + pub fn cooperative_matrix_supported_stages( + mut self, + cooperative_matrix_supported_stages: crate::vk::ShaderStageFlags, + ) -> Self { + self.cooperative_matrix_supported_stages = cooperative_matrix_supported_stages; + self + } + } ///Provided by [`khr::cooperative_matrix`](crate::khr::cooperative_matrix) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR: Self = Self( diff --git a/ash-rewrite/src/generated/khr/copy_memory_indirect.rs b/ash-rewrite/src/generated/khr/copy_memory_indirect.rs index e02638336..1f32ec140 100644 --- a/ash-rewrite/src/generated/khr/copy_memory_indirect.rs +++ b/ash-rewrite/src/generated/khr/copy_memory_indirect.rs @@ -51,12 +51,26 @@ impl DeviceFn { } pub(crate) mod reexport { #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct CopyMemoryIndirectCommandKHR { pub src_address: crate::vk::DeviceAddress, pub dst_address: crate::vk::DeviceAddress, pub size: crate::vk::DeviceSize, } + impl CopyMemoryIndirectCommandKHR { + pub fn src_address(mut self, src_address: crate::vk::DeviceAddress) -> Self { + self.src_address = src_address; + self + } + pub fn dst_address(mut self, dst_address: crate::vk::DeviceAddress) -> Self { + self.dst_address = dst_address; + self + } + pub fn size(mut self, size: crate::vk::DeviceSize) -> Self { + self.size = size; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct CopyMemoryIndirectInfoKHR<'a> { @@ -68,8 +82,51 @@ pub(crate) mod reexport { pub copy_address_range: crate::vk::StridedDeviceAddressRangeKHR, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for CopyMemoryIndirectInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::COPY_MEMORY_INDIRECT_INFO_KHR; + } + impl<'a> Default for CopyMemoryIndirectInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + src_copy_flags: Default::default(), + dst_copy_flags: Default::default(), + copy_count: Default::default(), + copy_address_range: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> CopyMemoryIndirectInfoKHR<'a> { + pub fn src_copy_flags( + mut self, + src_copy_flags: crate::vk::AddressCopyFlagsKHR, + ) -> Self { + self.src_copy_flags = src_copy_flags; + self + } + pub fn dst_copy_flags( + mut self, + dst_copy_flags: crate::vk::AddressCopyFlagsKHR, + ) -> Self { + self.dst_copy_flags = dst_copy_flags; + self + } + pub fn copy_count(mut self, copy_count: u32) -> Self { + self.copy_count = copy_count; + self + } + pub fn copy_address_range( + mut self, + copy_address_range: crate::vk::StridedDeviceAddressRangeKHR, + ) -> Self { + self.copy_address_range = copy_address_range; + self + } + } #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct CopyMemoryToImageIndirectCommandKHR { pub src_address: crate::vk::DeviceAddress, pub buffer_row_length: u32, @@ -78,6 +135,35 @@ pub(crate) mod reexport { pub image_offset: crate::vk::Offset3D, pub image_extent: crate::vk::Extent3D, } + impl CopyMemoryToImageIndirectCommandKHR { + pub fn src_address(mut self, src_address: crate::vk::DeviceAddress) -> Self { + self.src_address = src_address; + self + } + pub fn buffer_row_length(mut self, buffer_row_length: u32) -> Self { + self.buffer_row_length = buffer_row_length; + self + } + pub fn buffer_image_height(mut self, buffer_image_height: u32) -> Self { + self.buffer_image_height = buffer_image_height; + self + } + pub fn image_subresource( + mut self, + image_subresource: crate::vk::ImageSubresourceLayers, + ) -> Self { + self.image_subresource = image_subresource; + self + } + pub fn image_offset(mut self, image_offset: crate::vk::Offset3D) -> Self { + self.image_offset = image_offset; + self + } + pub fn image_extent(mut self, image_extent: crate::vk::Extent3D) -> Self { + self.image_extent = image_extent; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct CopyMemoryToImageIndirectInfoKHR<'a> { @@ -91,6 +177,63 @@ pub(crate) mod reexport { pub p_image_subresources: *const crate::vk::ImageSubresourceLayers, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for CopyMemoryToImageIndirectInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::COPY_MEMORY_TO_IMAGE_INDIRECT_INFO_KHR; + } + impl<'a> Default for CopyMemoryToImageIndirectInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + src_copy_flags: Default::default(), + copy_count: Default::default(), + copy_address_range: Default::default(), + dst_image: Default::default(), + dst_image_layout: Default::default(), + p_image_subresources: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> CopyMemoryToImageIndirectInfoKHR<'a> { + pub fn src_copy_flags( + mut self, + src_copy_flags: crate::vk::AddressCopyFlagsKHR, + ) -> Self { + self.src_copy_flags = src_copy_flags; + self + } + pub fn copy_count(mut self, copy_count: u32) -> Self { + self.copy_count = copy_count; + self + } + pub fn copy_address_range( + mut self, + copy_address_range: crate::vk::StridedDeviceAddressRangeKHR, + ) -> Self { + self.copy_address_range = copy_address_range; + self + } + pub fn dst_image(mut self, dst_image: crate::vk::Image) -> Self { + self.dst_image = dst_image; + self + } + pub fn dst_image_layout( + mut self, + dst_image_layout: crate::vk::ImageLayout, + ) -> Self { + self.dst_image_layout = dst_image_layout; + self + } + pub fn p_image_subresources( + mut self, + p_image_subresources: &'a [crate::vk::ImageSubresourceLayers], + ) -> Self { + self.copy_count = p_image_subresources.len() as _; + self.p_image_subresources = p_image_subresources.as_ptr(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceCopyMemoryIndirectFeaturesKHR<'a> { @@ -100,6 +243,38 @@ pub(crate) mod reexport { pub indirect_memory_to_image_copy: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceCopyMemoryIndirectFeaturesKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_KHR; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceCopyMemoryIndirectFeaturesKHR<'a> {} + unsafe impl<'a> crate::Extends> + for PhysicalDeviceCopyMemoryIndirectFeaturesKHR<'a> {} + impl<'a> Default for PhysicalDeviceCopyMemoryIndirectFeaturesKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + indirect_memory_copy: Default::default(), + indirect_memory_to_image_copy: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceCopyMemoryIndirectFeaturesKHR<'a> { + pub fn indirect_memory_copy(mut self, indirect_memory_copy: bool) -> Self { + self.indirect_memory_copy = indirect_memory_copy.into(); + self + } + pub fn indirect_memory_to_image_copy( + mut self, + indirect_memory_to_image_copy: bool, + ) -> Self { + self.indirect_memory_to_image_copy = indirect_memory_to_image_copy.into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceCopyMemoryIndirectPropertiesKHR<'a> { @@ -108,6 +283,31 @@ pub(crate) mod reexport { pub supported_queues: crate::vk::QueueFlags, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceCopyMemoryIndirectPropertiesKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_KHR; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceCopyMemoryIndirectPropertiesKHR<'a> {} + impl<'a> Default for PhysicalDeviceCopyMemoryIndirectPropertiesKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + supported_queues: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceCopyMemoryIndirectPropertiesKHR<'a> { + pub fn supported_queues( + mut self, + supported_queues: crate::vk::QueueFlags, + ) -> Self { + self.supported_queues = supported_queues; + self + } + } ///Provided by [`khr::copy_memory_indirect`](crate::khr::copy_memory_indirect) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_KHR: Self = Self( @@ -200,7 +400,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct AddressCopyFlagBitsKHR(pub(crate) u32); ///Provided by [`khr::copy_memory_indirect`](crate::khr::copy_memory_indirect) impl AddressCopyFlagBitsKHR { diff --git a/ash-rewrite/src/generated/khr/depth_clamp_zero_one.rs b/ash-rewrite/src/generated/khr/depth_clamp_zero_one.rs index 72468c849..6887dd0ce 100644 --- a/ash-rewrite/src/generated/khr/depth_clamp_zero_one.rs +++ b/ash-rewrite/src/generated/khr/depth_clamp_zero_one.rs @@ -9,6 +9,30 @@ pub struct PhysicalDeviceDepthClampZeroOneFeaturesKHR<'a> { pub depth_clamp_zero_one: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceDepthClampZeroOneFeaturesKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_KHR; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceDepthClampZeroOneFeaturesKHR<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceDepthClampZeroOneFeaturesKHR<'a> {} +impl<'a> Default for PhysicalDeviceDepthClampZeroOneFeaturesKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + depth_clamp_zero_one: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceDepthClampZeroOneFeaturesKHR<'a> { + pub fn depth_clamp_zero_one(mut self, depth_clamp_zero_one: bool) -> Self { + self.depth_clamp_zero_one = depth_clamp_zero_one.into(); + self + } +} ///Provided by [`khr::depth_clamp_zero_one`](crate::khr::depth_clamp_zero_one) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_KHR: Self = Self(1000421000); diff --git a/ash-rewrite/src/generated/khr/device_address_commands.rs b/ash-rewrite/src/generated/khr/device_address_commands.rs index c28d3e555..291b95cec 100644 --- a/ash-rewrite/src/generated/khr/device_address_commands.rs +++ b/ash-rewrite/src/generated/khr/device_address_commands.rs @@ -375,18 +375,42 @@ impl DeviceFn { } pub(crate) mod reexport { #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct StridedDeviceAddressRangeKHR { pub address: crate::vk::DeviceAddress, pub size: crate::vk::DeviceSize, pub stride: crate::vk::DeviceSize, } + impl StridedDeviceAddressRangeKHR { + pub fn address(mut self, address: crate::vk::DeviceAddress) -> Self { + self.address = address; + self + } + pub fn size(mut self, size: crate::vk::DeviceSize) -> Self { + self.size = size; + self + } + pub fn stride(mut self, stride: crate::vk::DeviceSize) -> Self { + self.stride = stride; + self + } + } #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct DeviceAddressRangeKHR { pub address: crate::vk::DeviceAddress, pub size: crate::vk::DeviceSize, } + impl DeviceAddressRangeKHR { + pub fn address(mut self, address: crate::vk::DeviceAddress) -> Self { + self.address = address; + self + } + pub fn size(mut self, size: crate::vk::DeviceSize) -> Self { + self.size = size; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct DeviceMemoryCopyKHR<'a> { @@ -398,6 +422,46 @@ pub(crate) mod reexport { pub dst_flags: crate::vk::AddressCommandFlagsKHR, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for DeviceMemoryCopyKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::DEVICE_MEMORY_COPY_KHR; + } + impl<'a> Default for DeviceMemoryCopyKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + src_range: Default::default(), + src_flags: Default::default(), + dst_range: Default::default(), + dst_flags: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> DeviceMemoryCopyKHR<'a> { + pub fn src_range(mut self, src_range: crate::vk::DeviceAddressRangeKHR) -> Self { + self.src_range = src_range; + self + } + pub fn src_flags( + mut self, + src_flags: crate::vk::AddressCommandFlagsKHR, + ) -> Self { + self.src_flags = src_flags; + self + } + pub fn dst_range(mut self, dst_range: crate::vk::DeviceAddressRangeKHR) -> Self { + self.dst_range = dst_range; + self + } + pub fn dst_flags( + mut self, + dst_flags: crate::vk::AddressCommandFlagsKHR, + ) -> Self { + self.dst_flags = dst_flags; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct CopyDeviceMemoryInfoKHR<'a> { @@ -407,6 +471,34 @@ pub(crate) mod reexport { pub p_regions: *const crate::vk::DeviceMemoryCopyKHR<'a>, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for CopyDeviceMemoryInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::COPY_DEVICE_MEMORY_INFO_KHR; + } + impl<'a> Default for CopyDeviceMemoryInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + region_count: Default::default(), + p_regions: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> CopyDeviceMemoryInfoKHR<'a> { + pub fn region_count(mut self, region_count: u32) -> Self { + self.region_count = region_count; + self + } + pub fn p_regions( + mut self, + p_regions: &'a [crate::vk::DeviceMemoryCopyKHR<'a>], + ) -> Self { + self.region_count = p_regions.len() as _; + self.p_regions = p_regions.as_ptr(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct DeviceMemoryImageCopyKHR<'a> { @@ -422,6 +514,69 @@ pub(crate) mod reexport { pub image_extent: crate::vk::Extent3D, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for DeviceMemoryImageCopyKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::DEVICE_MEMORY_IMAGE_COPY_KHR; + } + impl<'a> Default for DeviceMemoryImageCopyKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + address_range: Default::default(), + address_flags: Default::default(), + address_row_length: Default::default(), + address_image_height: Default::default(), + image_subresource: Default::default(), + image_layout: Default::default(), + image_offset: Default::default(), + image_extent: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> DeviceMemoryImageCopyKHR<'a> { + pub fn address_range( + mut self, + address_range: crate::vk::DeviceAddressRangeKHR, + ) -> Self { + self.address_range = address_range; + self + } + pub fn address_flags( + mut self, + address_flags: crate::vk::AddressCommandFlagsKHR, + ) -> Self { + self.address_flags = address_flags; + self + } + pub fn address_row_length(mut self, address_row_length: u32) -> Self { + self.address_row_length = address_row_length; + self + } + pub fn address_image_height(mut self, address_image_height: u32) -> Self { + self.address_image_height = address_image_height; + self + } + pub fn image_subresource( + mut self, + image_subresource: crate::vk::ImageSubresourceLayers, + ) -> Self { + self.image_subresource = image_subresource; + self + } + pub fn image_layout(mut self, image_layout: crate::vk::ImageLayout) -> Self { + self.image_layout = image_layout; + self + } + pub fn image_offset(mut self, image_offset: crate::vk::Offset3D) -> Self { + self.image_offset = image_offset; + self + } + pub fn image_extent(mut self, image_extent: crate::vk::Extent3D) -> Self { + self.image_extent = image_extent; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct CopyDeviceMemoryImageInfoKHR<'a> { @@ -432,6 +587,39 @@ pub(crate) mod reexport { pub p_regions: *const crate::vk::DeviceMemoryImageCopyKHR<'a>, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for CopyDeviceMemoryImageInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::COPY_DEVICE_MEMORY_IMAGE_INFO_KHR; + } + impl<'a> Default for CopyDeviceMemoryImageInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + image: Default::default(), + region_count: Default::default(), + p_regions: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> CopyDeviceMemoryImageInfoKHR<'a> { + pub fn image(mut self, image: crate::vk::Image) -> Self { + self.image = image; + self + } + pub fn region_count(mut self, region_count: u32) -> Self { + self.region_count = region_count; + self + } + pub fn p_regions( + mut self, + p_regions: &'a [crate::vk::DeviceMemoryImageCopyKHR<'a>], + ) -> Self { + self.region_count = p_regions.len() as _; + self.p_regions = p_regions.as_ptr(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct MemoryRangeBarriersInfoKHR<'a> { @@ -441,6 +629,39 @@ pub(crate) mod reexport { pub p_memory_range_barriers: *const crate::vk::MemoryRangeBarrierKHR<'a>, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for MemoryRangeBarriersInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::MEMORY_RANGE_BARRIERS_INFO_KHR; + } + unsafe impl<'a> crate::Extends> + for MemoryRangeBarriersInfoKHR<'a> {} + impl<'a> Default for MemoryRangeBarriersInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + memory_range_barrier_count: Default::default(), + p_memory_range_barriers: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> MemoryRangeBarriersInfoKHR<'a> { + pub fn memory_range_barrier_count( + mut self, + memory_range_barrier_count: u32, + ) -> Self { + self.memory_range_barrier_count = memory_range_barrier_count; + self + } + pub fn p_memory_range_barriers( + mut self, + p_memory_range_barriers: &'a [crate::vk::MemoryRangeBarrierKHR<'a>], + ) -> Self { + self.memory_range_barrier_count = p_memory_range_barriers.len() as _; + self.p_memory_range_barriers = p_memory_range_barriers.as_ptr(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct MemoryRangeBarrierKHR<'a> { @@ -456,6 +677,78 @@ pub(crate) mod reexport { pub address_flags: crate::vk::AddressCommandFlagsKHR, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for MemoryRangeBarrierKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::MEMORY_RANGE_BARRIER_KHR; + } + impl<'a> Default for MemoryRangeBarrierKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + src_stage_mask: Default::default(), + src_access_mask: Default::default(), + dst_stage_mask: Default::default(), + dst_access_mask: Default::default(), + src_queue_family_index: Default::default(), + dst_queue_family_index: Default::default(), + address_range: Default::default(), + address_flags: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> MemoryRangeBarrierKHR<'a> { + pub fn src_stage_mask( + mut self, + src_stage_mask: crate::vk::PipelineStageFlags2, + ) -> Self { + self.src_stage_mask = src_stage_mask; + self + } + pub fn src_access_mask( + mut self, + src_access_mask: crate::vk::AccessFlags2, + ) -> Self { + self.src_access_mask = src_access_mask; + self + } + pub fn dst_stage_mask( + mut self, + dst_stage_mask: crate::vk::PipelineStageFlags2, + ) -> Self { + self.dst_stage_mask = dst_stage_mask; + self + } + pub fn dst_access_mask( + mut self, + dst_access_mask: crate::vk::AccessFlags2, + ) -> Self { + self.dst_access_mask = dst_access_mask; + self + } + pub fn src_queue_family_index(mut self, src_queue_family_index: u32) -> Self { + self.src_queue_family_index = src_queue_family_index; + self + } + pub fn dst_queue_family_index(mut self, dst_queue_family_index: u32) -> Self { + self.dst_queue_family_index = dst_queue_family_index; + self + } + pub fn address_range( + mut self, + address_range: crate::vk::DeviceAddressRangeKHR, + ) -> Self { + self.address_range = address_range; + self + } + pub fn address_flags( + mut self, + address_flags: crate::vk::AddressCommandFlagsKHR, + ) -> Self { + self.address_flags = address_flags; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceDeviceAddressCommandsFeaturesKHR<'a> { @@ -464,6 +757,30 @@ pub(crate) mod reexport { pub device_address_commands: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceDeviceAddressCommandsFeaturesKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_DEVICE_ADDRESS_COMMANDS_FEATURES_KHR; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceDeviceAddressCommandsFeaturesKHR<'a> {} + unsafe impl<'a> crate::Extends> + for PhysicalDeviceDeviceAddressCommandsFeaturesKHR<'a> {} + impl<'a> Default for PhysicalDeviceDeviceAddressCommandsFeaturesKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + device_address_commands: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceDeviceAddressCommandsFeaturesKHR<'a> { + pub fn device_address_commands(mut self, device_address_commands: bool) -> Self { + self.device_address_commands = device_address_commands.into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct ConditionalRenderingBeginInfo2EXT<'a> { @@ -474,6 +791,42 @@ pub(crate) mod reexport { pub flags: crate::vk::ConditionalRenderingFlagsEXT, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for ConditionalRenderingBeginInfo2EXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::CONDITIONAL_RENDERING_BEGIN_INFO_2_EXT; + } + impl<'a> Default for ConditionalRenderingBeginInfo2EXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + address_range: Default::default(), + address_flags: Default::default(), + flags: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> ConditionalRenderingBeginInfo2EXT<'a> { + pub fn address_range( + mut self, + address_range: crate::vk::DeviceAddressRangeKHR, + ) -> Self { + self.address_range = address_range; + self + } + pub fn address_flags( + mut self, + address_flags: crate::vk::AddressCommandFlagsKHR, + ) -> Self { + self.address_flags = address_flags; + self + } + pub fn flags(mut self, flags: crate::vk::ConditionalRenderingFlagsEXT) -> Self { + self.flags = flags; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct AccelerationStructureCreateInfo2KHR<'a> { @@ -485,6 +838,50 @@ pub(crate) mod reexport { pub _type: crate::vk::AccelerationStructureTypeKHR, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for AccelerationStructureCreateInfo2KHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::ACCELERATION_STRUCTURE_CREATE_INFO_2_KHR; + } + impl<'a> Default for AccelerationStructureCreateInfo2KHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + create_flags: Default::default(), + address_range: Default::default(), + address_flags: Default::default(), + _type: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> AccelerationStructureCreateInfo2KHR<'a> { + pub fn create_flags( + mut self, + create_flags: crate::vk::AccelerationStructureCreateFlagsKHR, + ) -> Self { + self.create_flags = create_flags; + self + } + pub fn address_range( + mut self, + address_range: crate::vk::DeviceAddressRangeKHR, + ) -> Self { + self.address_range = address_range; + self + } + pub fn address_flags( + mut self, + address_flags: crate::vk::AddressCommandFlagsKHR, + ) -> Self { + self.address_flags = address_flags; + self + } + pub fn _type(mut self, _type: crate::vk::AccelerationStructureTypeKHR) -> Self { + self._type = _type; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct BindIndexBuffer3InfoKHR<'a> { @@ -495,6 +892,41 @@ pub(crate) mod reexport { pub index_type: crate::vk::IndexType, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for BindIndexBuffer3InfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::BIND_INDEX_BUFFER_3_INFO_KHR; + } + impl<'a> Default for BindIndexBuffer3InfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + address_range: Default::default(), + address_flags: Default::default(), + index_type: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> BindIndexBuffer3InfoKHR<'a> { + pub fn address_range( + mut self, + address_range: crate::vk::DeviceAddressRangeKHR, + ) -> Self { + self.address_range = address_range; + self + } + pub fn address_flags( + mut self, + address_flags: crate::vk::AddressCommandFlagsKHR, + ) -> Self { + self.address_flags = address_flags; + self + } + pub fn index_type(mut self, index_type: crate::vk::IndexType) -> Self { + self.index_type = index_type; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct BindVertexBuffer3InfoKHR<'a> { @@ -505,6 +937,41 @@ pub(crate) mod reexport { pub address_flags: crate::vk::AddressCommandFlagsKHR, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for BindVertexBuffer3InfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::BIND_VERTEX_BUFFER_3_INFO_KHR; + } + impl<'a> Default for BindVertexBuffer3InfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + set_stride: Default::default(), + address_range: Default::default(), + address_flags: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> BindVertexBuffer3InfoKHR<'a> { + pub fn set_stride(mut self, set_stride: bool) -> Self { + self.set_stride = set_stride.into(); + self + } + pub fn address_range( + mut self, + address_range: crate::vk::StridedDeviceAddressRangeKHR, + ) -> Self { + self.address_range = address_range; + self + } + pub fn address_flags( + mut self, + address_flags: crate::vk::AddressCommandFlagsKHR, + ) -> Self { + self.address_flags = address_flags; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct DrawIndirect2InfoKHR<'a> { @@ -515,6 +982,41 @@ pub(crate) mod reexport { pub draw_count: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for DrawIndirect2InfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::DRAW_INDIRECT_2_INFO_KHR; + } + impl<'a> Default for DrawIndirect2InfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + address_range: Default::default(), + address_flags: Default::default(), + draw_count: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> DrawIndirect2InfoKHR<'a> { + pub fn address_range( + mut self, + address_range: crate::vk::StridedDeviceAddressRangeKHR, + ) -> Self { + self.address_range = address_range; + self + } + pub fn address_flags( + mut self, + address_flags: crate::vk::AddressCommandFlagsKHR, + ) -> Self { + self.address_flags = address_flags; + self + } + pub fn draw_count(mut self, draw_count: u32) -> Self { + self.draw_count = draw_count; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct DrawIndirectCount2InfoKHR<'a> { @@ -527,6 +1029,57 @@ pub(crate) mod reexport { pub max_draw_count: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for DrawIndirectCount2InfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::DRAW_INDIRECT_COUNT_2_INFO_KHR; + } + impl<'a> Default for DrawIndirectCount2InfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + address_range: Default::default(), + address_flags: Default::default(), + count_address_range: Default::default(), + count_address_flags: Default::default(), + max_draw_count: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> DrawIndirectCount2InfoKHR<'a> { + pub fn address_range( + mut self, + address_range: crate::vk::StridedDeviceAddressRangeKHR, + ) -> Self { + self.address_range = address_range; + self + } + pub fn address_flags( + mut self, + address_flags: crate::vk::AddressCommandFlagsKHR, + ) -> Self { + self.address_flags = address_flags; + self + } + pub fn count_address_range( + mut self, + count_address_range: crate::vk::DeviceAddressRangeKHR, + ) -> Self { + self.count_address_range = count_address_range; + self + } + pub fn count_address_flags( + mut self, + count_address_flags: crate::vk::AddressCommandFlagsKHR, + ) -> Self { + self.count_address_flags = count_address_flags; + self + } + pub fn max_draw_count(mut self, max_draw_count: u32) -> Self { + self.max_draw_count = max_draw_count; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct DispatchIndirect2InfoKHR<'a> { @@ -536,6 +1089,36 @@ pub(crate) mod reexport { pub address_flags: crate::vk::AddressCommandFlagsKHR, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for DispatchIndirect2InfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::DISPATCH_INDIRECT_2_INFO_KHR; + } + impl<'a> Default for DispatchIndirect2InfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + address_range: Default::default(), + address_flags: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> DispatchIndirect2InfoKHR<'a> { + pub fn address_range( + mut self, + address_range: crate::vk::DeviceAddressRangeKHR, + ) -> Self { + self.address_range = address_range; + self + } + pub fn address_flags( + mut self, + address_flags: crate::vk::AddressCommandFlagsKHR, + ) -> Self { + self.address_flags = address_flags; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct BindTransformFeedbackBuffer2InfoEXT<'a> { @@ -545,6 +1128,37 @@ pub(crate) mod reexport { pub address_flags: crate::vk::AddressCommandFlagsKHR, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for BindTransformFeedbackBuffer2InfoEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::BIND_TRANSFORM_FEEDBACK_BUFFER_2_INFO_EXT; + } + impl<'a> Default for BindTransformFeedbackBuffer2InfoEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + address_range: Default::default(), + address_flags: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> BindTransformFeedbackBuffer2InfoEXT<'a> { + pub fn address_range( + mut self, + address_range: crate::vk::DeviceAddressRangeKHR, + ) -> Self { + self.address_range = address_range; + self + } + pub fn address_flags( + mut self, + address_flags: crate::vk::AddressCommandFlagsKHR, + ) -> Self { + self.address_flags = address_flags; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct MemoryMarkerInfoAMD<'a> { @@ -556,6 +1170,43 @@ pub(crate) mod reexport { pub marker: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for MemoryMarkerInfoAMD<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::MEMORY_MARKER_INFO_AMD; + } + impl<'a> Default for MemoryMarkerInfoAMD<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + stage: Default::default(), + dst_range: Default::default(), + dst_flags: Default::default(), + marker: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> MemoryMarkerInfoAMD<'a> { + pub fn stage(mut self, stage: crate::vk::PipelineStageFlags2KHR) -> Self { + self.stage = stage; + self + } + pub fn dst_range(mut self, dst_range: crate::vk::DeviceAddressRangeKHR) -> Self { + self.dst_range = dst_range; + self + } + pub fn dst_flags( + mut self, + dst_flags: crate::vk::AddressCommandFlagsKHR, + ) -> Self { + self.dst_flags = dst_flags; + self + } + pub fn marker(mut self, marker: u32) -> Self { + self.marker = marker; + self + } + } ///Provided by [`khr::device_address_commands`](crate::khr::device_address_commands) impl crate::vk::StructureType { pub const DEVICE_MEMORY_COPY_KHR: Self = Self(1000318000); @@ -661,7 +1312,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct AddressCommandFlagBitsKHR(pub(crate) u32); ///Provided by [`khr::device_address_commands`](crate::khr::device_address_commands) impl AddressCommandFlagBitsKHR { diff --git a/ash-rewrite/src/generated/khr/device_fault.rs b/ash-rewrite/src/generated/khr/device_fault.rs index bcfdcf81a..e58d2eb49 100644 --- a/ash-rewrite/src/generated/khr/device_fault.rs +++ b/ash-rewrite/src/generated/khr/device_fault.rs @@ -53,12 +53,35 @@ impl DeviceFn { } pub(crate) mod reexport { #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct DeviceFaultAddressInfoKHR { pub address_type: crate::vk::DeviceFaultAddressTypeKHR, pub reported_address: crate::vk::DeviceAddress, pub address_precision: crate::vk::DeviceSize, } + impl DeviceFaultAddressInfoKHR { + pub fn address_type( + mut self, + address_type: crate::vk::DeviceFaultAddressTypeKHR, + ) -> Self { + self.address_type = address_type; + self + } + pub fn reported_address( + mut self, + reported_address: crate::vk::DeviceAddress, + ) -> Self { + self.reported_address = reported_address; + self + } + pub fn address_precision( + mut self, + address_precision: crate::vk::DeviceSize, + ) -> Self { + self.address_precision = address_precision; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct DeviceFaultVendorInfoKHR { @@ -66,6 +89,37 @@ pub(crate) mod reexport { pub vendor_fault_code: u64, pub vendor_fault_data: u64, } + impl Default for DeviceFaultVendorInfoKHR { + fn default() -> Self { + Self { + description: unsafe { core::mem::zeroed() }, + vendor_fault_code: Default::default(), + vendor_fault_data: Default::default(), + } + } + } + impl DeviceFaultVendorInfoKHR { + pub fn description( + mut self, + description: &core::ffi::CStr, + ) -> core::result::Result { + crate::write_c_str_slice_with_nul(&mut self.description, description) + .map(|_| self) + } + pub fn description_as_c_str( + &self, + ) -> core::result::Result<&core::ffi::CStr, core::ffi::FromBytesUntilNulError> { + crate::wrap_c_str_slice_until_nul(&self.description) + } + pub fn vendor_fault_code(mut self, vendor_fault_code: u64) -> Self { + self.vendor_fault_code = vendor_fault_code; + self + } + pub fn vendor_fault_data(mut self, vendor_fault_data: u64) -> Self { + self.vendor_fault_data = vendor_fault_data; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct DeviceFaultInfoKHR<'a> { @@ -79,6 +133,67 @@ pub(crate) mod reexport { pub vendor_info: crate::vk::DeviceFaultVendorInfoKHR, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for DeviceFaultInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::DEVICE_FAULT_INFO_KHR; + } + impl<'a> Default for DeviceFaultInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + flags: Default::default(), + group_id: Default::default(), + description: unsafe { core::mem::zeroed() }, + fault_address_info: Default::default(), + instruction_address_info: Default::default(), + vendor_info: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> DeviceFaultInfoKHR<'a> { + pub fn flags(mut self, flags: crate::vk::DeviceFaultFlagsKHR) -> Self { + self.flags = flags; + self + } + pub fn group_id(mut self, group_id: u64) -> Self { + self.group_id = group_id; + self + } + pub fn description( + mut self, + description: &core::ffi::CStr, + ) -> core::result::Result { + crate::write_c_str_slice_with_nul(&mut self.description, description) + .map(|_| self) + } + pub fn description_as_c_str( + &self, + ) -> core::result::Result<&core::ffi::CStr, core::ffi::FromBytesUntilNulError> { + crate::wrap_c_str_slice_until_nul(&self.description) + } + pub fn fault_address_info( + mut self, + fault_address_info: crate::vk::DeviceFaultAddressInfoKHR, + ) -> Self { + self.fault_address_info = fault_address_info; + self + } + pub fn instruction_address_info( + mut self, + instruction_address_info: crate::vk::DeviceFaultAddressInfoKHR, + ) -> Self { + self.instruction_address_info = instruction_address_info; + self + } + pub fn vendor_info( + mut self, + vendor_info: crate::vk::DeviceFaultVendorInfoKHR, + ) -> Self { + self.vendor_info = vendor_info; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct DeviceFaultDebugInfoKHR<'a> { @@ -88,6 +203,34 @@ pub(crate) mod reexport { pub p_vendor_binary_data: *mut core::ffi::c_void, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for DeviceFaultDebugInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::DEVICE_FAULT_DEBUG_INFO_KHR; + } + impl<'a> Default for DeviceFaultDebugInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + vendor_binary_size: Default::default(), + p_vendor_binary_data: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> DeviceFaultDebugInfoKHR<'a> { + pub fn vendor_binary_size(mut self, vendor_binary_size: u32) -> Self { + self.vendor_binary_size = vendor_binary_size; + self + } + pub fn p_vendor_binary_data( + mut self, + p_vendor_binary_data: &'a mut [u8], + ) -> Self { + self.vendor_binary_size = p_vendor_binary_data.len() as _; + self.p_vendor_binary_data = p_vendor_binary_data.as_mut_ptr().cast(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct DeviceFaultVendorBinaryHeaderVersionOneKHR { @@ -103,6 +246,75 @@ pub(crate) mod reexport { pub engine_version: u32, pub api_version: u32, } + impl Default for DeviceFaultVendorBinaryHeaderVersionOneKHR { + fn default() -> Self { + Self { + header_size: Default::default(), + header_version: Default::default(), + vendor_id: Default::default(), + device_id: Default::default(), + driver_version: Default::default(), + pipeline_cache_uuid: unsafe { core::mem::zeroed() }, + application_name_offset: Default::default(), + application_version: Default::default(), + engine_name_offset: Default::default(), + engine_version: Default::default(), + api_version: Default::default(), + } + } + } + impl DeviceFaultVendorBinaryHeaderVersionOneKHR { + pub fn header_size(mut self, header_size: u32) -> Self { + self.header_size = header_size; + self + } + pub fn header_version( + mut self, + header_version: crate::vk::DeviceFaultVendorBinaryHeaderVersionKHR, + ) -> Self { + self.header_version = header_version; + self + } + pub fn vendor_id(mut self, vendor_id: u32) -> Self { + self.vendor_id = vendor_id; + self + } + pub fn device_id(mut self, device_id: u32) -> Self { + self.device_id = device_id; + self + } + pub fn driver_version(mut self, driver_version: u32) -> Self { + self.driver_version = driver_version; + self + } + pub fn pipeline_cache_uuid( + mut self, + pipeline_cache_uuid: [u8; crate::vk::UUID_SIZE as _], + ) -> Self { + self.pipeline_cache_uuid = pipeline_cache_uuid; + self + } + pub fn application_name_offset(mut self, application_name_offset: u32) -> Self { + self.application_name_offset = application_name_offset; + self + } + pub fn application_version(mut self, application_version: u32) -> Self { + self.application_version = application_version; + self + } + pub fn engine_name_offset(mut self, engine_name_offset: u32) -> Self { + self.engine_name_offset = engine_name_offset; + self + } + pub fn engine_version(mut self, engine_version: u32) -> Self { + self.engine_version = engine_version; + self + } + pub fn api_version(mut self, api_version: u32) -> Self { + self.api_version = api_version; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceFaultFeaturesKHR<'a> { @@ -114,6 +326,54 @@ pub(crate) mod reexport { pub device_fault_device_lost_on_masked: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for PhysicalDeviceFaultFeaturesKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_FAULT_FEATURES_KHR; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceFaultFeaturesKHR<'a> {} + unsafe impl<'a> crate::Extends> + for PhysicalDeviceFaultFeaturesKHR<'a> {} + impl<'a> Default for PhysicalDeviceFaultFeaturesKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + device_fault: Default::default(), + device_fault_vendor_binary: Default::default(), + device_fault_report_masked: Default::default(), + device_fault_device_lost_on_masked: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceFaultFeaturesKHR<'a> { + pub fn device_fault(mut self, device_fault: bool) -> Self { + self.device_fault = device_fault.into(); + self + } + pub fn device_fault_vendor_binary( + mut self, + device_fault_vendor_binary: bool, + ) -> Self { + self.device_fault_vendor_binary = device_fault_vendor_binary.into(); + self + } + pub fn device_fault_report_masked( + mut self, + device_fault_report_masked: bool, + ) -> Self { + self.device_fault_report_masked = device_fault_report_masked.into(); + self + } + pub fn device_fault_device_lost_on_masked( + mut self, + device_fault_device_lost_on_masked: bool, + ) -> Self { + self.device_fault_device_lost_on_masked = device_fault_device_lost_on_masked + .into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceFaultPropertiesKHR<'a> { @@ -122,6 +382,27 @@ pub(crate) mod reexport { pub max_device_fault_count: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for PhysicalDeviceFaultPropertiesKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_FAULT_PROPERTIES_KHR; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceFaultPropertiesKHR<'a> {} + impl<'a> Default for PhysicalDeviceFaultPropertiesKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + max_device_fault_count: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceFaultPropertiesKHR<'a> { + pub fn max_device_fault_count(mut self, max_device_fault_count: u32) -> Self { + self.max_device_fault_count = max_device_fault_count; + self + } + } ///Provided by [`khr::device_fault`](crate::khr::device_fault) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_FAULT_FEATURES_KHR: Self = Self(1000573000); @@ -254,7 +535,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct DeviceFaultFlagBitsKHR(pub(crate) u32); ///Provided by [`khr::device_fault`](crate::khr::device_fault) impl DeviceFaultFlagBitsKHR { diff --git a/ash-rewrite/src/generated/khr/display.rs b/ash-rewrite/src/generated/khr/display.rs index 0a90335c1..e18735e8e 100644 --- a/ash-rewrite/src/generated/khr/display.rs +++ b/ash-rewrite/src/generated/khr/display.rs @@ -139,7 +139,7 @@ impl InstanceFn { } pub(crate) mod reexport { #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct DisplayPropertiesKHR<'a> { pub display: crate::vk::DisplayKHR, pub display_name: *const core::ffi::c_char, @@ -150,24 +150,106 @@ pub(crate) mod reexport { pub persistent_content: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + impl<'a> DisplayPropertiesKHR<'a> { + pub fn display(mut self, display: crate::vk::DisplayKHR) -> Self { + self.display = display; + self + } + pub fn display_name(mut self, display_name: &'a core::ffi::CStr) -> Self { + self.display_name = display_name.as_ptr(); + self + } + pub unsafe fn display_name_as_c_str(&self) -> Option<&core::ffi::CStr> { + if self.display_name.is_null() { + None + } else { + Some(unsafe { core::ffi::CStr::from_ptr(self.display_name) }) + } + } + pub fn physical_dimensions( + mut self, + physical_dimensions: crate::vk::Extent2D, + ) -> Self { + self.physical_dimensions = physical_dimensions; + self + } + pub fn physical_resolution( + mut self, + physical_resolution: crate::vk::Extent2D, + ) -> Self { + self.physical_resolution = physical_resolution; + self + } + pub fn supported_transforms( + mut self, + supported_transforms: crate::vk::SurfaceTransformFlagsKHR, + ) -> Self { + self.supported_transforms = supported_transforms; + self + } + pub fn plane_reorder_possible(mut self, plane_reorder_possible: bool) -> Self { + self.plane_reorder_possible = plane_reorder_possible.into(); + self + } + pub fn persistent_content(mut self, persistent_content: bool) -> Self { + self.persistent_content = persistent_content.into(); + self + } + } #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct DisplayPlanePropertiesKHR { pub current_display: crate::vk::DisplayKHR, pub current_stack_index: u32, } + impl DisplayPlanePropertiesKHR { + pub fn current_display( + mut self, + current_display: crate::vk::DisplayKHR, + ) -> Self { + self.current_display = current_display; + self + } + pub fn current_stack_index(mut self, current_stack_index: u32) -> Self { + self.current_stack_index = current_stack_index; + self + } + } #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct DisplayModeParametersKHR { pub visible_region: crate::vk::Extent2D, pub refresh_rate: u32, } + impl DisplayModeParametersKHR { + pub fn visible_region(mut self, visible_region: crate::vk::Extent2D) -> Self { + self.visible_region = visible_region; + self + } + pub fn refresh_rate(mut self, refresh_rate: u32) -> Self { + self.refresh_rate = refresh_rate; + self + } + } #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct DisplayModePropertiesKHR { pub display_mode: crate::vk::DisplayModeKHR, pub parameters: crate::vk::DisplayModeParametersKHR, } + impl DisplayModePropertiesKHR { + pub fn display_mode(mut self, display_mode: crate::vk::DisplayModeKHR) -> Self { + self.display_mode = display_mode; + self + } + pub fn parameters( + mut self, + parameters: crate::vk::DisplayModeParametersKHR, + ) -> Self { + self.parameters = parameters; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct DisplayModeCreateInfoKHR<'a> { @@ -177,8 +259,35 @@ pub(crate) mod reexport { pub parameters: crate::vk::DisplayModeParametersKHR, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for DisplayModeCreateInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::DISPLAY_MODE_CREATE_INFO_KHR; + } + impl<'a> Default for DisplayModeCreateInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + flags: Default::default(), + parameters: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> DisplayModeCreateInfoKHR<'a> { + pub fn flags(mut self, flags: crate::vk::DisplayModeCreateFlagsKHR) -> Self { + self.flags = flags; + self + } + pub fn parameters( + mut self, + parameters: crate::vk::DisplayModeParametersKHR, + ) -> Self { + self.parameters = parameters; + self + } + } #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct DisplayPlaneCapabilitiesKHR { pub supported_alpha: crate::vk::DisplayPlaneAlphaFlagsKHR, pub min_src_position: crate::vk::Offset2D, @@ -190,6 +299,59 @@ pub(crate) mod reexport { pub min_dst_extent: crate::vk::Extent2D, pub max_dst_extent: crate::vk::Extent2D, } + impl DisplayPlaneCapabilitiesKHR { + pub fn supported_alpha( + mut self, + supported_alpha: crate::vk::DisplayPlaneAlphaFlagsKHR, + ) -> Self { + self.supported_alpha = supported_alpha; + self + } + pub fn min_src_position( + mut self, + min_src_position: crate::vk::Offset2D, + ) -> Self { + self.min_src_position = min_src_position; + self + } + pub fn max_src_position( + mut self, + max_src_position: crate::vk::Offset2D, + ) -> Self { + self.max_src_position = max_src_position; + self + } + pub fn min_src_extent(mut self, min_src_extent: crate::vk::Extent2D) -> Self { + self.min_src_extent = min_src_extent; + self + } + pub fn max_src_extent(mut self, max_src_extent: crate::vk::Extent2D) -> Self { + self.max_src_extent = max_src_extent; + self + } + pub fn min_dst_position( + mut self, + min_dst_position: crate::vk::Offset2D, + ) -> Self { + self.min_dst_position = min_dst_position; + self + } + pub fn max_dst_position( + mut self, + max_dst_position: crate::vk::Offset2D, + ) -> Self { + self.max_dst_position = max_dst_position; + self + } + pub fn min_dst_extent(mut self, min_dst_extent: crate::vk::Extent2D) -> Self { + self.min_dst_extent = min_dst_extent; + self + } + pub fn max_dst_extent(mut self, max_dst_extent: crate::vk::Extent2D) -> Self { + self.max_dst_extent = max_dst_extent; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct DisplaySurfaceCreateInfoKHR<'a> { @@ -205,6 +367,66 @@ pub(crate) mod reexport { pub image_extent: crate::vk::Extent2D, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for DisplaySurfaceCreateInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::DISPLAY_SURFACE_CREATE_INFO_KHR; + } + impl<'a> Default for DisplaySurfaceCreateInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + flags: Default::default(), + display_mode: Default::default(), + plane_index: Default::default(), + plane_stack_index: Default::default(), + transform: Default::default(), + global_alpha: Default::default(), + alpha_mode: Default::default(), + image_extent: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> DisplaySurfaceCreateInfoKHR<'a> { + pub fn flags(mut self, flags: crate::vk::DisplaySurfaceCreateFlagsKHR) -> Self { + self.flags = flags; + self + } + pub fn display_mode(mut self, display_mode: crate::vk::DisplayModeKHR) -> Self { + self.display_mode = display_mode; + self + } + pub fn plane_index(mut self, plane_index: u32) -> Self { + self.plane_index = plane_index; + self + } + pub fn plane_stack_index(mut self, plane_stack_index: u32) -> Self { + self.plane_stack_index = plane_stack_index; + self + } + pub fn transform( + mut self, + transform: crate::vk::SurfaceTransformFlagBitsKHR, + ) -> Self { + self.transform = transform; + self + } + pub fn global_alpha(mut self, global_alpha: core::ffi::c_float) -> Self { + self.global_alpha = global_alpha; + self + } + pub fn alpha_mode( + mut self, + alpha_mode: crate::vk::DisplayPlaneAlphaFlagBitsKHR, + ) -> Self { + self.alpha_mode = alpha_mode; + self + } + pub fn image_extent(mut self, image_extent: crate::vk::Extent2D) -> Self { + self.image_extent = image_extent; + self + } + } ///Provided by [`khr::display`](crate::khr::display) impl crate::vk::StructureType { pub const DISPLAY_MODE_CREATE_INFO_KHR: Self = Self(1000002000); @@ -291,7 +513,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct DisplayPlaneAlphaFlagBitsKHR(pub(crate) u32); ///Provided by [`khr::display`](crate::khr::display) impl DisplayPlaneAlphaFlagBitsKHR { diff --git a/ash-rewrite/src/generated/khr/display_swapchain.rs b/ash-rewrite/src/generated/khr/display_swapchain.rs index 5ea87a3b9..81b02bd42 100644 --- a/ash-rewrite/src/generated/khr/display_swapchain.rs +++ b/ash-rewrite/src/generated/khr/display_swapchain.rs @@ -48,6 +48,37 @@ pub(crate) mod reexport { pub persistent: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for DisplayPresentInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::DISPLAY_PRESENT_INFO_KHR; + } + unsafe impl<'a> crate::Extends> + for DisplayPresentInfoKHR<'a> {} + impl<'a> Default for DisplayPresentInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + src_rect: Default::default(), + dst_rect: Default::default(), + persistent: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> DisplayPresentInfoKHR<'a> { + pub fn src_rect(mut self, src_rect: crate::vk::Rect2D) -> Self { + self.src_rect = src_rect; + self + } + pub fn dst_rect(mut self, dst_rect: crate::vk::Rect2D) -> Self { + self.dst_rect = dst_rect; + self + } + pub fn persistent(mut self, persistent: bool) -> Self { + self.persistent = persistent.into(); + self + } + } ///Provided by [`khr::display_swapchain`](crate::khr::display_swapchain) impl crate::vk::StructureType { pub const DISPLAY_PRESENT_INFO_KHR: Self = Self(1000003000); diff --git a/ash-rewrite/src/generated/khr/external_fence_fd.rs b/ash-rewrite/src/generated/khr/external_fence_fd.rs index f9c9bc455..c1b5f96dd 100644 --- a/ash-rewrite/src/generated/khr/external_fence_fd.rs +++ b/ash-rewrite/src/generated/khr/external_fence_fd.rs @@ -62,6 +62,43 @@ pub(crate) mod reexport { pub fd: core::ffi::c_int, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for ImportFenceFdInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::IMPORT_FENCE_FD_INFO_KHR; + } + impl<'a> Default for ImportFenceFdInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + fence: Default::default(), + flags: Default::default(), + handle_type: Default::default(), + fd: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> ImportFenceFdInfoKHR<'a> { + pub fn fence(mut self, fence: crate::vk::Fence) -> Self { + self.fence = fence; + self + } + pub fn flags(mut self, flags: crate::vk::FenceImportFlags) -> Self { + self.flags = flags; + self + } + pub fn handle_type( + mut self, + handle_type: crate::vk::ExternalFenceHandleTypeFlagBits, + ) -> Self { + self.handle_type = handle_type; + self + } + pub fn fd(mut self, fd: core::ffi::c_int) -> Self { + self.fd = fd; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct FenceGetFdInfoKHR<'a> { @@ -71,6 +108,33 @@ pub(crate) mod reexport { pub handle_type: crate::vk::ExternalFenceHandleTypeFlagBits, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for FenceGetFdInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::FENCE_GET_FD_INFO_KHR; + } + impl<'a> Default for FenceGetFdInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + fence: Default::default(), + handle_type: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> FenceGetFdInfoKHR<'a> { + pub fn fence(mut self, fence: crate::vk::Fence) -> Self { + self.fence = fence; + self + } + pub fn handle_type( + mut self, + handle_type: crate::vk::ExternalFenceHandleTypeFlagBits, + ) -> Self { + self.handle_type = handle_type; + self + } + } ///Provided by [`khr::external_fence_fd`](crate::khr::external_fence_fd) impl crate::vk::StructureType { pub const IMPORT_FENCE_FD_INFO_KHR: Self = Self(1000115000); diff --git a/ash-rewrite/src/generated/khr/external_fence_win32.rs b/ash-rewrite/src/generated/khr/external_fence_win32.rs index cfca277a6..b4c95ef9a 100644 --- a/ash-rewrite/src/generated/khr/external_fence_win32.rs +++ b/ash-rewrite/src/generated/khr/external_fence_win32.rs @@ -63,6 +63,48 @@ pub(crate) mod reexport { pub name: crate::platform_types::LPCWSTR, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for ImportFenceWin32HandleInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::IMPORT_FENCE_WIN32_HANDLE_INFO_KHR; + } + impl<'a> Default for ImportFenceWin32HandleInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + fence: Default::default(), + flags: Default::default(), + handle_type: Default::default(), + handle: Default::default(), + name: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> ImportFenceWin32HandleInfoKHR<'a> { + pub fn fence(mut self, fence: crate::vk::Fence) -> Self { + self.fence = fence; + self + } + pub fn flags(mut self, flags: crate::vk::FenceImportFlags) -> Self { + self.flags = flags; + self + } + pub fn handle_type( + mut self, + handle_type: crate::vk::ExternalFenceHandleTypeFlagBits, + ) -> Self { + self.handle_type = handle_type; + self + } + pub fn handle(mut self, handle: crate::platform_types::HANDLE) -> Self { + self.handle = handle; + self + } + pub fn name(mut self, name: crate::platform_types::LPCWSTR) -> Self { + self.name = name; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct ExportFenceWin32HandleInfoKHR<'a> { @@ -73,6 +115,40 @@ pub(crate) mod reexport { pub name: crate::platform_types::LPCWSTR, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for ExportFenceWin32HandleInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::EXPORT_FENCE_WIN32_HANDLE_INFO_KHR; + } + unsafe impl<'a> crate::Extends> + for ExportFenceWin32HandleInfoKHR<'a> {} + impl<'a> Default for ExportFenceWin32HandleInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + p_attributes: Default::default(), + dw_access: Default::default(), + name: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> ExportFenceWin32HandleInfoKHR<'a> { + pub fn p_attributes( + mut self, + p_attributes: &'a crate::platform_types::SECURITY_ATTRIBUTES, + ) -> Self { + self.p_attributes = p_attributes; + self + } + pub fn dw_access(mut self, dw_access: crate::platform_types::DWORD) -> Self { + self.dw_access = dw_access; + self + } + pub fn name(mut self, name: crate::platform_types::LPCWSTR) -> Self { + self.name = name; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct FenceGetWin32HandleInfoKHR<'a> { @@ -82,6 +158,33 @@ pub(crate) mod reexport { pub handle_type: crate::vk::ExternalFenceHandleTypeFlagBits, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for FenceGetWin32HandleInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::FENCE_GET_WIN32_HANDLE_INFO_KHR; + } + impl<'a> Default for FenceGetWin32HandleInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + fence: Default::default(), + handle_type: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> FenceGetWin32HandleInfoKHR<'a> { + pub fn fence(mut self, fence: crate::vk::Fence) -> Self { + self.fence = fence; + self + } + pub fn handle_type( + mut self, + handle_type: crate::vk::ExternalFenceHandleTypeFlagBits, + ) -> Self { + self.handle_type = handle_type; + self + } + } ///Provided by [`khr::external_fence_win32`](crate::khr::external_fence_win32) impl crate::vk::StructureType { pub const IMPORT_FENCE_WIN32_HANDLE_INFO_KHR: Self = Self(1000114000); diff --git a/ash-rewrite/src/generated/khr/external_memory_fd.rs b/ash-rewrite/src/generated/khr/external_memory_fd.rs index 17acdaac5..564e4786d 100644 --- a/ash-rewrite/src/generated/khr/external_memory_fd.rs +++ b/ash-rewrite/src/generated/khr/external_memory_fd.rs @@ -62,6 +62,35 @@ pub(crate) mod reexport { pub fd: core::ffi::c_int, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for ImportMemoryFdInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::IMPORT_MEMORY_FD_INFO_KHR; + } + unsafe impl<'a> crate::Extends> + for ImportMemoryFdInfoKHR<'a> {} + impl<'a> Default for ImportMemoryFdInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + handle_type: Default::default(), + fd: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> ImportMemoryFdInfoKHR<'a> { + pub fn handle_type( + mut self, + handle_type: crate::vk::ExternalMemoryHandleTypeFlagBits, + ) -> Self { + self.handle_type = handle_type; + self + } + pub fn fd(mut self, fd: core::ffi::c_int) -> Self { + self.fd = fd; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct MemoryFdPropertiesKHR<'a> { @@ -70,6 +99,25 @@ pub(crate) mod reexport { pub memory_type_bits: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for MemoryFdPropertiesKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::MEMORY_FD_PROPERTIES_KHR; + } + impl<'a> Default for MemoryFdPropertiesKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + memory_type_bits: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> MemoryFdPropertiesKHR<'a> { + pub fn memory_type_bits(mut self, memory_type_bits: u32) -> Self { + self.memory_type_bits = memory_type_bits; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct MemoryGetFdInfoKHR<'a> { @@ -79,6 +127,33 @@ pub(crate) mod reexport { pub handle_type: crate::vk::ExternalMemoryHandleTypeFlagBits, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for MemoryGetFdInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::MEMORY_GET_FD_INFO_KHR; + } + impl<'a> Default for MemoryGetFdInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + memory: Default::default(), + handle_type: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> MemoryGetFdInfoKHR<'a> { + pub fn memory(mut self, memory: crate::vk::DeviceMemory) -> Self { + self.memory = memory; + self + } + pub fn handle_type( + mut self, + handle_type: crate::vk::ExternalMemoryHandleTypeFlagBits, + ) -> Self { + self.handle_type = handle_type; + self + } + } ///Provided by [`khr::external_memory_fd`](crate::khr::external_memory_fd) impl crate::vk::StructureType { pub const IMPORT_MEMORY_FD_INFO_KHR: Self = Self(1000074000); diff --git a/ash-rewrite/src/generated/khr/external_memory_win32.rs b/ash-rewrite/src/generated/khr/external_memory_win32.rs index 69390c31c..1fb059597 100644 --- a/ash-rewrite/src/generated/khr/external_memory_win32.rs +++ b/ash-rewrite/src/generated/khr/external_memory_win32.rs @@ -63,6 +63,40 @@ pub(crate) mod reexport { pub name: crate::platform_types::LPCWSTR, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for ImportMemoryWin32HandleInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR; + } + unsafe impl<'a> crate::Extends> + for ImportMemoryWin32HandleInfoKHR<'a> {} + impl<'a> Default for ImportMemoryWin32HandleInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + handle_type: Default::default(), + handle: Default::default(), + name: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> ImportMemoryWin32HandleInfoKHR<'a> { + pub fn handle_type( + mut self, + handle_type: crate::vk::ExternalMemoryHandleTypeFlagBits, + ) -> Self { + self.handle_type = handle_type; + self + } + pub fn handle(mut self, handle: crate::platform_types::HANDLE) -> Self { + self.handle = handle; + self + } + pub fn name(mut self, name: crate::platform_types::LPCWSTR) -> Self { + self.name = name; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct ExportMemoryWin32HandleInfoKHR<'a> { @@ -73,6 +107,40 @@ pub(crate) mod reexport { pub name: crate::platform_types::LPCWSTR, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for ExportMemoryWin32HandleInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR; + } + unsafe impl<'a> crate::Extends> + for ExportMemoryWin32HandleInfoKHR<'a> {} + impl<'a> Default for ExportMemoryWin32HandleInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + p_attributes: Default::default(), + dw_access: Default::default(), + name: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> ExportMemoryWin32HandleInfoKHR<'a> { + pub fn p_attributes( + mut self, + p_attributes: &'a crate::platform_types::SECURITY_ATTRIBUTES, + ) -> Self { + self.p_attributes = p_attributes; + self + } + pub fn dw_access(mut self, dw_access: crate::platform_types::DWORD) -> Self { + self.dw_access = dw_access; + self + } + pub fn name(mut self, name: crate::platform_types::LPCWSTR) -> Self { + self.name = name; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct MemoryWin32HandlePropertiesKHR<'a> { @@ -81,6 +149,25 @@ pub(crate) mod reexport { pub memory_type_bits: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for MemoryWin32HandlePropertiesKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::MEMORY_WIN32_HANDLE_PROPERTIES_KHR; + } + impl<'a> Default for MemoryWin32HandlePropertiesKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + memory_type_bits: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> MemoryWin32HandlePropertiesKHR<'a> { + pub fn memory_type_bits(mut self, memory_type_bits: u32) -> Self { + self.memory_type_bits = memory_type_bits; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct MemoryGetWin32HandleInfoKHR<'a> { @@ -90,6 +177,33 @@ pub(crate) mod reexport { pub handle_type: crate::vk::ExternalMemoryHandleTypeFlagBits, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for MemoryGetWin32HandleInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::MEMORY_GET_WIN32_HANDLE_INFO_KHR; + } + impl<'a> Default for MemoryGetWin32HandleInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + memory: Default::default(), + handle_type: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> MemoryGetWin32HandleInfoKHR<'a> { + pub fn memory(mut self, memory: crate::vk::DeviceMemory) -> Self { + self.memory = memory; + self + } + pub fn handle_type( + mut self, + handle_type: crate::vk::ExternalMemoryHandleTypeFlagBits, + ) -> Self { + self.handle_type = handle_type; + self + } + } ///Provided by [`khr::external_memory_win32`](crate::khr::external_memory_win32) impl crate::vk::StructureType { pub const IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR: Self = Self(1000073000); diff --git a/ash-rewrite/src/generated/khr/external_semaphore_fd.rs b/ash-rewrite/src/generated/khr/external_semaphore_fd.rs index a2cd63d0b..17a4f7632 100644 --- a/ash-rewrite/src/generated/khr/external_semaphore_fd.rs +++ b/ash-rewrite/src/generated/khr/external_semaphore_fd.rs @@ -62,6 +62,43 @@ pub(crate) mod reexport { pub fd: core::ffi::c_int, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for ImportSemaphoreFdInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::IMPORT_SEMAPHORE_FD_INFO_KHR; + } + impl<'a> Default for ImportSemaphoreFdInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + semaphore: Default::default(), + flags: Default::default(), + handle_type: Default::default(), + fd: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> ImportSemaphoreFdInfoKHR<'a> { + pub fn semaphore(mut self, semaphore: crate::vk::Semaphore) -> Self { + self.semaphore = semaphore; + self + } + pub fn flags(mut self, flags: crate::vk::SemaphoreImportFlags) -> Self { + self.flags = flags; + self + } + pub fn handle_type( + mut self, + handle_type: crate::vk::ExternalSemaphoreHandleTypeFlagBits, + ) -> Self { + self.handle_type = handle_type; + self + } + pub fn fd(mut self, fd: core::ffi::c_int) -> Self { + self.fd = fd; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct SemaphoreGetFdInfoKHR<'a> { @@ -71,6 +108,33 @@ pub(crate) mod reexport { pub handle_type: crate::vk::ExternalSemaphoreHandleTypeFlagBits, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for SemaphoreGetFdInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::SEMAPHORE_GET_FD_INFO_KHR; + } + impl<'a> Default for SemaphoreGetFdInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + semaphore: Default::default(), + handle_type: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> SemaphoreGetFdInfoKHR<'a> { + pub fn semaphore(mut self, semaphore: crate::vk::Semaphore) -> Self { + self.semaphore = semaphore; + self + } + pub fn handle_type( + mut self, + handle_type: crate::vk::ExternalSemaphoreHandleTypeFlagBits, + ) -> Self { + self.handle_type = handle_type; + self + } + } ///Provided by [`khr::external_semaphore_fd`](crate::khr::external_semaphore_fd) impl crate::vk::StructureType { pub const IMPORT_SEMAPHORE_FD_INFO_KHR: Self = Self(1000079000); diff --git a/ash-rewrite/src/generated/khr/external_semaphore_win32.rs b/ash-rewrite/src/generated/khr/external_semaphore_win32.rs index 756a01ad7..967b02907 100644 --- a/ash-rewrite/src/generated/khr/external_semaphore_win32.rs +++ b/ash-rewrite/src/generated/khr/external_semaphore_win32.rs @@ -63,6 +63,49 @@ pub(crate) mod reexport { pub name: crate::platform_types::LPCWSTR, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for ImportSemaphoreWin32HandleInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR; + } + impl<'a> Default for ImportSemaphoreWin32HandleInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + semaphore: Default::default(), + flags: Default::default(), + handle_type: Default::default(), + handle: Default::default(), + name: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> ImportSemaphoreWin32HandleInfoKHR<'a> { + pub fn semaphore(mut self, semaphore: crate::vk::Semaphore) -> Self { + self.semaphore = semaphore; + self + } + pub fn flags(mut self, flags: crate::vk::SemaphoreImportFlags) -> Self { + self.flags = flags; + self + } + pub fn handle_type( + mut self, + handle_type: crate::vk::ExternalSemaphoreHandleTypeFlagBits, + ) -> Self { + self.handle_type = handle_type; + self + } + pub fn handle(mut self, handle: crate::platform_types::HANDLE) -> Self { + self.handle = handle; + self + } + pub fn name(mut self, name: crate::platform_types::LPCWSTR) -> Self { + self.name = name; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct ExportSemaphoreWin32HandleInfoKHR<'a> { @@ -73,6 +116,41 @@ pub(crate) mod reexport { pub name: crate::platform_types::LPCWSTR, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for ExportSemaphoreWin32HandleInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR; + } + unsafe impl<'a> crate::Extends> + for ExportSemaphoreWin32HandleInfoKHR<'a> {} + impl<'a> Default for ExportSemaphoreWin32HandleInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + p_attributes: Default::default(), + dw_access: Default::default(), + name: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> ExportSemaphoreWin32HandleInfoKHR<'a> { + pub fn p_attributes( + mut self, + p_attributes: &'a crate::platform_types::SECURITY_ATTRIBUTES, + ) -> Self { + self.p_attributes = p_attributes; + self + } + pub fn dw_access(mut self, dw_access: crate::platform_types::DWORD) -> Self { + self.dw_access = dw_access; + self + } + pub fn name(mut self, name: crate::platform_types::LPCWSTR) -> Self { + self.name = name; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct D3D12FenceSubmitInfoKHR<'a> { @@ -84,6 +162,56 @@ pub(crate) mod reexport { pub p_signal_semaphore_values: *const u64, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for D3D12FenceSubmitInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::D3D12_FENCE_SUBMIT_INFO_KHR; + } + unsafe impl<'a> crate::Extends> + for D3D12FenceSubmitInfoKHR<'a> {} + impl<'a> Default for D3D12FenceSubmitInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + wait_semaphore_values_count: Default::default(), + p_wait_semaphore_values: Default::default(), + signal_semaphore_values_count: Default::default(), + p_signal_semaphore_values: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> D3D12FenceSubmitInfoKHR<'a> { + pub fn wait_semaphore_values_count( + mut self, + wait_semaphore_values_count: u32, + ) -> Self { + self.wait_semaphore_values_count = wait_semaphore_values_count; + self + } + pub fn p_wait_semaphore_values( + mut self, + p_wait_semaphore_values: &'a [u64], + ) -> Self { + self.wait_semaphore_values_count = p_wait_semaphore_values.len() as _; + self.p_wait_semaphore_values = p_wait_semaphore_values.as_ptr(); + self + } + pub fn signal_semaphore_values_count( + mut self, + signal_semaphore_values_count: u32, + ) -> Self { + self.signal_semaphore_values_count = signal_semaphore_values_count; + self + } + pub fn p_signal_semaphore_values( + mut self, + p_signal_semaphore_values: &'a [u64], + ) -> Self { + self.signal_semaphore_values_count = p_signal_semaphore_values.len() as _; + self.p_signal_semaphore_values = p_signal_semaphore_values.as_ptr(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct SemaphoreGetWin32HandleInfoKHR<'a> { @@ -93,6 +221,33 @@ pub(crate) mod reexport { pub handle_type: crate::vk::ExternalSemaphoreHandleTypeFlagBits, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for SemaphoreGetWin32HandleInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR; + } + impl<'a> Default for SemaphoreGetWin32HandleInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + semaphore: Default::default(), + handle_type: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> SemaphoreGetWin32HandleInfoKHR<'a> { + pub fn semaphore(mut self, semaphore: crate::vk::Semaphore) -> Self { + self.semaphore = semaphore; + self + } + pub fn handle_type( + mut self, + handle_type: crate::vk::ExternalSemaphoreHandleTypeFlagBits, + ) -> Self { + self.handle_type = handle_type; + self + } + } ///Provided by [`khr::external_semaphore_win32`](crate::khr::external_semaphore_win32) impl crate::vk::StructureType { pub const IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR: Self = Self(1000078000); diff --git a/ash-rewrite/src/generated/khr/fragment_shader_barycentric.rs b/ash-rewrite/src/generated/khr/fragment_shader_barycentric.rs index 1797692b7..2eaeacf27 100644 --- a/ash-rewrite/src/generated/khr/fragment_shader_barycentric.rs +++ b/ash-rewrite/src/generated/khr/fragment_shader_barycentric.rs @@ -9,6 +9,33 @@ pub struct PhysicalDeviceFragmentShaderBarycentricFeaturesKHR<'a> { pub fragment_shader_barycentric: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceFragmentShaderBarycentricFeaturesKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceFragmentShaderBarycentricFeaturesKHR<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceFragmentShaderBarycentricFeaturesKHR<'a> {} +impl<'a> Default for PhysicalDeviceFragmentShaderBarycentricFeaturesKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + fragment_shader_barycentric: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceFragmentShaderBarycentricFeaturesKHR<'a> { + pub fn fragment_shader_barycentric( + mut self, + fragment_shader_barycentric: bool, + ) -> Self { + self.fragment_shader_barycentric = fragment_shader_barycentric.into(); + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceFragmentShaderBarycentricPropertiesKHR<'a> { @@ -17,6 +44,32 @@ pub struct PhysicalDeviceFragmentShaderBarycentricPropertiesKHR<'a> { pub tri_strip_vertex_order_independent_of_provoking_vertex: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceFragmentShaderBarycentricPropertiesKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceFragmentShaderBarycentricPropertiesKHR<'a> {} +impl<'a> Default for PhysicalDeviceFragmentShaderBarycentricPropertiesKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + tri_strip_vertex_order_independent_of_provoking_vertex: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceFragmentShaderBarycentricPropertiesKHR<'a> { + pub fn tri_strip_vertex_order_independent_of_provoking_vertex( + mut self, + tri_strip_vertex_order_independent_of_provoking_vertex: bool, + ) -> Self { + self.tri_strip_vertex_order_independent_of_provoking_vertex = tri_strip_vertex_order_independent_of_provoking_vertex + .into(); + self + } +} ///Provided by [`khr::fragment_shader_barycentric`](crate::khr::fragment_shader_barycentric) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR: Self = Self( diff --git a/ash-rewrite/src/generated/khr/fragment_shading_rate.rs b/ash-rewrite/src/generated/khr/fragment_shading_rate.rs index 7400c6ebf..08bd905e0 100644 --- a/ash-rewrite/src/generated/khr/fragment_shading_rate.rs +++ b/ash-rewrite/src/generated/khr/fragment_shading_rate.rs @@ -81,6 +81,39 @@ pub(crate) mod reexport { pub shading_rate_attachment_texel_size: crate::vk::Extent2D, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for FragmentShadingRateAttachmentInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR; + } + unsafe impl<'a> crate::Extends> + for FragmentShadingRateAttachmentInfoKHR<'a> {} + impl<'a> Default for FragmentShadingRateAttachmentInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + p_fragment_shading_rate_attachment: Default::default(), + shading_rate_attachment_texel_size: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> FragmentShadingRateAttachmentInfoKHR<'a> { + pub fn p_fragment_shading_rate_attachment( + mut self, + p_fragment_shading_rate_attachment: &'a crate::vk::AttachmentReference2<'a>, + ) -> Self { + self.p_fragment_shading_rate_attachment = p_fragment_shading_rate_attachment; + self + } + pub fn shading_rate_attachment_texel_size( + mut self, + shading_rate_attachment_texel_size: crate::vk::Extent2D, + ) -> Self { + self.shading_rate_attachment_texel_size = shading_rate_attachment_texel_size; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PipelineFragmentShadingRateStateCreateInfoKHR<'a> { @@ -90,6 +123,36 @@ pub(crate) mod reexport { pub combiner_ops: [crate::vk::FragmentShadingRateCombinerOpKHR; 2 as _], pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PipelineFragmentShadingRateStateCreateInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR; + } + unsafe impl<'a> crate::Extends> + for PipelineFragmentShadingRateStateCreateInfoKHR<'a> {} + impl<'a> Default for PipelineFragmentShadingRateStateCreateInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + fragment_size: Default::default(), + combiner_ops: unsafe { core::mem::zeroed() }, + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PipelineFragmentShadingRateStateCreateInfoKHR<'a> { + pub fn fragment_size(mut self, fragment_size: crate::vk::Extent2D) -> Self { + self.fragment_size = fragment_size; + self + } + pub fn combiner_ops( + mut self, + combiner_ops: [crate::vk::FragmentShadingRateCombinerOpKHR; 2 as _], + ) -> Self { + self.combiner_ops = combiner_ops; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceFragmentShadingRateFeaturesKHR<'a> { @@ -100,6 +163,51 @@ pub(crate) mod reexport { pub attachment_fragment_shading_rate: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceFragmentShadingRateFeaturesKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceFragmentShadingRateFeaturesKHR<'a> {} + unsafe impl<'a> crate::Extends> + for PhysicalDeviceFragmentShadingRateFeaturesKHR<'a> {} + impl<'a> Default for PhysicalDeviceFragmentShadingRateFeaturesKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + pipeline_fragment_shading_rate: Default::default(), + primitive_fragment_shading_rate: Default::default(), + attachment_fragment_shading_rate: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceFragmentShadingRateFeaturesKHR<'a> { + pub fn pipeline_fragment_shading_rate( + mut self, + pipeline_fragment_shading_rate: bool, + ) -> Self { + self.pipeline_fragment_shading_rate = pipeline_fragment_shading_rate.into(); + self + } + pub fn primitive_fragment_shading_rate( + mut self, + primitive_fragment_shading_rate: bool, + ) -> Self { + self.primitive_fragment_shading_rate = primitive_fragment_shading_rate + .into(); + self + } + pub fn attachment_fragment_shading_rate( + mut self, + attachment_fragment_shading_rate: bool, + ) -> Self { + self.attachment_fragment_shading_rate = attachment_fragment_shading_rate + .into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceFragmentShadingRatePropertiesKHR<'a> { @@ -124,6 +232,169 @@ pub(crate) mod reexport { pub fragment_shading_rate_strict_multiply_combiner: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceFragmentShadingRatePropertiesKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceFragmentShadingRatePropertiesKHR<'a> {} + impl<'a> Default for PhysicalDeviceFragmentShadingRatePropertiesKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + min_fragment_shading_rate_attachment_texel_size: Default::default(), + max_fragment_shading_rate_attachment_texel_size: Default::default(), + max_fragment_shading_rate_attachment_texel_size_aspect_ratio: Default::default(), + primitive_fragment_shading_rate_with_multiple_viewports: Default::default(), + layered_shading_rate_attachments: Default::default(), + fragment_shading_rate_non_trivial_combiner_ops: Default::default(), + max_fragment_size: Default::default(), + max_fragment_size_aspect_ratio: Default::default(), + max_fragment_shading_rate_coverage_samples: Default::default(), + max_fragment_shading_rate_rasterization_samples: Default::default(), + fragment_shading_rate_with_shader_depth_stencil_writes: Default::default(), + fragment_shading_rate_with_sample_mask: Default::default(), + fragment_shading_rate_with_shader_sample_mask: Default::default(), + fragment_shading_rate_with_conservative_rasterization: Default::default(), + fragment_shading_rate_with_fragment_shader_interlock: Default::default(), + fragment_shading_rate_with_custom_sample_locations: Default::default(), + fragment_shading_rate_strict_multiply_combiner: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceFragmentShadingRatePropertiesKHR<'a> { + pub fn min_fragment_shading_rate_attachment_texel_size( + mut self, + min_fragment_shading_rate_attachment_texel_size: crate::vk::Extent2D, + ) -> Self { + self.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: crate::vk::Extent2D, + ) -> Self { + self.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, + ) -> Self { + self.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, + ) -> Self { + self.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, + ) -> Self { + self.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, + ) -> Self { + self.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: crate::vk::Extent2D, + ) -> Self { + self.max_fragment_size = max_fragment_size; + self + } + pub fn max_fragment_size_aspect_ratio( + mut self, + max_fragment_size_aspect_ratio: u32, + ) -> Self { + self.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, + ) -> Self { + self.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: crate::vk::SampleCountFlagBits, + ) -> Self { + self.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, + ) -> Self { + self.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, + ) -> Self { + self.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, + ) -> Self { + self.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, + ) -> Self { + self.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, + ) -> Self { + self.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, + ) -> Self { + self.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, + ) -> Self { + self.fragment_shading_rate_strict_multiply_combiner = fragment_shading_rate_strict_multiply_combiner + .into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceFragmentShadingRateKHR<'a> { @@ -133,6 +404,34 @@ pub(crate) mod reexport { pub fragment_size: crate::vk::Extent2D, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceFragmentShadingRateKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR; + } + impl<'a> Default for PhysicalDeviceFragmentShadingRateKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + sample_counts: Default::default(), + fragment_size: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceFragmentShadingRateKHR<'a> { + pub fn sample_counts( + mut self, + sample_counts: crate::vk::SampleCountFlags, + ) -> Self { + self.sample_counts = sample_counts; + self + } + pub fn fragment_size(mut self, fragment_size: crate::vk::Extent2D) -> Self { + self.fragment_size = fragment_size; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct RenderingFragmentShadingRateAttachmentInfoKHR<'a> { @@ -143,6 +442,41 @@ pub(crate) mod reexport { pub shading_rate_attachment_texel_size: crate::vk::Extent2D, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for RenderingFragmentShadingRateAttachmentInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR; + } + unsafe impl<'a> crate::Extends> + for RenderingFragmentShadingRateAttachmentInfoKHR<'a> {} + impl<'a> Default for RenderingFragmentShadingRateAttachmentInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + image_view: Default::default(), + image_layout: Default::default(), + shading_rate_attachment_texel_size: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> RenderingFragmentShadingRateAttachmentInfoKHR<'a> { + pub fn image_view(mut self, image_view: crate::vk::ImageView) -> Self { + self.image_view = image_view; + self + } + pub fn image_layout(mut self, image_layout: crate::vk::ImageLayout) -> Self { + self.image_layout = image_layout; + self + } + pub fn shading_rate_attachment_texel_size( + mut self, + shading_rate_attachment_texel_size: crate::vk::Extent2D, + ) -> Self { + self.shading_rate_attachment_texel_size = shading_rate_attachment_texel_size; + self + } + } ///Provided by [`khr::fragment_shading_rate`](crate::khr::fragment_shading_rate) impl crate::vk::ImageLayout { pub const FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR: Self = Self(1000164003); diff --git a/ash-rewrite/src/generated/khr/get_display_properties2.rs b/ash-rewrite/src/generated/khr/get_display_properties2.rs index 79683d3a6..6046ca2f8 100644 --- a/ash-rewrite/src/generated/khr/get_display_properties2.rs +++ b/ash-rewrite/src/generated/khr/get_display_properties2.rs @@ -95,6 +95,28 @@ pub(crate) mod reexport { pub display_properties: crate::vk::DisplayPropertiesKHR<'a>, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for DisplayProperties2KHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::DISPLAY_PROPERTIES_2_KHR; + } + impl<'a> Default for DisplayProperties2KHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + display_properties: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> DisplayProperties2KHR<'a> { + pub fn display_properties( + mut self, + display_properties: crate::vk::DisplayPropertiesKHR<'a>, + ) -> Self { + self.display_properties = display_properties; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct DisplayPlaneProperties2KHR<'a> { @@ -103,6 +125,28 @@ pub(crate) mod reexport { pub display_plane_properties: crate::vk::DisplayPlanePropertiesKHR, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for DisplayPlaneProperties2KHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::DISPLAY_PLANE_PROPERTIES_2_KHR; + } + impl<'a> Default for DisplayPlaneProperties2KHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + display_plane_properties: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> DisplayPlaneProperties2KHR<'a> { + pub fn display_plane_properties( + mut self, + display_plane_properties: crate::vk::DisplayPlanePropertiesKHR, + ) -> Self { + self.display_plane_properties = display_plane_properties; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct DisplayModeProperties2KHR<'a> { @@ -111,6 +155,28 @@ pub(crate) mod reexport { pub display_mode_properties: crate::vk::DisplayModePropertiesKHR, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for DisplayModeProperties2KHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::DISPLAY_MODE_PROPERTIES_2_KHR; + } + impl<'a> Default for DisplayModeProperties2KHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + display_mode_properties: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> DisplayModeProperties2KHR<'a> { + pub fn display_mode_properties( + mut self, + display_mode_properties: crate::vk::DisplayModePropertiesKHR, + ) -> Self { + self.display_mode_properties = display_mode_properties; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct DisplayPlaneInfo2KHR<'a> { @@ -120,6 +186,30 @@ pub(crate) mod reexport { pub plane_index: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for DisplayPlaneInfo2KHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::DISPLAY_PLANE_INFO_2_KHR; + } + impl<'a> Default for DisplayPlaneInfo2KHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + mode: Default::default(), + plane_index: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> DisplayPlaneInfo2KHR<'a> { + pub fn mode(mut self, mode: crate::vk::DisplayModeKHR) -> Self { + self.mode = mode; + self + } + pub fn plane_index(mut self, plane_index: u32) -> Self { + self.plane_index = plane_index; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct DisplayPlaneCapabilities2KHR<'a> { @@ -128,6 +218,28 @@ pub(crate) mod reexport { pub capabilities: crate::vk::DisplayPlaneCapabilitiesKHR, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for DisplayPlaneCapabilities2KHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::DISPLAY_PLANE_CAPABILITIES_2_KHR; + } + impl<'a> Default for DisplayPlaneCapabilities2KHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + capabilities: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> DisplayPlaneCapabilities2KHR<'a> { + pub fn capabilities( + mut self, + capabilities: crate::vk::DisplayPlaneCapabilitiesKHR, + ) -> Self { + self.capabilities = capabilities; + self + } + } ///Provided by [`khr::get_display_properties2`](crate::khr::get_display_properties2) impl crate::vk::StructureType { pub const DISPLAY_PROPERTIES_2_KHR: Self = Self(1000121000); diff --git a/ash-rewrite/src/generated/khr/get_surface_capabilities2.rs b/ash-rewrite/src/generated/khr/get_surface_capabilities2.rs index 61368b914..d7d52a9ed 100644 --- a/ash-rewrite/src/generated/khr/get_surface_capabilities2.rs +++ b/ash-rewrite/src/generated/khr/get_surface_capabilities2.rs @@ -61,6 +61,25 @@ pub(crate) mod reexport { pub surface: crate::vk::SurfaceKHR, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for PhysicalDeviceSurfaceInfo2KHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_SURFACE_INFO_2_KHR; + } + impl<'a> Default for PhysicalDeviceSurfaceInfo2KHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + surface: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceSurfaceInfo2KHR<'a> { + pub fn surface(mut self, surface: crate::vk::SurfaceKHR) -> Self { + self.surface = surface; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct SurfaceCapabilities2KHR<'a> { @@ -69,6 +88,28 @@ pub(crate) mod reexport { pub surface_capabilities: crate::vk::SurfaceCapabilitiesKHR, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for SurfaceCapabilities2KHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::SURFACE_CAPABILITIES_2_KHR; + } + impl<'a> Default for SurfaceCapabilities2KHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + surface_capabilities: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> SurfaceCapabilities2KHR<'a> { + pub fn surface_capabilities( + mut self, + surface_capabilities: crate::vk::SurfaceCapabilitiesKHR, + ) -> Self { + self.surface_capabilities = surface_capabilities; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct SurfaceFormat2KHR<'a> { @@ -77,6 +118,28 @@ pub(crate) mod reexport { pub surface_format: crate::vk::SurfaceFormatKHR, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for SurfaceFormat2KHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::SURFACE_FORMAT_2_KHR; + } + impl<'a> Default for SurfaceFormat2KHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + surface_format: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> SurfaceFormat2KHR<'a> { + pub fn surface_format( + mut self, + surface_format: crate::vk::SurfaceFormatKHR, + ) -> Self { + self.surface_format = surface_format; + self + } + } ///Provided by [`khr::get_surface_capabilities2`](crate::khr::get_surface_capabilities2) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_SURFACE_INFO_2_KHR: Self = Self(1000119000); diff --git a/ash-rewrite/src/generated/khr/incremental_present.rs b/ash-rewrite/src/generated/khr/incremental_present.rs index 795249e10..064bd868f 100644 --- a/ash-rewrite/src/generated/khr/incremental_present.rs +++ b/ash-rewrite/src/generated/khr/incremental_present.rs @@ -10,20 +10,74 @@ pub struct PresentRegionsKHR<'a> { pub p_regions: *const crate::vk::PresentRegionKHR<'a>, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> for PresentRegionsKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PRESENT_REGIONS_KHR; +} +unsafe impl<'a> crate::Extends> for PresentRegionsKHR<'a> {} +impl<'a> Default for PresentRegionsKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + swapchain_count: Default::default(), + p_regions: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PresentRegionsKHR<'a> { + pub fn swapchain_count(mut self, swapchain_count: u32) -> Self { + self.swapchain_count = swapchain_count; + self + } + pub fn p_regions( + mut self, + p_regions: &'a [crate::vk::PresentRegionKHR<'a>], + ) -> Self { + self.swapchain_count = p_regions.len() as _; + self.p_regions = p_regions.as_ptr(); + self + } +} #[repr(C)] -#[derive(Clone, Copy)] +#[derive(Clone, Copy, Default)] pub struct PresentRegionKHR<'a> { pub rectangle_count: u32, pub p_rectangles: *const crate::vk::RectLayerKHR, pub _marker: ::core::marker::PhantomData<&'a ()>, } +impl<'a> PresentRegionKHR<'a> { + pub fn rectangle_count(mut self, rectangle_count: u32) -> Self { + self.rectangle_count = rectangle_count; + self + } + pub fn p_rectangles(mut self, p_rectangles: &'a [crate::vk::RectLayerKHR]) -> Self { + self.rectangle_count = p_rectangles.len() as _; + self.p_rectangles = p_rectangles.as_ptr(); + self + } +} #[repr(C)] -#[derive(Clone, Copy)] +#[derive(Clone, Copy, Default)] pub struct RectLayerKHR { pub offset: crate::vk::Offset2D, pub extent: crate::vk::Extent2D, pub layer: u32, } +impl RectLayerKHR { + pub fn offset(mut self, offset: crate::vk::Offset2D) -> Self { + self.offset = offset; + self + } + pub fn extent(mut self, extent: crate::vk::Extent2D) -> Self { + self.extent = extent; + self + } + pub fn layer(mut self, layer: u32) -> Self { + self.layer = layer; + self + } +} ///Provided by [`khr::incremental_present`](crate::khr::incremental_present) impl crate::vk::StructureType { pub const PRESENT_REGIONS_KHR: Self = Self(1000084000); diff --git a/ash-rewrite/src/generated/khr/internally_synchronized_queues.rs b/ash-rewrite/src/generated/khr/internally_synchronized_queues.rs index 7dacab4a4..eba7b1eef 100644 --- a/ash-rewrite/src/generated/khr/internally_synchronized_queues.rs +++ b/ash-rewrite/src/generated/khr/internally_synchronized_queues.rs @@ -9,6 +9,33 @@ pub struct PhysicalDeviceInternallySynchronizedQueuesFeaturesKHR<'a> { pub internally_synchronized_queues: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceInternallySynchronizedQueuesFeaturesKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_INTERNALLY_SYNCHRONIZED_QUEUES_FEATURES_KHR; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceInternallySynchronizedQueuesFeaturesKHR<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceInternallySynchronizedQueuesFeaturesKHR<'a> {} +impl<'a> Default for PhysicalDeviceInternallySynchronizedQueuesFeaturesKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + internally_synchronized_queues: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceInternallySynchronizedQueuesFeaturesKHR<'a> { + pub fn internally_synchronized_queues( + mut self, + internally_synchronized_queues: bool, + ) -> Self { + self.internally_synchronized_queues = internally_synchronized_queues.into(); + self + } +} ///Provided by [`khr::internally_synchronized_queues`](crate::khr::internally_synchronized_queues) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_INTERNALLY_SYNCHRONIZED_QUEUES_FEATURES_KHR: Self = Self( diff --git a/ash-rewrite/src/generated/khr/maintenance10.rs b/ash-rewrite/src/generated/khr/maintenance10.rs index d386a0e2d..b800c2231 100644 --- a/ash-rewrite/src/generated/khr/maintenance10.rs +++ b/ash-rewrite/src/generated/khr/maintenance10.rs @@ -45,6 +45,49 @@ pub(crate) mod reexport { pub resolve_srgb_format_supports_transfer_function_control: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceMaintenance10PropertiesKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_MAINTENANCE_10_PROPERTIES_KHR; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceMaintenance10PropertiesKHR<'a> {} + impl<'a> Default for PhysicalDeviceMaintenance10PropertiesKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + rgba4_opaque_black_swizzled: Default::default(), + resolve_srgb_format_applies_transfer_function: Default::default(), + resolve_srgb_format_supports_transfer_function_control: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceMaintenance10PropertiesKHR<'a> { + pub fn rgba4_opaque_black_swizzled( + mut self, + rgba4_opaque_black_swizzled: bool, + ) -> Self { + self.rgba4_opaque_black_swizzled = rgba4_opaque_black_swizzled.into(); + self + } + pub fn resolve_srgb_format_applies_transfer_function( + mut self, + resolve_srgb_format_applies_transfer_function: bool, + ) -> Self { + self.resolve_srgb_format_applies_transfer_function = resolve_srgb_format_applies_transfer_function + .into(); + self + } + pub fn resolve_srgb_format_supports_transfer_function_control( + mut self, + resolve_srgb_format_supports_transfer_function_control: bool, + ) -> Self { + self.resolve_srgb_format_supports_transfer_function_control = resolve_srgb_format_supports_transfer_function_control + .into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceMaintenance10FeaturesKHR<'a> { @@ -53,6 +96,30 @@ pub(crate) mod reexport { pub maintenance10: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceMaintenance10FeaturesKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_MAINTENANCE_10_FEATURES_KHR; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceMaintenance10FeaturesKHR<'a> {} + unsafe impl<'a> crate::Extends> + for PhysicalDeviceMaintenance10FeaturesKHR<'a> {} + impl<'a> Default for PhysicalDeviceMaintenance10FeaturesKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + maintenance10: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceMaintenance10FeaturesKHR<'a> { + pub fn maintenance10(mut self, maintenance10: bool) -> Self { + self.maintenance10 = maintenance10.into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct RenderingEndInfoKHR<'a> { @@ -60,6 +127,19 @@ pub(crate) mod reexport { pub p_next: *const core::ffi::c_void, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for RenderingEndInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::RENDERING_END_INFO_KHR; + } + impl<'a> Default for RenderingEndInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> RenderingEndInfoKHR<'a> {} #[repr(C)] #[derive(Clone, Copy)] pub struct RenderingAttachmentFlagsInfoKHR<'a> { @@ -68,6 +148,27 @@ pub(crate) mod reexport { pub flags: crate::vk::RenderingAttachmentFlagsKHR, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for RenderingAttachmentFlagsInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::RENDERING_ATTACHMENT_FLAGS_INFO_KHR; + } + unsafe impl<'a> crate::Extends> + for RenderingAttachmentFlagsInfoKHR<'a> {} + impl<'a> Default for RenderingAttachmentFlagsInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + flags: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> RenderingAttachmentFlagsInfoKHR<'a> { + pub fn flags(mut self, flags: crate::vk::RenderingAttachmentFlagsKHR) -> Self { + self.flags = flags; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct ResolveImageModeInfoKHR<'a> { @@ -78,6 +179,43 @@ pub(crate) mod reexport { pub stencil_resolve_mode: crate::vk::ResolveModeFlagBits, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for ResolveImageModeInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::RESOLVE_IMAGE_MODE_INFO_KHR; + } + unsafe impl<'a> crate::Extends> + for ResolveImageModeInfoKHR<'a> {} + impl<'a> Default for ResolveImageModeInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + flags: Default::default(), + resolve_mode: Default::default(), + stencil_resolve_mode: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> ResolveImageModeInfoKHR<'a> { + pub fn flags(mut self, flags: crate::vk::ResolveImageFlagsKHR) -> Self { + self.flags = flags; + self + } + pub fn resolve_mode( + mut self, + resolve_mode: crate::vk::ResolveModeFlagBits, + ) -> Self { + self.resolve_mode = resolve_mode; + self + } + pub fn stencil_resolve_mode( + mut self, + stencil_resolve_mode: crate::vk::ResolveModeFlagBits, + ) -> Self { + self.stencil_resolve_mode = stencil_resolve_mode; + self + } + } ///Provided by [`khr::maintenance10`](crate::khr::maintenance10) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_MAINTENANCE_10_FEATURES_KHR: Self = Self(1000630000); @@ -179,7 +317,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct RenderingAttachmentFlagBitsKHR(pub(crate) u32); ///Provided by [`khr::maintenance10`](crate::khr::maintenance10) impl RenderingAttachmentFlagBitsKHR { @@ -261,7 +399,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct ResolveImageFlagBitsKHR(pub(crate) u32); ///Provided by [`khr::maintenance10`](crate::khr::maintenance10) impl ResolveImageFlagBitsKHR { diff --git a/ash-rewrite/src/generated/khr/maintenance11.rs b/ash-rewrite/src/generated/khr/maintenance11.rs index 81513f4d1..64ed6fafd 100644 --- a/ash-rewrite/src/generated/khr/maintenance11.rs +++ b/ash-rewrite/src/generated/khr/maintenance11.rs @@ -9,6 +9,30 @@ pub struct PhysicalDeviceMaintenance11FeaturesKHR<'a> { pub maintenance11: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceMaintenance11FeaturesKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_MAINTENANCE_11_FEATURES_KHR; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceMaintenance11FeaturesKHR<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceMaintenance11FeaturesKHR<'a> {} +impl<'a> Default for PhysicalDeviceMaintenance11FeaturesKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + maintenance11: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceMaintenance11FeaturesKHR<'a> { + pub fn maintenance11(mut self, maintenance11: bool) -> Self { + self.maintenance11 = maintenance11.into(); + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct QueueFamilyOptimalImageTransferGranularityPropertiesKHR<'a> { @@ -17,6 +41,31 @@ pub struct QueueFamilyOptimalImageTransferGranularityPropertiesKHR<'a> { pub optimal_image_transfer_granularity: crate::vk::Extent3D, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for QueueFamilyOptimalImageTransferGranularityPropertiesKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::QUEUE_FAMILY_OPTIMAL_IMAGE_TRANSFER_GRANULARITY_PROPERTIES_KHR; +} +unsafe impl<'a> crate::Extends> +for QueueFamilyOptimalImageTransferGranularityPropertiesKHR<'a> {} +impl<'a> Default for QueueFamilyOptimalImageTransferGranularityPropertiesKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + optimal_image_transfer_granularity: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> QueueFamilyOptimalImageTransferGranularityPropertiesKHR<'a> { + pub fn optimal_image_transfer_granularity( + mut self, + optimal_image_transfer_granularity: crate::vk::Extent3D, + ) -> Self { + self.optimal_image_transfer_granularity = optimal_image_transfer_granularity; + self + } +} ///Provided by [`khr::maintenance11`](crate::khr::maintenance11) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_MAINTENANCE_11_FEATURES_KHR: Self = Self(1000657000); diff --git a/ash-rewrite/src/generated/khr/maintenance6.rs b/ash-rewrite/src/generated/khr/maintenance6.rs index 6dcdc3f45..9324601a9 100644 --- a/ash-rewrite/src/generated/khr/maintenance6.rs +++ b/ash-rewrite/src/generated/khr/maintenance6.rs @@ -125,6 +125,53 @@ pub(crate) mod reexport { pub p_offsets: *const crate::vk::DeviceSize, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for SetDescriptorBufferOffsetsInfoEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::SET_DESCRIPTOR_BUFFER_OFFSETS_INFO_EXT; + } + impl<'a> Default for SetDescriptorBufferOffsetsInfoEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + stage_flags: Default::default(), + layout: Default::default(), + first_set: Default::default(), + set_count: Default::default(), + p_buffer_indices: Default::default(), + p_offsets: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> SetDescriptorBufferOffsetsInfoEXT<'a> { + pub fn stage_flags(mut self, stage_flags: crate::vk::ShaderStageFlags) -> Self { + self.stage_flags = stage_flags; + self + } + pub fn layout(mut self, layout: crate::vk::PipelineLayout) -> Self { + self.layout = layout; + self + } + pub fn first_set(mut self, first_set: u32) -> Self { + self.first_set = first_set; + self + } + pub fn set_count(mut self, set_count: u32) -> Self { + self.set_count = set_count; + self + } + pub fn p_buffer_indices(mut self, p_buffer_indices: &'a [u32]) -> Self { + self.set_count = p_buffer_indices.len() as _; + self.p_buffer_indices = p_buffer_indices.as_ptr(); + self + } + pub fn p_offsets(mut self, p_offsets: &'a [crate::vk::DeviceSize]) -> Self { + self.set_count = p_offsets.len() as _; + self.p_offsets = p_offsets.as_ptr(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct BindDescriptorBufferEmbeddedSamplersInfoEXT<'a> { @@ -135,6 +182,36 @@ pub(crate) mod reexport { pub set: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for BindDescriptorBufferEmbeddedSamplersInfoEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::BIND_DESCRIPTOR_BUFFER_EMBEDDED_SAMPLERS_INFO_EXT; + } + impl<'a> Default for BindDescriptorBufferEmbeddedSamplersInfoEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + stage_flags: Default::default(), + layout: Default::default(), + set: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> BindDescriptorBufferEmbeddedSamplersInfoEXT<'a> { + pub fn stage_flags(mut self, stage_flags: crate::vk::ShaderStageFlags) -> Self { + self.stage_flags = stage_flags; + self + } + pub fn layout(mut self, layout: crate::vk::PipelineLayout) -> Self { + self.layout = layout; + self + } + pub fn set(mut self, set: u32) -> Self { + self.set = set; + self + } + } pub type PhysicalDeviceMaintenance6FeaturesKHR<'a> = crate::vk::PhysicalDeviceMaintenance6Features< 'a, >; diff --git a/ash-rewrite/src/generated/khr/maintenance7.rs b/ash-rewrite/src/generated/khr/maintenance7.rs index 9daa3e13e..e6d7c82a4 100644 --- a/ash-rewrite/src/generated/khr/maintenance7.rs +++ b/ash-rewrite/src/generated/khr/maintenance7.rs @@ -9,6 +9,30 @@ pub struct PhysicalDeviceMaintenance7FeaturesKHR<'a> { pub maintenance7: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceMaintenance7FeaturesKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_MAINTENANCE_7_FEATURES_KHR; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceMaintenance7FeaturesKHR<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceMaintenance7FeaturesKHR<'a> {} +impl<'a> Default for PhysicalDeviceMaintenance7FeaturesKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + maintenance7: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceMaintenance7FeaturesKHR<'a> { + pub fn maintenance7(mut self, maintenance7: bool) -> Self { + self.maintenance7 = maintenance7.into(); + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceMaintenance7PropertiesKHR<'a> { @@ -24,6 +48,89 @@ pub struct PhysicalDeviceMaintenance7PropertiesKHR<'a> { pub max_descriptor_set_update_after_bind_total_buffers_dynamic: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceMaintenance7PropertiesKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_MAINTENANCE_7_PROPERTIES_KHR; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceMaintenance7PropertiesKHR<'a> {} +impl<'a> Default for PhysicalDeviceMaintenance7PropertiesKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + robust_fragment_shading_rate_attachment_access: Default::default(), + separate_depth_stencil_attachment_access: Default::default(), + max_descriptor_set_total_uniform_buffers_dynamic: Default::default(), + max_descriptor_set_total_storage_buffers_dynamic: Default::default(), + max_descriptor_set_total_buffers_dynamic: Default::default(), + max_descriptor_set_update_after_bind_total_uniform_buffers_dynamic: Default::default(), + max_descriptor_set_update_after_bind_total_storage_buffers_dynamic: Default::default(), + max_descriptor_set_update_after_bind_total_buffers_dynamic: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceMaintenance7PropertiesKHR<'a> { + pub fn robust_fragment_shading_rate_attachment_access( + mut self, + robust_fragment_shading_rate_attachment_access: bool, + ) -> Self { + self.robust_fragment_shading_rate_attachment_access = robust_fragment_shading_rate_attachment_access + .into(); + self + } + pub fn separate_depth_stencil_attachment_access( + mut self, + separate_depth_stencil_attachment_access: bool, + ) -> Self { + self.separate_depth_stencil_attachment_access = separate_depth_stencil_attachment_access + .into(); + self + } + pub fn max_descriptor_set_total_uniform_buffers_dynamic( + mut self, + max_descriptor_set_total_uniform_buffers_dynamic: u32, + ) -> Self { + self.max_descriptor_set_total_uniform_buffers_dynamic = max_descriptor_set_total_uniform_buffers_dynamic; + self + } + pub fn max_descriptor_set_total_storage_buffers_dynamic( + mut self, + max_descriptor_set_total_storage_buffers_dynamic: u32, + ) -> Self { + self.max_descriptor_set_total_storage_buffers_dynamic = max_descriptor_set_total_storage_buffers_dynamic; + self + } + pub fn max_descriptor_set_total_buffers_dynamic( + mut self, + max_descriptor_set_total_buffers_dynamic: u32, + ) -> Self { + self.max_descriptor_set_total_buffers_dynamic = max_descriptor_set_total_buffers_dynamic; + self + } + pub fn max_descriptor_set_update_after_bind_total_uniform_buffers_dynamic( + mut self, + max_descriptor_set_update_after_bind_total_uniform_buffers_dynamic: u32, + ) -> Self { + self.max_descriptor_set_update_after_bind_total_uniform_buffers_dynamic = max_descriptor_set_update_after_bind_total_uniform_buffers_dynamic; + self + } + pub fn max_descriptor_set_update_after_bind_total_storage_buffers_dynamic( + mut self, + max_descriptor_set_update_after_bind_total_storage_buffers_dynamic: u32, + ) -> Self { + self.max_descriptor_set_update_after_bind_total_storage_buffers_dynamic = max_descriptor_set_update_after_bind_total_storage_buffers_dynamic; + self + } + pub fn max_descriptor_set_update_after_bind_total_buffers_dynamic( + mut self, + max_descriptor_set_update_after_bind_total_buffers_dynamic: u32, + ) -> Self { + self.max_descriptor_set_update_after_bind_total_buffers_dynamic = max_descriptor_set_update_after_bind_total_buffers_dynamic; + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceLayeredApiPropertiesListKHR<'a> { @@ -33,6 +140,37 @@ pub struct PhysicalDeviceLayeredApiPropertiesListKHR<'a> { pub p_layered_apis: *mut crate::vk::PhysicalDeviceLayeredApiPropertiesKHR<'a>, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceLayeredApiPropertiesListKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_LAYERED_API_PROPERTIES_LIST_KHR; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceLayeredApiPropertiesListKHR<'a> {} +impl<'a> Default for PhysicalDeviceLayeredApiPropertiesListKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + layered_api_count: Default::default(), + p_layered_apis: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceLayeredApiPropertiesListKHR<'a> { + pub fn layered_api_count(mut self, layered_api_count: u32) -> Self { + self.layered_api_count = layered_api_count; + self + } + pub fn p_layered_apis( + mut self, + p_layered_apis: &'a mut [crate::vk::PhysicalDeviceLayeredApiPropertiesKHR<'a>], + ) -> Self { + self.layered_api_count = p_layered_apis.len() as _; + self.p_layered_apis = p_layered_apis.as_mut_ptr(); + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceLayeredApiPropertiesKHR<'a> { @@ -44,6 +182,47 @@ pub struct PhysicalDeviceLayeredApiPropertiesKHR<'a> { pub device_name: [core::ffi::c_char; crate::vk::MAX_PHYSICAL_DEVICE_NAME_SIZE as _], pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceLayeredApiPropertiesKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_LAYERED_API_PROPERTIES_KHR; +} +impl<'a> Default for PhysicalDeviceLayeredApiPropertiesKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + vendor_id: Default::default(), + device_id: Default::default(), + layered_api: Default::default(), + device_name: unsafe { core::mem::zeroed() }, + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceLayeredApiPropertiesKHR<'a> { + pub fn vendor_id(mut self, vendor_id: u32) -> Self { + self.vendor_id = vendor_id; + self + } + pub fn device_id(mut self, device_id: u32) -> Self { + self.device_id = device_id; + self + } + pub fn layered_api( + mut self, + layered_api: crate::vk::PhysicalDeviceLayeredApiKHR, + ) -> Self { + self.layered_api = layered_api; + self + } + pub fn device_name( + mut self, + device_name: [core::ffi::c_char; crate::vk::MAX_PHYSICAL_DEVICE_NAME_SIZE as _], + ) -> Self { + self.device_name = device_name; + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceLayeredApiVulkanPropertiesKHR<'a> { @@ -52,6 +231,31 @@ pub struct PhysicalDeviceLayeredApiVulkanPropertiesKHR<'a> { pub properties: crate::vk::PhysicalDeviceProperties2<'a>, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceLayeredApiVulkanPropertiesKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_LAYERED_API_VULKAN_PROPERTIES_KHR; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceLayeredApiVulkanPropertiesKHR<'a> {} +impl<'a> Default for PhysicalDeviceLayeredApiVulkanPropertiesKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + properties: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceLayeredApiVulkanPropertiesKHR<'a> { + pub fn properties( + mut self, + properties: crate::vk::PhysicalDeviceProperties2<'a>, + ) -> Self { + self.properties = properties; + self + } +} ///Provided by [`khr::maintenance7`](crate::khr::maintenance7) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_MAINTENANCE_7_FEATURES_KHR: Self = Self(1000562000); diff --git a/ash-rewrite/src/generated/khr/maintenance8.rs b/ash-rewrite/src/generated/khr/maintenance8.rs index 26cfb98db..a775cad5c 100644 --- a/ash-rewrite/src/generated/khr/maintenance8.rs +++ b/ash-rewrite/src/generated/khr/maintenance8.rs @@ -9,6 +9,30 @@ pub struct PhysicalDeviceMaintenance8FeaturesKHR<'a> { pub maintenance8: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceMaintenance8FeaturesKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_MAINTENANCE_8_FEATURES_KHR; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceMaintenance8FeaturesKHR<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceMaintenance8FeaturesKHR<'a> {} +impl<'a> Default for PhysicalDeviceMaintenance8FeaturesKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + maintenance8: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceMaintenance8FeaturesKHR<'a> { + pub fn maintenance8(mut self, maintenance8: bool) -> Self { + self.maintenance8 = maintenance8.into(); + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct MemoryBarrierAccessFlags3KHR<'a> { @@ -18,6 +42,44 @@ pub struct MemoryBarrierAccessFlags3KHR<'a> { pub dst_access_mask3: crate::vk::AccessFlags3KHR, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> for MemoryBarrierAccessFlags3KHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::MEMORY_BARRIER_ACCESS_FLAGS_3_KHR; +} +unsafe impl<'a> crate::Extends> +for MemoryBarrierAccessFlags3KHR<'a> {} +unsafe impl<'a> crate::Extends> +for MemoryBarrierAccessFlags3KHR<'a> {} +unsafe impl<'a> crate::Extends> +for MemoryBarrierAccessFlags3KHR<'a> {} +unsafe impl<'a> crate::Extends> +for MemoryBarrierAccessFlags3KHR<'a> {} +impl<'a> Default for MemoryBarrierAccessFlags3KHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + src_access_mask3: Default::default(), + dst_access_mask3: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> MemoryBarrierAccessFlags3KHR<'a> { + pub fn src_access_mask3( + mut self, + src_access_mask3: crate::vk::AccessFlags3KHR, + ) -> Self { + self.src_access_mask3 = src_access_mask3; + self + } + pub fn dst_access_mask3( + mut self, + dst_access_mask3: crate::vk::AccessFlags3KHR, + ) -> Self { + self.dst_access_mask3 = dst_access_mask3; + self + } +} ///Provided by [`khr::maintenance8`](crate::khr::maintenance8) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_MAINTENANCE_8_FEATURES_KHR: Self = Self(1000574000); @@ -100,7 +162,7 @@ impl core::ops::Not for AccessFlags3KHR { } } #[repr(transparent)] -#[derive(Clone, Copy)] +#[derive(Clone, Copy, Default)] pub struct AccessFlagBits3KHR(pub(crate) u64); ///Provided by [`khr::maintenance8`](crate::khr::maintenance8) impl AccessFlagBits3KHR { diff --git a/ash-rewrite/src/generated/khr/maintenance9.rs b/ash-rewrite/src/generated/khr/maintenance9.rs index 7e7f5f4d2..12a732789 100644 --- a/ash-rewrite/src/generated/khr/maintenance9.rs +++ b/ash-rewrite/src/generated/khr/maintenance9.rs @@ -9,6 +9,30 @@ pub struct PhysicalDeviceMaintenance9FeaturesKHR<'a> { pub maintenance9: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceMaintenance9FeaturesKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_MAINTENANCE_9_FEATURES_KHR; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceMaintenance9FeaturesKHR<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceMaintenance9FeaturesKHR<'a> {} +impl<'a> Default for PhysicalDeviceMaintenance9FeaturesKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + maintenance9: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceMaintenance9FeaturesKHR<'a> { + pub fn maintenance9(mut self, maintenance9: bool) -> Self { + self.maintenance9 = maintenance9.into(); + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceMaintenance9PropertiesKHR<'a> { @@ -18,6 +42,39 @@ pub struct PhysicalDeviceMaintenance9PropertiesKHR<'a> { pub default_vertex_attribute_value: crate::vk::DefaultVertexAttributeValueKHR, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceMaintenance9PropertiesKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_MAINTENANCE_9_PROPERTIES_KHR; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceMaintenance9PropertiesKHR<'a> {} +impl<'a> Default for PhysicalDeviceMaintenance9PropertiesKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + image2_d_view_of3_d_sparse: Default::default(), + default_vertex_attribute_value: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceMaintenance9PropertiesKHR<'a> { + pub fn image2_d_view_of3_d_sparse( + mut self, + image2_d_view_of3_d_sparse: bool, + ) -> Self { + self.image2_d_view_of3_d_sparse = image2_d_view_of3_d_sparse.into(); + self + } + pub fn default_vertex_attribute_value( + mut self, + default_vertex_attribute_value: crate::vk::DefaultVertexAttributeValueKHR, + ) -> Self { + self.default_vertex_attribute_value = default_vertex_attribute_value; + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct QueueFamilyOwnershipTransferPropertiesKHR<'a> { @@ -26,6 +83,31 @@ pub struct QueueFamilyOwnershipTransferPropertiesKHR<'a> { pub optimal_image_transfer_to_queue_families: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for QueueFamilyOwnershipTransferPropertiesKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::QUEUE_FAMILY_OWNERSHIP_TRANSFER_PROPERTIES_KHR; +} +unsafe impl<'a> crate::Extends> +for QueueFamilyOwnershipTransferPropertiesKHR<'a> {} +impl<'a> Default for QueueFamilyOwnershipTransferPropertiesKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + optimal_image_transfer_to_queue_families: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> QueueFamilyOwnershipTransferPropertiesKHR<'a> { + pub fn optimal_image_transfer_to_queue_families( + mut self, + optimal_image_transfer_to_queue_families: u32, + ) -> Self { + self.optimal_image_transfer_to_queue_families = optimal_image_transfer_to_queue_families; + self + } +} ///Provided by [`khr::maintenance9`](crate::khr::maintenance9) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_MAINTENANCE_9_FEATURES_KHR: Self = Self(1000584000); diff --git a/ash-rewrite/src/generated/khr/performance_query.rs b/ash-rewrite/src/generated/khr/performance_query.rs index 2a09c5b90..6f326fcfe 100644 --- a/ash-rewrite/src/generated/khr/performance_query.rs +++ b/ash-rewrite/src/generated/khr/performance_query.rs @@ -116,6 +116,43 @@ pub(crate) mod reexport { pub performance_counter_multiple_query_pools: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDevicePerformanceQueryFeaturesKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR; + } + unsafe impl<'a> crate::Extends> + for PhysicalDevicePerformanceQueryFeaturesKHR<'a> {} + unsafe impl<'a> crate::Extends> + for PhysicalDevicePerformanceQueryFeaturesKHR<'a> {} + impl<'a> Default for PhysicalDevicePerformanceQueryFeaturesKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + performance_counter_query_pools: Default::default(), + performance_counter_multiple_query_pools: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDevicePerformanceQueryFeaturesKHR<'a> { + pub fn performance_counter_query_pools( + mut self, + performance_counter_query_pools: bool, + ) -> Self { + self.performance_counter_query_pools = performance_counter_query_pools + .into(); + self + } + pub fn performance_counter_multiple_query_pools( + mut self, + performance_counter_multiple_query_pools: bool, + ) -> Self { + self.performance_counter_multiple_query_pools = performance_counter_multiple_query_pools + .into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDevicePerformanceQueryPropertiesKHR<'a> { @@ -124,6 +161,32 @@ pub(crate) mod reexport { pub allow_command_buffer_query_copies: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDevicePerformanceQueryPropertiesKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR; + } + unsafe impl<'a> crate::Extends> + for PhysicalDevicePerformanceQueryPropertiesKHR<'a> {} + impl<'a> Default for PhysicalDevicePerformanceQueryPropertiesKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + allow_command_buffer_query_copies: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDevicePerformanceQueryPropertiesKHR<'a> { + pub fn allow_command_buffer_query_copies( + mut self, + allow_command_buffer_query_copies: bool, + ) -> Self { + self.allow_command_buffer_query_copies = allow_command_buffer_query_copies + .into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PerformanceCounterKHR<'a> { @@ -135,6 +198,43 @@ pub(crate) mod reexport { pub uuid: [u8; crate::vk::UUID_SIZE as _], pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for PerformanceCounterKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PERFORMANCE_COUNTER_KHR; + } + impl<'a> Default for PerformanceCounterKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + unit: Default::default(), + scope: Default::default(), + storage: Default::default(), + uuid: unsafe { core::mem::zeroed() }, + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PerformanceCounterKHR<'a> { + pub fn unit(mut self, unit: crate::vk::PerformanceCounterUnitKHR) -> Self { + self.unit = unit; + self + } + pub fn scope(mut self, scope: crate::vk::PerformanceCounterScopeKHR) -> Self { + self.scope = scope; + self + } + pub fn storage( + mut self, + storage: crate::vk::PerformanceCounterStorageKHR, + ) -> Self { + self.storage = storage; + self + } + pub fn uuid(mut self, uuid: [u8; crate::vk::UUID_SIZE as _]) -> Self { + self.uuid = uuid; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PerformanceCounterDescriptionKHR<'a> { @@ -146,6 +246,65 @@ pub(crate) mod reexport { pub description: [core::ffi::c_char; crate::vk::MAX_DESCRIPTION_SIZE as _], pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for PerformanceCounterDescriptionKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PERFORMANCE_COUNTER_DESCRIPTION_KHR; + } + impl<'a> Default for PerformanceCounterDescriptionKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + flags: Default::default(), + name: unsafe { core::mem::zeroed() }, + category: unsafe { core::mem::zeroed() }, + description: unsafe { core::mem::zeroed() }, + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PerformanceCounterDescriptionKHR<'a> { + pub fn flags( + mut self, + flags: crate::vk::PerformanceCounterDescriptionFlagsKHR, + ) -> Self { + self.flags = flags; + self + } + pub fn name( + mut self, + name: &core::ffi::CStr, + ) -> core::result::Result { + crate::write_c_str_slice_with_nul(&mut self.name, name).map(|_| self) + } + pub fn name_as_c_str( + &self, + ) -> core::result::Result<&core::ffi::CStr, core::ffi::FromBytesUntilNulError> { + crate::wrap_c_str_slice_until_nul(&self.name) + } + pub fn category( + mut self, + category: &core::ffi::CStr, + ) -> core::result::Result { + crate::write_c_str_slice_with_nul(&mut self.category, category).map(|_| self) + } + pub fn category_as_c_str( + &self, + ) -> core::result::Result<&core::ffi::CStr, core::ffi::FromBytesUntilNulError> { + crate::wrap_c_str_slice_until_nul(&self.category) + } + pub fn description( + mut self, + description: &core::ffi::CStr, + ) -> core::result::Result { + crate::write_c_str_slice_with_nul(&mut self.description, description) + .map(|_| self) + } + pub fn description_as_c_str( + &self, + ) -> core::result::Result<&core::ffi::CStr, core::ffi::FromBytesUntilNulError> { + crate::wrap_c_str_slice_until_nul(&self.description) + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct QueryPoolPerformanceCreateInfoKHR<'a> { @@ -156,6 +315,39 @@ pub(crate) mod reexport { pub p_counter_indices: *const u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for QueryPoolPerformanceCreateInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR; + } + unsafe impl<'a> crate::Extends> + for QueryPoolPerformanceCreateInfoKHR<'a> {} + impl<'a> Default for QueryPoolPerformanceCreateInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + queue_family_index: Default::default(), + counter_index_count: Default::default(), + p_counter_indices: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> QueryPoolPerformanceCreateInfoKHR<'a> { + pub fn queue_family_index(mut self, queue_family_index: u32) -> Self { + self.queue_family_index = queue_family_index; + self + } + pub fn counter_index_count(mut self, counter_index_count: u32) -> Self { + self.counter_index_count = counter_index_count; + self + } + pub fn p_counter_indices(mut self, p_counter_indices: &'a [u32]) -> Self { + self.counter_index_count = p_counter_indices.len() as _; + self.p_counter_indices = p_counter_indices.as_ptr(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct AcquireProfilingLockInfoKHR<'a> { @@ -165,6 +357,30 @@ pub(crate) mod reexport { pub timeout: u64, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for AcquireProfilingLockInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::ACQUIRE_PROFILING_LOCK_INFO_KHR; + } + impl<'a> Default for AcquireProfilingLockInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + flags: Default::default(), + timeout: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> AcquireProfilingLockInfoKHR<'a> { + pub fn flags(mut self, flags: crate::vk::AcquireProfilingLockFlagsKHR) -> Self { + self.flags = flags; + self + } + pub fn timeout(mut self, timeout: u64) -> Self { + self.timeout = timeout; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PerformanceQuerySubmitInfoKHR<'a> { @@ -173,6 +389,29 @@ pub(crate) mod reexport { pub counter_pass_index: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for PerformanceQuerySubmitInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PERFORMANCE_QUERY_SUBMIT_INFO_KHR; + } + unsafe impl<'a> crate::Extends> + for PerformanceQuerySubmitInfoKHR<'a> {} + unsafe impl<'a> crate::Extends> + for PerformanceQuerySubmitInfoKHR<'a> {} + impl<'a> Default for PerformanceQuerySubmitInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + counter_pass_index: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PerformanceQuerySubmitInfoKHR<'a> { + pub fn counter_pass_index(mut self, counter_pass_index: u32) -> Self { + self.counter_pass_index = counter_pass_index; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub union PerformanceCounterResultKHR { @@ -183,6 +422,11 @@ pub(crate) mod reexport { pub float32: core::ffi::c_float, pub float64: core::ffi::c_double, } + impl Default for PerformanceCounterResultKHR { + fn default() -> Self { + unsafe { core::mem::zeroed() } + } + } ///Provided by [`khr::performance_query`](crate::khr::performance_query) impl crate::vk::QueryType { pub const PERFORMANCE_QUERY_KHR: Self = Self(1000116000); @@ -340,7 +584,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct PerformanceCounterDescriptionFlagBitsKHR(pub(crate) u32); ///Provided by [`khr::performance_query`](crate::khr::performance_query) impl PerformanceCounterDescriptionFlagBitsKHR { @@ -415,7 +659,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct AcquireProfilingLockFlagBitsKHR(pub(crate) u32); pub type PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR = unsafe extern "system" fn( physical_device: crate::vk::PhysicalDevice, diff --git a/ash-rewrite/src/generated/khr/pipeline_binary.rs b/ash-rewrite/src/generated/khr/pipeline_binary.rs index 4ea9f3847..13e23a177 100644 --- a/ash-rewrite/src/generated/khr/pipeline_binary.rs +++ b/ash-rewrite/src/generated/khr/pipeline_binary.rs @@ -113,6 +113,41 @@ pub(crate) mod reexport { pub p_pipeline_create_info: *const crate::vk::PipelineCreateInfoKHR<'a>, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for PipelineBinaryCreateInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PIPELINE_BINARY_CREATE_INFO_KHR; + } + impl<'a> Default for PipelineBinaryCreateInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + p_keys_and_data_info: Default::default(), + pipeline: Default::default(), + p_pipeline_create_info: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PipelineBinaryCreateInfoKHR<'a> { + pub fn p_keys_and_data_info( + mut self, + p_keys_and_data_info: &'a crate::vk::PipelineBinaryKeysAndDataKHR<'a>, + ) -> Self { + self.p_keys_and_data_info = p_keys_and_data_info; + self + } + pub fn pipeline(mut self, pipeline: crate::vk::Pipeline) -> Self { + self.pipeline = pipeline; + self + } + pub fn p_pipeline_create_info( + mut self, + p_pipeline_create_info: &'a crate::vk::PipelineCreateInfoKHR<'a>, + ) -> Self { + self.p_pipeline_create_info = p_pipeline_create_info; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PipelineBinaryHandlesInfoKHR<'a> { @@ -122,21 +157,82 @@ pub(crate) mod reexport { pub p_pipeline_binaries: *mut crate::vk::PipelineBinaryKHR, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for PipelineBinaryHandlesInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PIPELINE_BINARY_HANDLES_INFO_KHR; + } + impl<'a> Default for PipelineBinaryHandlesInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + pipeline_binary_count: Default::default(), + p_pipeline_binaries: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PipelineBinaryHandlesInfoKHR<'a> { + pub fn pipeline_binary_count(mut self, pipeline_binary_count: u32) -> Self { + self.pipeline_binary_count = pipeline_binary_count; + self + } + pub fn p_pipeline_binaries( + mut self, + p_pipeline_binaries: &'a mut [crate::vk::PipelineBinaryKHR], + ) -> Self { + self.pipeline_binary_count = p_pipeline_binaries.len() as _; + self.p_pipeline_binaries = p_pipeline_binaries.as_mut_ptr(); + self + } + } #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct PipelineBinaryDataKHR<'a> { pub data_size: usize, pub p_data: *mut core::ffi::c_void, pub _marker: ::core::marker::PhantomData<&'a ()>, } + impl<'a> PipelineBinaryDataKHR<'a> { + pub fn data_size(mut self, data_size: usize) -> Self { + self.data_size = data_size; + self + } + pub fn p_data(mut self, p_data: &'a mut [u8]) -> Self { + self.data_size = p_data.len() as _; + self.p_data = p_data.as_mut_ptr().cast(); + self + } + } #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct PipelineBinaryKeysAndDataKHR<'a> { pub binary_count: u32, pub p_pipeline_binary_keys: *const crate::vk::PipelineBinaryKeyKHR<'a>, pub p_pipeline_binary_data: *const crate::vk::PipelineBinaryDataKHR<'a>, pub _marker: ::core::marker::PhantomData<&'a ()>, } + impl<'a> PipelineBinaryKeysAndDataKHR<'a> { + pub fn binary_count(mut self, binary_count: u32) -> Self { + self.binary_count = binary_count; + self + } + pub fn p_pipeline_binary_keys( + mut self, + p_pipeline_binary_keys: &'a [crate::vk::PipelineBinaryKeyKHR<'a>], + ) -> Self { + self.binary_count = p_pipeline_binary_keys.len() as _; + self.p_pipeline_binary_keys = p_pipeline_binary_keys.as_ptr(); + self + } + pub fn p_pipeline_binary_data( + mut self, + p_pipeline_binary_data: &'a [crate::vk::PipelineBinaryDataKHR<'a>], + ) -> Self { + self.binary_count = p_pipeline_binary_data.len() as _; + self.p_pipeline_binary_data = p_pipeline_binary_data.as_ptr(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PipelineBinaryKeyKHR<'a> { @@ -146,6 +242,33 @@ pub(crate) mod reexport { pub key: [u8; crate::vk::MAX_PIPELINE_BINARY_KEY_SIZE_KHR as _], pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for PipelineBinaryKeyKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PIPELINE_BINARY_KEY_KHR; + } + impl<'a> Default for PipelineBinaryKeyKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + key_size: Default::default(), + key: unsafe { core::mem::zeroed() }, + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PipelineBinaryKeyKHR<'a> { + pub fn key_size(mut self, key_size: u32) -> Self { + self.key_size = key_size; + self + } + pub fn key( + mut self, + key: [u8; crate::vk::MAX_PIPELINE_BINARY_KEY_SIZE_KHR as _], + ) -> Self { + self.key = key; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PipelineBinaryInfoKHR<'a> { @@ -155,6 +278,40 @@ pub(crate) mod reexport { pub p_pipeline_binaries: *const crate::vk::PipelineBinaryKHR, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for PipelineBinaryInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PIPELINE_BINARY_INFO_KHR; + } + unsafe impl<'a> crate::Extends> + for PipelineBinaryInfoKHR<'a> {} + unsafe impl<'a> crate::Extends> + for PipelineBinaryInfoKHR<'a> {} + unsafe impl<'a> crate::Extends> + for PipelineBinaryInfoKHR<'a> {} + impl<'a> Default for PipelineBinaryInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + binary_count: Default::default(), + p_pipeline_binaries: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PipelineBinaryInfoKHR<'a> { + pub fn binary_count(mut self, binary_count: u32) -> Self { + self.binary_count = binary_count; + self + } + pub fn p_pipeline_binaries( + mut self, + p_pipeline_binaries: &'a [crate::vk::PipelineBinaryKHR], + ) -> Self { + self.binary_count = p_pipeline_binaries.len() as _; + self.p_pipeline_binaries = p_pipeline_binaries.as_ptr(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct ReleaseCapturedPipelineDataInfoKHR<'a> { @@ -163,6 +320,26 @@ pub(crate) mod reexport { pub pipeline: crate::vk::Pipeline, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for ReleaseCapturedPipelineDataInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::RELEASE_CAPTURED_PIPELINE_DATA_INFO_KHR; + } + impl<'a> Default for ReleaseCapturedPipelineDataInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + pipeline: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> ReleaseCapturedPipelineDataInfoKHR<'a> { + pub fn pipeline(mut self, pipeline: crate::vk::Pipeline) -> Self { + self.pipeline = pipeline; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PipelineBinaryDataInfoKHR<'a> { @@ -171,6 +348,28 @@ pub(crate) mod reexport { pub pipeline_binary: crate::vk::PipelineBinaryKHR, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for PipelineBinaryDataInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PIPELINE_BINARY_DATA_INFO_KHR; + } + impl<'a> Default for PipelineBinaryDataInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + pipeline_binary: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PipelineBinaryDataInfoKHR<'a> { + pub fn pipeline_binary( + mut self, + pipeline_binary: crate::vk::PipelineBinaryKHR, + ) -> Self { + self.pipeline_binary = pipeline_binary; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PipelineCreateInfoKHR<'a> { @@ -178,6 +377,19 @@ pub(crate) mod reexport { pub p_next: *mut core::ffi::c_void, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for PipelineCreateInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PIPELINE_CREATE_INFO_KHR; + } + impl<'a> Default for PipelineCreateInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PipelineCreateInfoKHR<'a> {} #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDevicePipelineBinaryFeaturesKHR<'a> { @@ -186,6 +398,30 @@ pub(crate) mod reexport { pub pipeline_binaries: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDevicePipelineBinaryFeaturesKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR; + } + unsafe impl<'a> crate::Extends> + for PhysicalDevicePipelineBinaryFeaturesKHR<'a> {} + unsafe impl<'a> crate::Extends> + for PhysicalDevicePipelineBinaryFeaturesKHR<'a> {} + impl<'a> Default for PhysicalDevicePipelineBinaryFeaturesKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + pipeline_binaries: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDevicePipelineBinaryFeaturesKHR<'a> { + pub fn pipeline_binaries(mut self, pipeline_binaries: bool) -> Self { + self.pipeline_binaries = pipeline_binaries.into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct DevicePipelineBinaryInternalCacheControlKHR<'a> { @@ -194,6 +430,28 @@ pub(crate) mod reexport { pub disable_internal_cache: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for DevicePipelineBinaryInternalCacheControlKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::DEVICE_PIPELINE_BINARY_INTERNAL_CACHE_CONTROL_KHR; + } + unsafe impl<'a> crate::Extends> + for DevicePipelineBinaryInternalCacheControlKHR<'a> {} + impl<'a> Default for DevicePipelineBinaryInternalCacheControlKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + disable_internal_cache: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> DevicePipelineBinaryInternalCacheControlKHR<'a> { + pub fn disable_internal_cache(mut self, disable_internal_cache: bool) -> Self { + self.disable_internal_cache = disable_internal_cache.into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDevicePipelineBinaryPropertiesKHR<'a> { @@ -206,6 +464,67 @@ pub(crate) mod reexport { pub pipeline_binary_compressed_data: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDevicePipelineBinaryPropertiesKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_PIPELINE_BINARY_PROPERTIES_KHR; + } + unsafe impl<'a> crate::Extends> + for PhysicalDevicePipelineBinaryPropertiesKHR<'a> {} + impl<'a> Default for PhysicalDevicePipelineBinaryPropertiesKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + pipeline_binary_internal_cache: Default::default(), + pipeline_binary_internal_cache_control: Default::default(), + pipeline_binary_prefers_internal_cache: Default::default(), + pipeline_binary_precompiled_internal_cache: Default::default(), + pipeline_binary_compressed_data: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDevicePipelineBinaryPropertiesKHR<'a> { + pub fn pipeline_binary_internal_cache( + mut self, + pipeline_binary_internal_cache: bool, + ) -> Self { + self.pipeline_binary_internal_cache = pipeline_binary_internal_cache.into(); + self + } + pub fn pipeline_binary_internal_cache_control( + mut self, + pipeline_binary_internal_cache_control: bool, + ) -> Self { + self.pipeline_binary_internal_cache_control = pipeline_binary_internal_cache_control + .into(); + self + } + pub fn pipeline_binary_prefers_internal_cache( + mut self, + pipeline_binary_prefers_internal_cache: bool, + ) -> Self { + self.pipeline_binary_prefers_internal_cache = pipeline_binary_prefers_internal_cache + .into(); + self + } + pub fn pipeline_binary_precompiled_internal_cache( + mut self, + pipeline_binary_precompiled_internal_cache: bool, + ) -> Self { + self.pipeline_binary_precompiled_internal_cache = pipeline_binary_precompiled_internal_cache + .into(); + self + } + pub fn pipeline_binary_compressed_data( + mut self, + pipeline_binary_compressed_data: bool, + ) -> Self { + self.pipeline_binary_compressed_data = pipeline_binary_compressed_data + .into(); + self + } + } ///Provided by [`khr::pipeline_binary`](crate::khr::pipeline_binary) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR: Self = Self(1000483000); diff --git a/ash-rewrite/src/generated/khr/pipeline_executable_properties.rs b/ash-rewrite/src/generated/khr/pipeline_executable_properties.rs index a6dc8c918..ff671f8fa 100644 --- a/ash-rewrite/src/generated/khr/pipeline_executable_properties.rs +++ b/ash-rewrite/src/generated/khr/pipeline_executable_properties.rs @@ -81,6 +81,33 @@ pub(crate) mod reexport { pub pipeline_executable_info: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDevicePipelineExecutablePropertiesFeaturesKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR; + } + unsafe impl<'a> crate::Extends> + for PhysicalDevicePipelineExecutablePropertiesFeaturesKHR<'a> {} + unsafe impl<'a> crate::Extends> + for PhysicalDevicePipelineExecutablePropertiesFeaturesKHR<'a> {} + impl<'a> Default for PhysicalDevicePipelineExecutablePropertiesFeaturesKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + pipeline_executable_info: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDevicePipelineExecutablePropertiesFeaturesKHR<'a> { + pub fn pipeline_executable_info( + mut self, + pipeline_executable_info: bool, + ) -> Self { + self.pipeline_executable_info = pipeline_executable_info.into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PipelineInfoKHR<'a> { @@ -89,6 +116,25 @@ pub(crate) mod reexport { pub pipeline: crate::vk::Pipeline, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for PipelineInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PIPELINE_INFO_KHR; + } + impl<'a> Default for PipelineInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + pipeline: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PipelineInfoKHR<'a> { + pub fn pipeline(mut self, pipeline: crate::vk::Pipeline) -> Self { + self.pipeline = pipeline; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PipelineExecutablePropertiesKHR<'a> { @@ -100,6 +146,55 @@ pub(crate) mod reexport { pub subgroup_size: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for PipelineExecutablePropertiesKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PIPELINE_EXECUTABLE_PROPERTIES_KHR; + } + impl<'a> Default for PipelineExecutablePropertiesKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + stages: Default::default(), + name: unsafe { core::mem::zeroed() }, + description: unsafe { core::mem::zeroed() }, + subgroup_size: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PipelineExecutablePropertiesKHR<'a> { + pub fn stages(mut self, stages: crate::vk::ShaderStageFlags) -> Self { + self.stages = stages; + self + } + pub fn name( + mut self, + name: &core::ffi::CStr, + ) -> core::result::Result { + crate::write_c_str_slice_with_nul(&mut self.name, name).map(|_| self) + } + pub fn name_as_c_str( + &self, + ) -> core::result::Result<&core::ffi::CStr, core::ffi::FromBytesUntilNulError> { + crate::wrap_c_str_slice_until_nul(&self.name) + } + pub fn description( + mut self, + description: &core::ffi::CStr, + ) -> core::result::Result { + crate::write_c_str_slice_with_nul(&mut self.description, description) + .map(|_| self) + } + pub fn description_as_c_str( + &self, + ) -> core::result::Result<&core::ffi::CStr, core::ffi::FromBytesUntilNulError> { + crate::wrap_c_str_slice_until_nul(&self.description) + } + pub fn subgroup_size(mut self, subgroup_size: u32) -> Self { + self.subgroup_size = subgroup_size; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PipelineExecutableInfoKHR<'a> { @@ -109,6 +204,30 @@ pub(crate) mod reexport { pub executable_index: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for PipelineExecutableInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PIPELINE_EXECUTABLE_INFO_KHR; + } + impl<'a> Default for PipelineExecutableInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + pipeline: Default::default(), + executable_index: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PipelineExecutableInfoKHR<'a> { + pub fn pipeline(mut self, pipeline: crate::vk::Pipeline) -> Self { + self.pipeline = pipeline; + self + } + pub fn executable_index(mut self, executable_index: u32) -> Self { + self.executable_index = executable_index; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PipelineExecutableStatisticKHR<'a> { @@ -120,6 +239,61 @@ pub(crate) mod reexport { pub value: crate::vk::PipelineExecutableStatisticValueKHR, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for PipelineExecutableStatisticKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PIPELINE_EXECUTABLE_STATISTIC_KHR; + } + impl<'a> Default for PipelineExecutableStatisticKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + name: unsafe { core::mem::zeroed() }, + description: unsafe { core::mem::zeroed() }, + format: Default::default(), + value: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PipelineExecutableStatisticKHR<'a> { + pub fn name( + mut self, + name: &core::ffi::CStr, + ) -> core::result::Result { + crate::write_c_str_slice_with_nul(&mut self.name, name).map(|_| self) + } + pub fn name_as_c_str( + &self, + ) -> core::result::Result<&core::ffi::CStr, core::ffi::FromBytesUntilNulError> { + crate::wrap_c_str_slice_until_nul(&self.name) + } + pub fn description( + mut self, + description: &core::ffi::CStr, + ) -> core::result::Result { + crate::write_c_str_slice_with_nul(&mut self.description, description) + .map(|_| self) + } + pub fn description_as_c_str( + &self, + ) -> core::result::Result<&core::ffi::CStr, core::ffi::FromBytesUntilNulError> { + crate::wrap_c_str_slice_until_nul(&self.description) + } + pub fn format( + mut self, + format: crate::vk::PipelineExecutableStatisticFormatKHR, + ) -> Self { + self.format = format; + self + } + pub fn value( + mut self, + value: crate::vk::PipelineExecutableStatisticValueKHR, + ) -> Self { + self.value = value; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PipelineExecutableInternalRepresentationKHR<'a> { @@ -132,6 +306,62 @@ pub(crate) mod reexport { pub p_data: *mut core::ffi::c_void, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PipelineExecutableInternalRepresentationKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR; + } + impl<'a> Default for PipelineExecutableInternalRepresentationKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + name: unsafe { core::mem::zeroed() }, + description: unsafe { core::mem::zeroed() }, + is_text: Default::default(), + data_size: Default::default(), + p_data: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PipelineExecutableInternalRepresentationKHR<'a> { + pub fn name( + mut self, + name: &core::ffi::CStr, + ) -> core::result::Result { + crate::write_c_str_slice_with_nul(&mut self.name, name).map(|_| self) + } + pub fn name_as_c_str( + &self, + ) -> core::result::Result<&core::ffi::CStr, core::ffi::FromBytesUntilNulError> { + crate::wrap_c_str_slice_until_nul(&self.name) + } + pub fn description( + mut self, + description: &core::ffi::CStr, + ) -> core::result::Result { + crate::write_c_str_slice_with_nul(&mut self.description, description) + .map(|_| self) + } + pub fn description_as_c_str( + &self, + ) -> core::result::Result<&core::ffi::CStr, core::ffi::FromBytesUntilNulError> { + crate::wrap_c_str_slice_until_nul(&self.description) + } + pub fn is_text(mut self, is_text: bool) -> Self { + self.is_text = is_text.into(); + self + } + pub fn data_size(mut self, data_size: usize) -> Self { + self.data_size = data_size; + self + } + pub fn p_data(mut self, p_data: &'a mut [u8]) -> Self { + self.data_size = p_data.len() as _; + self.p_data = p_data.as_mut_ptr().cast(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub union PipelineExecutableStatisticValueKHR { @@ -140,6 +370,11 @@ pub(crate) mod reexport { pub u64: u64, pub f64: core::ffi::c_double, } + impl Default for PipelineExecutableStatisticValueKHR { + fn default() -> Self { + unsafe { core::mem::zeroed() } + } + } ///Provided by [`khr::pipeline_executable_properties`](crate::khr::pipeline_executable_properties) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR: Self = Self( diff --git a/ash-rewrite/src/generated/khr/pipeline_library.rs b/ash-rewrite/src/generated/khr/pipeline_library.rs index 47210132f..124d85ac7 100644 --- a/ash-rewrite/src/generated/khr/pipeline_library.rs +++ b/ash-rewrite/src/generated/khr/pipeline_library.rs @@ -10,6 +10,33 @@ pub struct PipelineLibraryCreateInfoKHR<'a> { pub p_libraries: *const crate::vk::Pipeline, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> for PipelineLibraryCreateInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PIPELINE_LIBRARY_CREATE_INFO_KHR; +} +unsafe impl<'a> crate::Extends> +for PipelineLibraryCreateInfoKHR<'a> {} +impl<'a> Default for PipelineLibraryCreateInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + library_count: Default::default(), + p_libraries: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PipelineLibraryCreateInfoKHR<'a> { + pub fn library_count(mut self, library_count: u32) -> Self { + self.library_count = library_count; + self + } + pub fn p_libraries(mut self, p_libraries: &'a [crate::vk::Pipeline]) -> Self { + self.library_count = p_libraries.len() as _; + self.p_libraries = p_libraries.as_ptr(); + self + } +} ///Provided by [`khr::pipeline_library`](crate::khr::pipeline_library) impl crate::vk::StructureType { pub const PIPELINE_LIBRARY_CREATE_INFO_KHR: Self = Self(1000290000); diff --git a/ash-rewrite/src/generated/khr/portability_subset.rs b/ash-rewrite/src/generated/khr/portability_subset.rs index f38a748cf..e9400abf8 100644 --- a/ash-rewrite/src/generated/khr/portability_subset.rs +++ b/ash-rewrite/src/generated/khr/portability_subset.rs @@ -23,6 +23,119 @@ pub struct PhysicalDevicePortabilitySubsetFeaturesKHR<'a> { pub vertex_attribute_access_beyond_stride: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDevicePortabilitySubsetFeaturesKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR; +} +unsafe impl<'a> crate::Extends> +for PhysicalDevicePortabilitySubsetFeaturesKHR<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDevicePortabilitySubsetFeaturesKHR<'a> {} +impl<'a> Default for PhysicalDevicePortabilitySubsetFeaturesKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + constant_alpha_color_blend_factors: Default::default(), + events: Default::default(), + image_view_format_reinterpretation: Default::default(), + image_view_format_swizzle: Default::default(), + image_view2_d_on3_d_image: Default::default(), + multisample_array_image: Default::default(), + mutable_comparison_samplers: Default::default(), + point_polygons: Default::default(), + sampler_mip_lod_bias: Default::default(), + separate_stencil_mask_ref: Default::default(), + shader_sample_rate_interpolation_functions: Default::default(), + tessellation_isolines: Default::default(), + tessellation_point_mode: Default::default(), + triangle_fans: Default::default(), + vertex_attribute_access_beyond_stride: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDevicePortabilitySubsetFeaturesKHR<'a> { + pub fn constant_alpha_color_blend_factors( + mut self, + constant_alpha_color_blend_factors: bool, + ) -> Self { + self.constant_alpha_color_blend_factors = constant_alpha_color_blend_factors + .into(); + self + } + pub fn events(mut self, events: bool) -> Self { + self.events = events.into(); + self + } + pub fn image_view_format_reinterpretation( + mut self, + image_view_format_reinterpretation: bool, + ) -> Self { + self.image_view_format_reinterpretation = image_view_format_reinterpretation + .into(); + self + } + pub fn image_view_format_swizzle(mut self, image_view_format_swizzle: bool) -> Self { + self.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) -> Self { + self.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) -> Self { + self.multisample_array_image = multisample_array_image.into(); + self + } + pub fn mutable_comparison_samplers( + mut self, + mutable_comparison_samplers: bool, + ) -> Self { + self.mutable_comparison_samplers = mutable_comparison_samplers.into(); + self + } + pub fn point_polygons(mut self, point_polygons: bool) -> Self { + self.point_polygons = point_polygons.into(); + self + } + pub fn sampler_mip_lod_bias(mut self, sampler_mip_lod_bias: bool) -> Self { + self.sampler_mip_lod_bias = sampler_mip_lod_bias.into(); + self + } + pub fn separate_stencil_mask_ref(mut self, separate_stencil_mask_ref: bool) -> Self { + self.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, + ) -> Self { + self.shader_sample_rate_interpolation_functions = shader_sample_rate_interpolation_functions + .into(); + self + } + pub fn tessellation_isolines(mut self, tessellation_isolines: bool) -> Self { + self.tessellation_isolines = tessellation_isolines.into(); + self + } + pub fn tessellation_point_mode(mut self, tessellation_point_mode: bool) -> Self { + self.tessellation_point_mode = tessellation_point_mode.into(); + self + } + pub fn triangle_fans(mut self, triangle_fans: bool) -> Self { + self.triangle_fans = triangle_fans.into(); + self + } + pub fn vertex_attribute_access_beyond_stride( + mut self, + vertex_attribute_access_beyond_stride: bool, + ) -> Self { + self.vertex_attribute_access_beyond_stride = vertex_attribute_access_beyond_stride + .into(); + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDevicePortabilitySubsetPropertiesKHR<'a> { @@ -31,6 +144,31 @@ pub struct PhysicalDevicePortabilitySubsetPropertiesKHR<'a> { pub min_vertex_input_binding_stride_alignment: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDevicePortabilitySubsetPropertiesKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR; +} +unsafe impl<'a> crate::Extends> +for PhysicalDevicePortabilitySubsetPropertiesKHR<'a> {} +impl<'a> Default for PhysicalDevicePortabilitySubsetPropertiesKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + min_vertex_input_binding_stride_alignment: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDevicePortabilitySubsetPropertiesKHR<'a> { + pub fn min_vertex_input_binding_stride_alignment( + mut self, + min_vertex_input_binding_stride_alignment: u32, + ) -> Self { + self.min_vertex_input_binding_stride_alignment = min_vertex_input_binding_stride_alignment; + self + } +} ///Provided by [`khr::portability_subset`](crate::khr::portability_subset) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR: Self = Self(1000163000); diff --git a/ash-rewrite/src/generated/khr/present_id.rs b/ash-rewrite/src/generated/khr/present_id.rs index 685b34b2a..160097063 100644 --- a/ash-rewrite/src/generated/khr/present_id.rs +++ b/ash-rewrite/src/generated/khr/present_id.rs @@ -9,6 +9,29 @@ pub struct PhysicalDevicePresentIdFeaturesKHR<'a> { pub present_id: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> for PhysicalDevicePresentIdFeaturesKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR; +} +unsafe impl<'a> crate::Extends> +for PhysicalDevicePresentIdFeaturesKHR<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDevicePresentIdFeaturesKHR<'a> {} +impl<'a> Default for PhysicalDevicePresentIdFeaturesKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + present_id: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDevicePresentIdFeaturesKHR<'a> { + pub fn present_id(mut self, present_id: bool) -> Self { + self.present_id = present_id.into(); + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct PresentIdKHR<'a> { @@ -18,6 +41,32 @@ pub struct PresentIdKHR<'a> { pub p_present_ids: *const u64, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> for PresentIdKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PRESENT_ID_KHR; +} +unsafe impl<'a> crate::Extends> for PresentIdKHR<'a> {} +impl<'a> Default for PresentIdKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + swapchain_count: Default::default(), + p_present_ids: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PresentIdKHR<'a> { + pub fn swapchain_count(mut self, swapchain_count: u32) -> Self { + self.swapchain_count = swapchain_count; + self + } + pub fn p_present_ids(mut self, p_present_ids: &'a [u64]) -> Self { + self.swapchain_count = p_present_ids.len() as _; + self.p_present_ids = p_present_ids.as_ptr(); + self + } +} ///Provided by [`khr::present_id`](crate::khr::present_id) impl crate::vk::StructureType { pub const PRESENT_ID_KHR: Self = Self(1000294000); diff --git a/ash-rewrite/src/generated/khr/present_id2.rs b/ash-rewrite/src/generated/khr/present_id2.rs index 7086c74b8..a952c2e0d 100644 --- a/ash-rewrite/src/generated/khr/present_id2.rs +++ b/ash-rewrite/src/generated/khr/present_id2.rs @@ -9,6 +9,29 @@ pub struct PhysicalDevicePresentId2FeaturesKHR<'a> { pub present_id2: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> for PhysicalDevicePresentId2FeaturesKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_PRESENT_ID_2_FEATURES_KHR; +} +unsafe impl<'a> crate::Extends> +for PhysicalDevicePresentId2FeaturesKHR<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDevicePresentId2FeaturesKHR<'a> {} +impl<'a> Default for PhysicalDevicePresentId2FeaturesKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + present_id2: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDevicePresentId2FeaturesKHR<'a> { + pub fn present_id2(mut self, present_id2: bool) -> Self { + self.present_id2 = present_id2.into(); + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct PresentId2KHR<'a> { @@ -18,6 +41,32 @@ pub struct PresentId2KHR<'a> { pub p_present_ids: *const u64, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> for PresentId2KHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PRESENT_ID_2_KHR; +} +unsafe impl<'a> crate::Extends> for PresentId2KHR<'a> {} +impl<'a> Default for PresentId2KHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + swapchain_count: Default::default(), + p_present_ids: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PresentId2KHR<'a> { + pub fn swapchain_count(mut self, swapchain_count: u32) -> Self { + self.swapchain_count = swapchain_count; + self + } + pub fn p_present_ids(mut self, p_present_ids: &'a [u64]) -> Self { + self.swapchain_count = p_present_ids.len() as _; + self.p_present_ids = p_present_ids.as_ptr(); + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct SurfaceCapabilitiesPresentId2KHR<'a> { @@ -26,6 +75,27 @@ pub struct SurfaceCapabilitiesPresentId2KHR<'a> { pub present_id2_supported: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> for SurfaceCapabilitiesPresentId2KHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::SURFACE_CAPABILITIES_PRESENT_ID_2_KHR; +} +unsafe impl<'a> crate::Extends> +for SurfaceCapabilitiesPresentId2KHR<'a> {} +impl<'a> Default for SurfaceCapabilitiesPresentId2KHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + present_id2_supported: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> SurfaceCapabilitiesPresentId2KHR<'a> { + pub fn present_id2_supported(mut self, present_id2_supported: bool) -> Self { + self.present_id2_supported = present_id2_supported.into(); + self + } +} ///Provided by [`khr::present_id2`](crate::khr::present_id2) impl crate::vk::StructureType { pub const SURFACE_CAPABILITIES_PRESENT_ID_2_KHR: Self = Self(1000479000); diff --git a/ash-rewrite/src/generated/khr/present_mode_fifo_latest_ready.rs b/ash-rewrite/src/generated/khr/present_mode_fifo_latest_ready.rs index fb4f0cf9d..6e026b1c4 100644 --- a/ash-rewrite/src/generated/khr/present_mode_fifo_latest_ready.rs +++ b/ash-rewrite/src/generated/khr/present_mode_fifo_latest_ready.rs @@ -9,6 +9,33 @@ pub struct PhysicalDevicePresentModeFifoLatestReadyFeaturesKHR<'a> { pub present_mode_fifo_latest_ready: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDevicePresentModeFifoLatestReadyFeaturesKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_KHR; +} +unsafe impl<'a> crate::Extends> +for PhysicalDevicePresentModeFifoLatestReadyFeaturesKHR<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDevicePresentModeFifoLatestReadyFeaturesKHR<'a> {} +impl<'a> Default for PhysicalDevicePresentModeFifoLatestReadyFeaturesKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + present_mode_fifo_latest_ready: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDevicePresentModeFifoLatestReadyFeaturesKHR<'a> { + pub fn present_mode_fifo_latest_ready( + mut self, + present_mode_fifo_latest_ready: bool, + ) -> Self { + self.present_mode_fifo_latest_ready = present_mode_fifo_latest_ready.into(); + self + } +} ///Provided by [`khr::present_mode_fifo_latest_ready`](crate::khr::present_mode_fifo_latest_ready) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_KHR: Self = Self( diff --git a/ash-rewrite/src/generated/khr/present_wait.rs b/ash-rewrite/src/generated/khr/present_wait.rs index 8847d3868..71aa0bdd8 100644 --- a/ash-rewrite/src/generated/khr/present_wait.rs +++ b/ash-rewrite/src/generated/khr/present_wait.rs @@ -45,6 +45,30 @@ pub(crate) mod reexport { pub present_wait: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDevicePresentWaitFeaturesKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR; + } + unsafe impl<'a> crate::Extends> + for PhysicalDevicePresentWaitFeaturesKHR<'a> {} + unsafe impl<'a> crate::Extends> + for PhysicalDevicePresentWaitFeaturesKHR<'a> {} + impl<'a> Default for PhysicalDevicePresentWaitFeaturesKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + present_wait: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDevicePresentWaitFeaturesKHR<'a> { + pub fn present_wait(mut self, present_wait: bool) -> Self { + self.present_wait = present_wait.into(); + self + } + } ///Provided by [`khr::present_wait`](crate::khr::present_wait) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR: Self = Self(1000248000); diff --git a/ash-rewrite/src/generated/khr/present_wait2.rs b/ash-rewrite/src/generated/khr/present_wait2.rs index d4c229792..ec55169b8 100644 --- a/ash-rewrite/src/generated/khr/present_wait2.rs +++ b/ash-rewrite/src/generated/khr/present_wait2.rs @@ -45,6 +45,30 @@ pub(crate) mod reexport { pub timeout: u64, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for PresentWait2InfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PRESENT_WAIT_2_INFO_KHR; + } + impl<'a> Default for PresentWait2InfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + present_id: Default::default(), + timeout: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PresentWait2InfoKHR<'a> { + pub fn present_id(mut self, present_id: u64) -> Self { + self.present_id = present_id; + self + } + pub fn timeout(mut self, timeout: u64) -> Self { + self.timeout = timeout; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDevicePresentWait2FeaturesKHR<'a> { @@ -53,6 +77,30 @@ pub(crate) mod reexport { pub present_wait2: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDevicePresentWait2FeaturesKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_PRESENT_WAIT_2_FEATURES_KHR; + } + unsafe impl<'a> crate::Extends> + for PhysicalDevicePresentWait2FeaturesKHR<'a> {} + unsafe impl<'a> crate::Extends> + for PhysicalDevicePresentWait2FeaturesKHR<'a> {} + impl<'a> Default for PhysicalDevicePresentWait2FeaturesKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + present_wait2: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDevicePresentWait2FeaturesKHR<'a> { + pub fn present_wait2(mut self, present_wait2: bool) -> Self { + self.present_wait2 = present_wait2.into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct SurfaceCapabilitiesPresentWait2KHR<'a> { @@ -61,6 +109,28 @@ pub(crate) mod reexport { pub present_wait2_supported: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for SurfaceCapabilitiesPresentWait2KHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::SURFACE_CAPABILITIES_PRESENT_WAIT_2_KHR; + } + unsafe impl<'a> crate::Extends> + for SurfaceCapabilitiesPresentWait2KHR<'a> {} + impl<'a> Default for SurfaceCapabilitiesPresentWait2KHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + present_wait2_supported: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> SurfaceCapabilitiesPresentWait2KHR<'a> { + pub fn present_wait2_supported(mut self, present_wait2_supported: bool) -> Self { + self.present_wait2_supported = present_wait2_supported.into(); + self + } + } ///Provided by [`khr::present_wait2`](crate::khr::present_wait2) impl crate::vk::StructureType { pub const SURFACE_CAPABILITIES_PRESENT_WAIT_2_KHR: Self = Self(1000480000); diff --git a/ash-rewrite/src/generated/khr/ray_query.rs b/ash-rewrite/src/generated/khr/ray_query.rs index 21aa88d81..a510d1009 100644 --- a/ash-rewrite/src/generated/khr/ray_query.rs +++ b/ash-rewrite/src/generated/khr/ray_query.rs @@ -9,6 +9,29 @@ pub struct PhysicalDeviceRayQueryFeaturesKHR<'a> { pub ray_query: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> for PhysicalDeviceRayQueryFeaturesKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceRayQueryFeaturesKHR<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceRayQueryFeaturesKHR<'a> {} +impl<'a> Default for PhysicalDeviceRayQueryFeaturesKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + ray_query: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceRayQueryFeaturesKHR<'a> { + pub fn ray_query(mut self, ray_query: bool) -> Self { + self.ray_query = ray_query.into(); + self + } +} ///Provided by [`khr::ray_query`](crate::khr::ray_query) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR: Self = Self(1000348013); diff --git a/ash-rewrite/src/generated/khr/ray_tracing_maintenance1.rs b/ash-rewrite/src/generated/khr/ray_tracing_maintenance1.rs index dfe5e5371..a2420dc45 100644 --- a/ash-rewrite/src/generated/khr/ray_tracing_maintenance1.rs +++ b/ash-rewrite/src/generated/khr/ray_tracing_maintenance1.rs @@ -36,7 +36,7 @@ impl DeviceFn { } pub(crate) mod reexport { #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct TraceRaysIndirectCommand2KHR { pub raygen_shader_record_address: crate::vk::DeviceAddress, pub raygen_shader_record_size: crate::vk::DeviceSize, @@ -53,6 +53,97 @@ pub(crate) mod reexport { pub height: u32, pub depth: u32, } + impl TraceRaysIndirectCommand2KHR { + pub fn raygen_shader_record_address( + mut self, + raygen_shader_record_address: crate::vk::DeviceAddress, + ) -> Self { + self.raygen_shader_record_address = raygen_shader_record_address; + self + } + pub fn raygen_shader_record_size( + mut self, + raygen_shader_record_size: crate::vk::DeviceSize, + ) -> Self { + self.raygen_shader_record_size = raygen_shader_record_size; + self + } + pub fn miss_shader_binding_table_address( + mut self, + miss_shader_binding_table_address: crate::vk::DeviceAddress, + ) -> Self { + self.miss_shader_binding_table_address = miss_shader_binding_table_address; + self + } + pub fn miss_shader_binding_table_size( + mut self, + miss_shader_binding_table_size: crate::vk::DeviceSize, + ) -> Self { + self.miss_shader_binding_table_size = miss_shader_binding_table_size; + self + } + pub fn miss_shader_binding_table_stride( + mut self, + miss_shader_binding_table_stride: crate::vk::DeviceSize, + ) -> Self { + self.miss_shader_binding_table_stride = miss_shader_binding_table_stride; + self + } + pub fn hit_shader_binding_table_address( + mut self, + hit_shader_binding_table_address: crate::vk::DeviceAddress, + ) -> Self { + self.hit_shader_binding_table_address = hit_shader_binding_table_address; + self + } + pub fn hit_shader_binding_table_size( + mut self, + hit_shader_binding_table_size: crate::vk::DeviceSize, + ) -> Self { + self.hit_shader_binding_table_size = hit_shader_binding_table_size; + self + } + pub fn hit_shader_binding_table_stride( + mut self, + hit_shader_binding_table_stride: crate::vk::DeviceSize, + ) -> Self { + self.hit_shader_binding_table_stride = hit_shader_binding_table_stride; + self + } + pub fn callable_shader_binding_table_address( + mut self, + callable_shader_binding_table_address: crate::vk::DeviceAddress, + ) -> Self { + self.callable_shader_binding_table_address = callable_shader_binding_table_address; + self + } + pub fn callable_shader_binding_table_size( + mut self, + callable_shader_binding_table_size: crate::vk::DeviceSize, + ) -> Self { + self.callable_shader_binding_table_size = callable_shader_binding_table_size; + self + } + pub fn callable_shader_binding_table_stride( + mut self, + callable_shader_binding_table_stride: crate::vk::DeviceSize, + ) -> Self { + self.callable_shader_binding_table_stride = callable_shader_binding_table_stride; + self + } + pub fn width(mut self, width: u32) -> Self { + self.width = width; + self + } + pub fn height(mut self, height: u32) -> Self { + self.height = height; + self + } + pub fn depth(mut self, depth: u32) -> Self { + self.depth = depth; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceRayTracingMaintenance1FeaturesKHR<'a> { @@ -62,6 +153,42 @@ pub(crate) mod reexport { pub ray_tracing_pipeline_trace_rays_indirect2: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceRayTracingMaintenance1FeaturesKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceRayTracingMaintenance1FeaturesKHR<'a> {} + unsafe impl<'a> crate::Extends> + for PhysicalDeviceRayTracingMaintenance1FeaturesKHR<'a> {} + impl<'a> Default for PhysicalDeviceRayTracingMaintenance1FeaturesKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + ray_tracing_maintenance1: Default::default(), + ray_tracing_pipeline_trace_rays_indirect2: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceRayTracingMaintenance1FeaturesKHR<'a> { + pub fn ray_tracing_maintenance1( + mut self, + ray_tracing_maintenance1: bool, + ) -> Self { + self.ray_tracing_maintenance1 = ray_tracing_maintenance1.into(); + self + } + pub fn ray_tracing_pipeline_trace_rays_indirect2( + mut self, + ray_tracing_pipeline_trace_rays_indirect2: bool, + ) -> Self { + self.ray_tracing_pipeline_trace_rays_indirect2 = ray_tracing_pipeline_trace_rays_indirect2 + .into(); + self + } + } ///Provided by [`khr::ray_tracing_maintenance1`](crate::khr::ray_tracing_maintenance1) impl crate::vk::QueryType { pub const ACCELERATION_STRUCTURE_SERIALIZATION_BOTTOM_LEVEL_POINTERS_KHR: Self = Self( diff --git a/ash-rewrite/src/generated/khr/ray_tracing_pipeline.rs b/ash-rewrite/src/generated/khr/ray_tracing_pipeline.rs index f4cd2824a..3a054aa7e 100644 --- a/ash-rewrite/src/generated/khr/ray_tracing_pipeline.rs +++ b/ash-rewrite/src/generated/khr/ray_tracing_pipeline.rs @@ -165,6 +165,54 @@ pub(crate) mod reexport { pub p_shader_group_capture_replay_handle: *const core::ffi::c_void, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for RayTracingShaderGroupCreateInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR; + } + impl<'a> Default for RayTracingShaderGroupCreateInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + _type: Default::default(), + general_shader: Default::default(), + closest_hit_shader: Default::default(), + any_hit_shader: Default::default(), + intersection_shader: Default::default(), + p_shader_group_capture_replay_handle: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> RayTracingShaderGroupCreateInfoKHR<'a> { + pub fn _type(mut self, _type: crate::vk::RayTracingShaderGroupTypeKHR) -> Self { + self._type = _type; + self + } + pub fn general_shader(mut self, general_shader: u32) -> Self { + self.general_shader = general_shader; + self + } + pub fn closest_hit_shader(mut self, closest_hit_shader: u32) -> Self { + self.closest_hit_shader = closest_hit_shader; + self + } + pub fn any_hit_shader(mut self, any_hit_shader: u32) -> Self { + self.any_hit_shader = any_hit_shader; + self + } + pub fn intersection_shader(mut self, intersection_shader: u32) -> Self { + self.intersection_shader = intersection_shader; + self + } + pub fn p_shader_group_capture_replay_handle( + mut self, + p_shader_group_capture_replay_handle: &'a core::ffi::c_void, + ) -> Self { + self.p_shader_group_capture_replay_handle = p_shader_group_capture_replay_handle; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct RayTracingPipelineCreateInfoKHR<'a> { @@ -186,6 +234,105 @@ pub(crate) mod reexport { pub base_pipeline_index: i32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for RayTracingPipelineCreateInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::RAY_TRACING_PIPELINE_CREATE_INFO_KHR; + } + impl<'a> Default for RayTracingPipelineCreateInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + flags: Default::default(), + stage_count: Default::default(), + p_stages: Default::default(), + group_count: Default::default(), + p_groups: Default::default(), + max_pipeline_ray_recursion_depth: Default::default(), + p_library_info: Default::default(), + p_library_interface: Default::default(), + p_dynamic_state: Default::default(), + layout: Default::default(), + base_pipeline_handle: Default::default(), + base_pipeline_index: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> RayTracingPipelineCreateInfoKHR<'a> { + pub fn flags(mut self, flags: crate::vk::PipelineCreateFlags) -> Self { + self.flags = flags; + self + } + pub fn stage_count(mut self, stage_count: u32) -> Self { + self.stage_count = stage_count; + self + } + pub fn p_stages( + mut self, + p_stages: &'a [crate::vk::PipelineShaderStageCreateInfo<'a>], + ) -> Self { + self.stage_count = p_stages.len() as _; + self.p_stages = p_stages.as_ptr(); + self + } + pub fn group_count(mut self, group_count: u32) -> Self { + self.group_count = group_count; + self + } + pub fn p_groups( + mut self, + p_groups: &'a [crate::vk::RayTracingShaderGroupCreateInfoKHR<'a>], + ) -> Self { + self.group_count = p_groups.len() as _; + self.p_groups = p_groups.as_ptr(); + self + } + pub fn max_pipeline_ray_recursion_depth( + mut self, + max_pipeline_ray_recursion_depth: u32, + ) -> Self { + self.max_pipeline_ray_recursion_depth = max_pipeline_ray_recursion_depth; + self + } + pub fn p_library_info( + mut self, + p_library_info: &'a crate::vk::PipelineLibraryCreateInfoKHR<'a>, + ) -> Self { + self.p_library_info = p_library_info; + self + } + pub fn p_library_interface( + mut self, + p_library_interface: &'a crate::vk::RayTracingPipelineInterfaceCreateInfoKHR< + 'a, + >, + ) -> Self { + self.p_library_interface = p_library_interface; + self + } + pub fn p_dynamic_state( + mut self, + p_dynamic_state: &'a crate::vk::PipelineDynamicStateCreateInfo<'a>, + ) -> Self { + self.p_dynamic_state = p_dynamic_state; + self + } + pub fn layout(mut self, layout: crate::vk::PipelineLayout) -> Self { + self.layout = layout; + self + } + pub fn base_pipeline_handle( + mut self, + base_pipeline_handle: crate::vk::Pipeline, + ) -> Self { + self.base_pipeline_handle = base_pipeline_handle; + self + } + pub fn base_pipeline_index(mut self, base_pipeline_index: i32) -> Self { + self.base_pipeline_index = base_pipeline_index; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceRayTracingPipelineFeaturesKHR<'a> { @@ -198,6 +345,66 @@ pub(crate) mod reexport { pub ray_traversal_primitive_culling: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceRayTracingPipelineFeaturesKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceRayTracingPipelineFeaturesKHR<'a> {} + unsafe impl<'a> crate::Extends> + for PhysicalDeviceRayTracingPipelineFeaturesKHR<'a> {} + impl<'a> Default for PhysicalDeviceRayTracingPipelineFeaturesKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + ray_tracing_pipeline: Default::default(), + ray_tracing_pipeline_shader_group_handle_capture_replay: Default::default(), + ray_tracing_pipeline_shader_group_handle_capture_replay_mixed: Default::default(), + ray_tracing_pipeline_trace_rays_indirect: Default::default(), + ray_traversal_primitive_culling: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceRayTracingPipelineFeaturesKHR<'a> { + pub fn ray_tracing_pipeline(mut self, ray_tracing_pipeline: bool) -> Self { + self.ray_tracing_pipeline = ray_tracing_pipeline.into(); + self + } + pub fn ray_tracing_pipeline_shader_group_handle_capture_replay( + mut self, + ray_tracing_pipeline_shader_group_handle_capture_replay: bool, + ) -> Self { + self.ray_tracing_pipeline_shader_group_handle_capture_replay = ray_tracing_pipeline_shader_group_handle_capture_replay + .into(); + self + } + pub fn ray_tracing_pipeline_shader_group_handle_capture_replay_mixed( + mut self, + ray_tracing_pipeline_shader_group_handle_capture_replay_mixed: bool, + ) -> Self { + self.ray_tracing_pipeline_shader_group_handle_capture_replay_mixed = ray_tracing_pipeline_shader_group_handle_capture_replay_mixed + .into(); + self + } + pub fn ray_tracing_pipeline_trace_rays_indirect( + mut self, + ray_tracing_pipeline_trace_rays_indirect: bool, + ) -> Self { + self.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, + ) -> Self { + self.ray_traversal_primitive_culling = ray_traversal_primitive_culling + .into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceRayTracingPipelinePropertiesKHR<'a> { @@ -213,20 +420,126 @@ pub(crate) mod reexport { pub max_ray_hit_attribute_size: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceRayTracingPipelinePropertiesKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceRayTracingPipelinePropertiesKHR<'a> {} + impl<'a> Default for PhysicalDeviceRayTracingPipelinePropertiesKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + shader_group_handle_size: Default::default(), + max_ray_recursion_depth: Default::default(), + max_shader_group_stride: Default::default(), + shader_group_base_alignment: Default::default(), + shader_group_handle_capture_replay_size: Default::default(), + max_ray_dispatch_invocation_count: Default::default(), + shader_group_handle_alignment: Default::default(), + max_ray_hit_attribute_size: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceRayTracingPipelinePropertiesKHR<'a> { + pub fn shader_group_handle_size( + mut self, + shader_group_handle_size: u32, + ) -> Self { + self.shader_group_handle_size = shader_group_handle_size; + self + } + pub fn max_ray_recursion_depth(mut self, max_ray_recursion_depth: u32) -> Self { + self.max_ray_recursion_depth = max_ray_recursion_depth; + self + } + pub fn max_shader_group_stride(mut self, max_shader_group_stride: u32) -> Self { + self.max_shader_group_stride = max_shader_group_stride; + self + } + pub fn shader_group_base_alignment( + mut self, + shader_group_base_alignment: u32, + ) -> Self { + self.shader_group_base_alignment = shader_group_base_alignment; + self + } + pub fn shader_group_handle_capture_replay_size( + mut self, + shader_group_handle_capture_replay_size: u32, + ) -> Self { + self.shader_group_handle_capture_replay_size = shader_group_handle_capture_replay_size; + self + } + pub fn max_ray_dispatch_invocation_count( + mut self, + max_ray_dispatch_invocation_count: u32, + ) -> Self { + self.max_ray_dispatch_invocation_count = max_ray_dispatch_invocation_count; + self + } + pub fn shader_group_handle_alignment( + mut self, + shader_group_handle_alignment: u32, + ) -> Self { + self.shader_group_handle_alignment = shader_group_handle_alignment; + self + } + pub fn max_ray_hit_attribute_size( + mut self, + max_ray_hit_attribute_size: u32, + ) -> Self { + self.max_ray_hit_attribute_size = max_ray_hit_attribute_size; + self + } + } #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct StridedDeviceAddressRegionKHR { pub device_address: crate::vk::DeviceAddress, pub stride: crate::vk::DeviceSize, pub size: crate::vk::DeviceSize, } + impl StridedDeviceAddressRegionKHR { + pub fn device_address( + mut self, + device_address: crate::vk::DeviceAddress, + ) -> Self { + self.device_address = device_address; + self + } + pub fn stride(mut self, stride: crate::vk::DeviceSize) -> Self { + self.stride = stride; + self + } + pub fn size(mut self, size: crate::vk::DeviceSize) -> Self { + self.size = size; + self + } + } #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct TraceRaysIndirectCommandKHR { pub width: u32, pub height: u32, pub depth: u32, } + impl TraceRaysIndirectCommandKHR { + pub fn width(mut self, width: u32) -> Self { + self.width = width; + self + } + pub fn height(mut self, height: u32) -> Self { + self.height = height; + self + } + pub fn depth(mut self, depth: u32) -> Self { + self.depth = depth; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct RayTracingPipelineInterfaceCreateInfoKHR<'a> { @@ -236,6 +549,37 @@ pub(crate) mod reexport { pub max_pipeline_ray_hit_attribute_size: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for RayTracingPipelineInterfaceCreateInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::RAY_TRACING_PIPELINE_INTERFACE_CREATE_INFO_KHR; + } + impl<'a> Default for RayTracingPipelineInterfaceCreateInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + max_pipeline_ray_payload_size: Default::default(), + max_pipeline_ray_hit_attribute_size: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> RayTracingPipelineInterfaceCreateInfoKHR<'a> { + pub fn max_pipeline_ray_payload_size( + mut self, + max_pipeline_ray_payload_size: u32, + ) -> Self { + self.max_pipeline_ray_payload_size = max_pipeline_ray_payload_size; + self + } + pub fn max_pipeline_ray_hit_attribute_size( + mut self, + max_pipeline_ray_hit_attribute_size: u32, + ) -> Self { + self.max_pipeline_ray_hit_attribute_size = max_pipeline_ray_hit_attribute_size; + self + } + } ///Provided by [`khr::ray_tracing_pipeline`](crate::khr::ray_tracing_pipeline) impl crate::vk::PipelineBindPoint { pub const RAY_TRACING_KHR: Self = Self(1000165000); diff --git a/ash-rewrite/src/generated/khr/ray_tracing_position_fetch.rs b/ash-rewrite/src/generated/khr/ray_tracing_position_fetch.rs index 2fb56117d..fbfb2f4f4 100644 --- a/ash-rewrite/src/generated/khr/ray_tracing_position_fetch.rs +++ b/ash-rewrite/src/generated/khr/ray_tracing_position_fetch.rs @@ -9,6 +9,33 @@ pub struct PhysicalDeviceRayTracingPositionFetchFeaturesKHR<'a> { pub ray_tracing_position_fetch: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceRayTracingPositionFetchFeaturesKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceRayTracingPositionFetchFeaturesKHR<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceRayTracingPositionFetchFeaturesKHR<'a> {} +impl<'a> Default for PhysicalDeviceRayTracingPositionFetchFeaturesKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + ray_tracing_position_fetch: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceRayTracingPositionFetchFeaturesKHR<'a> { + pub fn ray_tracing_position_fetch( + mut self, + ray_tracing_position_fetch: bool, + ) -> Self { + self.ray_tracing_position_fetch = ray_tracing_position_fetch.into(); + self + } +} ///Provided by [`khr::ray_tracing_position_fetch`](crate::khr::ray_tracing_position_fetch) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR: Self = Self( diff --git a/ash-rewrite/src/generated/khr/robustness2.rs b/ash-rewrite/src/generated/khr/robustness2.rs index d4df94fac..07bf14818 100644 --- a/ash-rewrite/src/generated/khr/robustness2.rs +++ b/ash-rewrite/src/generated/khr/robustness2.rs @@ -11,6 +11,39 @@ pub struct PhysicalDeviceRobustness2FeaturesKHR<'a> { pub null_descriptor: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> for PhysicalDeviceRobustness2FeaturesKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_KHR; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceRobustness2FeaturesKHR<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceRobustness2FeaturesKHR<'a> {} +impl<'a> Default for PhysicalDeviceRobustness2FeaturesKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + robust_buffer_access2: Default::default(), + robust_image_access2: Default::default(), + null_descriptor: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceRobustness2FeaturesKHR<'a> { + pub fn robust_buffer_access2(mut self, robust_buffer_access2: bool) -> Self { + self.robust_buffer_access2 = robust_buffer_access2.into(); + self + } + pub fn robust_image_access2(mut self, robust_image_access2: bool) -> Self { + self.robust_image_access2 = robust_image_access2.into(); + self + } + pub fn null_descriptor(mut self, null_descriptor: bool) -> Self { + self.null_descriptor = null_descriptor.into(); + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceRobustness2PropertiesKHR<'a> { @@ -20,6 +53,39 @@ pub struct PhysicalDeviceRobustness2PropertiesKHR<'a> { pub robust_uniform_buffer_access_size_alignment: crate::vk::DeviceSize, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceRobustness2PropertiesKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_KHR; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceRobustness2PropertiesKHR<'a> {} +impl<'a> Default for PhysicalDeviceRobustness2PropertiesKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + robust_storage_buffer_access_size_alignment: Default::default(), + robust_uniform_buffer_access_size_alignment: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceRobustness2PropertiesKHR<'a> { + pub fn robust_storage_buffer_access_size_alignment( + mut self, + robust_storage_buffer_access_size_alignment: crate::vk::DeviceSize, + ) -> Self { + self.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: crate::vk::DeviceSize, + ) -> Self { + self.robust_uniform_buffer_access_size_alignment = robust_uniform_buffer_access_size_alignment; + self + } +} ///Provided by [`khr::robustness2`](crate::khr::robustness2) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_KHR: Self = Self(1000286000); diff --git a/ash-rewrite/src/generated/khr/shader_abort.rs b/ash-rewrite/src/generated/khr/shader_abort.rs index 1429966b1..e6aa8efe3 100644 --- a/ash-rewrite/src/generated/khr/shader_abort.rs +++ b/ash-rewrite/src/generated/khr/shader_abort.rs @@ -9,6 +9,29 @@ pub struct PhysicalDeviceShaderAbortFeaturesKHR<'a> { pub shader_abort: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> for PhysicalDeviceShaderAbortFeaturesKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_SHADER_ABORT_FEATURES_KHR; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceShaderAbortFeaturesKHR<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceShaderAbortFeaturesKHR<'a> {} +impl<'a> Default for PhysicalDeviceShaderAbortFeaturesKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + shader_abort: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceShaderAbortFeaturesKHR<'a> { + pub fn shader_abort(mut self, shader_abort: bool) -> Self { + self.shader_abort = shader_abort.into(); + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceShaderAbortPropertiesKHR<'a> { @@ -17,6 +40,31 @@ pub struct PhysicalDeviceShaderAbortPropertiesKHR<'a> { pub max_shader_abort_message_size: u64, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceShaderAbortPropertiesKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_SHADER_ABORT_PROPERTIES_KHR; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceShaderAbortPropertiesKHR<'a> {} +impl<'a> Default for PhysicalDeviceShaderAbortPropertiesKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + max_shader_abort_message_size: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceShaderAbortPropertiesKHR<'a> { + pub fn max_shader_abort_message_size( + mut self, + max_shader_abort_message_size: u64, + ) -> Self { + self.max_shader_abort_message_size = max_shader_abort_message_size; + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct DeviceFaultShaderAbortMessageInfoKHR<'a> { @@ -26,6 +74,33 @@ pub struct DeviceFaultShaderAbortMessageInfoKHR<'a> { pub p_message_data: *mut core::ffi::c_void, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> for DeviceFaultShaderAbortMessageInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::DEVICE_FAULT_SHADER_ABORT_MESSAGE_INFO_KHR; +} +unsafe impl<'a> crate::Extends> +for DeviceFaultShaderAbortMessageInfoKHR<'a> {} +impl<'a> Default for DeviceFaultShaderAbortMessageInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + message_data_size: Default::default(), + p_message_data: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> DeviceFaultShaderAbortMessageInfoKHR<'a> { + pub fn message_data_size(mut self, message_data_size: u64) -> Self { + self.message_data_size = message_data_size; + self + } + pub fn p_message_data(mut self, p_message_data: &'a mut [u8]) -> Self { + self.message_data_size = p_message_data.len() as _; + self.p_message_data = p_message_data.as_mut_ptr().cast(); + self + } +} ///Provided by [`khr::shader_abort`](crate::khr::shader_abort) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_SHADER_ABORT_FEATURES_KHR: Self = Self(1000233000); diff --git a/ash-rewrite/src/generated/khr/shader_bfloat16.rs b/ash-rewrite/src/generated/khr/shader_bfloat16.rs index ef09cac7e..c402d7367 100644 --- a/ash-rewrite/src/generated/khr/shader_bfloat16.rs +++ b/ash-rewrite/src/generated/khr/shader_bfloat16.rs @@ -11,6 +11,47 @@ pub struct PhysicalDeviceShaderBfloat16FeaturesKHR<'a> { pub shader_b_float16_cooperative_matrix: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceShaderBfloat16FeaturesKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_SHADER_BFLOAT16_FEATURES_KHR; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceShaderBfloat16FeaturesKHR<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceShaderBfloat16FeaturesKHR<'a> {} +impl<'a> Default for PhysicalDeviceShaderBfloat16FeaturesKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + shader_b_float16_type: Default::default(), + shader_b_float16_dot_product: Default::default(), + shader_b_float16_cooperative_matrix: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceShaderBfloat16FeaturesKHR<'a> { + pub fn shader_b_float16_type(mut self, shader_b_float16_type: bool) -> Self { + self.shader_b_float16_type = shader_b_float16_type.into(); + self + } + pub fn shader_b_float16_dot_product( + mut self, + shader_b_float16_dot_product: bool, + ) -> Self { + self.shader_b_float16_dot_product = shader_b_float16_dot_product.into(); + self + } + pub fn shader_b_float16_cooperative_matrix( + mut self, + shader_b_float16_cooperative_matrix: bool, + ) -> Self { + self.shader_b_float16_cooperative_matrix = shader_b_float16_cooperative_matrix + .into(); + self + } +} ///Provided by [`khr::shader_bfloat16`](crate::khr::shader_bfloat16) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_SHADER_BFLOAT16_FEATURES_KHR: Self = Self(1000141000); diff --git a/ash-rewrite/src/generated/khr/shader_clock.rs b/ash-rewrite/src/generated/khr/shader_clock.rs index b5d2fd5ef..dba5fd403 100644 --- a/ash-rewrite/src/generated/khr/shader_clock.rs +++ b/ash-rewrite/src/generated/khr/shader_clock.rs @@ -10,6 +10,34 @@ pub struct PhysicalDeviceShaderClockFeaturesKHR<'a> { pub shader_device_clock: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> for PhysicalDeviceShaderClockFeaturesKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceShaderClockFeaturesKHR<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceShaderClockFeaturesKHR<'a> {} +impl<'a> Default for PhysicalDeviceShaderClockFeaturesKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + shader_subgroup_clock: Default::default(), + shader_device_clock: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceShaderClockFeaturesKHR<'a> { + pub fn shader_subgroup_clock(mut self, shader_subgroup_clock: bool) -> Self { + self.shader_subgroup_clock = shader_subgroup_clock.into(); + self + } + pub fn shader_device_clock(mut self, shader_device_clock: bool) -> Self { + self.shader_device_clock = shader_device_clock.into(); + self + } +} ///Provided by [`khr::shader_clock`](crate::khr::shader_clock) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR: Self = Self(1000181000); diff --git a/ash-rewrite/src/generated/khr/shader_constant_data.rs b/ash-rewrite/src/generated/khr/shader_constant_data.rs index ee8fc9a81..e8c0e948b 100644 --- a/ash-rewrite/src/generated/khr/shader_constant_data.rs +++ b/ash-rewrite/src/generated/khr/shader_constant_data.rs @@ -9,6 +9,30 @@ pub struct PhysicalDeviceShaderConstantDataFeaturesKHR<'a> { pub shader_constant_data: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceShaderConstantDataFeaturesKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_SHADER_CONSTANT_DATA_FEATURES_KHR; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceShaderConstantDataFeaturesKHR<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceShaderConstantDataFeaturesKHR<'a> {} +impl<'a> Default for PhysicalDeviceShaderConstantDataFeaturesKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + shader_constant_data: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceShaderConstantDataFeaturesKHR<'a> { + pub fn shader_constant_data(mut self, shader_constant_data: bool) -> Self { + self.shader_constant_data = shader_constant_data.into(); + self + } +} ///Provided by [`khr::shader_constant_data`](crate::khr::shader_constant_data) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_SHADER_CONSTANT_DATA_FEATURES_KHR: Self = Self(1000231000); diff --git a/ash-rewrite/src/generated/khr/shader_fma.rs b/ash-rewrite/src/generated/khr/shader_fma.rs index 5ed94483c..799b6471d 100644 --- a/ash-rewrite/src/generated/khr/shader_fma.rs +++ b/ash-rewrite/src/generated/khr/shader_fma.rs @@ -11,6 +11,39 @@ pub struct PhysicalDeviceShaderFmaFeaturesKHR<'a> { pub shader_fma_float64: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> for PhysicalDeviceShaderFmaFeaturesKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_SHADER_FMA_FEATURES_KHR; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceShaderFmaFeaturesKHR<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceShaderFmaFeaturesKHR<'a> {} +impl<'a> Default for PhysicalDeviceShaderFmaFeaturesKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + shader_fma_float16: Default::default(), + shader_fma_float32: Default::default(), + shader_fma_float64: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceShaderFmaFeaturesKHR<'a> { + pub fn shader_fma_float16(mut self, shader_fma_float16: bool) -> Self { + self.shader_fma_float16 = shader_fma_float16.into(); + self + } + pub fn shader_fma_float32(mut self, shader_fma_float32: bool) -> Self { + self.shader_fma_float32 = shader_fma_float32.into(); + self + } + pub fn shader_fma_float64(mut self, shader_fma_float64: bool) -> Self { + self.shader_fma_float64 = shader_fma_float64.into(); + self + } +} ///Provided by [`khr::shader_fma`](crate::khr::shader_fma) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_SHADER_FMA_FEATURES_KHR: Self = Self(1000579000); diff --git a/ash-rewrite/src/generated/khr/shader_maximal_reconvergence.rs b/ash-rewrite/src/generated/khr/shader_maximal_reconvergence.rs index ea5f43bab..a0cf897c7 100644 --- a/ash-rewrite/src/generated/khr/shader_maximal_reconvergence.rs +++ b/ash-rewrite/src/generated/khr/shader_maximal_reconvergence.rs @@ -9,6 +9,33 @@ pub struct PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR<'a> { pub shader_maximal_reconvergence: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR<'a> {} +impl<'a> Default for PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + shader_maximal_reconvergence: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR<'a> { + pub fn shader_maximal_reconvergence( + mut self, + shader_maximal_reconvergence: bool, + ) -> Self { + self.shader_maximal_reconvergence = shader_maximal_reconvergence.into(); + self + } +} ///Provided by [`khr::shader_maximal_reconvergence`](crate::khr::shader_maximal_reconvergence) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR: Self = Self( diff --git a/ash-rewrite/src/generated/khr/shader_quad_control.rs b/ash-rewrite/src/generated/khr/shader_quad_control.rs index 380ecde60..99e2ef7c1 100644 --- a/ash-rewrite/src/generated/khr/shader_quad_control.rs +++ b/ash-rewrite/src/generated/khr/shader_quad_control.rs @@ -9,6 +9,30 @@ pub struct PhysicalDeviceShaderQuadControlFeaturesKHR<'a> { pub shader_quad_control: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceShaderQuadControlFeaturesKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceShaderQuadControlFeaturesKHR<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceShaderQuadControlFeaturesKHR<'a> {} +impl<'a> Default for PhysicalDeviceShaderQuadControlFeaturesKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + shader_quad_control: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceShaderQuadControlFeaturesKHR<'a> { + pub fn shader_quad_control(mut self, shader_quad_control: bool) -> Self { + self.shader_quad_control = shader_quad_control.into(); + self + } +} ///Provided by [`khr::shader_quad_control`](crate::khr::shader_quad_control) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR: Self = Self(1000235000); diff --git a/ash-rewrite/src/generated/khr/shader_relaxed_extended_instruction.rs b/ash-rewrite/src/generated/khr/shader_relaxed_extended_instruction.rs index bc03ba1ed..6fe778f02 100644 --- a/ash-rewrite/src/generated/khr/shader_relaxed_extended_instruction.rs +++ b/ash-rewrite/src/generated/khr/shader_relaxed_extended_instruction.rs @@ -9,6 +9,34 @@ pub struct PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR<'a> { pub shader_relaxed_extended_instruction: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR<'a> {} +impl<'a> Default for PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + shader_relaxed_extended_instruction: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR<'a> { + pub fn shader_relaxed_extended_instruction( + mut self, + shader_relaxed_extended_instruction: bool, + ) -> Self { + self.shader_relaxed_extended_instruction = shader_relaxed_extended_instruction + .into(); + self + } +} ///Provided by [`khr::shader_relaxed_extended_instruction`](crate::khr::shader_relaxed_extended_instruction) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR: Self = Self( diff --git a/ash-rewrite/src/generated/khr/shader_subgroup_uniform_control_flow.rs b/ash-rewrite/src/generated/khr/shader_subgroup_uniform_control_flow.rs index 122c7f13d..e596799ad 100644 --- a/ash-rewrite/src/generated/khr/shader_subgroup_uniform_control_flow.rs +++ b/ash-rewrite/src/generated/khr/shader_subgroup_uniform_control_flow.rs @@ -9,6 +9,34 @@ pub struct PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR<'a> { pub shader_subgroup_uniform_control_flow: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR<'a> {} +impl<'a> Default for PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + shader_subgroup_uniform_control_flow: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR<'a> { + pub fn shader_subgroup_uniform_control_flow( + mut self, + shader_subgroup_uniform_control_flow: bool, + ) -> Self { + self.shader_subgroup_uniform_control_flow = shader_subgroup_uniform_control_flow + .into(); + self + } +} ///Provided by [`khr::shader_subgroup_uniform_control_flow`](crate::khr::shader_subgroup_uniform_control_flow) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR: Self = Self( diff --git a/ash-rewrite/src/generated/khr/shader_untyped_pointers.rs b/ash-rewrite/src/generated/khr/shader_untyped_pointers.rs index f3ca92983..88ee8f663 100644 --- a/ash-rewrite/src/generated/khr/shader_untyped_pointers.rs +++ b/ash-rewrite/src/generated/khr/shader_untyped_pointers.rs @@ -9,6 +9,30 @@ pub struct PhysicalDeviceShaderUntypedPointersFeaturesKHR<'a> { pub shader_untyped_pointers: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceShaderUntypedPointersFeaturesKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_SHADER_UNTYPED_POINTERS_FEATURES_KHR; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceShaderUntypedPointersFeaturesKHR<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceShaderUntypedPointersFeaturesKHR<'a> {} +impl<'a> Default for PhysicalDeviceShaderUntypedPointersFeaturesKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + shader_untyped_pointers: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceShaderUntypedPointersFeaturesKHR<'a> { + pub fn shader_untyped_pointers(mut self, shader_untyped_pointers: bool) -> Self { + self.shader_untyped_pointers = shader_untyped_pointers.into(); + self + } +} ///Provided by [`khr::shader_untyped_pointers`](crate::khr::shader_untyped_pointers) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_SHADER_UNTYPED_POINTERS_FEATURES_KHR: Self = Self( diff --git a/ash-rewrite/src/generated/khr/shared_presentable_image.rs b/ash-rewrite/src/generated/khr/shared_presentable_image.rs index c2d832e80..6fcdbaa37 100644 --- a/ash-rewrite/src/generated/khr/shared_presentable_image.rs +++ b/ash-rewrite/src/generated/khr/shared_presentable_image.rs @@ -43,6 +43,31 @@ pub(crate) mod reexport { pub shared_present_supported_usage_flags: crate::vk::ImageUsageFlags, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for SharedPresentSurfaceCapabilitiesKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::SHARED_PRESENT_SURFACE_CAPABILITIES_KHR; + } + unsafe impl<'a> crate::Extends> + for SharedPresentSurfaceCapabilitiesKHR<'a> {} + impl<'a> Default for SharedPresentSurfaceCapabilitiesKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + shared_present_supported_usage_flags: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> SharedPresentSurfaceCapabilitiesKHR<'a> { + pub fn shared_present_supported_usage_flags( + mut self, + shared_present_supported_usage_flags: crate::vk::ImageUsageFlags, + ) -> Self { + self.shared_present_supported_usage_flags = shared_present_supported_usage_flags; + self + } + } ///Provided by [`khr::shared_presentable_image`](crate::khr::shared_presentable_image) impl crate::vk::ImageLayout { pub const SHARED_PRESENT_KHR: Self = Self(1000111000); diff --git a/ash-rewrite/src/generated/khr/surface.rs b/ash-rewrite/src/generated/khr/surface.rs index 50c3d41a6..8e03f3a2c 100644 --- a/ash-rewrite/src/generated/khr/surface.rs +++ b/ash-rewrite/src/generated/khr/surface.rs @@ -104,7 +104,7 @@ impl InstanceFn { } pub(crate) mod reexport { #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct SurfaceCapabilitiesKHR { pub min_image_count: u32, pub max_image_count: u32, @@ -117,12 +117,82 @@ pub(crate) mod reexport { pub supported_composite_alpha: crate::vk::CompositeAlphaFlagsKHR, pub supported_usage_flags: crate::vk::ImageUsageFlags, } + impl SurfaceCapabilitiesKHR { + pub fn min_image_count(mut self, min_image_count: u32) -> Self { + self.min_image_count = min_image_count; + self + } + pub fn max_image_count(mut self, max_image_count: u32) -> Self { + self.max_image_count = max_image_count; + self + } + pub fn current_extent(mut self, current_extent: crate::vk::Extent2D) -> Self { + self.current_extent = current_extent; + self + } + pub fn min_image_extent( + mut self, + min_image_extent: crate::vk::Extent2D, + ) -> Self { + self.min_image_extent = min_image_extent; + self + } + pub fn max_image_extent( + mut self, + max_image_extent: crate::vk::Extent2D, + ) -> Self { + self.max_image_extent = max_image_extent; + self + } + pub fn max_image_array_layers(mut self, max_image_array_layers: u32) -> Self { + self.max_image_array_layers = max_image_array_layers; + self + } + pub fn supported_transforms( + mut self, + supported_transforms: crate::vk::SurfaceTransformFlagsKHR, + ) -> Self { + self.supported_transforms = supported_transforms; + self + } + pub fn current_transform( + mut self, + current_transform: crate::vk::SurfaceTransformFlagBitsKHR, + ) -> Self { + self.current_transform = current_transform; + self + } + pub fn supported_composite_alpha( + mut self, + supported_composite_alpha: crate::vk::CompositeAlphaFlagsKHR, + ) -> Self { + self.supported_composite_alpha = supported_composite_alpha; + self + } + pub fn supported_usage_flags( + mut self, + supported_usage_flags: crate::vk::ImageUsageFlags, + ) -> Self { + self.supported_usage_flags = supported_usage_flags; + self + } + } #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct SurfaceFormatKHR { pub format: crate::vk::Format, pub color_space: crate::vk::ColorSpaceKHR, } + impl SurfaceFormatKHR { + pub fn format(mut self, format: crate::vk::Format) -> Self { + self.format = format; + self + } + pub fn color_space(mut self, color_space: crate::vk::ColorSpaceKHR) -> Self { + self.color_space = color_space; + self + } + } ///Provided by [`khr::surface`](crate::khr::surface) impl crate::vk::Result { pub const ERROR_SURFACE_LOST_KHR: Self = Self(-1000000000); @@ -243,7 +313,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct CompositeAlphaFlagBitsKHR(pub(crate) u32); ///Provided by [`khr::surface`](crate::khr::surface) impl CompositeAlphaFlagBitsKHR { @@ -343,7 +413,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct SurfaceTransformFlagBitsKHR(pub(crate) u32); ///Provided by [`khr::surface`](crate::khr::surface) impl SurfaceTransformFlagBitsKHR { diff --git a/ash-rewrite/src/generated/khr/surface_maintenance1.rs b/ash-rewrite/src/generated/khr/surface_maintenance1.rs index 94fe76f49..253c5671f 100644 --- a/ash-rewrite/src/generated/khr/surface_maintenance1.rs +++ b/ash-rewrite/src/generated/khr/surface_maintenance1.rs @@ -9,6 +9,27 @@ pub struct SurfacePresentModeKHR<'a> { pub present_mode: crate::vk::PresentModeKHR, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> for SurfacePresentModeKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::SURFACE_PRESENT_MODE_KHR; +} +unsafe impl<'a> crate::Extends> +for SurfacePresentModeKHR<'a> {} +impl<'a> Default for SurfacePresentModeKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + present_mode: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> SurfacePresentModeKHR<'a> { + pub fn present_mode(mut self, present_mode: crate::vk::PresentModeKHR) -> Self { + self.present_mode = present_mode; + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct SurfacePresentScalingCapabilitiesKHR<'a> { @@ -21,6 +42,62 @@ pub struct SurfacePresentScalingCapabilitiesKHR<'a> { pub max_scaled_image_extent: crate::vk::Extent2D, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> for SurfacePresentScalingCapabilitiesKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::SURFACE_PRESENT_SCALING_CAPABILITIES_KHR; +} +unsafe impl<'a> crate::Extends> +for SurfacePresentScalingCapabilitiesKHR<'a> {} +impl<'a> Default for SurfacePresentScalingCapabilitiesKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + supported_present_scaling: Default::default(), + supported_present_gravity_x: Default::default(), + supported_present_gravity_y: Default::default(), + min_scaled_image_extent: Default::default(), + max_scaled_image_extent: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> SurfacePresentScalingCapabilitiesKHR<'a> { + pub fn supported_present_scaling( + mut self, + supported_present_scaling: crate::vk::PresentScalingFlagsKHR, + ) -> Self { + self.supported_present_scaling = supported_present_scaling; + self + } + pub fn supported_present_gravity_x( + mut self, + supported_present_gravity_x: crate::vk::PresentGravityFlagsKHR, + ) -> Self { + self.supported_present_gravity_x = supported_present_gravity_x; + self + } + pub fn supported_present_gravity_y( + mut self, + supported_present_gravity_y: crate::vk::PresentGravityFlagsKHR, + ) -> Self { + self.supported_present_gravity_y = supported_present_gravity_y; + self + } + pub fn min_scaled_image_extent( + mut self, + min_scaled_image_extent: crate::vk::Extent2D, + ) -> Self { + self.min_scaled_image_extent = min_scaled_image_extent; + self + } + pub fn max_scaled_image_extent( + mut self, + max_scaled_image_extent: crate::vk::Extent2D, + ) -> Self { + self.max_scaled_image_extent = max_scaled_image_extent; + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct SurfacePresentModeCompatibilityKHR<'a> { @@ -30,6 +107,36 @@ pub struct SurfacePresentModeCompatibilityKHR<'a> { pub p_present_modes: *mut crate::vk::PresentModeKHR, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> for SurfacePresentModeCompatibilityKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::SURFACE_PRESENT_MODE_COMPATIBILITY_KHR; +} +unsafe impl<'a> crate::Extends> +for SurfacePresentModeCompatibilityKHR<'a> {} +impl<'a> Default for SurfacePresentModeCompatibilityKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + present_mode_count: Default::default(), + p_present_modes: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> SurfacePresentModeCompatibilityKHR<'a> { + pub fn present_mode_count(mut self, present_mode_count: u32) -> Self { + self.present_mode_count = present_mode_count; + self + } + pub fn p_present_modes( + mut self, + p_present_modes: &'a mut [crate::vk::PresentModeKHR], + ) -> Self { + self.present_mode_count = p_present_modes.len() as _; + self.p_present_modes = p_present_modes.as_mut_ptr(); + self + } +} ///Provided by [`khr::surface_maintenance1`](crate::khr::surface_maintenance1) impl crate::vk::StructureType { pub const SURFACE_PRESENT_MODE_KHR: Self = Self(1000274000); @@ -114,7 +221,7 @@ impl core::ops::Not for PresentScalingFlagsKHR { } } #[repr(transparent)] -#[derive(Clone, Copy)] +#[derive(Clone, Copy, Default)] pub struct PresentScalingFlagBitsKHR(pub(crate) u32); ///Provided by [`khr::surface_maintenance1`](crate::khr::surface_maintenance1) impl PresentScalingFlagBitsKHR { @@ -199,7 +306,7 @@ impl core::ops::Not for PresentGravityFlagsKHR { } } #[repr(transparent)] -#[derive(Clone, Copy)] +#[derive(Clone, Copy, Default)] pub struct PresentGravityFlagBitsKHR(pub(crate) u32); ///Provided by [`khr::surface_maintenance1`](crate::khr::surface_maintenance1) impl PresentGravityFlagBitsKHR { diff --git a/ash-rewrite/src/generated/khr/surface_protected_capabilities.rs b/ash-rewrite/src/generated/khr/surface_protected_capabilities.rs index 37c56cb00..d7981cdef 100644 --- a/ash-rewrite/src/generated/khr/surface_protected_capabilities.rs +++ b/ash-rewrite/src/generated/khr/surface_protected_capabilities.rs @@ -9,6 +9,27 @@ pub struct SurfaceProtectedCapabilitiesKHR<'a> { pub supports_protected: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> for SurfaceProtectedCapabilitiesKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::SURFACE_PROTECTED_CAPABILITIES_KHR; +} +unsafe impl<'a> crate::Extends> +for SurfaceProtectedCapabilitiesKHR<'a> {} +impl<'a> Default for SurfaceProtectedCapabilitiesKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + supports_protected: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> SurfaceProtectedCapabilitiesKHR<'a> { + pub fn supports_protected(mut self, supports_protected: bool) -> Self { + self.supports_protected = supports_protected.into(); + self + } +} ///Provided by [`khr::surface_protected_capabilities`](crate::khr::surface_protected_capabilities) impl crate::vk::StructureType { pub const SURFACE_PROTECTED_CAPABILITIES_KHR: Self = Self(1000239000); diff --git a/ash-rewrite/src/generated/khr/swapchain.rs b/ash-rewrite/src/generated/khr/swapchain.rs index 0e2ffa299..78c7ef522 100644 --- a/ash-rewrite/src/generated/khr/swapchain.rs +++ b/ash-rewrite/src/generated/khr/swapchain.rs @@ -209,6 +209,119 @@ pub(crate) mod reexport { pub old_swapchain: crate::vk::SwapchainKHR, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for SwapchainCreateInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::SWAPCHAIN_CREATE_INFO_KHR; + } + impl<'a> Default for SwapchainCreateInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + flags: Default::default(), + surface: Default::default(), + min_image_count: Default::default(), + image_format: Default::default(), + image_color_space: Default::default(), + image_extent: Default::default(), + image_array_layers: Default::default(), + image_usage: Default::default(), + image_sharing_mode: Default::default(), + queue_family_index_count: Default::default(), + p_queue_family_indices: Default::default(), + pre_transform: Default::default(), + composite_alpha: Default::default(), + present_mode: Default::default(), + clipped: Default::default(), + old_swapchain: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> SwapchainCreateInfoKHR<'a> { + pub fn flags(mut self, flags: crate::vk::SwapchainCreateFlagsKHR) -> Self { + self.flags = flags; + self + } + pub fn surface(mut self, surface: crate::vk::SurfaceKHR) -> Self { + self.surface = surface; + self + } + pub fn min_image_count(mut self, min_image_count: u32) -> Self { + self.min_image_count = min_image_count; + self + } + pub fn image_format(mut self, image_format: crate::vk::Format) -> Self { + self.image_format = image_format; + self + } + pub fn image_color_space( + mut self, + image_color_space: crate::vk::ColorSpaceKHR, + ) -> Self { + self.image_color_space = image_color_space; + self + } + pub fn image_extent(mut self, image_extent: crate::vk::Extent2D) -> Self { + self.image_extent = image_extent; + self + } + pub fn image_array_layers(mut self, image_array_layers: u32) -> Self { + self.image_array_layers = image_array_layers; + self + } + pub fn image_usage(mut self, image_usage: crate::vk::ImageUsageFlags) -> Self { + self.image_usage = image_usage; + self + } + pub fn image_sharing_mode( + mut self, + image_sharing_mode: crate::vk::SharingMode, + ) -> Self { + self.image_sharing_mode = image_sharing_mode; + self + } + pub fn queue_family_index_count( + mut self, + queue_family_index_count: u32, + ) -> Self { + self.queue_family_index_count = queue_family_index_count; + self + } + pub fn p_queue_family_indices( + mut self, + p_queue_family_indices: &'a [u32], + ) -> Self { + self.queue_family_index_count = p_queue_family_indices.len() as _; + self.p_queue_family_indices = p_queue_family_indices.as_ptr(); + self + } + pub fn pre_transform( + mut self, + pre_transform: crate::vk::SurfaceTransformFlagBitsKHR, + ) -> Self { + self.pre_transform = pre_transform; + self + } + pub fn composite_alpha( + mut self, + composite_alpha: crate::vk::CompositeAlphaFlagBitsKHR, + ) -> Self { + self.composite_alpha = composite_alpha; + self + } + pub fn present_mode(mut self, present_mode: crate::vk::PresentModeKHR) -> Self { + self.present_mode = present_mode; + self + } + pub fn clipped(mut self, clipped: bool) -> Self { + self.clipped = clipped.into(); + self + } + pub fn old_swapchain(mut self, old_swapchain: crate::vk::SwapchainKHR) -> Self { + self.old_swapchain = old_swapchain; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PresentInfoKHR<'a> { @@ -222,6 +335,60 @@ pub(crate) mod reexport { pub p_results: *mut crate::vk::Result, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for PresentInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PRESENT_INFO_KHR; + } + impl<'a> Default for PresentInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + wait_semaphore_count: Default::default(), + p_wait_semaphores: Default::default(), + swapchain_count: Default::default(), + p_swapchains: Default::default(), + p_image_indices: Default::default(), + p_results: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PresentInfoKHR<'a> { + pub fn wait_semaphore_count(mut self, wait_semaphore_count: u32) -> Self { + self.wait_semaphore_count = wait_semaphore_count; + self + } + pub fn p_wait_semaphores( + mut self, + p_wait_semaphores: &'a [crate::vk::Semaphore], + ) -> Self { + self.wait_semaphore_count = p_wait_semaphores.len() as _; + self.p_wait_semaphores = p_wait_semaphores.as_ptr(); + self + } + pub fn swapchain_count(mut self, swapchain_count: u32) -> Self { + self.swapchain_count = swapchain_count; + self + } + pub fn p_swapchains( + mut self, + p_swapchains: &'a [crate::vk::SwapchainKHR], + ) -> Self { + self.swapchain_count = p_swapchains.len() as _; + self.p_swapchains = p_swapchains.as_ptr(); + self + } + pub fn p_image_indices(mut self, p_image_indices: &'a [u32]) -> Self { + self.swapchain_count = p_image_indices.len() as _; + self.p_image_indices = p_image_indices.as_ptr(); + self + } + pub fn p_results(mut self, p_results: &'a mut [crate::vk::Result]) -> Self { + self.swapchain_count = p_results.len() as _; + self.p_results = p_results.as_mut_ptr(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct DeviceGroupPresentCapabilitiesKHR<'a> { @@ -231,6 +398,37 @@ pub(crate) mod reexport { pub modes: crate::vk::DeviceGroupPresentModeFlagsKHR, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for DeviceGroupPresentCapabilitiesKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::DEVICE_GROUP_PRESENT_CAPABILITIES_KHR; + } + impl<'a> Default for DeviceGroupPresentCapabilitiesKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + present_mask: unsafe { core::mem::zeroed() }, + modes: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> DeviceGroupPresentCapabilitiesKHR<'a> { + pub fn present_mask( + mut self, + present_mask: [u32; crate::vk::MAX_DEVICE_GROUP_SIZE as _], + ) -> Self { + self.present_mask = present_mask; + self + } + pub fn modes( + mut self, + modes: crate::vk::DeviceGroupPresentModeFlagsKHR, + ) -> Self { + self.modes = modes; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct ImageSwapchainCreateInfoKHR<'a> { @@ -239,6 +437,27 @@ pub(crate) mod reexport { pub swapchain: crate::vk::SwapchainKHR, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for ImageSwapchainCreateInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::IMAGE_SWAPCHAIN_CREATE_INFO_KHR; + } + unsafe impl<'a> crate::Extends> + for ImageSwapchainCreateInfoKHR<'a> {} + impl<'a> Default for ImageSwapchainCreateInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + swapchain: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> ImageSwapchainCreateInfoKHR<'a> { + pub fn swapchain(mut self, swapchain: crate::vk::SwapchainKHR) -> Self { + self.swapchain = swapchain; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct BindImageMemorySwapchainInfoKHR<'a> { @@ -248,6 +467,32 @@ pub(crate) mod reexport { pub image_index: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for BindImageMemorySwapchainInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR; + } + unsafe impl<'a> crate::Extends> + for BindImageMemorySwapchainInfoKHR<'a> {} + impl<'a> Default for BindImageMemorySwapchainInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + swapchain: Default::default(), + image_index: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> BindImageMemorySwapchainInfoKHR<'a> { + pub fn swapchain(mut self, swapchain: crate::vk::SwapchainKHR) -> Self { + self.swapchain = swapchain; + self + } + pub fn image_index(mut self, image_index: u32) -> Self { + self.image_index = image_index; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct AcquireNextImageInfoKHR<'a> { @@ -260,6 +505,45 @@ pub(crate) mod reexport { pub device_mask: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for AcquireNextImageInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::ACQUIRE_NEXT_IMAGE_INFO_KHR; + } + impl<'a> Default for AcquireNextImageInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + swapchain: Default::default(), + timeout: Default::default(), + semaphore: Default::default(), + fence: Default::default(), + device_mask: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> AcquireNextImageInfoKHR<'a> { + pub fn swapchain(mut self, swapchain: crate::vk::SwapchainKHR) -> Self { + self.swapchain = swapchain; + self + } + pub fn timeout(mut self, timeout: u64) -> Self { + self.timeout = timeout; + self + } + pub fn semaphore(mut self, semaphore: crate::vk::Semaphore) -> Self { + self.semaphore = semaphore; + self + } + pub fn fence(mut self, fence: crate::vk::Fence) -> Self { + self.fence = fence; + self + } + pub fn device_mask(mut self, device_mask: u32) -> Self { + self.device_mask = device_mask; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct DeviceGroupPresentInfoKHR<'a> { @@ -270,6 +554,41 @@ pub(crate) mod reexport { pub mode: crate::vk::DeviceGroupPresentModeFlagBitsKHR, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for DeviceGroupPresentInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::DEVICE_GROUP_PRESENT_INFO_KHR; + } + unsafe impl<'a> crate::Extends> + for DeviceGroupPresentInfoKHR<'a> {} + impl<'a> Default for DeviceGroupPresentInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + swapchain_count: Default::default(), + p_device_masks: Default::default(), + mode: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> DeviceGroupPresentInfoKHR<'a> { + pub fn swapchain_count(mut self, swapchain_count: u32) -> Self { + self.swapchain_count = swapchain_count; + self + } + pub fn p_device_masks(mut self, p_device_masks: &'a [u32]) -> Self { + self.swapchain_count = p_device_masks.len() as _; + self.p_device_masks = p_device_masks.as_ptr(); + self + } + pub fn mode( + mut self, + mode: crate::vk::DeviceGroupPresentModeFlagBitsKHR, + ) -> Self { + self.mode = mode; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct DeviceGroupSwapchainCreateInfoKHR<'a> { @@ -278,6 +597,31 @@ pub(crate) mod reexport { pub modes: crate::vk::DeviceGroupPresentModeFlagsKHR, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for DeviceGroupSwapchainCreateInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR; + } + unsafe impl<'a> crate::Extends> + for DeviceGroupSwapchainCreateInfoKHR<'a> {} + impl<'a> Default for DeviceGroupSwapchainCreateInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + modes: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> DeviceGroupSwapchainCreateInfoKHR<'a> { + pub fn modes( + mut self, + modes: crate::vk::DeviceGroupPresentModeFlagsKHR, + ) -> Self { + self.modes = modes; + self + } + } ///Provided by [`khr::swapchain`](crate::khr::swapchain) impl crate::vk::ImageLayout { pub const PRESENT_SRC_KHR: Self = Self(1000001002); @@ -394,7 +738,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct SwapchainCreateFlagBitsKHR(pub(crate) u32); ///Provided by [`khr::swapchain`](crate::khr::swapchain) impl SwapchainCreateFlagBitsKHR { @@ -477,7 +821,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct DeviceGroupPresentModeFlagBitsKHR(pub(crate) u32); ///Provided by [`khr::swapchain`](crate::khr::swapchain) impl DeviceGroupPresentModeFlagBitsKHR { diff --git a/ash-rewrite/src/generated/khr/swapchain_maintenance1.rs b/ash-rewrite/src/generated/khr/swapchain_maintenance1.rs index 4a5406f5a..f5068bbf7 100644 --- a/ash-rewrite/src/generated/khr/swapchain_maintenance1.rs +++ b/ash-rewrite/src/generated/khr/swapchain_maintenance1.rs @@ -43,6 +43,30 @@ pub(crate) mod reexport { pub swapchain_maintenance1: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceSwapchainMaintenance1FeaturesKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_KHR; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceSwapchainMaintenance1FeaturesKHR<'a> {} + unsafe impl<'a> crate::Extends> + for PhysicalDeviceSwapchainMaintenance1FeaturesKHR<'a> {} + impl<'a> Default for PhysicalDeviceSwapchainMaintenance1FeaturesKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + swapchain_maintenance1: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceSwapchainMaintenance1FeaturesKHR<'a> { + pub fn swapchain_maintenance1(mut self, swapchain_maintenance1: bool) -> Self { + self.swapchain_maintenance1 = swapchain_maintenance1.into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct SwapchainPresentFenceInfoKHR<'a> { @@ -52,6 +76,33 @@ pub(crate) mod reexport { pub p_fences: *const crate::vk::Fence, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for SwapchainPresentFenceInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::SWAPCHAIN_PRESENT_FENCE_INFO_KHR; + } + unsafe impl<'a> crate::Extends> + for SwapchainPresentFenceInfoKHR<'a> {} + impl<'a> Default for SwapchainPresentFenceInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + swapchain_count: Default::default(), + p_fences: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> SwapchainPresentFenceInfoKHR<'a> { + pub fn swapchain_count(mut self, swapchain_count: u32) -> Self { + self.swapchain_count = swapchain_count; + self + } + pub fn p_fences(mut self, p_fences: &'a [crate::vk::Fence]) -> Self { + self.swapchain_count = p_fences.len() as _; + self.p_fences = p_fences.as_ptr(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct SwapchainPresentModesCreateInfoKHR<'a> { @@ -61,6 +112,37 @@ pub(crate) mod reexport { pub p_present_modes: *const crate::vk::PresentModeKHR, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for SwapchainPresentModesCreateInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::SWAPCHAIN_PRESENT_MODES_CREATE_INFO_KHR; + } + unsafe impl<'a> crate::Extends> + for SwapchainPresentModesCreateInfoKHR<'a> {} + impl<'a> Default for SwapchainPresentModesCreateInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + present_mode_count: Default::default(), + p_present_modes: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> SwapchainPresentModesCreateInfoKHR<'a> { + pub fn present_mode_count(mut self, present_mode_count: u32) -> Self { + self.present_mode_count = present_mode_count; + self + } + pub fn p_present_modes( + mut self, + p_present_modes: &'a [crate::vk::PresentModeKHR], + ) -> Self { + self.present_mode_count = p_present_modes.len() as _; + self.p_present_modes = p_present_modes.as_ptr(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct SwapchainPresentModeInfoKHR<'a> { @@ -70,6 +152,36 @@ pub(crate) mod reexport { pub p_present_modes: *const crate::vk::PresentModeKHR, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for SwapchainPresentModeInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::SWAPCHAIN_PRESENT_MODE_INFO_KHR; + } + unsafe impl<'a> crate::Extends> + for SwapchainPresentModeInfoKHR<'a> {} + impl<'a> Default for SwapchainPresentModeInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + swapchain_count: Default::default(), + p_present_modes: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> SwapchainPresentModeInfoKHR<'a> { + pub fn swapchain_count(mut self, swapchain_count: u32) -> Self { + self.swapchain_count = swapchain_count; + self + } + pub fn p_present_modes( + mut self, + p_present_modes: &'a [crate::vk::PresentModeKHR], + ) -> Self { + self.swapchain_count = p_present_modes.len() as _; + self.p_present_modes = p_present_modes.as_ptr(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct SwapchainPresentScalingCreateInfoKHR<'a> { @@ -80,6 +192,47 @@ pub(crate) mod reexport { pub present_gravity_y: crate::vk::PresentGravityFlagsKHR, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for SwapchainPresentScalingCreateInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_KHR; + } + unsafe impl<'a> crate::Extends> + for SwapchainPresentScalingCreateInfoKHR<'a> {} + impl<'a> Default for SwapchainPresentScalingCreateInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + scaling_behavior: Default::default(), + present_gravity_x: Default::default(), + present_gravity_y: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> SwapchainPresentScalingCreateInfoKHR<'a> { + pub fn scaling_behavior( + mut self, + scaling_behavior: crate::vk::PresentScalingFlagsKHR, + ) -> Self { + self.scaling_behavior = scaling_behavior; + self + } + pub fn present_gravity_x( + mut self, + present_gravity_x: crate::vk::PresentGravityFlagsKHR, + ) -> Self { + self.present_gravity_x = present_gravity_x; + self + } + pub fn present_gravity_y( + mut self, + present_gravity_y: crate::vk::PresentGravityFlagsKHR, + ) -> Self { + self.present_gravity_y = present_gravity_y; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct ReleaseSwapchainImagesInfoKHR<'a> { @@ -90,6 +243,36 @@ pub(crate) mod reexport { pub p_image_indices: *const u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for ReleaseSwapchainImagesInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::RELEASE_SWAPCHAIN_IMAGES_INFO_KHR; + } + impl<'a> Default for ReleaseSwapchainImagesInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + swapchain: Default::default(), + image_index_count: Default::default(), + p_image_indices: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> ReleaseSwapchainImagesInfoKHR<'a> { + pub fn swapchain(mut self, swapchain: crate::vk::SwapchainKHR) -> Self { + self.swapchain = swapchain; + self + } + pub fn image_index_count(mut self, image_index_count: u32) -> Self { + self.image_index_count = image_index_count; + self + } + pub fn p_image_indices(mut self, p_image_indices: &'a [u32]) -> Self { + self.image_index_count = p_image_indices.len() as _; + self.p_image_indices = p_image_indices.as_ptr(); + self + } + } ///Provided by [`khr::swapchain_maintenance1`](crate::khr::swapchain_maintenance1) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_KHR: Self = Self( diff --git a/ash-rewrite/src/generated/khr/unified_image_layouts.rs b/ash-rewrite/src/generated/khr/unified_image_layouts.rs index fe150e06c..c899ff761 100644 --- a/ash-rewrite/src/generated/khr/unified_image_layouts.rs +++ b/ash-rewrite/src/generated/khr/unified_image_layouts.rs @@ -10,6 +10,38 @@ pub struct PhysicalDeviceUnifiedImageLayoutsFeaturesKHR<'a> { pub unified_image_layouts_video: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceUnifiedImageLayoutsFeaturesKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_UNIFIED_IMAGE_LAYOUTS_FEATURES_KHR; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceUnifiedImageLayoutsFeaturesKHR<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceUnifiedImageLayoutsFeaturesKHR<'a> {} +impl<'a> Default for PhysicalDeviceUnifiedImageLayoutsFeaturesKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + unified_image_layouts: Default::default(), + unified_image_layouts_video: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceUnifiedImageLayoutsFeaturesKHR<'a> { + pub fn unified_image_layouts(mut self, unified_image_layouts: bool) -> Self { + self.unified_image_layouts = unified_image_layouts.into(); + self + } + pub fn unified_image_layouts_video( + mut self, + unified_image_layouts_video: bool, + ) -> Self { + self.unified_image_layouts_video = unified_image_layouts_video.into(); + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct AttachmentFeedbackLoopInfoEXT<'a> { @@ -18,6 +50,27 @@ pub struct AttachmentFeedbackLoopInfoEXT<'a> { pub feedback_loop_enable: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> for AttachmentFeedbackLoopInfoEXT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::ATTACHMENT_FEEDBACK_LOOP_INFO_EXT; +} +unsafe impl<'a> crate::Extends> +for AttachmentFeedbackLoopInfoEXT<'a> {} +impl<'a> Default for AttachmentFeedbackLoopInfoEXT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + feedback_loop_enable: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> AttachmentFeedbackLoopInfoEXT<'a> { + pub fn feedback_loop_enable(mut self, feedback_loop_enable: bool) -> Self { + self.feedback_loop_enable = feedback_loop_enable.into(); + self + } +} ///Provided by [`khr::unified_image_layouts`](crate::khr::unified_image_layouts) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_UNIFIED_IMAGE_LAYOUTS_FEATURES_KHR: Self = Self( diff --git a/ash-rewrite/src/generated/khr/video_decode_av1.rs b/ash-rewrite/src/generated/khr/video_decode_av1.rs index f0b1f6307..813a270e5 100644 --- a/ash-rewrite/src/generated/khr/video_decode_av1.rs +++ b/ash-rewrite/src/generated/khr/video_decode_av1.rs @@ -10,6 +10,34 @@ pub struct VideoDecodeAV1ProfileInfoKHR<'a> { pub film_grain_support: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> for VideoDecodeAV1ProfileInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::VIDEO_DECODE_AV1_PROFILE_INFO_KHR; +} +unsafe impl<'a> crate::Extends> +for VideoDecodeAV1ProfileInfoKHR<'a> {} +unsafe impl<'a> crate::Extends> +for VideoDecodeAV1ProfileInfoKHR<'a> {} +impl<'a> Default for VideoDecodeAV1ProfileInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + std_profile: Default::default(), + film_grain_support: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> VideoDecodeAV1ProfileInfoKHR<'a> { + pub fn std_profile(mut self, std_profile: crate::vk::AV1Profile) -> Self { + self.std_profile = std_profile; + self + } + pub fn film_grain_support(mut self, film_grain_support: bool) -> Self { + self.film_grain_support = film_grain_support.into(); + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct VideoDecodeAV1CapabilitiesKHR<'a> { @@ -18,6 +46,27 @@ pub struct VideoDecodeAV1CapabilitiesKHR<'a> { pub max_level: crate::vk::AV1Level, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> for VideoDecodeAV1CapabilitiesKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::VIDEO_DECODE_AV1_CAPABILITIES_KHR; +} +unsafe impl<'a> crate::Extends> +for VideoDecodeAV1CapabilitiesKHR<'a> {} +impl<'a> Default for VideoDecodeAV1CapabilitiesKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + max_level: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> VideoDecodeAV1CapabilitiesKHR<'a> { + pub fn max_level(mut self, max_level: crate::vk::AV1Level) -> Self { + self.max_level = max_level; + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct VideoDecodeAV1SessionParametersCreateInfoKHR<'a> { @@ -26,6 +75,31 @@ pub struct VideoDecodeAV1SessionParametersCreateInfoKHR<'a> { pub p_std_sequence_header: *const crate::vk::AV1SequenceHeader<'a>, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for VideoDecodeAV1SessionParametersCreateInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::VIDEO_DECODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR; +} +unsafe impl<'a> crate::Extends> +for VideoDecodeAV1SessionParametersCreateInfoKHR<'a> {} +impl<'a> Default for VideoDecodeAV1SessionParametersCreateInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + p_std_sequence_header: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> VideoDecodeAV1SessionParametersCreateInfoKHR<'a> { + pub fn p_std_sequence_header( + mut self, + p_std_sequence_header: &'a crate::vk::AV1SequenceHeader<'a>, + ) -> Self { + self.p_std_sequence_header = p_std_sequence_header; + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct VideoDecodeAV1PictureInfoKHR<'a> { @@ -40,6 +114,61 @@ pub struct VideoDecodeAV1PictureInfoKHR<'a> { pub p_tile_sizes: *const u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> for VideoDecodeAV1PictureInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::VIDEO_DECODE_AV1_PICTURE_INFO_KHR; +} +unsafe impl<'a> crate::Extends> +for VideoDecodeAV1PictureInfoKHR<'a> {} +impl<'a> Default for VideoDecodeAV1PictureInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + p_std_picture_info: Default::default(), + reference_name_slot_indices: unsafe { core::mem::zeroed() }, + frame_header_offset: Default::default(), + tile_count: Default::default(), + p_tile_offsets: Default::default(), + p_tile_sizes: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> VideoDecodeAV1PictureInfoKHR<'a> { + pub fn p_std_picture_info( + mut self, + p_std_picture_info: &'a crate::vk::DecodeAV1PictureInfo<'a>, + ) -> Self { + self.p_std_picture_info = p_std_picture_info; + self + } + pub fn reference_name_slot_indices( + mut self, + reference_name_slot_indices: [i32; crate::vk::MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR + as _], + ) -> Self { + self.reference_name_slot_indices = reference_name_slot_indices; + self + } + pub fn frame_header_offset(mut self, frame_header_offset: u32) -> Self { + self.frame_header_offset = frame_header_offset; + self + } + pub fn tile_count(mut self, tile_count: u32) -> Self { + self.tile_count = tile_count; + self + } + pub fn p_tile_offsets(mut self, p_tile_offsets: &'a [u32]) -> Self { + self.tile_count = p_tile_offsets.len() as _; + self.p_tile_offsets = p_tile_offsets.as_ptr(); + self + } + pub fn p_tile_sizes(mut self, p_tile_sizes: &'a [u32]) -> Self { + self.tile_count = p_tile_sizes.len() as _; + self.p_tile_sizes = p_tile_sizes.as_ptr(); + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct VideoDecodeAV1DpbSlotInfoKHR<'a> { @@ -48,6 +177,30 @@ pub struct VideoDecodeAV1DpbSlotInfoKHR<'a> { pub p_std_reference_info: *const crate::vk::DecodeAV1ReferenceInfo, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> for VideoDecodeAV1DpbSlotInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::VIDEO_DECODE_AV1_DPB_SLOT_INFO_KHR; +} +unsafe impl<'a> crate::Extends> +for VideoDecodeAV1DpbSlotInfoKHR<'a> {} +impl<'a> Default for VideoDecodeAV1DpbSlotInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + p_std_reference_info: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> VideoDecodeAV1DpbSlotInfoKHR<'a> { + pub fn p_std_reference_info( + mut self, + p_std_reference_info: &'a crate::vk::DecodeAV1ReferenceInfo, + ) -> Self { + self.p_std_reference_info = p_std_reference_info; + self + } +} ///Provided by [`khr::video_decode_av1`](crate::khr::video_decode_av1) impl crate::vk::StructureType { pub const VIDEO_DECODE_AV1_CAPABILITIES_KHR: Self = Self(1000512000); diff --git a/ash-rewrite/src/generated/khr/video_decode_h264.rs b/ash-rewrite/src/generated/khr/video_decode_h264.rs index 9242859d0..13ddbd60c 100644 --- a/ash-rewrite/src/generated/khr/video_decode_h264.rs +++ b/ash-rewrite/src/generated/khr/video_decode_h264.rs @@ -10,6 +10,40 @@ pub struct VideoDecodeH264ProfileInfoKHR<'a> { pub picture_layout: crate::vk::VideoDecodeH264PictureLayoutFlagBitsKHR, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> for VideoDecodeH264ProfileInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::VIDEO_DECODE_H264_PROFILE_INFO_KHR; +} +unsafe impl<'a> crate::Extends> +for VideoDecodeH264ProfileInfoKHR<'a> {} +unsafe impl<'a> crate::Extends> +for VideoDecodeH264ProfileInfoKHR<'a> {} +impl<'a> Default for VideoDecodeH264ProfileInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + std_profile_idc: Default::default(), + picture_layout: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> VideoDecodeH264ProfileInfoKHR<'a> { + pub fn std_profile_idc( + mut self, + std_profile_idc: crate::vk::H264ProfileIdc, + ) -> Self { + self.std_profile_idc = std_profile_idc; + self + } + pub fn picture_layout( + mut self, + picture_layout: crate::vk::VideoDecodeH264PictureLayoutFlagBitsKHR, + ) -> Self { + self.picture_layout = picture_layout; + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct VideoDecodeH264CapabilitiesKHR<'a> { @@ -19,6 +53,35 @@ pub struct VideoDecodeH264CapabilitiesKHR<'a> { pub field_offset_granularity: crate::vk::Offset2D, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> for VideoDecodeH264CapabilitiesKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::VIDEO_DECODE_H264_CAPABILITIES_KHR; +} +unsafe impl<'a> crate::Extends> +for VideoDecodeH264CapabilitiesKHR<'a> {} +impl<'a> Default for VideoDecodeH264CapabilitiesKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + max_level_idc: Default::default(), + field_offset_granularity: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> VideoDecodeH264CapabilitiesKHR<'a> { + pub fn max_level_idc(mut self, max_level_idc: crate::vk::H264LevelIdc) -> Self { + self.max_level_idc = max_level_idc; + self + } + pub fn field_offset_granularity( + mut self, + field_offset_granularity: crate::vk::Offset2D, + ) -> Self { + self.field_offset_granularity = field_offset_granularity; + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct VideoDecodeH264SessionParametersAddInfoKHR<'a> { @@ -30,6 +93,51 @@ pub struct VideoDecodeH264SessionParametersAddInfoKHR<'a> { pub p_std_pp_ss: *const crate::vk::H264PictureParameterSet<'a>, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for VideoDecodeH264SessionParametersAddInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR; +} +unsafe impl<'a> crate::Extends> +for VideoDecodeH264SessionParametersAddInfoKHR<'a> {} +impl<'a> Default for VideoDecodeH264SessionParametersAddInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + std_sps_count: Default::default(), + p_std_sp_ss: Default::default(), + std_pps_count: Default::default(), + p_std_pp_ss: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> VideoDecodeH264SessionParametersAddInfoKHR<'a> { + pub fn std_sps_count(mut self, std_sps_count: u32) -> Self { + self.std_sps_count = std_sps_count; + self + } + pub fn p_std_sp_ss( + mut self, + p_std_sp_ss: &'a [crate::vk::H264SequenceParameterSet<'a>], + ) -> Self { + self.std_sps_count = p_std_sp_ss.len() as _; + self.p_std_sp_ss = p_std_sp_ss.as_ptr(); + self + } + pub fn std_pps_count(mut self, std_pps_count: u32) -> Self { + self.std_pps_count = std_pps_count; + self + } + pub fn p_std_pp_ss( + mut self, + p_std_pp_ss: &'a [crate::vk::H264PictureParameterSet<'a>], + ) -> Self { + self.std_pps_count = p_std_pp_ss.len() as _; + self.p_std_pp_ss = p_std_pp_ss.as_ptr(); + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct VideoDecodeH264SessionParametersCreateInfoKHR<'a> { @@ -42,6 +150,43 @@ pub struct VideoDecodeH264SessionParametersCreateInfoKHR<'a> { >, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for VideoDecodeH264SessionParametersCreateInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR; +} +unsafe impl<'a> crate::Extends> +for VideoDecodeH264SessionParametersCreateInfoKHR<'a> {} +impl<'a> Default for VideoDecodeH264SessionParametersCreateInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + max_std_sps_count: Default::default(), + max_std_pps_count: Default::default(), + p_parameters_add_info: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> VideoDecodeH264SessionParametersCreateInfoKHR<'a> { + pub fn max_std_sps_count(mut self, max_std_sps_count: u32) -> Self { + self.max_std_sps_count = max_std_sps_count; + self + } + pub fn max_std_pps_count(mut self, max_std_pps_count: u32) -> Self { + self.max_std_pps_count = max_std_pps_count; + self + } + pub fn p_parameters_add_info( + mut self, + p_parameters_add_info: &'a crate::vk::VideoDecodeH264SessionParametersAddInfoKHR< + 'a, + >, + ) -> Self { + self.p_parameters_add_info = p_parameters_add_info; + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct VideoDecodeH264PictureInfoKHR<'a> { @@ -52,6 +197,41 @@ pub struct VideoDecodeH264PictureInfoKHR<'a> { pub p_slice_offsets: *const u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> for VideoDecodeH264PictureInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::VIDEO_DECODE_H264_PICTURE_INFO_KHR; +} +unsafe impl<'a> crate::Extends> +for VideoDecodeH264PictureInfoKHR<'a> {} +impl<'a> Default for VideoDecodeH264PictureInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + p_std_picture_info: Default::default(), + slice_count: Default::default(), + p_slice_offsets: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> VideoDecodeH264PictureInfoKHR<'a> { + pub fn p_std_picture_info( + mut self, + p_std_picture_info: &'a crate::vk::DecodeH264PictureInfo, + ) -> Self { + self.p_std_picture_info = p_std_picture_info; + self + } + pub fn slice_count(mut self, slice_count: u32) -> Self { + self.slice_count = slice_count; + self + } + pub fn p_slice_offsets(mut self, p_slice_offsets: &'a [u32]) -> Self { + self.slice_count = p_slice_offsets.len() as _; + self.p_slice_offsets = p_slice_offsets.as_ptr(); + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct VideoDecodeH264DpbSlotInfoKHR<'a> { @@ -60,6 +240,30 @@ pub struct VideoDecodeH264DpbSlotInfoKHR<'a> { pub p_std_reference_info: *const crate::vk::DecodeH264ReferenceInfo, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> for VideoDecodeH264DpbSlotInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::VIDEO_DECODE_H264_DPB_SLOT_INFO_KHR; +} +unsafe impl<'a> crate::Extends> +for VideoDecodeH264DpbSlotInfoKHR<'a> {} +impl<'a> Default for VideoDecodeH264DpbSlotInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + p_std_reference_info: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> VideoDecodeH264DpbSlotInfoKHR<'a> { + pub fn p_std_reference_info( + mut self, + p_std_reference_info: &'a crate::vk::DecodeH264ReferenceInfo, + ) -> Self { + self.p_std_reference_info = p_std_reference_info; + self + } +} ///Provided by [`khr::video_decode_h264`](crate::khr::video_decode_h264) impl crate::vk::StructureType { pub const VIDEO_DECODE_H264_CAPABILITIES_KHR: Self = Self(1000040000); @@ -152,7 +356,7 @@ impl core::ops::Not for VideoDecodeH264PictureLayoutFlagsKHR { } } #[repr(transparent)] -#[derive(Clone, Copy)] +#[derive(Clone, Copy, Default)] pub struct VideoDecodeH264PictureLayoutFlagBitsKHR(pub(crate) u32); ///Provided by [`khr::video_decode_h264`](crate::khr::video_decode_h264) impl VideoDecodeH264PictureLayoutFlagBitsKHR { diff --git a/ash-rewrite/src/generated/khr/video_decode_h265.rs b/ash-rewrite/src/generated/khr/video_decode_h265.rs index b7f5ca3c5..e71b502a0 100644 --- a/ash-rewrite/src/generated/khr/video_decode_h265.rs +++ b/ash-rewrite/src/generated/khr/video_decode_h265.rs @@ -9,6 +9,32 @@ pub struct VideoDecodeH265ProfileInfoKHR<'a> { pub std_profile_idc: crate::vk::H265ProfileIdc, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> for VideoDecodeH265ProfileInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::VIDEO_DECODE_H265_PROFILE_INFO_KHR; +} +unsafe impl<'a> crate::Extends> +for VideoDecodeH265ProfileInfoKHR<'a> {} +unsafe impl<'a> crate::Extends> +for VideoDecodeH265ProfileInfoKHR<'a> {} +impl<'a> Default for VideoDecodeH265ProfileInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + std_profile_idc: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> VideoDecodeH265ProfileInfoKHR<'a> { + pub fn std_profile_idc( + mut self, + std_profile_idc: crate::vk::H265ProfileIdc, + ) -> Self { + self.std_profile_idc = std_profile_idc; + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct VideoDecodeH265CapabilitiesKHR<'a> { @@ -17,6 +43,27 @@ pub struct VideoDecodeH265CapabilitiesKHR<'a> { pub max_level_idc: crate::vk::H265LevelIdc, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> for VideoDecodeH265CapabilitiesKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::VIDEO_DECODE_H265_CAPABILITIES_KHR; +} +unsafe impl<'a> crate::Extends> +for VideoDecodeH265CapabilitiesKHR<'a> {} +impl<'a> Default for VideoDecodeH265CapabilitiesKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + max_level_idc: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> VideoDecodeH265CapabilitiesKHR<'a> { + pub fn max_level_idc(mut self, max_level_idc: crate::vk::H265LevelIdc) -> Self { + self.max_level_idc = max_level_idc; + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct VideoDecodeH265SessionParametersAddInfoKHR<'a> { @@ -30,6 +77,65 @@ pub struct VideoDecodeH265SessionParametersAddInfoKHR<'a> { pub p_std_pp_ss: *const crate::vk::H265PictureParameterSet<'a>, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for VideoDecodeH265SessionParametersAddInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR; +} +unsafe impl<'a> crate::Extends> +for VideoDecodeH265SessionParametersAddInfoKHR<'a> {} +impl<'a> Default for VideoDecodeH265SessionParametersAddInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + std_vps_count: Default::default(), + p_std_vp_ss: Default::default(), + std_sps_count: Default::default(), + p_std_sp_ss: Default::default(), + std_pps_count: Default::default(), + p_std_pp_ss: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> VideoDecodeH265SessionParametersAddInfoKHR<'a> { + pub fn std_vps_count(mut self, std_vps_count: u32) -> Self { + self.std_vps_count = std_vps_count; + self + } + pub fn p_std_vp_ss( + mut self, + p_std_vp_ss: &'a [crate::vk::H265VideoParameterSet<'a>], + ) -> Self { + self.std_vps_count = p_std_vp_ss.len() as _; + self.p_std_vp_ss = p_std_vp_ss.as_ptr(); + self + } + pub fn std_sps_count(mut self, std_sps_count: u32) -> Self { + self.std_sps_count = std_sps_count; + self + } + pub fn p_std_sp_ss( + mut self, + p_std_sp_ss: &'a [crate::vk::H265SequenceParameterSet<'a>], + ) -> Self { + self.std_sps_count = p_std_sp_ss.len() as _; + self.p_std_sp_ss = p_std_sp_ss.as_ptr(); + self + } + pub fn std_pps_count(mut self, std_pps_count: u32) -> Self { + self.std_pps_count = std_pps_count; + self + } + pub fn p_std_pp_ss( + mut self, + p_std_pp_ss: &'a [crate::vk::H265PictureParameterSet<'a>], + ) -> Self { + self.std_pps_count = p_std_pp_ss.len() as _; + self.p_std_pp_ss = p_std_pp_ss.as_ptr(); + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct VideoDecodeH265SessionParametersCreateInfoKHR<'a> { @@ -43,6 +149,48 @@ pub struct VideoDecodeH265SessionParametersCreateInfoKHR<'a> { >, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for VideoDecodeH265SessionParametersCreateInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR; +} +unsafe impl<'a> crate::Extends> +for VideoDecodeH265SessionParametersCreateInfoKHR<'a> {} +impl<'a> Default for VideoDecodeH265SessionParametersCreateInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + max_std_vps_count: Default::default(), + max_std_sps_count: Default::default(), + max_std_pps_count: Default::default(), + p_parameters_add_info: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> VideoDecodeH265SessionParametersCreateInfoKHR<'a> { + pub fn max_std_vps_count(mut self, max_std_vps_count: u32) -> Self { + self.max_std_vps_count = max_std_vps_count; + self + } + pub fn max_std_sps_count(mut self, max_std_sps_count: u32) -> Self { + self.max_std_sps_count = max_std_sps_count; + self + } + pub fn max_std_pps_count(mut self, max_std_pps_count: u32) -> Self { + self.max_std_pps_count = max_std_pps_count; + self + } + pub fn p_parameters_add_info( + mut self, + p_parameters_add_info: &'a crate::vk::VideoDecodeH265SessionParametersAddInfoKHR< + 'a, + >, + ) -> Self { + self.p_parameters_add_info = p_parameters_add_info; + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct VideoDecodeH265PictureInfoKHR<'a> { @@ -53,6 +201,44 @@ pub struct VideoDecodeH265PictureInfoKHR<'a> { pub p_slice_segment_offsets: *const u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> for VideoDecodeH265PictureInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::VIDEO_DECODE_H265_PICTURE_INFO_KHR; +} +unsafe impl<'a> crate::Extends> +for VideoDecodeH265PictureInfoKHR<'a> {} +impl<'a> Default for VideoDecodeH265PictureInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + p_std_picture_info: Default::default(), + slice_segment_count: Default::default(), + p_slice_segment_offsets: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> VideoDecodeH265PictureInfoKHR<'a> { + pub fn p_std_picture_info( + mut self, + p_std_picture_info: &'a crate::vk::DecodeH265PictureInfo, + ) -> Self { + self.p_std_picture_info = p_std_picture_info; + self + } + pub fn slice_segment_count(mut self, slice_segment_count: u32) -> Self { + self.slice_segment_count = slice_segment_count; + self + } + pub fn p_slice_segment_offsets( + mut self, + p_slice_segment_offsets: &'a [u32], + ) -> Self { + self.slice_segment_count = p_slice_segment_offsets.len() as _; + self.p_slice_segment_offsets = p_slice_segment_offsets.as_ptr(); + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct VideoDecodeH265DpbSlotInfoKHR<'a> { @@ -61,6 +247,30 @@ pub struct VideoDecodeH265DpbSlotInfoKHR<'a> { pub p_std_reference_info: *const crate::vk::DecodeH265ReferenceInfo, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> for VideoDecodeH265DpbSlotInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::VIDEO_DECODE_H265_DPB_SLOT_INFO_KHR; +} +unsafe impl<'a> crate::Extends> +for VideoDecodeH265DpbSlotInfoKHR<'a> {} +impl<'a> Default for VideoDecodeH265DpbSlotInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + p_std_reference_info: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> VideoDecodeH265DpbSlotInfoKHR<'a> { + pub fn p_std_reference_info( + mut self, + p_std_reference_info: &'a crate::vk::DecodeH265ReferenceInfo, + ) -> Self { + self.p_std_reference_info = p_std_reference_info; + self + } +} ///Provided by [`khr::video_decode_h265`](crate::khr::video_decode_h265) impl crate::vk::StructureType { pub const VIDEO_DECODE_H265_CAPABILITIES_KHR: Self = Self(1000187000); diff --git a/ash-rewrite/src/generated/khr/video_decode_queue.rs b/ash-rewrite/src/generated/khr/video_decode_queue.rs index d50fdcf57..4f39924a9 100644 --- a/ash-rewrite/src/generated/khr/video_decode_queue.rs +++ b/ash-rewrite/src/generated/khr/video_decode_queue.rs @@ -43,6 +43,27 @@ pub(crate) mod reexport { pub flags: crate::vk::VideoDecodeCapabilityFlagsKHR, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for VideoDecodeCapabilitiesKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::VIDEO_DECODE_CAPABILITIES_KHR; + } + unsafe impl<'a> crate::Extends> + for VideoDecodeCapabilitiesKHR<'a> {} + impl<'a> Default for VideoDecodeCapabilitiesKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + flags: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> VideoDecodeCapabilitiesKHR<'a> { + pub fn flags(mut self, flags: crate::vk::VideoDecodeCapabilityFlagsKHR) -> Self { + self.flags = flags; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct VideoDecodeUsageInfoKHR<'a> { @@ -51,6 +72,32 @@ pub(crate) mod reexport { pub video_usage_hints: crate::vk::VideoDecodeUsageFlagsKHR, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for VideoDecodeUsageInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::VIDEO_DECODE_USAGE_INFO_KHR; + } + unsafe impl<'a> crate::Extends> + for VideoDecodeUsageInfoKHR<'a> {} + unsafe impl<'a> crate::Extends> + for VideoDecodeUsageInfoKHR<'a> {} + impl<'a> Default for VideoDecodeUsageInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + video_usage_hints: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> VideoDecodeUsageInfoKHR<'a> { + pub fn video_usage_hints( + mut self, + video_usage_hints: crate::vk::VideoDecodeUsageFlagsKHR, + ) -> Self { + self.video_usage_hints = video_usage_hints; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct VideoDecodeInfoKHR<'a> { @@ -66,6 +113,76 @@ pub(crate) mod reexport { pub p_reference_slots: *const crate::vk::VideoReferenceSlotInfoKHR<'a>, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for VideoDecodeInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::VIDEO_DECODE_INFO_KHR; + } + impl<'a> Default for VideoDecodeInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + flags: Default::default(), + src_buffer: Default::default(), + src_buffer_offset: Default::default(), + src_buffer_range: Default::default(), + dst_picture_resource: Default::default(), + p_setup_reference_slot: Default::default(), + reference_slot_count: Default::default(), + p_reference_slots: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> VideoDecodeInfoKHR<'a> { + pub fn flags(mut self, flags: crate::vk::VideoDecodeFlagsKHR) -> Self { + self.flags = flags; + self + } + pub fn src_buffer(mut self, src_buffer: crate::vk::Buffer) -> Self { + self.src_buffer = src_buffer; + self + } + pub fn src_buffer_offset( + mut self, + src_buffer_offset: crate::vk::DeviceSize, + ) -> Self { + self.src_buffer_offset = src_buffer_offset; + self + } + pub fn src_buffer_range( + mut self, + src_buffer_range: crate::vk::DeviceSize, + ) -> Self { + self.src_buffer_range = src_buffer_range; + self + } + pub fn dst_picture_resource( + mut self, + dst_picture_resource: crate::vk::VideoPictureResourceInfoKHR<'a>, + ) -> Self { + self.dst_picture_resource = dst_picture_resource; + self + } + pub fn p_setup_reference_slot( + mut self, + p_setup_reference_slot: &'a crate::vk::VideoReferenceSlotInfoKHR<'a>, + ) -> Self { + self.p_setup_reference_slot = p_setup_reference_slot; + self + } + pub fn reference_slot_count(mut self, reference_slot_count: u32) -> Self { + self.reference_slot_count = reference_slot_count; + self + } + pub fn p_reference_slots( + mut self, + p_reference_slots: &'a [crate::vk::VideoReferenceSlotInfoKHR<'a>], + ) -> Self { + self.reference_slot_count = p_reference_slots.len() as _; + self.p_reference_slots = p_reference_slots.as_ptr(); + self + } + } ///Provided by [`khr::video_decode_queue`](crate::khr::video_decode_queue) impl crate::vk::ImageLayout { pub const VIDEO_DECODE_DST_KHR: Self = Self(1000024000); @@ -188,7 +305,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct VideoDecodeUsageFlagBitsKHR(pub(crate) u32); ///Provided by [`khr::video_decode_queue`](crate::khr::video_decode_queue) impl VideoDecodeUsageFlagBitsKHR { @@ -271,7 +388,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct VideoDecodeCapabilityFlagBitsKHR(pub(crate) u32); ///Provided by [`khr::video_decode_queue`](crate::khr::video_decode_queue) impl VideoDecodeCapabilityFlagBitsKHR { diff --git a/ash-rewrite/src/generated/khr/video_decode_vp9.rs b/ash-rewrite/src/generated/khr/video_decode_vp9.rs index 7de3b6ed7..280a0d168 100644 --- a/ash-rewrite/src/generated/khr/video_decode_vp9.rs +++ b/ash-rewrite/src/generated/khr/video_decode_vp9.rs @@ -9,6 +9,30 @@ pub struct PhysicalDeviceVideoDecodeVP9FeaturesKHR<'a> { pub video_decode_vp9: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceVideoDecodeVP9FeaturesKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_VIDEO_DECODE_VP9_FEATURES_KHR; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceVideoDecodeVP9FeaturesKHR<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceVideoDecodeVP9FeaturesKHR<'a> {} +impl<'a> Default for PhysicalDeviceVideoDecodeVP9FeaturesKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + video_decode_vp9: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceVideoDecodeVP9FeaturesKHR<'a> { + pub fn video_decode_vp9(mut self, video_decode_vp9: bool) -> Self { + self.video_decode_vp9 = video_decode_vp9.into(); + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct VideoDecodeVP9ProfileInfoKHR<'a> { @@ -17,6 +41,29 @@ pub struct VideoDecodeVP9ProfileInfoKHR<'a> { pub std_profile: crate::vk::VP9Profile, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> for VideoDecodeVP9ProfileInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::VIDEO_DECODE_VP9_PROFILE_INFO_KHR; +} +unsafe impl<'a> crate::Extends> +for VideoDecodeVP9ProfileInfoKHR<'a> {} +unsafe impl<'a> crate::Extends> +for VideoDecodeVP9ProfileInfoKHR<'a> {} +impl<'a> Default for VideoDecodeVP9ProfileInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + std_profile: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> VideoDecodeVP9ProfileInfoKHR<'a> { + pub fn std_profile(mut self, std_profile: crate::vk::VP9Profile) -> Self { + self.std_profile = std_profile; + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct VideoDecodeVP9CapabilitiesKHR<'a> { @@ -25,6 +72,27 @@ pub struct VideoDecodeVP9CapabilitiesKHR<'a> { pub max_level: crate::vk::VP9Level, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> for VideoDecodeVP9CapabilitiesKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::VIDEO_DECODE_VP9_CAPABILITIES_KHR; +} +unsafe impl<'a> crate::Extends> +for VideoDecodeVP9CapabilitiesKHR<'a> {} +impl<'a> Default for VideoDecodeVP9CapabilitiesKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + max_level: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> VideoDecodeVP9CapabilitiesKHR<'a> { + pub fn max_level(mut self, max_level: crate::vk::VP9Level) -> Self { + self.max_level = max_level; + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct VideoDecodeVP9PictureInfoKHR<'a> { @@ -38,6 +106,57 @@ pub struct VideoDecodeVP9PictureInfoKHR<'a> { pub tiles_offset: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> for VideoDecodeVP9PictureInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::VIDEO_DECODE_VP9_PICTURE_INFO_KHR; +} +unsafe impl<'a> crate::Extends> +for VideoDecodeVP9PictureInfoKHR<'a> {} +impl<'a> Default for VideoDecodeVP9PictureInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + p_std_picture_info: Default::default(), + reference_name_slot_indices: unsafe { core::mem::zeroed() }, + uncompressed_header_offset: Default::default(), + compressed_header_offset: Default::default(), + tiles_offset: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> VideoDecodeVP9PictureInfoKHR<'a> { + pub fn p_std_picture_info( + mut self, + p_std_picture_info: &'a crate::vk::DecodeVP9PictureInfo<'a>, + ) -> Self { + self.p_std_picture_info = p_std_picture_info; + self + } + pub fn reference_name_slot_indices( + mut self, + reference_name_slot_indices: [i32; crate::vk::MAX_VIDEO_VP9_REFERENCES_PER_FRAME_KHR + as _], + ) -> Self { + self.reference_name_slot_indices = reference_name_slot_indices; + self + } + pub fn uncompressed_header_offset( + mut self, + uncompressed_header_offset: u32, + ) -> Self { + self.uncompressed_header_offset = uncompressed_header_offset; + self + } + pub fn compressed_header_offset(mut self, compressed_header_offset: u32) -> Self { + self.compressed_header_offset = compressed_header_offset; + self + } + pub fn tiles_offset(mut self, tiles_offset: u32) -> Self { + self.tiles_offset = tiles_offset; + self + } +} ///Provided by [`khr::video_decode_vp9`](crate::khr::video_decode_vp9) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_VIDEO_DECODE_VP9_FEATURES_KHR: Self = Self(1000514000); diff --git a/ash-rewrite/src/generated/khr/video_encode_av1.rs b/ash-rewrite/src/generated/khr/video_encode_av1.rs index 12e9ac474..f4ff64803 100644 --- a/ash-rewrite/src/generated/khr/video_encode_av1.rs +++ b/ash-rewrite/src/generated/khr/video_encode_av1.rs @@ -32,6 +32,184 @@ pub struct VideoEncodeAV1CapabilitiesKHR<'a> { pub std_syntax_flags: crate::vk::VideoEncodeAV1StdFlagsKHR, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> for VideoEncodeAV1CapabilitiesKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::VIDEO_ENCODE_AV1_CAPABILITIES_KHR; +} +unsafe impl<'a> crate::Extends> +for VideoEncodeAV1CapabilitiesKHR<'a> {} +impl<'a> Default for VideoEncodeAV1CapabilitiesKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + flags: Default::default(), + max_level: Default::default(), + coded_picture_alignment: Default::default(), + max_tiles: Default::default(), + min_tile_size: Default::default(), + max_tile_size: Default::default(), + superblock_sizes: Default::default(), + max_single_reference_count: Default::default(), + single_reference_name_mask: Default::default(), + max_unidirectional_compound_reference_count: Default::default(), + max_unidirectional_compound_group1_reference_count: Default::default(), + unidirectional_compound_reference_name_mask: Default::default(), + max_bidirectional_compound_reference_count: Default::default(), + max_bidirectional_compound_group1_reference_count: Default::default(), + max_bidirectional_compound_group2_reference_count: Default::default(), + bidirectional_compound_reference_name_mask: Default::default(), + max_temporal_layer_count: Default::default(), + max_spatial_layer_count: Default::default(), + max_operating_points: Default::default(), + min_q_index: Default::default(), + max_q_index: Default::default(), + prefers_gop_remaining_frames: Default::default(), + requires_gop_remaining_frames: Default::default(), + std_syntax_flags: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> VideoEncodeAV1CapabilitiesKHR<'a> { + pub fn flags(mut self, flags: crate::vk::VideoEncodeAV1CapabilityFlagsKHR) -> Self { + self.flags = flags; + self + } + pub fn max_level(mut self, max_level: crate::vk::AV1Level) -> Self { + self.max_level = max_level; + self + } + pub fn coded_picture_alignment( + mut self, + coded_picture_alignment: crate::vk::Extent2D, + ) -> Self { + self.coded_picture_alignment = coded_picture_alignment; + self + } + pub fn max_tiles(mut self, max_tiles: crate::vk::Extent2D) -> Self { + self.max_tiles = max_tiles; + self + } + pub fn min_tile_size(mut self, min_tile_size: crate::vk::Extent2D) -> Self { + self.min_tile_size = min_tile_size; + self + } + pub fn max_tile_size(mut self, max_tile_size: crate::vk::Extent2D) -> Self { + self.max_tile_size = max_tile_size; + self + } + pub fn superblock_sizes( + mut self, + superblock_sizes: crate::vk::VideoEncodeAV1SuperblockSizeFlagsKHR, + ) -> Self { + self.superblock_sizes = superblock_sizes; + self + } + pub fn max_single_reference_count( + mut self, + max_single_reference_count: u32, + ) -> Self { + self.max_single_reference_count = max_single_reference_count; + self + } + pub fn single_reference_name_mask( + mut self, + single_reference_name_mask: u32, + ) -> Self { + self.single_reference_name_mask = single_reference_name_mask; + self + } + pub fn max_unidirectional_compound_reference_count( + mut self, + max_unidirectional_compound_reference_count: u32, + ) -> Self { + self.max_unidirectional_compound_reference_count = max_unidirectional_compound_reference_count; + self + } + pub fn max_unidirectional_compound_group1_reference_count( + mut self, + max_unidirectional_compound_group1_reference_count: u32, + ) -> Self { + self.max_unidirectional_compound_group1_reference_count = max_unidirectional_compound_group1_reference_count; + self + } + pub fn unidirectional_compound_reference_name_mask( + mut self, + unidirectional_compound_reference_name_mask: u32, + ) -> Self { + self.unidirectional_compound_reference_name_mask = unidirectional_compound_reference_name_mask; + self + } + pub fn max_bidirectional_compound_reference_count( + mut self, + max_bidirectional_compound_reference_count: u32, + ) -> Self { + self.max_bidirectional_compound_reference_count = max_bidirectional_compound_reference_count; + self + } + pub fn max_bidirectional_compound_group1_reference_count( + mut self, + max_bidirectional_compound_group1_reference_count: u32, + ) -> Self { + self.max_bidirectional_compound_group1_reference_count = max_bidirectional_compound_group1_reference_count; + self + } + pub fn max_bidirectional_compound_group2_reference_count( + mut self, + max_bidirectional_compound_group2_reference_count: u32, + ) -> Self { + self.max_bidirectional_compound_group2_reference_count = max_bidirectional_compound_group2_reference_count; + self + } + pub fn bidirectional_compound_reference_name_mask( + mut self, + bidirectional_compound_reference_name_mask: u32, + ) -> Self { + self.bidirectional_compound_reference_name_mask = bidirectional_compound_reference_name_mask; + self + } + pub fn max_temporal_layer_count(mut self, max_temporal_layer_count: u32) -> Self { + self.max_temporal_layer_count = max_temporal_layer_count; + self + } + pub fn max_spatial_layer_count(mut self, max_spatial_layer_count: u32) -> Self { + self.max_spatial_layer_count = max_spatial_layer_count; + self + } + pub fn max_operating_points(mut self, max_operating_points: u32) -> Self { + self.max_operating_points = max_operating_points; + self + } + pub fn min_q_index(mut self, min_q_index: u32) -> Self { + self.min_q_index = min_q_index; + self + } + pub fn max_q_index(mut self, max_q_index: u32) -> Self { + self.max_q_index = max_q_index; + self + } + pub fn prefers_gop_remaining_frames( + mut self, + prefers_gop_remaining_frames: bool, + ) -> Self { + self.prefers_gop_remaining_frames = prefers_gop_remaining_frames.into(); + self + } + pub fn requires_gop_remaining_frames( + mut self, + requires_gop_remaining_frames: bool, + ) -> Self { + self.requires_gop_remaining_frames = requires_gop_remaining_frames.into(); + self + } + pub fn std_syntax_flags( + mut self, + std_syntax_flags: crate::vk::VideoEncodeAV1StdFlagsKHR, + ) -> Self { + self.std_syntax_flags = std_syntax_flags; + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct VideoEncodeAV1QualityLevelPropertiesKHR<'a> { @@ -54,6 +232,140 @@ pub struct VideoEncodeAV1QualityLevelPropertiesKHR<'a> { pub preferred_bidirectional_compound_reference_name_mask: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for VideoEncodeAV1QualityLevelPropertiesKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::VIDEO_ENCODE_AV1_QUALITY_LEVEL_PROPERTIES_KHR; +} +unsafe impl<'a> crate::Extends> +for VideoEncodeAV1QualityLevelPropertiesKHR<'a> {} +impl<'a> Default for VideoEncodeAV1QualityLevelPropertiesKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + preferred_rate_control_flags: Default::default(), + preferred_gop_frame_count: Default::default(), + preferred_key_frame_period: Default::default(), + preferred_consecutive_bipredictive_frame_count: Default::default(), + preferred_temporal_layer_count: Default::default(), + preferred_constant_q_index: Default::default(), + preferred_max_single_reference_count: Default::default(), + preferred_single_reference_name_mask: Default::default(), + preferred_max_unidirectional_compound_reference_count: Default::default(), + preferred_max_unidirectional_compound_group1_reference_count: Default::default(), + preferred_unidirectional_compound_reference_name_mask: Default::default(), + preferred_max_bidirectional_compound_reference_count: Default::default(), + preferred_max_bidirectional_compound_group1_reference_count: Default::default(), + preferred_max_bidirectional_compound_group2_reference_count: Default::default(), + preferred_bidirectional_compound_reference_name_mask: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> VideoEncodeAV1QualityLevelPropertiesKHR<'a> { + pub fn preferred_rate_control_flags( + mut self, + preferred_rate_control_flags: crate::vk::VideoEncodeAV1RateControlFlagsKHR, + ) -> Self { + self.preferred_rate_control_flags = preferred_rate_control_flags; + self + } + pub fn preferred_gop_frame_count(mut self, preferred_gop_frame_count: u32) -> Self { + self.preferred_gop_frame_count = preferred_gop_frame_count; + self + } + pub fn preferred_key_frame_period( + mut self, + preferred_key_frame_period: u32, + ) -> Self { + self.preferred_key_frame_period = preferred_key_frame_period; + self + } + pub fn preferred_consecutive_bipredictive_frame_count( + mut self, + preferred_consecutive_bipredictive_frame_count: u32, + ) -> Self { + self.preferred_consecutive_bipredictive_frame_count = preferred_consecutive_bipredictive_frame_count; + self + } + pub fn preferred_temporal_layer_count( + mut self, + preferred_temporal_layer_count: u32, + ) -> Self { + self.preferred_temporal_layer_count = preferred_temporal_layer_count; + self + } + pub fn preferred_constant_q_index( + mut self, + preferred_constant_q_index: crate::vk::VideoEncodeAV1QIndexKHR, + ) -> Self { + self.preferred_constant_q_index = preferred_constant_q_index; + self + } + pub fn preferred_max_single_reference_count( + mut self, + preferred_max_single_reference_count: u32, + ) -> Self { + self.preferred_max_single_reference_count = preferred_max_single_reference_count; + self + } + pub fn preferred_single_reference_name_mask( + mut self, + preferred_single_reference_name_mask: u32, + ) -> Self { + self.preferred_single_reference_name_mask = preferred_single_reference_name_mask; + self + } + pub fn preferred_max_unidirectional_compound_reference_count( + mut self, + preferred_max_unidirectional_compound_reference_count: u32, + ) -> Self { + self.preferred_max_unidirectional_compound_reference_count = preferred_max_unidirectional_compound_reference_count; + self + } + pub fn preferred_max_unidirectional_compound_group1_reference_count( + mut self, + preferred_max_unidirectional_compound_group1_reference_count: u32, + ) -> Self { + self.preferred_max_unidirectional_compound_group1_reference_count = preferred_max_unidirectional_compound_group1_reference_count; + self + } + pub fn preferred_unidirectional_compound_reference_name_mask( + mut self, + preferred_unidirectional_compound_reference_name_mask: u32, + ) -> Self { + self.preferred_unidirectional_compound_reference_name_mask = preferred_unidirectional_compound_reference_name_mask; + self + } + pub fn preferred_max_bidirectional_compound_reference_count( + mut self, + preferred_max_bidirectional_compound_reference_count: u32, + ) -> Self { + self.preferred_max_bidirectional_compound_reference_count = preferred_max_bidirectional_compound_reference_count; + self + } + pub fn preferred_max_bidirectional_compound_group1_reference_count( + mut self, + preferred_max_bidirectional_compound_group1_reference_count: u32, + ) -> Self { + self.preferred_max_bidirectional_compound_group1_reference_count = preferred_max_bidirectional_compound_group1_reference_count; + self + } + pub fn preferred_max_bidirectional_compound_group2_reference_count( + mut self, + preferred_max_bidirectional_compound_group2_reference_count: u32, + ) -> Self { + self.preferred_max_bidirectional_compound_group2_reference_count = preferred_max_bidirectional_compound_group2_reference_count; + self + } + pub fn preferred_bidirectional_compound_reference_name_mask( + mut self, + preferred_bidirectional_compound_reference_name_mask: u32, + ) -> Self { + self.preferred_bidirectional_compound_reference_name_mask = preferred_bidirectional_compound_reference_name_mask; + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceVideoEncodeAV1FeaturesKHR<'a> { @@ -62,6 +374,30 @@ pub struct PhysicalDeviceVideoEncodeAV1FeaturesKHR<'a> { pub video_encode_av1: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceVideoEncodeAV1FeaturesKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_VIDEO_ENCODE_AV1_FEATURES_KHR; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceVideoEncodeAV1FeaturesKHR<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceVideoEncodeAV1FeaturesKHR<'a> {} +impl<'a> Default for PhysicalDeviceVideoEncodeAV1FeaturesKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + video_encode_av1: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceVideoEncodeAV1FeaturesKHR<'a> { + pub fn video_encode_av1(mut self, video_encode_av1: bool) -> Self { + self.video_encode_av1 = video_encode_av1.into(); + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct VideoEncodeAV1SessionCreateInfoKHR<'a> { @@ -71,6 +407,32 @@ pub struct VideoEncodeAV1SessionCreateInfoKHR<'a> { pub max_level: crate::vk::AV1Level, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> for VideoEncodeAV1SessionCreateInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::VIDEO_ENCODE_AV1_SESSION_CREATE_INFO_KHR; +} +unsafe impl<'a> crate::Extends> +for VideoEncodeAV1SessionCreateInfoKHR<'a> {} +impl<'a> Default for VideoEncodeAV1SessionCreateInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + use_max_level: Default::default(), + max_level: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> VideoEncodeAV1SessionCreateInfoKHR<'a> { + pub fn use_max_level(mut self, use_max_level: bool) -> Self { + self.use_max_level = use_max_level.into(); + self + } + pub fn max_level(mut self, max_level: crate::vk::AV1Level) -> Self { + self.max_level = max_level; + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct VideoEncodeAV1SessionParametersCreateInfoKHR<'a> { @@ -82,6 +444,53 @@ pub struct VideoEncodeAV1SessionParametersCreateInfoKHR<'a> { pub p_std_operating_points: *const crate::vk::EncodeAV1OperatingPointInfo, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for VideoEncodeAV1SessionParametersCreateInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::VIDEO_ENCODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR; +} +unsafe impl<'a> crate::Extends> +for VideoEncodeAV1SessionParametersCreateInfoKHR<'a> {} +impl<'a> Default for VideoEncodeAV1SessionParametersCreateInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + p_std_sequence_header: Default::default(), + p_std_decoder_model_info: Default::default(), + std_operating_point_count: Default::default(), + p_std_operating_points: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> VideoEncodeAV1SessionParametersCreateInfoKHR<'a> { + pub fn p_std_sequence_header( + mut self, + p_std_sequence_header: &'a crate::vk::AV1SequenceHeader<'a>, + ) -> Self { + self.p_std_sequence_header = p_std_sequence_header; + self + } + pub fn p_std_decoder_model_info( + mut self, + p_std_decoder_model_info: &'a crate::vk::EncodeAV1DecoderModelInfo, + ) -> Self { + self.p_std_decoder_model_info = p_std_decoder_model_info; + self + } + pub fn std_operating_point_count(mut self, std_operating_point_count: u32) -> Self { + self.std_operating_point_count = std_operating_point_count; + self + } + pub fn p_std_operating_points( + mut self, + p_std_operating_points: &'a [crate::vk::EncodeAV1OperatingPointInfo], + ) -> Self { + self.std_operating_point_count = p_std_operating_points.len() as _; + self.p_std_operating_points = p_std_operating_points.as_ptr(); + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct VideoEncodeAV1DpbSlotInfoKHR<'a> { @@ -90,6 +499,30 @@ pub struct VideoEncodeAV1DpbSlotInfoKHR<'a> { pub p_std_reference_info: *const crate::vk::EncodeAV1ReferenceInfo<'a>, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> for VideoEncodeAV1DpbSlotInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::VIDEO_ENCODE_AV1_DPB_SLOT_INFO_KHR; +} +unsafe impl<'a> crate::Extends> +for VideoEncodeAV1DpbSlotInfoKHR<'a> {} +impl<'a> Default for VideoEncodeAV1DpbSlotInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + p_std_reference_info: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> VideoEncodeAV1DpbSlotInfoKHR<'a> { + pub fn p_std_reference_info( + mut self, + p_std_reference_info: &'a crate::vk::EncodeAV1ReferenceInfo<'a>, + ) -> Self { + self.p_std_reference_info = p_std_reference_info; + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct VideoEncodeAV1PictureInfoKHR<'a> { @@ -105,6 +538,76 @@ pub struct VideoEncodeAV1PictureInfoKHR<'a> { pub generate_obu_extension_header: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> for VideoEncodeAV1PictureInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::VIDEO_ENCODE_AV1_PICTURE_INFO_KHR; +} +unsafe impl<'a> crate::Extends> +for VideoEncodeAV1PictureInfoKHR<'a> {} +impl<'a> Default for VideoEncodeAV1PictureInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + prediction_mode: Default::default(), + rate_control_group: Default::default(), + constant_q_index: Default::default(), + p_std_picture_info: Default::default(), + reference_name_slot_indices: unsafe { core::mem::zeroed() }, + primary_reference_cdf_only: Default::default(), + generate_obu_extension_header: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> VideoEncodeAV1PictureInfoKHR<'a> { + pub fn prediction_mode( + mut self, + prediction_mode: crate::vk::VideoEncodeAV1PredictionModeKHR, + ) -> Self { + self.prediction_mode = prediction_mode; + self + } + pub fn rate_control_group( + mut self, + rate_control_group: crate::vk::VideoEncodeAV1RateControlGroupKHR, + ) -> Self { + self.rate_control_group = rate_control_group; + self + } + pub fn constant_q_index(mut self, constant_q_index: u32) -> Self { + self.constant_q_index = constant_q_index; + self + } + pub fn p_std_picture_info( + mut self, + p_std_picture_info: &'a crate::vk::EncodeAV1PictureInfo<'a>, + ) -> Self { + self.p_std_picture_info = p_std_picture_info; + self + } + pub fn reference_name_slot_indices( + mut self, + reference_name_slot_indices: [i32; crate::vk::MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR + as _], + ) -> Self { + self.reference_name_slot_indices = reference_name_slot_indices; + self + } + pub fn primary_reference_cdf_only( + mut self, + primary_reference_cdf_only: bool, + ) -> Self { + self.primary_reference_cdf_only = primary_reference_cdf_only.into(); + self + } + pub fn generate_obu_extension_header( + mut self, + generate_obu_extension_header: bool, + ) -> Self { + self.generate_obu_extension_header = generate_obu_extension_header.into(); + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct VideoEncodeAV1ProfileInfoKHR<'a> { @@ -113,6 +616,29 @@ pub struct VideoEncodeAV1ProfileInfoKHR<'a> { pub std_profile: crate::vk::AV1Profile, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> for VideoEncodeAV1ProfileInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::VIDEO_ENCODE_AV1_PROFILE_INFO_KHR; +} +unsafe impl<'a> crate::Extends> +for VideoEncodeAV1ProfileInfoKHR<'a> {} +unsafe impl<'a> crate::Extends> +for VideoEncodeAV1ProfileInfoKHR<'a> {} +impl<'a> Default for VideoEncodeAV1ProfileInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + std_profile: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> VideoEncodeAV1ProfileInfoKHR<'a> { + pub fn std_profile(mut self, std_profile: crate::vk::AV1Profile) -> Self { + self.std_profile = std_profile; + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct VideoEncodeAV1RateControlInfoKHR<'a> { @@ -125,20 +651,94 @@ pub struct VideoEncodeAV1RateControlInfoKHR<'a> { pub temporal_layer_count: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> for VideoEncodeAV1RateControlInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::VIDEO_ENCODE_AV1_RATE_CONTROL_INFO_KHR; +} +unsafe impl<'a> crate::Extends> +for VideoEncodeAV1RateControlInfoKHR<'a> {} +unsafe impl<'a> crate::Extends> +for VideoEncodeAV1RateControlInfoKHR<'a> {} +impl<'a> Default for VideoEncodeAV1RateControlInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + flags: Default::default(), + gop_frame_count: Default::default(), + key_frame_period: Default::default(), + consecutive_bipredictive_frame_count: Default::default(), + temporal_layer_count: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> VideoEncodeAV1RateControlInfoKHR<'a> { + pub fn flags(mut self, flags: crate::vk::VideoEncodeAV1RateControlFlagsKHR) -> Self { + self.flags = flags; + self + } + pub fn gop_frame_count(mut self, gop_frame_count: u32) -> Self { + self.gop_frame_count = gop_frame_count; + self + } + pub fn key_frame_period(mut self, key_frame_period: u32) -> Self { + self.key_frame_period = key_frame_period; + self + } + pub fn consecutive_bipredictive_frame_count( + mut self, + consecutive_bipredictive_frame_count: u32, + ) -> Self { + self.consecutive_bipredictive_frame_count = consecutive_bipredictive_frame_count; + self + } + pub fn temporal_layer_count(mut self, temporal_layer_count: u32) -> Self { + self.temporal_layer_count = temporal_layer_count; + self + } +} #[repr(C)] -#[derive(Clone, Copy)] +#[derive(Clone, Copy, Default)] pub struct VideoEncodeAV1QIndexKHR { pub intra_q_index: u32, pub predictive_q_index: u32, pub bipredictive_q_index: u32, } +impl VideoEncodeAV1QIndexKHR { + pub fn intra_q_index(mut self, intra_q_index: u32) -> Self { + self.intra_q_index = intra_q_index; + self + } + pub fn predictive_q_index(mut self, predictive_q_index: u32) -> Self { + self.predictive_q_index = predictive_q_index; + self + } + pub fn bipredictive_q_index(mut self, bipredictive_q_index: u32) -> Self { + self.bipredictive_q_index = bipredictive_q_index; + self + } +} #[repr(C)] -#[derive(Clone, Copy)] +#[derive(Clone, Copy, Default)] pub struct VideoEncodeAV1FrameSizeKHR { pub intra_frame_size: u32, pub predictive_frame_size: u32, pub bipredictive_frame_size: u32, } +impl VideoEncodeAV1FrameSizeKHR { + pub fn intra_frame_size(mut self, intra_frame_size: u32) -> Self { + self.intra_frame_size = intra_frame_size; + self + } + pub fn predictive_frame_size(mut self, predictive_frame_size: u32) -> Self { + self.predictive_frame_size = predictive_frame_size; + self + } + pub fn bipredictive_frame_size(mut self, bipredictive_frame_size: u32) -> Self { + self.bipredictive_frame_size = bipredictive_frame_size; + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct VideoEncodeAV1GopRemainingFrameInfoKHR<'a> { @@ -150,6 +750,46 @@ pub struct VideoEncodeAV1GopRemainingFrameInfoKHR<'a> { pub gop_remaining_bipredictive: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for VideoEncodeAV1GopRemainingFrameInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::VIDEO_ENCODE_AV1_GOP_REMAINING_FRAME_INFO_KHR; +} +unsafe impl<'a> crate::Extends> +for VideoEncodeAV1GopRemainingFrameInfoKHR<'a> {} +impl<'a> Default for VideoEncodeAV1GopRemainingFrameInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + use_gop_remaining_frames: Default::default(), + gop_remaining_intra: Default::default(), + gop_remaining_predictive: Default::default(), + gop_remaining_bipredictive: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> VideoEncodeAV1GopRemainingFrameInfoKHR<'a> { + pub fn use_gop_remaining_frames(mut self, use_gop_remaining_frames: bool) -> Self { + self.use_gop_remaining_frames = use_gop_remaining_frames.into(); + self + } + pub fn gop_remaining_intra(mut self, gop_remaining_intra: u32) -> Self { + self.gop_remaining_intra = gop_remaining_intra; + self + } + pub fn gop_remaining_predictive(mut self, gop_remaining_predictive: u32) -> Self { + self.gop_remaining_predictive = gop_remaining_predictive; + self + } + pub fn gop_remaining_bipredictive( + mut self, + gop_remaining_bipredictive: u32, + ) -> Self { + self.gop_remaining_bipredictive = gop_remaining_bipredictive; + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct VideoEncodeAV1RateControlLayerInfoKHR<'a> { @@ -163,6 +803,62 @@ pub struct VideoEncodeAV1RateControlLayerInfoKHR<'a> { pub max_frame_size: crate::vk::VideoEncodeAV1FrameSizeKHR, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for VideoEncodeAV1RateControlLayerInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::VIDEO_ENCODE_AV1_RATE_CONTROL_LAYER_INFO_KHR; +} +unsafe impl<'a> crate::Extends> +for VideoEncodeAV1RateControlLayerInfoKHR<'a> {} +impl<'a> Default for VideoEncodeAV1RateControlLayerInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + use_min_q_index: Default::default(), + min_q_index: Default::default(), + use_max_q_index: Default::default(), + max_q_index: Default::default(), + use_max_frame_size: Default::default(), + max_frame_size: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> VideoEncodeAV1RateControlLayerInfoKHR<'a> { + pub fn use_min_q_index(mut self, use_min_q_index: bool) -> Self { + self.use_min_q_index = use_min_q_index.into(); + self + } + pub fn min_q_index( + mut self, + min_q_index: crate::vk::VideoEncodeAV1QIndexKHR, + ) -> Self { + self.min_q_index = min_q_index; + self + } + pub fn use_max_q_index(mut self, use_max_q_index: bool) -> Self { + self.use_max_q_index = use_max_q_index.into(); + self + } + pub fn max_q_index( + mut self, + max_q_index: crate::vk::VideoEncodeAV1QIndexKHR, + ) -> Self { + self.max_q_index = max_q_index; + self + } + pub fn use_max_frame_size(mut self, use_max_frame_size: bool) -> Self { + self.use_max_frame_size = use_max_frame_size.into(); + self + } + pub fn max_frame_size( + mut self, + max_frame_size: crate::vk::VideoEncodeAV1FrameSizeKHR, + ) -> Self { + self.max_frame_size = max_frame_size; + self + } +} ///Provided by [`khr::video_encode_av1`](crate::khr::video_encode_av1) impl crate::vk::StructureType { pub const VIDEO_ENCODE_AV1_CAPABILITIES_KHR: Self = Self(1000513000); @@ -306,7 +1002,7 @@ impl core::ops::Not for VideoEncodeAV1CapabilityFlagsKHR { } } #[repr(transparent)] -#[derive(Clone, Copy)] +#[derive(Clone, Copy, Default)] pub struct VideoEncodeAV1CapabilityFlagBitsKHR(pub(crate) u32); ///Provided by [`khr::video_encode_av1`](crate::khr::video_encode_av1) impl VideoEncodeAV1CapabilityFlagBitsKHR { @@ -394,7 +1090,7 @@ impl core::ops::Not for VideoEncodeAV1StdFlagsKHR { } } #[repr(transparent)] -#[derive(Clone, Copy)] +#[derive(Clone, Copy, Default)] pub struct VideoEncodeAV1StdFlagBitsKHR(pub(crate) u32); ///Provided by [`khr::video_encode_av1`](crate::khr::video_encode_av1) impl VideoEncodeAV1StdFlagBitsKHR { @@ -483,7 +1179,7 @@ impl core::ops::Not for VideoEncodeAV1RateControlFlagsKHR { } } #[repr(transparent)] -#[derive(Clone, Copy)] +#[derive(Clone, Copy, Default)] pub struct VideoEncodeAV1RateControlFlagBitsKHR(pub(crate) u32); ///Provided by [`khr::video_encode_av1`](crate::khr::video_encode_av1) impl VideoEncodeAV1RateControlFlagBitsKHR { @@ -562,7 +1258,7 @@ impl core::ops::Not for VideoEncodeAV1SuperblockSizeFlagsKHR { } } #[repr(transparent)] -#[derive(Clone, Copy)] +#[derive(Clone, Copy, Default)] pub struct VideoEncodeAV1SuperblockSizeFlagBitsKHR(pub(crate) u32); ///Provided by [`khr::video_encode_av1`](crate::khr::video_encode_av1) impl VideoEncodeAV1SuperblockSizeFlagBitsKHR { diff --git a/ash-rewrite/src/generated/khr/video_encode_h264.rs b/ash-rewrite/src/generated/khr/video_encode_h264.rs index 3cadca007..3c3277608 100644 --- a/ash-rewrite/src/generated/khr/video_encode_h264.rs +++ b/ash-rewrite/src/generated/khr/video_encode_h264.rs @@ -21,6 +21,106 @@ pub struct VideoEncodeH264CapabilitiesKHR<'a> { pub std_syntax_flags: crate::vk::VideoEncodeH264StdFlagsKHR, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> for VideoEncodeH264CapabilitiesKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::VIDEO_ENCODE_H264_CAPABILITIES_KHR; +} +unsafe impl<'a> crate::Extends> +for VideoEncodeH264CapabilitiesKHR<'a> {} +impl<'a> Default for VideoEncodeH264CapabilitiesKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + flags: Default::default(), + max_level_idc: Default::default(), + max_slice_count: Default::default(), + max_p_picture_l0_reference_count: Default::default(), + max_b_picture_l0_reference_count: Default::default(), + max_l1_reference_count: Default::default(), + max_temporal_layer_count: Default::default(), + expect_dyadic_temporal_layer_pattern: Default::default(), + min_qp: Default::default(), + max_qp: Default::default(), + prefers_gop_remaining_frames: Default::default(), + requires_gop_remaining_frames: Default::default(), + std_syntax_flags: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> VideoEncodeH264CapabilitiesKHR<'a> { + pub fn flags(mut self, flags: crate::vk::VideoEncodeH264CapabilityFlagsKHR) -> Self { + self.flags = flags; + self + } + pub fn max_level_idc(mut self, max_level_idc: crate::vk::H264LevelIdc) -> Self { + self.max_level_idc = max_level_idc; + self + } + pub fn max_slice_count(mut self, max_slice_count: u32) -> Self { + self.max_slice_count = max_slice_count; + self + } + pub fn max_p_picture_l0_reference_count( + mut self, + max_p_picture_l0_reference_count: u32, + ) -> Self { + self.max_p_picture_l0_reference_count = max_p_picture_l0_reference_count; + self + } + pub fn max_b_picture_l0_reference_count( + mut self, + max_b_picture_l0_reference_count: u32, + ) -> Self { + self.max_b_picture_l0_reference_count = max_b_picture_l0_reference_count; + self + } + pub fn max_l1_reference_count(mut self, max_l1_reference_count: u32) -> Self { + self.max_l1_reference_count = max_l1_reference_count; + self + } + pub fn max_temporal_layer_count(mut self, max_temporal_layer_count: u32) -> Self { + self.max_temporal_layer_count = max_temporal_layer_count; + self + } + pub fn expect_dyadic_temporal_layer_pattern( + mut self, + expect_dyadic_temporal_layer_pattern: bool, + ) -> Self { + self.expect_dyadic_temporal_layer_pattern = expect_dyadic_temporal_layer_pattern + .into(); + self + } + pub fn min_qp(mut self, min_qp: i32) -> Self { + self.min_qp = min_qp; + self + } + pub fn max_qp(mut self, max_qp: i32) -> Self { + self.max_qp = max_qp; + self + } + pub fn prefers_gop_remaining_frames( + mut self, + prefers_gop_remaining_frames: bool, + ) -> Self { + self.prefers_gop_remaining_frames = prefers_gop_remaining_frames.into(); + self + } + pub fn requires_gop_remaining_frames( + mut self, + requires_gop_remaining_frames: bool, + ) -> Self { + self.requires_gop_remaining_frames = requires_gop_remaining_frames.into(); + self + } + pub fn std_syntax_flags( + mut self, + std_syntax_flags: crate::vk::VideoEncodeH264StdFlagsKHR, + ) -> Self { + self.std_syntax_flags = std_syntax_flags; + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct VideoEncodeH264QualityLevelPropertiesKHR<'a> { @@ -37,6 +137,90 @@ pub struct VideoEncodeH264QualityLevelPropertiesKHR<'a> { pub preferred_std_entropy_coding_mode_flag: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for VideoEncodeH264QualityLevelPropertiesKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::VIDEO_ENCODE_H264_QUALITY_LEVEL_PROPERTIES_KHR; +} +unsafe impl<'a> crate::Extends> +for VideoEncodeH264QualityLevelPropertiesKHR<'a> {} +impl<'a> Default for VideoEncodeH264QualityLevelPropertiesKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + preferred_rate_control_flags: Default::default(), + preferred_gop_frame_count: Default::default(), + preferred_idr_period: Default::default(), + preferred_consecutive_b_frame_count: Default::default(), + preferred_temporal_layer_count: Default::default(), + preferred_constant_qp: Default::default(), + preferred_max_l0_reference_count: Default::default(), + preferred_max_l1_reference_count: Default::default(), + preferred_std_entropy_coding_mode_flag: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> VideoEncodeH264QualityLevelPropertiesKHR<'a> { + pub fn preferred_rate_control_flags( + mut self, + preferred_rate_control_flags: crate::vk::VideoEncodeH264RateControlFlagsKHR, + ) -> Self { + self.preferred_rate_control_flags = preferred_rate_control_flags; + self + } + pub fn preferred_gop_frame_count(mut self, preferred_gop_frame_count: u32) -> Self { + self.preferred_gop_frame_count = preferred_gop_frame_count; + self + } + pub fn preferred_idr_period(mut self, preferred_idr_period: u32) -> Self { + self.preferred_idr_period = preferred_idr_period; + self + } + pub fn preferred_consecutive_b_frame_count( + mut self, + preferred_consecutive_b_frame_count: u32, + ) -> Self { + self.preferred_consecutive_b_frame_count = preferred_consecutive_b_frame_count; + self + } + pub fn preferred_temporal_layer_count( + mut self, + preferred_temporal_layer_count: u32, + ) -> Self { + self.preferred_temporal_layer_count = preferred_temporal_layer_count; + self + } + pub fn preferred_constant_qp( + mut self, + preferred_constant_qp: crate::vk::VideoEncodeH264QpKHR, + ) -> Self { + self.preferred_constant_qp = preferred_constant_qp; + self + } + pub fn preferred_max_l0_reference_count( + mut self, + preferred_max_l0_reference_count: u32, + ) -> Self { + self.preferred_max_l0_reference_count = preferred_max_l0_reference_count; + self + } + pub fn preferred_max_l1_reference_count( + mut self, + preferred_max_l1_reference_count: u32, + ) -> Self { + self.preferred_max_l1_reference_count = preferred_max_l1_reference_count; + self + } + pub fn preferred_std_entropy_coding_mode_flag( + mut self, + preferred_std_entropy_coding_mode_flag: bool, + ) -> Self { + self.preferred_std_entropy_coding_mode_flag = preferred_std_entropy_coding_mode_flag + .into(); + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct VideoEncodeH264SessionCreateInfoKHR<'a> { @@ -46,6 +230,32 @@ pub struct VideoEncodeH264SessionCreateInfoKHR<'a> { pub max_level_idc: crate::vk::H264LevelIdc, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> for VideoEncodeH264SessionCreateInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::VIDEO_ENCODE_H264_SESSION_CREATE_INFO_KHR; +} +unsafe impl<'a> crate::Extends> +for VideoEncodeH264SessionCreateInfoKHR<'a> {} +impl<'a> Default for VideoEncodeH264SessionCreateInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + use_max_level_idc: Default::default(), + max_level_idc: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> VideoEncodeH264SessionCreateInfoKHR<'a> { + pub fn use_max_level_idc(mut self, use_max_level_idc: bool) -> Self { + self.use_max_level_idc = use_max_level_idc.into(); + self + } + pub fn max_level_idc(mut self, max_level_idc: crate::vk::H264LevelIdc) -> Self { + self.max_level_idc = max_level_idc; + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct VideoEncodeH264SessionParametersAddInfoKHR<'a> { @@ -57,6 +267,51 @@ pub struct VideoEncodeH264SessionParametersAddInfoKHR<'a> { pub p_std_pp_ss: *const crate::vk::H264PictureParameterSet<'a>, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for VideoEncodeH264SessionParametersAddInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR; +} +unsafe impl<'a> crate::Extends> +for VideoEncodeH264SessionParametersAddInfoKHR<'a> {} +impl<'a> Default for VideoEncodeH264SessionParametersAddInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + std_sps_count: Default::default(), + p_std_sp_ss: Default::default(), + std_pps_count: Default::default(), + p_std_pp_ss: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> VideoEncodeH264SessionParametersAddInfoKHR<'a> { + pub fn std_sps_count(mut self, std_sps_count: u32) -> Self { + self.std_sps_count = std_sps_count; + self + } + pub fn p_std_sp_ss( + mut self, + p_std_sp_ss: &'a [crate::vk::H264SequenceParameterSet<'a>], + ) -> Self { + self.std_sps_count = p_std_sp_ss.len() as _; + self.p_std_sp_ss = p_std_sp_ss.as_ptr(); + self + } + pub fn std_pps_count(mut self, std_pps_count: u32) -> Self { + self.std_pps_count = std_pps_count; + self + } + pub fn p_std_pp_ss( + mut self, + p_std_pp_ss: &'a [crate::vk::H264PictureParameterSet<'a>], + ) -> Self { + self.std_pps_count = p_std_pp_ss.len() as _; + self.p_std_pp_ss = p_std_pp_ss.as_ptr(); + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct VideoEncodeH264SessionParametersCreateInfoKHR<'a> { @@ -69,6 +324,43 @@ pub struct VideoEncodeH264SessionParametersCreateInfoKHR<'a> { >, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for VideoEncodeH264SessionParametersCreateInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR; +} +unsafe impl<'a> crate::Extends> +for VideoEncodeH264SessionParametersCreateInfoKHR<'a> {} +impl<'a> Default for VideoEncodeH264SessionParametersCreateInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + max_std_sps_count: Default::default(), + max_std_pps_count: Default::default(), + p_parameters_add_info: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> VideoEncodeH264SessionParametersCreateInfoKHR<'a> { + pub fn max_std_sps_count(mut self, max_std_sps_count: u32) -> Self { + self.max_std_sps_count = max_std_sps_count; + self + } + pub fn max_std_pps_count(mut self, max_std_pps_count: u32) -> Self { + self.max_std_pps_count = max_std_pps_count; + self + } + pub fn p_parameters_add_info( + mut self, + p_parameters_add_info: &'a crate::vk::VideoEncodeH264SessionParametersAddInfoKHR< + 'a, + >, + ) -> Self { + self.p_parameters_add_info = p_parameters_add_info; + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct VideoEncodeH264SessionParametersGetInfoKHR<'a> { @@ -80,6 +372,43 @@ pub struct VideoEncodeH264SessionParametersGetInfoKHR<'a> { pub std_pps_id: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for VideoEncodeH264SessionParametersGetInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::VIDEO_ENCODE_H264_SESSION_PARAMETERS_GET_INFO_KHR; +} +unsafe impl<'a> crate::Extends> +for VideoEncodeH264SessionParametersGetInfoKHR<'a> {} +impl<'a> Default for VideoEncodeH264SessionParametersGetInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + write_std_sps: Default::default(), + write_std_pps: Default::default(), + std_sps_id: Default::default(), + std_pps_id: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> VideoEncodeH264SessionParametersGetInfoKHR<'a> { + pub fn write_std_sps(mut self, write_std_sps: bool) -> Self { + self.write_std_sps = write_std_sps.into(); + self + } + pub fn write_std_pps(mut self, write_std_pps: bool) -> Self { + self.write_std_pps = write_std_pps.into(); + self + } + pub fn std_sps_id(mut self, std_sps_id: u32) -> Self { + self.std_sps_id = std_sps_id; + self + } + pub fn std_pps_id(mut self, std_pps_id: u32) -> Self { + self.std_pps_id = std_pps_id; + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct VideoEncodeH264SessionParametersFeedbackInfoKHR<'a> { @@ -89,6 +418,35 @@ pub struct VideoEncodeH264SessionParametersFeedbackInfoKHR<'a> { pub has_std_pps_overrides: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for VideoEncodeH264SessionParametersFeedbackInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::VIDEO_ENCODE_H264_SESSION_PARAMETERS_FEEDBACK_INFO_KHR; +} +unsafe impl< + 'a, +> crate::Extends> +for VideoEncodeH264SessionParametersFeedbackInfoKHR<'a> {} +impl<'a> Default for VideoEncodeH264SessionParametersFeedbackInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + has_std_sps_overrides: Default::default(), + has_std_pps_overrides: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> VideoEncodeH264SessionParametersFeedbackInfoKHR<'a> { + pub fn has_std_sps_overrides(mut self, has_std_sps_overrides: bool) -> Self { + self.has_std_sps_overrides = has_std_sps_overrides.into(); + self + } + pub fn has_std_pps_overrides(mut self, has_std_pps_overrides: bool) -> Self { + self.has_std_pps_overrides = has_std_pps_overrides.into(); + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct VideoEncodeH264DpbSlotInfoKHR<'a> { @@ -97,6 +455,30 @@ pub struct VideoEncodeH264DpbSlotInfoKHR<'a> { pub p_std_reference_info: *const crate::vk::EncodeH264ReferenceInfo, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> for VideoEncodeH264DpbSlotInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::VIDEO_ENCODE_H264_DPB_SLOT_INFO_KHR; +} +unsafe impl<'a> crate::Extends> +for VideoEncodeH264DpbSlotInfoKHR<'a> {} +impl<'a> Default for VideoEncodeH264DpbSlotInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + p_std_reference_info: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> VideoEncodeH264DpbSlotInfoKHR<'a> { + pub fn p_std_reference_info( + mut self, + p_std_reference_info: &'a crate::vk::EncodeH264ReferenceInfo, + ) -> Self { + self.p_std_reference_info = p_std_reference_info; + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct VideoEncodeH264PictureInfoKHR<'a> { @@ -108,6 +490,49 @@ pub struct VideoEncodeH264PictureInfoKHR<'a> { pub generate_prefix_nalu: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> for VideoEncodeH264PictureInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::VIDEO_ENCODE_H264_PICTURE_INFO_KHR; +} +unsafe impl<'a> crate::Extends> +for VideoEncodeH264PictureInfoKHR<'a> {} +impl<'a> Default for VideoEncodeH264PictureInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + nalu_slice_entry_count: Default::default(), + p_nalu_slice_entries: Default::default(), + p_std_picture_info: Default::default(), + generate_prefix_nalu: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> VideoEncodeH264PictureInfoKHR<'a> { + pub fn nalu_slice_entry_count(mut self, nalu_slice_entry_count: u32) -> Self { + self.nalu_slice_entry_count = nalu_slice_entry_count; + self + } + pub fn p_nalu_slice_entries( + mut self, + p_nalu_slice_entries: &'a [crate::vk::VideoEncodeH264NaluSliceInfoKHR<'a>], + ) -> Self { + self.nalu_slice_entry_count = p_nalu_slice_entries.len() as _; + self.p_nalu_slice_entries = p_nalu_slice_entries.as_ptr(); + self + } + pub fn p_std_picture_info( + mut self, + p_std_picture_info: &'a crate::vk::EncodeH264PictureInfo<'a>, + ) -> Self { + self.p_std_picture_info = p_std_picture_info; + self + } + pub fn generate_prefix_nalu(mut self, generate_prefix_nalu: bool) -> Self { + self.generate_prefix_nalu = generate_prefix_nalu.into(); + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct VideoEncodeH264ProfileInfoKHR<'a> { @@ -116,6 +541,32 @@ pub struct VideoEncodeH264ProfileInfoKHR<'a> { pub std_profile_idc: crate::vk::H264ProfileIdc, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> for VideoEncodeH264ProfileInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::VIDEO_ENCODE_H264_PROFILE_INFO_KHR; +} +unsafe impl<'a> crate::Extends> +for VideoEncodeH264ProfileInfoKHR<'a> {} +unsafe impl<'a> crate::Extends> +for VideoEncodeH264ProfileInfoKHR<'a> {} +impl<'a> Default for VideoEncodeH264ProfileInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + std_profile_idc: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> VideoEncodeH264ProfileInfoKHR<'a> { + pub fn std_profile_idc( + mut self, + std_profile_idc: crate::vk::H264ProfileIdc, + ) -> Self { + self.std_profile_idc = std_profile_idc; + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct VideoEncodeH264NaluSliceInfoKHR<'a> { @@ -125,6 +576,33 @@ pub struct VideoEncodeH264NaluSliceInfoKHR<'a> { pub p_std_slice_header: *const crate::vk::EncodeH264SliceHeader<'a>, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> for VideoEncodeH264NaluSliceInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::VIDEO_ENCODE_H264_NALU_SLICE_INFO_KHR; +} +impl<'a> Default for VideoEncodeH264NaluSliceInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + constant_qp: Default::default(), + p_std_slice_header: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> VideoEncodeH264NaluSliceInfoKHR<'a> { + pub fn constant_qp(mut self, constant_qp: i32) -> Self { + self.constant_qp = constant_qp; + self + } + pub fn p_std_slice_header( + mut self, + p_std_slice_header: &'a crate::vk::EncodeH264SliceHeader<'a>, + ) -> Self { + self.p_std_slice_header = p_std_slice_header; + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct VideoEncodeH264RateControlInfoKHR<'a> { @@ -137,20 +615,94 @@ pub struct VideoEncodeH264RateControlInfoKHR<'a> { pub temporal_layer_count: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> for VideoEncodeH264RateControlInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::VIDEO_ENCODE_H264_RATE_CONTROL_INFO_KHR; +} +unsafe impl<'a> crate::Extends> +for VideoEncodeH264RateControlInfoKHR<'a> {} +unsafe impl<'a> crate::Extends> +for VideoEncodeH264RateControlInfoKHR<'a> {} +impl<'a> Default for VideoEncodeH264RateControlInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + flags: Default::default(), + gop_frame_count: Default::default(), + idr_period: Default::default(), + consecutive_b_frame_count: Default::default(), + temporal_layer_count: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> VideoEncodeH264RateControlInfoKHR<'a> { + pub fn flags( + mut self, + flags: crate::vk::VideoEncodeH264RateControlFlagsKHR, + ) -> Self { + self.flags = flags; + self + } + pub fn gop_frame_count(mut self, gop_frame_count: u32) -> Self { + self.gop_frame_count = gop_frame_count; + self + } + pub fn idr_period(mut self, idr_period: u32) -> Self { + self.idr_period = idr_period; + self + } + pub fn consecutive_b_frame_count(mut self, consecutive_b_frame_count: u32) -> Self { + self.consecutive_b_frame_count = consecutive_b_frame_count; + self + } + pub fn temporal_layer_count(mut self, temporal_layer_count: u32) -> Self { + self.temporal_layer_count = temporal_layer_count; + self + } +} #[repr(C)] -#[derive(Clone, Copy)] +#[derive(Clone, Copy, Default)] pub struct VideoEncodeH264QpKHR { pub qp_i: i32, pub qp_p: i32, pub qp_b: i32, } +impl VideoEncodeH264QpKHR { + pub fn qp_i(mut self, qp_i: i32) -> Self { + self.qp_i = qp_i; + self + } + pub fn qp_p(mut self, qp_p: i32) -> Self { + self.qp_p = qp_p; + self + } + pub fn qp_b(mut self, qp_b: i32) -> Self { + self.qp_b = qp_b; + self + } +} #[repr(C)] -#[derive(Clone, Copy)] +#[derive(Clone, Copy, Default)] pub struct VideoEncodeH264FrameSizeKHR { pub frame_i_size: u32, pub frame_p_size: u32, pub frame_b_size: u32, } +impl VideoEncodeH264FrameSizeKHR { + pub fn frame_i_size(mut self, frame_i_size: u32) -> Self { + self.frame_i_size = frame_i_size; + self + } + pub fn frame_p_size(mut self, frame_p_size: u32) -> Self { + self.frame_p_size = frame_p_size; + self + } + pub fn frame_b_size(mut self, frame_b_size: u32) -> Self { + self.frame_b_size = frame_b_size; + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct VideoEncodeH264GopRemainingFrameInfoKHR<'a> { @@ -162,6 +714,43 @@ pub struct VideoEncodeH264GopRemainingFrameInfoKHR<'a> { pub gop_remaining_b: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for VideoEncodeH264GopRemainingFrameInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::VIDEO_ENCODE_H264_GOP_REMAINING_FRAME_INFO_KHR; +} +unsafe impl<'a> crate::Extends> +for VideoEncodeH264GopRemainingFrameInfoKHR<'a> {} +impl<'a> Default for VideoEncodeH264GopRemainingFrameInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + use_gop_remaining_frames: Default::default(), + gop_remaining_i: Default::default(), + gop_remaining_p: Default::default(), + gop_remaining_b: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> VideoEncodeH264GopRemainingFrameInfoKHR<'a> { + pub fn use_gop_remaining_frames(mut self, use_gop_remaining_frames: bool) -> Self { + self.use_gop_remaining_frames = use_gop_remaining_frames.into(); + self + } + pub fn gop_remaining_i(mut self, gop_remaining_i: u32) -> Self { + self.gop_remaining_i = gop_remaining_i; + self + } + pub fn gop_remaining_p(mut self, gop_remaining_p: u32) -> Self { + self.gop_remaining_p = gop_remaining_p; + self + } + pub fn gop_remaining_b(mut self, gop_remaining_b: u32) -> Self { + self.gop_remaining_b = gop_remaining_b; + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct VideoEncodeH264RateControlLayerInfoKHR<'a> { @@ -175,6 +764,56 @@ pub struct VideoEncodeH264RateControlLayerInfoKHR<'a> { pub max_frame_size: crate::vk::VideoEncodeH264FrameSizeKHR, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for VideoEncodeH264RateControlLayerInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_KHR; +} +unsafe impl<'a> crate::Extends> +for VideoEncodeH264RateControlLayerInfoKHR<'a> {} +impl<'a> Default for VideoEncodeH264RateControlLayerInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + use_min_qp: Default::default(), + min_qp: Default::default(), + use_max_qp: Default::default(), + max_qp: Default::default(), + use_max_frame_size: Default::default(), + max_frame_size: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> VideoEncodeH264RateControlLayerInfoKHR<'a> { + pub fn use_min_qp(mut self, use_min_qp: bool) -> Self { + self.use_min_qp = use_min_qp.into(); + self + } + pub fn min_qp(mut self, min_qp: crate::vk::VideoEncodeH264QpKHR) -> Self { + self.min_qp = min_qp; + self + } + pub fn use_max_qp(mut self, use_max_qp: bool) -> Self { + self.use_max_qp = use_max_qp.into(); + self + } + pub fn max_qp(mut self, max_qp: crate::vk::VideoEncodeH264QpKHR) -> Self { + self.max_qp = max_qp; + self + } + pub fn use_max_frame_size(mut self, use_max_frame_size: bool) -> Self { + self.use_max_frame_size = use_max_frame_size.into(); + self + } + pub fn max_frame_size( + mut self, + max_frame_size: crate::vk::VideoEncodeH264FrameSizeKHR, + ) -> Self { + self.max_frame_size = max_frame_size; + self + } +} ///Provided by [`khr::video_encode_h264`](crate::khr::video_encode_h264) impl crate::vk::StructureType { pub const VIDEO_ENCODE_H264_CAPABILITIES_KHR: Self = Self(1000038000); @@ -301,7 +940,7 @@ impl core::ops::Not for VideoEncodeH264CapabilityFlagsKHR { } } #[repr(transparent)] -#[derive(Clone, Copy)] +#[derive(Clone, Copy, Default)] pub struct VideoEncodeH264CapabilityFlagBitsKHR(pub(crate) u32); ///Provided by [`khr::video_encode_h264`](crate::khr::video_encode_h264) impl VideoEncodeH264CapabilityFlagBitsKHR { @@ -443,7 +1082,7 @@ impl core::ops::Not for VideoEncodeH264StdFlagsKHR { } } #[repr(transparent)] -#[derive(Clone, Copy)] +#[derive(Clone, Copy, Default)] pub struct VideoEncodeH264StdFlagBitsKHR(pub(crate) u32); ///Provided by [`khr::video_encode_h264`](crate::khr::video_encode_h264) impl VideoEncodeH264StdFlagBitsKHR { @@ -551,7 +1190,7 @@ impl core::ops::Not for VideoEncodeH264RateControlFlagsKHR { } } #[repr(transparent)] -#[derive(Clone, Copy)] +#[derive(Clone, Copy, Default)] pub struct VideoEncodeH264RateControlFlagBitsKHR(pub(crate) u32); ///Provided by [`khr::video_encode_h264`](crate::khr::video_encode_h264) impl VideoEncodeH264RateControlFlagBitsKHR { diff --git a/ash-rewrite/src/generated/khr/video_encode_h265.rs b/ash-rewrite/src/generated/khr/video_encode_h265.rs index 4bc3c5659..36bc2c08b 100644 --- a/ash-rewrite/src/generated/khr/video_encode_h265.rs +++ b/ash-rewrite/src/generated/khr/video_encode_h265.rs @@ -24,6 +24,127 @@ pub struct VideoEncodeH265CapabilitiesKHR<'a> { pub std_syntax_flags: crate::vk::VideoEncodeH265StdFlagsKHR, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> for VideoEncodeH265CapabilitiesKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::VIDEO_ENCODE_H265_CAPABILITIES_KHR; +} +unsafe impl<'a> crate::Extends> +for VideoEncodeH265CapabilitiesKHR<'a> {} +impl<'a> Default for VideoEncodeH265CapabilitiesKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + flags: Default::default(), + max_level_idc: Default::default(), + max_slice_segment_count: Default::default(), + max_tiles: Default::default(), + ctb_sizes: Default::default(), + transform_block_sizes: Default::default(), + max_p_picture_l0_reference_count: Default::default(), + max_b_picture_l0_reference_count: Default::default(), + max_l1_reference_count: Default::default(), + max_sub_layer_count: Default::default(), + expect_dyadic_temporal_sub_layer_pattern: Default::default(), + min_qp: Default::default(), + max_qp: Default::default(), + prefers_gop_remaining_frames: Default::default(), + requires_gop_remaining_frames: Default::default(), + std_syntax_flags: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> VideoEncodeH265CapabilitiesKHR<'a> { + pub fn flags(mut self, flags: crate::vk::VideoEncodeH265CapabilityFlagsKHR) -> Self { + self.flags = flags; + self + } + pub fn max_level_idc(mut self, max_level_idc: crate::vk::H265LevelIdc) -> Self { + self.max_level_idc = max_level_idc; + self + } + pub fn max_slice_segment_count(mut self, max_slice_segment_count: u32) -> Self { + self.max_slice_segment_count = max_slice_segment_count; + self + } + pub fn max_tiles(mut self, max_tiles: crate::vk::Extent2D) -> Self { + self.max_tiles = max_tiles; + self + } + pub fn ctb_sizes( + mut self, + ctb_sizes: crate::vk::VideoEncodeH265CtbSizeFlagsKHR, + ) -> Self { + self.ctb_sizes = ctb_sizes; + self + } + pub fn transform_block_sizes( + mut self, + transform_block_sizes: crate::vk::VideoEncodeH265TransformBlockSizeFlagsKHR, + ) -> Self { + self.transform_block_sizes = transform_block_sizes; + self + } + pub fn max_p_picture_l0_reference_count( + mut self, + max_p_picture_l0_reference_count: u32, + ) -> Self { + self.max_p_picture_l0_reference_count = max_p_picture_l0_reference_count; + self + } + pub fn max_b_picture_l0_reference_count( + mut self, + max_b_picture_l0_reference_count: u32, + ) -> Self { + self.max_b_picture_l0_reference_count = max_b_picture_l0_reference_count; + self + } + pub fn max_l1_reference_count(mut self, max_l1_reference_count: u32) -> Self { + self.max_l1_reference_count = max_l1_reference_count; + self + } + pub fn max_sub_layer_count(mut self, max_sub_layer_count: u32) -> Self { + self.max_sub_layer_count = max_sub_layer_count; + self + } + pub fn expect_dyadic_temporal_sub_layer_pattern( + mut self, + expect_dyadic_temporal_sub_layer_pattern: bool, + ) -> Self { + self.expect_dyadic_temporal_sub_layer_pattern = expect_dyadic_temporal_sub_layer_pattern + .into(); + self + } + pub fn min_qp(mut self, min_qp: i32) -> Self { + self.min_qp = min_qp; + self + } + pub fn max_qp(mut self, max_qp: i32) -> Self { + self.max_qp = max_qp; + self + } + pub fn prefers_gop_remaining_frames( + mut self, + prefers_gop_remaining_frames: bool, + ) -> Self { + self.prefers_gop_remaining_frames = prefers_gop_remaining_frames.into(); + self + } + pub fn requires_gop_remaining_frames( + mut self, + requires_gop_remaining_frames: bool, + ) -> Self { + self.requires_gop_remaining_frames = requires_gop_remaining_frames.into(); + self + } + pub fn std_syntax_flags( + mut self, + std_syntax_flags: crate::vk::VideoEncodeH265StdFlagsKHR, + ) -> Self { + self.std_syntax_flags = std_syntax_flags; + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct VideoEncodeH265QualityLevelPropertiesKHR<'a> { @@ -39,6 +160,78 @@ pub struct VideoEncodeH265QualityLevelPropertiesKHR<'a> { pub preferred_max_l1_reference_count: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for VideoEncodeH265QualityLevelPropertiesKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::VIDEO_ENCODE_H265_QUALITY_LEVEL_PROPERTIES_KHR; +} +unsafe impl<'a> crate::Extends> +for VideoEncodeH265QualityLevelPropertiesKHR<'a> {} +impl<'a> Default for VideoEncodeH265QualityLevelPropertiesKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + preferred_rate_control_flags: Default::default(), + preferred_gop_frame_count: Default::default(), + preferred_idr_period: Default::default(), + preferred_consecutive_b_frame_count: Default::default(), + preferred_sub_layer_count: Default::default(), + preferred_constant_qp: Default::default(), + preferred_max_l0_reference_count: Default::default(), + preferred_max_l1_reference_count: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> VideoEncodeH265QualityLevelPropertiesKHR<'a> { + pub fn preferred_rate_control_flags( + mut self, + preferred_rate_control_flags: crate::vk::VideoEncodeH265RateControlFlagsKHR, + ) -> Self { + self.preferred_rate_control_flags = preferred_rate_control_flags; + self + } + pub fn preferred_gop_frame_count(mut self, preferred_gop_frame_count: u32) -> Self { + self.preferred_gop_frame_count = preferred_gop_frame_count; + self + } + pub fn preferred_idr_period(mut self, preferred_idr_period: u32) -> Self { + self.preferred_idr_period = preferred_idr_period; + self + } + pub fn preferred_consecutive_b_frame_count( + mut self, + preferred_consecutive_b_frame_count: u32, + ) -> Self { + self.preferred_consecutive_b_frame_count = preferred_consecutive_b_frame_count; + self + } + pub fn preferred_sub_layer_count(mut self, preferred_sub_layer_count: u32) -> Self { + self.preferred_sub_layer_count = preferred_sub_layer_count; + self + } + pub fn preferred_constant_qp( + mut self, + preferred_constant_qp: crate::vk::VideoEncodeH265QpKHR, + ) -> Self { + self.preferred_constant_qp = preferred_constant_qp; + self + } + pub fn preferred_max_l0_reference_count( + mut self, + preferred_max_l0_reference_count: u32, + ) -> Self { + self.preferred_max_l0_reference_count = preferred_max_l0_reference_count; + self + } + pub fn preferred_max_l1_reference_count( + mut self, + preferred_max_l1_reference_count: u32, + ) -> Self { + self.preferred_max_l1_reference_count = preferred_max_l1_reference_count; + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct VideoEncodeH265SessionCreateInfoKHR<'a> { @@ -48,6 +241,32 @@ pub struct VideoEncodeH265SessionCreateInfoKHR<'a> { pub max_level_idc: crate::vk::H265LevelIdc, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> for VideoEncodeH265SessionCreateInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::VIDEO_ENCODE_H265_SESSION_CREATE_INFO_KHR; +} +unsafe impl<'a> crate::Extends> +for VideoEncodeH265SessionCreateInfoKHR<'a> {} +impl<'a> Default for VideoEncodeH265SessionCreateInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + use_max_level_idc: Default::default(), + max_level_idc: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> VideoEncodeH265SessionCreateInfoKHR<'a> { + pub fn use_max_level_idc(mut self, use_max_level_idc: bool) -> Self { + self.use_max_level_idc = use_max_level_idc.into(); + self + } + pub fn max_level_idc(mut self, max_level_idc: crate::vk::H265LevelIdc) -> Self { + self.max_level_idc = max_level_idc; + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct VideoEncodeH265SessionParametersAddInfoKHR<'a> { @@ -61,6 +280,65 @@ pub struct VideoEncodeH265SessionParametersAddInfoKHR<'a> { pub p_std_pp_ss: *const crate::vk::H265PictureParameterSet<'a>, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for VideoEncodeH265SessionParametersAddInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR; +} +unsafe impl<'a> crate::Extends> +for VideoEncodeH265SessionParametersAddInfoKHR<'a> {} +impl<'a> Default for VideoEncodeH265SessionParametersAddInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + std_vps_count: Default::default(), + p_std_vp_ss: Default::default(), + std_sps_count: Default::default(), + p_std_sp_ss: Default::default(), + std_pps_count: Default::default(), + p_std_pp_ss: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> VideoEncodeH265SessionParametersAddInfoKHR<'a> { + pub fn std_vps_count(mut self, std_vps_count: u32) -> Self { + self.std_vps_count = std_vps_count; + self + } + pub fn p_std_vp_ss( + mut self, + p_std_vp_ss: &'a [crate::vk::H265VideoParameterSet<'a>], + ) -> Self { + self.std_vps_count = p_std_vp_ss.len() as _; + self.p_std_vp_ss = p_std_vp_ss.as_ptr(); + self + } + pub fn std_sps_count(mut self, std_sps_count: u32) -> Self { + self.std_sps_count = std_sps_count; + self + } + pub fn p_std_sp_ss( + mut self, + p_std_sp_ss: &'a [crate::vk::H265SequenceParameterSet<'a>], + ) -> Self { + self.std_sps_count = p_std_sp_ss.len() as _; + self.p_std_sp_ss = p_std_sp_ss.as_ptr(); + self + } + pub fn std_pps_count(mut self, std_pps_count: u32) -> Self { + self.std_pps_count = std_pps_count; + self + } + pub fn p_std_pp_ss( + mut self, + p_std_pp_ss: &'a [crate::vk::H265PictureParameterSet<'a>], + ) -> Self { + self.std_pps_count = p_std_pp_ss.len() as _; + self.p_std_pp_ss = p_std_pp_ss.as_ptr(); + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct VideoEncodeH265SessionParametersCreateInfoKHR<'a> { @@ -74,6 +352,48 @@ pub struct VideoEncodeH265SessionParametersCreateInfoKHR<'a> { >, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for VideoEncodeH265SessionParametersCreateInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR; +} +unsafe impl<'a> crate::Extends> +for VideoEncodeH265SessionParametersCreateInfoKHR<'a> {} +impl<'a> Default for VideoEncodeH265SessionParametersCreateInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + max_std_vps_count: Default::default(), + max_std_sps_count: Default::default(), + max_std_pps_count: Default::default(), + p_parameters_add_info: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> VideoEncodeH265SessionParametersCreateInfoKHR<'a> { + pub fn max_std_vps_count(mut self, max_std_vps_count: u32) -> Self { + self.max_std_vps_count = max_std_vps_count; + self + } + pub fn max_std_sps_count(mut self, max_std_sps_count: u32) -> Self { + self.max_std_sps_count = max_std_sps_count; + self + } + pub fn max_std_pps_count(mut self, max_std_pps_count: u32) -> Self { + self.max_std_pps_count = max_std_pps_count; + self + } + pub fn p_parameters_add_info( + mut self, + p_parameters_add_info: &'a crate::vk::VideoEncodeH265SessionParametersAddInfoKHR< + 'a, + >, + ) -> Self { + self.p_parameters_add_info = p_parameters_add_info; + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct VideoEncodeH265SessionParametersGetInfoKHR<'a> { @@ -87,6 +407,53 @@ pub struct VideoEncodeH265SessionParametersGetInfoKHR<'a> { pub std_pps_id: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for VideoEncodeH265SessionParametersGetInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::VIDEO_ENCODE_H265_SESSION_PARAMETERS_GET_INFO_KHR; +} +unsafe impl<'a> crate::Extends> +for VideoEncodeH265SessionParametersGetInfoKHR<'a> {} +impl<'a> Default for VideoEncodeH265SessionParametersGetInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + write_std_vps: Default::default(), + write_std_sps: Default::default(), + write_std_pps: Default::default(), + std_vps_id: Default::default(), + std_sps_id: Default::default(), + std_pps_id: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> VideoEncodeH265SessionParametersGetInfoKHR<'a> { + pub fn write_std_vps(mut self, write_std_vps: bool) -> Self { + self.write_std_vps = write_std_vps.into(); + self + } + pub fn write_std_sps(mut self, write_std_sps: bool) -> Self { + self.write_std_sps = write_std_sps.into(); + self + } + pub fn write_std_pps(mut self, write_std_pps: bool) -> Self { + self.write_std_pps = write_std_pps.into(); + self + } + pub fn std_vps_id(mut self, std_vps_id: u32) -> Self { + self.std_vps_id = std_vps_id; + self + } + pub fn std_sps_id(mut self, std_sps_id: u32) -> Self { + self.std_sps_id = std_sps_id; + self + } + pub fn std_pps_id(mut self, std_pps_id: u32) -> Self { + self.std_pps_id = std_pps_id; + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct VideoEncodeH265SessionParametersFeedbackInfoKHR<'a> { @@ -97,6 +464,40 @@ pub struct VideoEncodeH265SessionParametersFeedbackInfoKHR<'a> { pub has_std_pps_overrides: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for VideoEncodeH265SessionParametersFeedbackInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::VIDEO_ENCODE_H265_SESSION_PARAMETERS_FEEDBACK_INFO_KHR; +} +unsafe impl< + 'a, +> crate::Extends> +for VideoEncodeH265SessionParametersFeedbackInfoKHR<'a> {} +impl<'a> Default for VideoEncodeH265SessionParametersFeedbackInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + has_std_vps_overrides: Default::default(), + has_std_sps_overrides: Default::default(), + has_std_pps_overrides: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> VideoEncodeH265SessionParametersFeedbackInfoKHR<'a> { + pub fn has_std_vps_overrides(mut self, has_std_vps_overrides: bool) -> Self { + self.has_std_vps_overrides = has_std_vps_overrides.into(); + self + } + pub fn has_std_sps_overrides(mut self, has_std_sps_overrides: bool) -> Self { + self.has_std_sps_overrides = has_std_sps_overrides.into(); + self + } + pub fn has_std_pps_overrides(mut self, has_std_pps_overrides: bool) -> Self { + self.has_std_pps_overrides = has_std_pps_overrides.into(); + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct VideoEncodeH265PictureInfoKHR<'a> { @@ -109,6 +510,49 @@ pub struct VideoEncodeH265PictureInfoKHR<'a> { pub p_std_picture_info: *const crate::vk::EncodeH265PictureInfo<'a>, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> for VideoEncodeH265PictureInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::VIDEO_ENCODE_H265_PICTURE_INFO_KHR; +} +unsafe impl<'a> crate::Extends> +for VideoEncodeH265PictureInfoKHR<'a> {} +impl<'a> Default for VideoEncodeH265PictureInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + nalu_slice_segment_entry_count: Default::default(), + p_nalu_slice_segment_entries: Default::default(), + p_std_picture_info: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> VideoEncodeH265PictureInfoKHR<'a> { + pub fn nalu_slice_segment_entry_count( + mut self, + nalu_slice_segment_entry_count: u32, + ) -> Self { + self.nalu_slice_segment_entry_count = nalu_slice_segment_entry_count; + self + } + pub fn p_nalu_slice_segment_entries( + mut self, + p_nalu_slice_segment_entries: &'a [crate::vk::VideoEncodeH265NaluSliceSegmentInfoKHR< + 'a, + >], + ) -> Self { + self.nalu_slice_segment_entry_count = p_nalu_slice_segment_entries.len() as _; + self.p_nalu_slice_segment_entries = p_nalu_slice_segment_entries.as_ptr(); + self + } + pub fn p_std_picture_info( + mut self, + p_std_picture_info: &'a crate::vk::EncodeH265PictureInfo<'a>, + ) -> Self { + self.p_std_picture_info = p_std_picture_info; + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct VideoEncodeH265NaluSliceSegmentInfoKHR<'a> { @@ -118,6 +562,34 @@ pub struct VideoEncodeH265NaluSliceSegmentInfoKHR<'a> { pub p_std_slice_segment_header: *const crate::vk::EncodeH265SliceSegmentHeader<'a>, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for VideoEncodeH265NaluSliceSegmentInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::VIDEO_ENCODE_H265_NALU_SLICE_SEGMENT_INFO_KHR; +} +impl<'a> Default for VideoEncodeH265NaluSliceSegmentInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + constant_qp: Default::default(), + p_std_slice_segment_header: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> VideoEncodeH265NaluSliceSegmentInfoKHR<'a> { + pub fn constant_qp(mut self, constant_qp: i32) -> Self { + self.constant_qp = constant_qp; + self + } + pub fn p_std_slice_segment_header( + mut self, + p_std_slice_segment_header: &'a crate::vk::EncodeH265SliceSegmentHeader<'a>, + ) -> Self { + self.p_std_slice_segment_header = p_std_slice_segment_header; + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct VideoEncodeH265RateControlInfoKHR<'a> { @@ -130,20 +602,94 @@ pub struct VideoEncodeH265RateControlInfoKHR<'a> { pub sub_layer_count: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> for VideoEncodeH265RateControlInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::VIDEO_ENCODE_H265_RATE_CONTROL_INFO_KHR; +} +unsafe impl<'a> crate::Extends> +for VideoEncodeH265RateControlInfoKHR<'a> {} +unsafe impl<'a> crate::Extends> +for VideoEncodeH265RateControlInfoKHR<'a> {} +impl<'a> Default for VideoEncodeH265RateControlInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + flags: Default::default(), + gop_frame_count: Default::default(), + idr_period: Default::default(), + consecutive_b_frame_count: Default::default(), + sub_layer_count: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> VideoEncodeH265RateControlInfoKHR<'a> { + pub fn flags( + mut self, + flags: crate::vk::VideoEncodeH265RateControlFlagsKHR, + ) -> Self { + self.flags = flags; + self + } + pub fn gop_frame_count(mut self, gop_frame_count: u32) -> Self { + self.gop_frame_count = gop_frame_count; + self + } + pub fn idr_period(mut self, idr_period: u32) -> Self { + self.idr_period = idr_period; + self + } + pub fn consecutive_b_frame_count(mut self, consecutive_b_frame_count: u32) -> Self { + self.consecutive_b_frame_count = consecutive_b_frame_count; + self + } + pub fn sub_layer_count(mut self, sub_layer_count: u32) -> Self { + self.sub_layer_count = sub_layer_count; + self + } +} #[repr(C)] -#[derive(Clone, Copy)] +#[derive(Clone, Copy, Default)] pub struct VideoEncodeH265QpKHR { pub qp_i: i32, pub qp_p: i32, pub qp_b: i32, } +impl VideoEncodeH265QpKHR { + pub fn qp_i(mut self, qp_i: i32) -> Self { + self.qp_i = qp_i; + self + } + pub fn qp_p(mut self, qp_p: i32) -> Self { + self.qp_p = qp_p; + self + } + pub fn qp_b(mut self, qp_b: i32) -> Self { + self.qp_b = qp_b; + self + } +} #[repr(C)] -#[derive(Clone, Copy)] +#[derive(Clone, Copy, Default)] pub struct VideoEncodeH265FrameSizeKHR { pub frame_i_size: u32, pub frame_p_size: u32, pub frame_b_size: u32, } +impl VideoEncodeH265FrameSizeKHR { + pub fn frame_i_size(mut self, frame_i_size: u32) -> Self { + self.frame_i_size = frame_i_size; + self + } + pub fn frame_p_size(mut self, frame_p_size: u32) -> Self { + self.frame_p_size = frame_p_size; + self + } + pub fn frame_b_size(mut self, frame_b_size: u32) -> Self { + self.frame_b_size = frame_b_size; + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct VideoEncodeH265GopRemainingFrameInfoKHR<'a> { @@ -155,6 +701,43 @@ pub struct VideoEncodeH265GopRemainingFrameInfoKHR<'a> { pub gop_remaining_b: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for VideoEncodeH265GopRemainingFrameInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::VIDEO_ENCODE_H265_GOP_REMAINING_FRAME_INFO_KHR; +} +unsafe impl<'a> crate::Extends> +for VideoEncodeH265GopRemainingFrameInfoKHR<'a> {} +impl<'a> Default for VideoEncodeH265GopRemainingFrameInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + use_gop_remaining_frames: Default::default(), + gop_remaining_i: Default::default(), + gop_remaining_p: Default::default(), + gop_remaining_b: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> VideoEncodeH265GopRemainingFrameInfoKHR<'a> { + pub fn use_gop_remaining_frames(mut self, use_gop_remaining_frames: bool) -> Self { + self.use_gop_remaining_frames = use_gop_remaining_frames.into(); + self + } + pub fn gop_remaining_i(mut self, gop_remaining_i: u32) -> Self { + self.gop_remaining_i = gop_remaining_i; + self + } + pub fn gop_remaining_p(mut self, gop_remaining_p: u32) -> Self { + self.gop_remaining_p = gop_remaining_p; + self + } + pub fn gop_remaining_b(mut self, gop_remaining_b: u32) -> Self { + self.gop_remaining_b = gop_remaining_b; + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct VideoEncodeH265RateControlLayerInfoKHR<'a> { @@ -168,6 +751,56 @@ pub struct VideoEncodeH265RateControlLayerInfoKHR<'a> { pub max_frame_size: crate::vk::VideoEncodeH265FrameSizeKHR, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for VideoEncodeH265RateControlLayerInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_KHR; +} +unsafe impl<'a> crate::Extends> +for VideoEncodeH265RateControlLayerInfoKHR<'a> {} +impl<'a> Default for VideoEncodeH265RateControlLayerInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + use_min_qp: Default::default(), + min_qp: Default::default(), + use_max_qp: Default::default(), + max_qp: Default::default(), + use_max_frame_size: Default::default(), + max_frame_size: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> VideoEncodeH265RateControlLayerInfoKHR<'a> { + pub fn use_min_qp(mut self, use_min_qp: bool) -> Self { + self.use_min_qp = use_min_qp.into(); + self + } + pub fn min_qp(mut self, min_qp: crate::vk::VideoEncodeH265QpKHR) -> Self { + self.min_qp = min_qp; + self + } + pub fn use_max_qp(mut self, use_max_qp: bool) -> Self { + self.use_max_qp = use_max_qp.into(); + self + } + pub fn max_qp(mut self, max_qp: crate::vk::VideoEncodeH265QpKHR) -> Self { + self.max_qp = max_qp; + self + } + pub fn use_max_frame_size(mut self, use_max_frame_size: bool) -> Self { + self.use_max_frame_size = use_max_frame_size.into(); + self + } + pub fn max_frame_size( + mut self, + max_frame_size: crate::vk::VideoEncodeH265FrameSizeKHR, + ) -> Self { + self.max_frame_size = max_frame_size; + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct VideoEncodeH265ProfileInfoKHR<'a> { @@ -176,6 +809,32 @@ pub struct VideoEncodeH265ProfileInfoKHR<'a> { pub std_profile_idc: crate::vk::H265ProfileIdc, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> for VideoEncodeH265ProfileInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::VIDEO_ENCODE_H265_PROFILE_INFO_KHR; +} +unsafe impl<'a> crate::Extends> +for VideoEncodeH265ProfileInfoKHR<'a> {} +unsafe impl<'a> crate::Extends> +for VideoEncodeH265ProfileInfoKHR<'a> {} +impl<'a> Default for VideoEncodeH265ProfileInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + std_profile_idc: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> VideoEncodeH265ProfileInfoKHR<'a> { + pub fn std_profile_idc( + mut self, + std_profile_idc: crate::vk::H265ProfileIdc, + ) -> Self { + self.std_profile_idc = std_profile_idc; + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct VideoEncodeH265DpbSlotInfoKHR<'a> { @@ -184,6 +843,30 @@ pub struct VideoEncodeH265DpbSlotInfoKHR<'a> { pub p_std_reference_info: *const crate::vk::EncodeH265ReferenceInfo, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> for VideoEncodeH265DpbSlotInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::VIDEO_ENCODE_H265_DPB_SLOT_INFO_KHR; +} +unsafe impl<'a> crate::Extends> +for VideoEncodeH265DpbSlotInfoKHR<'a> {} +impl<'a> Default for VideoEncodeH265DpbSlotInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + p_std_reference_info: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> VideoEncodeH265DpbSlotInfoKHR<'a> { + pub fn p_std_reference_info( + mut self, + p_std_reference_info: &'a crate::vk::EncodeH265ReferenceInfo, + ) -> Self { + self.p_std_reference_info = p_std_reference_info; + self + } +} ///Provided by [`khr::video_encode_h265`](crate::khr::video_encode_h265) impl crate::vk::StructureType { pub const VIDEO_ENCODE_H265_CAPABILITIES_KHR: Self = Self(1000039000); @@ -313,7 +996,7 @@ impl core::ops::Not for VideoEncodeH265CapabilityFlagsKHR { } } #[repr(transparent)] -#[derive(Clone, Copy)] +#[derive(Clone, Copy, Default)] pub struct VideoEncodeH265CapabilityFlagBitsKHR(pub(crate) u32); ///Provided by [`khr::video_encode_h265`](crate::khr::video_encode_h265) impl VideoEncodeH265CapabilityFlagBitsKHR { @@ -459,7 +1142,7 @@ impl core::ops::Not for VideoEncodeH265StdFlagsKHR { } } #[repr(transparent)] -#[derive(Clone, Copy)] +#[derive(Clone, Copy, Default)] pub struct VideoEncodeH265StdFlagBitsKHR(pub(crate) u32); ///Provided by [`khr::video_encode_h265`](crate::khr::video_encode_h265) impl VideoEncodeH265StdFlagBitsKHR { @@ -568,7 +1251,7 @@ impl core::ops::Not for VideoEncodeH265RateControlFlagsKHR { } } #[repr(transparent)] -#[derive(Clone, Copy)] +#[derive(Clone, Copy, Default)] pub struct VideoEncodeH265RateControlFlagBitsKHR(pub(crate) u32); ///Provided by [`khr::video_encode_h265`](crate::khr::video_encode_h265) impl VideoEncodeH265RateControlFlagBitsKHR { @@ -649,7 +1332,7 @@ impl core::ops::Not for VideoEncodeH265CtbSizeFlagsKHR { } } #[repr(transparent)] -#[derive(Clone, Copy)] +#[derive(Clone, Copy, Default)] pub struct VideoEncodeH265CtbSizeFlagBitsKHR(pub(crate) u32); ///Provided by [`khr::video_encode_h265`](crate::khr::video_encode_h265) impl VideoEncodeH265CtbSizeFlagBitsKHR { @@ -737,7 +1420,7 @@ impl core::ops::Not for VideoEncodeH265TransformBlockSizeFlagsKHR { } } #[repr(transparent)] -#[derive(Clone, Copy)] +#[derive(Clone, Copy, Default)] pub struct VideoEncodeH265TransformBlockSizeFlagBitsKHR(pub(crate) u32); ///Provided by [`khr::video_encode_h265`](crate::khr::video_encode_h265) impl VideoEncodeH265TransformBlockSizeFlagBitsKHR { diff --git a/ash-rewrite/src/generated/khr/video_encode_intra_refresh.rs b/ash-rewrite/src/generated/khr/video_encode_intra_refresh.rs index f95477b04..c75f286f4 100644 --- a/ash-rewrite/src/generated/khr/video_encode_intra_refresh.rs +++ b/ash-rewrite/src/generated/khr/video_encode_intra_refresh.rs @@ -13,6 +13,65 @@ pub struct VideoEncodeIntraRefreshCapabilitiesKHR<'a> { pub non_rectangular_intra_refresh_regions: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for VideoEncodeIntraRefreshCapabilitiesKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::VIDEO_ENCODE_INTRA_REFRESH_CAPABILITIES_KHR; +} +unsafe impl<'a> crate::Extends> +for VideoEncodeIntraRefreshCapabilitiesKHR<'a> {} +impl<'a> Default for VideoEncodeIntraRefreshCapabilitiesKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + intra_refresh_modes: Default::default(), + max_intra_refresh_cycle_duration: Default::default(), + max_intra_refresh_active_reference_pictures: Default::default(), + partition_independent_intra_refresh_regions: Default::default(), + non_rectangular_intra_refresh_regions: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> VideoEncodeIntraRefreshCapabilitiesKHR<'a> { + pub fn intra_refresh_modes( + mut self, + intra_refresh_modes: crate::vk::VideoEncodeIntraRefreshModeFlagsKHR, + ) -> Self { + self.intra_refresh_modes = intra_refresh_modes; + self + } + pub fn max_intra_refresh_cycle_duration( + mut self, + max_intra_refresh_cycle_duration: u32, + ) -> Self { + self.max_intra_refresh_cycle_duration = max_intra_refresh_cycle_duration; + self + } + pub fn max_intra_refresh_active_reference_pictures( + mut self, + max_intra_refresh_active_reference_pictures: u32, + ) -> Self { + self.max_intra_refresh_active_reference_pictures = max_intra_refresh_active_reference_pictures; + self + } + pub fn partition_independent_intra_refresh_regions( + mut self, + partition_independent_intra_refresh_regions: bool, + ) -> Self { + self.partition_independent_intra_refresh_regions = partition_independent_intra_refresh_regions + .into(); + self + } + pub fn non_rectangular_intra_refresh_regions( + mut self, + non_rectangular_intra_refresh_regions: bool, + ) -> Self { + self.non_rectangular_intra_refresh_regions = non_rectangular_intra_refresh_regions + .into(); + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct VideoEncodeSessionIntraRefreshCreateInfoKHR<'a> { @@ -21,6 +80,31 @@ pub struct VideoEncodeSessionIntraRefreshCreateInfoKHR<'a> { pub intra_refresh_mode: crate::vk::VideoEncodeIntraRefreshModeFlagBitsKHR, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for VideoEncodeSessionIntraRefreshCreateInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::VIDEO_ENCODE_SESSION_INTRA_REFRESH_CREATE_INFO_KHR; +} +unsafe impl<'a> crate::Extends> +for VideoEncodeSessionIntraRefreshCreateInfoKHR<'a> {} +impl<'a> Default for VideoEncodeSessionIntraRefreshCreateInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + intra_refresh_mode: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> VideoEncodeSessionIntraRefreshCreateInfoKHR<'a> { + pub fn intra_refresh_mode( + mut self, + intra_refresh_mode: crate::vk::VideoEncodeIntraRefreshModeFlagBitsKHR, + ) -> Self { + self.intra_refresh_mode = intra_refresh_mode; + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct VideoEncodeIntraRefreshInfoKHR<'a> { @@ -30,6 +114,35 @@ pub struct VideoEncodeIntraRefreshInfoKHR<'a> { pub intra_refresh_index: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> for VideoEncodeIntraRefreshInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::VIDEO_ENCODE_INTRA_REFRESH_INFO_KHR; +} +unsafe impl<'a> crate::Extends> +for VideoEncodeIntraRefreshInfoKHR<'a> {} +impl<'a> Default for VideoEncodeIntraRefreshInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + intra_refresh_cycle_duration: Default::default(), + intra_refresh_index: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> VideoEncodeIntraRefreshInfoKHR<'a> { + pub fn intra_refresh_cycle_duration( + mut self, + intra_refresh_cycle_duration: u32, + ) -> Self { + self.intra_refresh_cycle_duration = intra_refresh_cycle_duration; + self + } + pub fn intra_refresh_index(mut self, intra_refresh_index: u32) -> Self { + self.intra_refresh_index = intra_refresh_index; + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct VideoReferenceIntraRefreshInfoKHR<'a> { @@ -38,6 +151,30 @@ pub struct VideoReferenceIntraRefreshInfoKHR<'a> { pub dirty_intra_refresh_regions: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> for VideoReferenceIntraRefreshInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::VIDEO_REFERENCE_INTRA_REFRESH_INFO_KHR; +} +unsafe impl<'a> crate::Extends> +for VideoReferenceIntraRefreshInfoKHR<'a> {} +impl<'a> Default for VideoReferenceIntraRefreshInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + dirty_intra_refresh_regions: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> VideoReferenceIntraRefreshInfoKHR<'a> { + pub fn dirty_intra_refresh_regions( + mut self, + dirty_intra_refresh_regions: u32, + ) -> Self { + self.dirty_intra_refresh_regions = dirty_intra_refresh_regions; + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR<'a> { @@ -46,6 +183,33 @@ pub struct PhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR<'a> { pub video_encode_intra_refresh: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_VIDEO_ENCODE_INTRA_REFRESH_FEATURES_KHR; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR<'a> {} +impl<'a> Default for PhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + video_encode_intra_refresh: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR<'a> { + pub fn video_encode_intra_refresh( + mut self, + video_encode_intra_refresh: bool, + ) -> Self { + self.video_encode_intra_refresh = video_encode_intra_refresh.into(); + self + } +} ///Provided by [`khr::video_encode_intra_refresh`](crate::khr::video_encode_intra_refresh) impl crate::vk::StructureType { pub const VIDEO_ENCODE_INTRA_REFRESH_CAPABILITIES_KHR: Self = Self(1000552000); @@ -143,7 +307,7 @@ impl core::ops::Not for VideoEncodeIntraRefreshModeFlagsKHR { } } #[repr(transparent)] -#[derive(Clone, Copy)] +#[derive(Clone, Copy, Default)] pub struct VideoEncodeIntraRefreshModeFlagBitsKHR(pub(crate) u32); ///Provided by [`khr::video_encode_intra_refresh`](crate::khr::video_encode_intra_refresh) impl VideoEncodeIntraRefreshModeFlagBitsKHR { diff --git a/ash-rewrite/src/generated/khr/video_encode_quantization_map.rs b/ash-rewrite/src/generated/khr/video_encode_quantization_map.rs index 0da33dea3..7e404c63f 100644 --- a/ash-rewrite/src/generated/khr/video_encode_quantization_map.rs +++ b/ash-rewrite/src/generated/khr/video_encode_quantization_map.rs @@ -9,6 +9,31 @@ pub struct VideoEncodeQuantizationMapCapabilitiesKHR<'a> { pub max_quantization_map_extent: crate::vk::Extent2D, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for VideoEncodeQuantizationMapCapabilitiesKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::VIDEO_ENCODE_QUANTIZATION_MAP_CAPABILITIES_KHR; +} +unsafe impl<'a> crate::Extends> +for VideoEncodeQuantizationMapCapabilitiesKHR<'a> {} +impl<'a> Default for VideoEncodeQuantizationMapCapabilitiesKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + max_quantization_map_extent: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> VideoEncodeQuantizationMapCapabilitiesKHR<'a> { + pub fn max_quantization_map_extent( + mut self, + max_quantization_map_extent: crate::vk::Extent2D, + ) -> Self { + self.max_quantization_map_extent = max_quantization_map_extent; + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct VideoEncodeH264QuantizationMapCapabilitiesKHR<'a> { @@ -18,6 +43,33 @@ pub struct VideoEncodeH264QuantizationMapCapabilitiesKHR<'a> { pub max_qp_delta: i32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for VideoEncodeH264QuantizationMapCapabilitiesKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::VIDEO_ENCODE_H264_QUANTIZATION_MAP_CAPABILITIES_KHR; +} +unsafe impl<'a> crate::Extends> +for VideoEncodeH264QuantizationMapCapabilitiesKHR<'a> {} +impl<'a> Default for VideoEncodeH264QuantizationMapCapabilitiesKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + min_qp_delta: Default::default(), + max_qp_delta: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> VideoEncodeH264QuantizationMapCapabilitiesKHR<'a> { + pub fn min_qp_delta(mut self, min_qp_delta: i32) -> Self { + self.min_qp_delta = min_qp_delta; + self + } + pub fn max_qp_delta(mut self, max_qp_delta: i32) -> Self { + self.max_qp_delta = max_qp_delta; + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct VideoEncodeH265QuantizationMapCapabilitiesKHR<'a> { @@ -27,6 +79,33 @@ pub struct VideoEncodeH265QuantizationMapCapabilitiesKHR<'a> { pub max_qp_delta: i32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for VideoEncodeH265QuantizationMapCapabilitiesKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::VIDEO_ENCODE_H265_QUANTIZATION_MAP_CAPABILITIES_KHR; +} +unsafe impl<'a> crate::Extends> +for VideoEncodeH265QuantizationMapCapabilitiesKHR<'a> {} +impl<'a> Default for VideoEncodeH265QuantizationMapCapabilitiesKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + min_qp_delta: Default::default(), + max_qp_delta: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> VideoEncodeH265QuantizationMapCapabilitiesKHR<'a> { + pub fn min_qp_delta(mut self, min_qp_delta: i32) -> Self { + self.min_qp_delta = min_qp_delta; + self + } + pub fn max_qp_delta(mut self, max_qp_delta: i32) -> Self { + self.max_qp_delta = max_qp_delta; + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct VideoEncodeAV1QuantizationMapCapabilitiesKHR<'a> { @@ -36,6 +115,33 @@ pub struct VideoEncodeAV1QuantizationMapCapabilitiesKHR<'a> { pub max_q_index_delta: i32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for VideoEncodeAV1QuantizationMapCapabilitiesKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::VIDEO_ENCODE_AV1_QUANTIZATION_MAP_CAPABILITIES_KHR; +} +unsafe impl<'a> crate::Extends> +for VideoEncodeAV1QuantizationMapCapabilitiesKHR<'a> {} +impl<'a> Default for VideoEncodeAV1QuantizationMapCapabilitiesKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + min_q_index_delta: Default::default(), + max_q_index_delta: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> VideoEncodeAV1QuantizationMapCapabilitiesKHR<'a> { + pub fn min_q_index_delta(mut self, min_q_index_delta: i32) -> Self { + self.min_q_index_delta = min_q_index_delta; + self + } + pub fn max_q_index_delta(mut self, max_q_index_delta: i32) -> Self { + self.max_q_index_delta = max_q_index_delta; + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct VideoFormatQuantizationMapPropertiesKHR<'a> { @@ -44,6 +150,31 @@ pub struct VideoFormatQuantizationMapPropertiesKHR<'a> { pub quantization_map_texel_size: crate::vk::Extent2D, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for VideoFormatQuantizationMapPropertiesKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::VIDEO_FORMAT_QUANTIZATION_MAP_PROPERTIES_KHR; +} +unsafe impl<'a> crate::Extends> +for VideoFormatQuantizationMapPropertiesKHR<'a> {} +impl<'a> Default for VideoFormatQuantizationMapPropertiesKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + quantization_map_texel_size: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> VideoFormatQuantizationMapPropertiesKHR<'a> { + pub fn quantization_map_texel_size( + mut self, + quantization_map_texel_size: crate::vk::Extent2D, + ) -> Self { + self.quantization_map_texel_size = quantization_map_texel_size; + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct VideoFormatH265QuantizationMapPropertiesKHR<'a> { @@ -52,6 +183,31 @@ pub struct VideoFormatH265QuantizationMapPropertiesKHR<'a> { pub compatible_ctb_sizes: crate::vk::VideoEncodeH265CtbSizeFlagsKHR, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for VideoFormatH265QuantizationMapPropertiesKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::VIDEO_FORMAT_H265_QUANTIZATION_MAP_PROPERTIES_KHR; +} +unsafe impl<'a> crate::Extends> +for VideoFormatH265QuantizationMapPropertiesKHR<'a> {} +impl<'a> Default for VideoFormatH265QuantizationMapPropertiesKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + compatible_ctb_sizes: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> VideoFormatH265QuantizationMapPropertiesKHR<'a> { + pub fn compatible_ctb_sizes( + mut self, + compatible_ctb_sizes: crate::vk::VideoEncodeH265CtbSizeFlagsKHR, + ) -> Self { + self.compatible_ctb_sizes = compatible_ctb_sizes; + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct VideoFormatAV1QuantizationMapPropertiesKHR<'a> { @@ -60,6 +216,31 @@ pub struct VideoFormatAV1QuantizationMapPropertiesKHR<'a> { pub compatible_superblock_sizes: crate::vk::VideoEncodeAV1SuperblockSizeFlagsKHR, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for VideoFormatAV1QuantizationMapPropertiesKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::VIDEO_FORMAT_AV1_QUANTIZATION_MAP_PROPERTIES_KHR; +} +unsafe impl<'a> crate::Extends> +for VideoFormatAV1QuantizationMapPropertiesKHR<'a> {} +impl<'a> Default for VideoFormatAV1QuantizationMapPropertiesKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + compatible_superblock_sizes: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> VideoFormatAV1QuantizationMapPropertiesKHR<'a> { + pub fn compatible_superblock_sizes( + mut self, + compatible_superblock_sizes: crate::vk::VideoEncodeAV1SuperblockSizeFlagsKHR, + ) -> Self { + self.compatible_superblock_sizes = compatible_superblock_sizes; + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct VideoEncodeQuantizationMapInfoKHR<'a> { @@ -69,6 +250,35 @@ pub struct VideoEncodeQuantizationMapInfoKHR<'a> { pub quantization_map_extent: crate::vk::Extent2D, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> for VideoEncodeQuantizationMapInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::VIDEO_ENCODE_QUANTIZATION_MAP_INFO_KHR; +} +unsafe impl<'a> crate::Extends> +for VideoEncodeQuantizationMapInfoKHR<'a> {} +impl<'a> Default for VideoEncodeQuantizationMapInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + quantization_map: Default::default(), + quantization_map_extent: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> VideoEncodeQuantizationMapInfoKHR<'a> { + pub fn quantization_map(mut self, quantization_map: crate::vk::ImageView) -> Self { + self.quantization_map = quantization_map; + self + } + pub fn quantization_map_extent( + mut self, + quantization_map_extent: crate::vk::Extent2D, + ) -> Self { + self.quantization_map_extent = quantization_map_extent; + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct VideoEncodeQuantizationMapSessionParametersCreateInfoKHR<'a> { @@ -77,6 +287,31 @@ pub struct VideoEncodeQuantizationMapSessionParametersCreateInfoKHR<'a> { pub quantization_map_texel_size: crate::vk::Extent2D, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for VideoEncodeQuantizationMapSessionParametersCreateInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::VIDEO_ENCODE_QUANTIZATION_MAP_SESSION_PARAMETERS_CREATE_INFO_KHR; +} +unsafe impl<'a> crate::Extends> +for VideoEncodeQuantizationMapSessionParametersCreateInfoKHR<'a> {} +impl<'a> Default for VideoEncodeQuantizationMapSessionParametersCreateInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + quantization_map_texel_size: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> VideoEncodeQuantizationMapSessionParametersCreateInfoKHR<'a> { + pub fn quantization_map_texel_size( + mut self, + quantization_map_texel_size: crate::vk::Extent2D, + ) -> Self { + self.quantization_map_texel_size = quantization_map_texel_size; + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR<'a> { @@ -85,6 +320,33 @@ pub struct PhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR<'a> { pub video_encode_quantization_map: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_VIDEO_ENCODE_QUANTIZATION_MAP_FEATURES_KHR; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR<'a> {} +impl<'a> Default for PhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + video_encode_quantization_map: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR<'a> { + pub fn video_encode_quantization_map( + mut self, + video_encode_quantization_map: bool, + ) -> Self { + self.video_encode_quantization_map = video_encode_quantization_map.into(); + self + } +} ///Provided by [`khr::video_encode_quantization_map`](crate::khr::video_encode_quantization_map) impl crate::vk::ImageLayout { pub const VIDEO_ENCODE_QUANTIZATION_MAP_KHR: Self = Self(1000553000); diff --git a/ash-rewrite/src/generated/khr/video_encode_queue.rs b/ash-rewrite/src/generated/khr/video_encode_queue.rs index edca200f1..da7f4ea02 100644 --- a/ash-rewrite/src/generated/khr/video_encode_queue.rs +++ b/ash-rewrite/src/generated/khr/video_encode_queue.rs @@ -99,6 +99,29 @@ pub(crate) mod reexport { pub video_session_parameters: crate::vk::VideoSessionParametersKHR, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for VideoEncodeSessionParametersGetInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::VIDEO_ENCODE_SESSION_PARAMETERS_GET_INFO_KHR; + } + impl<'a> Default for VideoEncodeSessionParametersGetInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + video_session_parameters: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> VideoEncodeSessionParametersGetInfoKHR<'a> { + pub fn video_session_parameters( + mut self, + video_session_parameters: crate::vk::VideoSessionParametersKHR, + ) -> Self { + self.video_session_parameters = video_session_parameters; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct VideoEncodeSessionParametersFeedbackInfoKHR<'a> { @@ -107,6 +130,26 @@ pub(crate) mod reexport { pub has_overrides: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for VideoEncodeSessionParametersFeedbackInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::VIDEO_ENCODE_SESSION_PARAMETERS_FEEDBACK_INFO_KHR; + } + impl<'a> Default for VideoEncodeSessionParametersFeedbackInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + has_overrides: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> VideoEncodeSessionParametersFeedbackInfoKHR<'a> { + pub fn has_overrides(mut self, has_overrides: bool) -> Self { + self.has_overrides = has_overrides.into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct VideoEncodeUsageInfoKHR<'a> { @@ -117,6 +160,48 @@ pub(crate) mod reexport { pub tuning_mode: crate::vk::VideoEncodeTuningModeKHR, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for VideoEncodeUsageInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::VIDEO_ENCODE_USAGE_INFO_KHR; + } + unsafe impl<'a> crate::Extends> + for VideoEncodeUsageInfoKHR<'a> {} + unsafe impl<'a> crate::Extends> + for VideoEncodeUsageInfoKHR<'a> {} + impl<'a> Default for VideoEncodeUsageInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + video_usage_hints: Default::default(), + video_content_hints: Default::default(), + tuning_mode: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> VideoEncodeUsageInfoKHR<'a> { + pub fn video_usage_hints( + mut self, + video_usage_hints: crate::vk::VideoEncodeUsageFlagsKHR, + ) -> Self { + self.video_usage_hints = video_usage_hints; + self + } + pub fn video_content_hints( + mut self, + video_content_hints: crate::vk::VideoEncodeContentFlagsKHR, + ) -> Self { + self.video_content_hints = video_content_hints; + self + } + pub fn tuning_mode( + mut self, + tuning_mode: crate::vk::VideoEncodeTuningModeKHR, + ) -> Self { + self.tuning_mode = tuning_mode; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct VideoEncodeInfoKHR<'a> { @@ -133,6 +218,84 @@ pub(crate) mod reexport { pub preceding_externally_encoded_bytes: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for VideoEncodeInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::VIDEO_ENCODE_INFO_KHR; + } + impl<'a> Default for VideoEncodeInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + flags: Default::default(), + dst_buffer: Default::default(), + dst_buffer_offset: Default::default(), + dst_buffer_range: Default::default(), + src_picture_resource: Default::default(), + p_setup_reference_slot: Default::default(), + reference_slot_count: Default::default(), + p_reference_slots: Default::default(), + preceding_externally_encoded_bytes: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> VideoEncodeInfoKHR<'a> { + pub fn flags(mut self, flags: crate::vk::VideoEncodeFlagsKHR) -> Self { + self.flags = flags; + self + } + pub fn dst_buffer(mut self, dst_buffer: crate::vk::Buffer) -> Self { + self.dst_buffer = dst_buffer; + self + } + pub fn dst_buffer_offset( + mut self, + dst_buffer_offset: crate::vk::DeviceSize, + ) -> Self { + self.dst_buffer_offset = dst_buffer_offset; + self + } + pub fn dst_buffer_range( + mut self, + dst_buffer_range: crate::vk::DeviceSize, + ) -> Self { + self.dst_buffer_range = dst_buffer_range; + self + } + pub fn src_picture_resource( + mut self, + src_picture_resource: crate::vk::VideoPictureResourceInfoKHR<'a>, + ) -> Self { + self.src_picture_resource = src_picture_resource; + self + } + pub fn p_setup_reference_slot( + mut self, + p_setup_reference_slot: &'a crate::vk::VideoReferenceSlotInfoKHR<'a>, + ) -> Self { + self.p_setup_reference_slot = p_setup_reference_slot; + self + } + pub fn reference_slot_count(mut self, reference_slot_count: u32) -> Self { + self.reference_slot_count = reference_slot_count; + self + } + pub fn p_reference_slots( + mut self, + p_reference_slots: &'a [crate::vk::VideoReferenceSlotInfoKHR<'a>], + ) -> Self { + self.reference_slot_count = p_reference_slots.len() as _; + self.p_reference_slots = p_reference_slots.as_ptr(); + self + } + pub fn preceding_externally_encoded_bytes( + mut self, + preceding_externally_encoded_bytes: u32, + ) -> Self { + self.preceding_externally_encoded_bytes = preceding_externally_encoded_bytes; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct QueryPoolVideoEncodeFeedbackCreateInfoKHR<'a> { @@ -141,6 +304,31 @@ pub(crate) mod reexport { pub encode_feedback_flags: crate::vk::VideoEncodeFeedbackFlagsKHR, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for QueryPoolVideoEncodeFeedbackCreateInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::QUERY_POOL_VIDEO_ENCODE_FEEDBACK_CREATE_INFO_KHR; + } + unsafe impl<'a> crate::Extends> + for QueryPoolVideoEncodeFeedbackCreateInfoKHR<'a> {} + impl<'a> Default for QueryPoolVideoEncodeFeedbackCreateInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + encode_feedback_flags: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> QueryPoolVideoEncodeFeedbackCreateInfoKHR<'a> { + pub fn encode_feedback_flags( + mut self, + encode_feedback_flags: crate::vk::VideoEncodeFeedbackFlagsKHR, + ) -> Self { + self.encode_feedback_flags = encode_feedback_flags; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct VideoEncodeQualityLevelInfoKHR<'a> { @@ -149,6 +337,29 @@ pub(crate) mod reexport { pub quality_level: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for VideoEncodeQualityLevelInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR; + } + unsafe impl<'a> crate::Extends> + for VideoEncodeQualityLevelInfoKHR<'a> {} + unsafe impl<'a> crate::Extends> + for VideoEncodeQualityLevelInfoKHR<'a> {} + impl<'a> Default for VideoEncodeQualityLevelInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + quality_level: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> VideoEncodeQualityLevelInfoKHR<'a> { + pub fn quality_level(mut self, quality_level: u32) -> Self { + self.quality_level = quality_level; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceVideoEncodeQualityLevelInfoKHR<'a> { @@ -158,6 +369,34 @@ pub(crate) mod reexport { pub quality_level: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceVideoEncodeQualityLevelInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR; + } + impl<'a> Default for PhysicalDeviceVideoEncodeQualityLevelInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + p_video_profile: Default::default(), + quality_level: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceVideoEncodeQualityLevelInfoKHR<'a> { + pub fn p_video_profile( + mut self, + p_video_profile: &'a crate::vk::VideoProfileInfoKHR<'a>, + ) -> Self { + self.p_video_profile = p_video_profile; + self + } + pub fn quality_level(mut self, quality_level: u32) -> Self { + self.quality_level = quality_level; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct VideoEncodeQualityLevelPropertiesKHR<'a> { @@ -167,6 +406,37 @@ pub(crate) mod reexport { pub preferred_rate_control_layer_count: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for VideoEncodeQualityLevelPropertiesKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::VIDEO_ENCODE_QUALITY_LEVEL_PROPERTIES_KHR; + } + impl<'a> Default for VideoEncodeQualityLevelPropertiesKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + preferred_rate_control_mode: Default::default(), + preferred_rate_control_layer_count: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> VideoEncodeQualityLevelPropertiesKHR<'a> { + pub fn preferred_rate_control_mode( + mut self, + preferred_rate_control_mode: crate::vk::VideoEncodeRateControlModeFlagBitsKHR, + ) -> Self { + self.preferred_rate_control_mode = preferred_rate_control_mode; + self + } + pub fn preferred_rate_control_layer_count( + mut self, + preferred_rate_control_layer_count: u32, + ) -> Self { + self.preferred_rate_control_layer_count = preferred_rate_control_layer_count; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct VideoEncodeRateControlInfoKHR<'a> { @@ -180,6 +450,70 @@ pub(crate) mod reexport { pub initial_virtual_buffer_size_in_ms: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for VideoEncodeRateControlInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::VIDEO_ENCODE_RATE_CONTROL_INFO_KHR; + } + unsafe impl<'a> crate::Extends> + for VideoEncodeRateControlInfoKHR<'a> {} + unsafe impl<'a> crate::Extends> + for VideoEncodeRateControlInfoKHR<'a> {} + impl<'a> Default for VideoEncodeRateControlInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + flags: Default::default(), + rate_control_mode: Default::default(), + layer_count: Default::default(), + p_layers: Default::default(), + virtual_buffer_size_in_ms: Default::default(), + initial_virtual_buffer_size_in_ms: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> VideoEncodeRateControlInfoKHR<'a> { + pub fn flags( + mut self, + flags: crate::vk::VideoEncodeRateControlFlagsKHR, + ) -> Self { + self.flags = flags; + self + } + pub fn rate_control_mode( + mut self, + rate_control_mode: crate::vk::VideoEncodeRateControlModeFlagBitsKHR, + ) -> Self { + self.rate_control_mode = rate_control_mode; + self + } + pub fn layer_count(mut self, layer_count: u32) -> Self { + self.layer_count = layer_count; + self + } + pub fn p_layers( + mut self, + p_layers: &'a [crate::vk::VideoEncodeRateControlLayerInfoKHR<'a>], + ) -> Self { + self.layer_count = p_layers.len() as _; + self.p_layers = p_layers.as_ptr(); + self + } + pub fn virtual_buffer_size_in_ms( + mut self, + virtual_buffer_size_in_ms: u32, + ) -> Self { + self.virtual_buffer_size_in_ms = virtual_buffer_size_in_ms; + self + } + pub fn initial_virtual_buffer_size_in_ms( + mut self, + initial_virtual_buffer_size_in_ms: u32, + ) -> Self { + self.initial_virtual_buffer_size_in_ms = initial_virtual_buffer_size_in_ms; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct VideoEncodeRateControlLayerInfoKHR<'a> { @@ -191,6 +525,41 @@ pub(crate) mod reexport { pub frame_rate_denominator: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for VideoEncodeRateControlLayerInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::VIDEO_ENCODE_RATE_CONTROL_LAYER_INFO_KHR; + } + impl<'a> Default for VideoEncodeRateControlLayerInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + average_bitrate: Default::default(), + max_bitrate: Default::default(), + frame_rate_numerator: Default::default(), + frame_rate_denominator: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> VideoEncodeRateControlLayerInfoKHR<'a> { + pub fn average_bitrate(mut self, average_bitrate: u64) -> Self { + self.average_bitrate = average_bitrate; + self + } + pub fn max_bitrate(mut self, max_bitrate: u64) -> Self { + self.max_bitrate = max_bitrate; + self + } + pub fn frame_rate_numerator(mut self, frame_rate_numerator: u32) -> Self { + self.frame_rate_numerator = frame_rate_numerator; + self + } + pub fn frame_rate_denominator(mut self, frame_rate_denominator: u32) -> Self { + self.frame_rate_denominator = frame_rate_denominator; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct VideoEncodeCapabilitiesKHR<'a> { @@ -205,6 +574,66 @@ pub(crate) mod reexport { pub supported_encode_feedback_flags: crate::vk::VideoEncodeFeedbackFlagsKHR, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for VideoEncodeCapabilitiesKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::VIDEO_ENCODE_CAPABILITIES_KHR; + } + unsafe impl<'a> crate::Extends> + for VideoEncodeCapabilitiesKHR<'a> {} + impl<'a> Default for VideoEncodeCapabilitiesKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + flags: Default::default(), + rate_control_modes: Default::default(), + max_rate_control_layers: Default::default(), + max_bitrate: Default::default(), + max_quality_levels: Default::default(), + encode_input_picture_granularity: Default::default(), + supported_encode_feedback_flags: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> VideoEncodeCapabilitiesKHR<'a> { + pub fn flags(mut self, flags: crate::vk::VideoEncodeCapabilityFlagsKHR) -> Self { + self.flags = flags; + self + } + pub fn rate_control_modes( + mut self, + rate_control_modes: crate::vk::VideoEncodeRateControlModeFlagsKHR, + ) -> Self { + self.rate_control_modes = rate_control_modes; + self + } + pub fn max_rate_control_layers(mut self, max_rate_control_layers: u32) -> Self { + self.max_rate_control_layers = max_rate_control_layers; + self + } + pub fn max_bitrate(mut self, max_bitrate: u64) -> Self { + self.max_bitrate = max_bitrate; + self + } + pub fn max_quality_levels(mut self, max_quality_levels: u32) -> Self { + self.max_quality_levels = max_quality_levels; + self + } + pub fn encode_input_picture_granularity( + mut self, + encode_input_picture_granularity: crate::vk::Extent2D, + ) -> Self { + self.encode_input_picture_granularity = encode_input_picture_granularity; + self + } + pub fn supported_encode_feedback_flags( + mut self, + supported_encode_feedback_flags: crate::vk::VideoEncodeFeedbackFlagsKHR, + ) -> Self { + self.supported_encode_feedback_flags = supported_encode_feedback_flags; + self + } + } ///Provided by [`khr::video_encode_queue`](crate::khr::video_encode_queue) impl crate::vk::ImageLayout { pub const VIDEO_ENCODE_DST_KHR: Self = Self(1000299000); @@ -383,7 +812,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct VideoEncodeFlagBitsKHR(pub(crate) u32); #[repr(transparent)] #[derive(Clone, Copy)] @@ -466,7 +895,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct VideoEncodeUsageFlagBitsKHR(pub(crate) u32); ///Provided by [`khr::video_encode_queue`](crate::khr::video_encode_queue) impl VideoEncodeUsageFlagBitsKHR { @@ -550,7 +979,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct VideoEncodeContentFlagBitsKHR(pub(crate) u32); ///Provided by [`khr::video_encode_queue`](crate::khr::video_encode_queue) impl VideoEncodeContentFlagBitsKHR { @@ -640,7 +1069,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct VideoEncodeCapabilityFlagBitsKHR(pub(crate) u32); ///Provided by [`khr::video_encode_queue`](crate::khr::video_encode_queue) impl VideoEncodeCapabilityFlagBitsKHR { @@ -724,7 +1153,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct VideoEncodeFeedbackFlagBitsKHR(pub(crate) u32); ///Provided by [`khr::video_encode_queue`](crate::khr::video_encode_queue) impl VideoEncodeFeedbackFlagBitsKHR { @@ -875,7 +1304,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct VideoEncodeRateControlModeFlagBitsKHR(pub(crate) u32); ///Provided by [`khr::video_encode_queue`](crate::khr::video_encode_queue) impl VideoEncodeRateControlModeFlagBitsKHR { diff --git a/ash-rewrite/src/generated/khr/video_maintenance1.rs b/ash-rewrite/src/generated/khr/video_maintenance1.rs index 1f062125d..5f10157d9 100644 --- a/ash-rewrite/src/generated/khr/video_maintenance1.rs +++ b/ash-rewrite/src/generated/khr/video_maintenance1.rs @@ -9,6 +9,30 @@ pub struct PhysicalDeviceVideoMaintenance1FeaturesKHR<'a> { pub video_maintenance1: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceVideoMaintenance1FeaturesKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceVideoMaintenance1FeaturesKHR<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceVideoMaintenance1FeaturesKHR<'a> {} +impl<'a> Default for PhysicalDeviceVideoMaintenance1FeaturesKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + video_maintenance1: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceVideoMaintenance1FeaturesKHR<'a> { + pub fn video_maintenance1(mut self, video_maintenance1: bool) -> Self { + self.video_maintenance1 = video_maintenance1.into(); + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct VideoInlineQueryInfoKHR<'a> { @@ -19,6 +43,39 @@ pub struct VideoInlineQueryInfoKHR<'a> { pub query_count: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> for VideoInlineQueryInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::VIDEO_INLINE_QUERY_INFO_KHR; +} +unsafe impl<'a> crate::Extends> +for VideoInlineQueryInfoKHR<'a> {} +unsafe impl<'a> crate::Extends> +for VideoInlineQueryInfoKHR<'a> {} +impl<'a> Default for VideoInlineQueryInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + query_pool: Default::default(), + first_query: Default::default(), + query_count: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> VideoInlineQueryInfoKHR<'a> { + pub fn query_pool(mut self, query_pool: crate::vk::QueryPool) -> Self { + self.query_pool = query_pool; + self + } + pub fn first_query(mut self, first_query: u32) -> Self { + self.first_query = first_query; + self + } + pub fn query_count(mut self, query_count: u32) -> Self { + self.query_count = query_count; + self + } +} ///Provided by [`khr::video_maintenance1`](crate::khr::video_maintenance1) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR: Self = Self(1000515000); diff --git a/ash-rewrite/src/generated/khr/video_maintenance2.rs b/ash-rewrite/src/generated/khr/video_maintenance2.rs index 79d59c633..800e588a0 100644 --- a/ash-rewrite/src/generated/khr/video_maintenance2.rs +++ b/ash-rewrite/src/generated/khr/video_maintenance2.rs @@ -9,6 +9,30 @@ pub struct PhysicalDeviceVideoMaintenance2FeaturesKHR<'a> { pub video_maintenance2: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceVideoMaintenance2FeaturesKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_VIDEO_MAINTENANCE_2_FEATURES_KHR; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceVideoMaintenance2FeaturesKHR<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceVideoMaintenance2FeaturesKHR<'a> {} +impl<'a> Default for PhysicalDeviceVideoMaintenance2FeaturesKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + video_maintenance2: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceVideoMaintenance2FeaturesKHR<'a> { + pub fn video_maintenance2(mut self, video_maintenance2: bool) -> Self { + self.video_maintenance2 = video_maintenance2.into(); + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct VideoDecodeH264InlineSessionParametersInfoKHR<'a> { @@ -18,6 +42,39 @@ pub struct VideoDecodeH264InlineSessionParametersInfoKHR<'a> { pub p_std_pps: *const crate::vk::H264PictureParameterSet<'a>, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for VideoDecodeH264InlineSessionParametersInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::VIDEO_DECODE_H264_INLINE_SESSION_PARAMETERS_INFO_KHR; +} +unsafe impl<'a> crate::Extends> +for VideoDecodeH264InlineSessionParametersInfoKHR<'a> {} +impl<'a> Default for VideoDecodeH264InlineSessionParametersInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + p_std_sps: Default::default(), + p_std_pps: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> VideoDecodeH264InlineSessionParametersInfoKHR<'a> { + pub fn p_std_sps( + mut self, + p_std_sps: &'a crate::vk::H264SequenceParameterSet<'a>, + ) -> Self { + self.p_std_sps = p_std_sps; + self + } + pub fn p_std_pps( + mut self, + p_std_pps: &'a crate::vk::H264PictureParameterSet<'a>, + ) -> Self { + self.p_std_pps = p_std_pps; + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct VideoDecodeH265InlineSessionParametersInfoKHR<'a> { @@ -28,6 +85,47 @@ pub struct VideoDecodeH265InlineSessionParametersInfoKHR<'a> { pub p_std_pps: *const crate::vk::H265PictureParameterSet<'a>, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for VideoDecodeH265InlineSessionParametersInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::VIDEO_DECODE_H265_INLINE_SESSION_PARAMETERS_INFO_KHR; +} +unsafe impl<'a> crate::Extends> +for VideoDecodeH265InlineSessionParametersInfoKHR<'a> {} +impl<'a> Default for VideoDecodeH265InlineSessionParametersInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + p_std_vps: Default::default(), + p_std_sps: Default::default(), + p_std_pps: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> VideoDecodeH265InlineSessionParametersInfoKHR<'a> { + pub fn p_std_vps( + mut self, + p_std_vps: &'a crate::vk::H265VideoParameterSet<'a>, + ) -> Self { + self.p_std_vps = p_std_vps; + self + } + pub fn p_std_sps( + mut self, + p_std_sps: &'a crate::vk::H265SequenceParameterSet<'a>, + ) -> Self { + self.p_std_sps = p_std_sps; + self + } + pub fn p_std_pps( + mut self, + p_std_pps: &'a crate::vk::H265PictureParameterSet<'a>, + ) -> Self { + self.p_std_pps = p_std_pps; + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct VideoDecodeAV1InlineSessionParametersInfoKHR<'a> { @@ -36,6 +134,31 @@ pub struct VideoDecodeAV1InlineSessionParametersInfoKHR<'a> { pub p_std_sequence_header: *const crate::vk::AV1SequenceHeader<'a>, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for VideoDecodeAV1InlineSessionParametersInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::VIDEO_DECODE_AV1_INLINE_SESSION_PARAMETERS_INFO_KHR; +} +unsafe impl<'a> crate::Extends> +for VideoDecodeAV1InlineSessionParametersInfoKHR<'a> {} +impl<'a> Default for VideoDecodeAV1InlineSessionParametersInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + p_std_sequence_header: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> VideoDecodeAV1InlineSessionParametersInfoKHR<'a> { + pub fn p_std_sequence_header( + mut self, + p_std_sequence_header: &'a crate::vk::AV1SequenceHeader<'a>, + ) -> Self { + self.p_std_sequence_header = p_std_sequence_header; + self + } +} ///Provided by [`khr::video_maintenance2`](crate::khr::video_maintenance2) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_VIDEO_MAINTENANCE_2_FEATURES_KHR: Self = Self(1000586000); diff --git a/ash-rewrite/src/generated/khr/video_queue.rs b/ash-rewrite/src/generated/khr/video_queue.rs index 54ca8be28..bf59d4067 100644 --- a/ash-rewrite/src/generated/khr/video_queue.rs +++ b/ash-rewrite/src/generated/khr/video_queue.rs @@ -240,6 +240,30 @@ pub(crate) mod reexport { pub video_codec_operations: crate::vk::VideoCodecOperationFlagsKHR, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for QueueFamilyVideoPropertiesKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::QUEUE_FAMILY_VIDEO_PROPERTIES_KHR; + } + unsafe impl<'a> crate::Extends> + for QueueFamilyVideoPropertiesKHR<'a> {} + impl<'a> Default for QueueFamilyVideoPropertiesKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + video_codec_operations: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> QueueFamilyVideoPropertiesKHR<'a> { + pub fn video_codec_operations( + mut self, + video_codec_operations: crate::vk::VideoCodecOperationFlagsKHR, + ) -> Self { + self.video_codec_operations = video_codec_operations; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct QueueFamilyQueryResultStatusPropertiesKHR<'a> { @@ -248,6 +272,31 @@ pub(crate) mod reexport { pub query_result_status_support: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for QueueFamilyQueryResultStatusPropertiesKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_KHR; + } + unsafe impl<'a> crate::Extends> + for QueueFamilyQueryResultStatusPropertiesKHR<'a> {} + impl<'a> Default for QueueFamilyQueryResultStatusPropertiesKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + query_result_status_support: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> QueueFamilyQueryResultStatusPropertiesKHR<'a> { + pub fn query_result_status_support( + mut self, + query_result_status_support: bool, + ) -> Self { + self.query_result_status_support = query_result_status_support.into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct VideoProfileListInfoKHR<'a> { @@ -257,6 +306,42 @@ pub(crate) mod reexport { pub p_profiles: *const crate::vk::VideoProfileInfoKHR<'a>, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for VideoProfileListInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::VIDEO_PROFILE_LIST_INFO_KHR; + } + unsafe impl<'a> crate::Extends> + for VideoProfileListInfoKHR<'a> {} + unsafe impl<'a> crate::Extends> + for VideoProfileListInfoKHR<'a> {} + unsafe impl<'a> crate::Extends> + for VideoProfileListInfoKHR<'a> {} + unsafe impl<'a> crate::Extends> + for VideoProfileListInfoKHR<'a> {} + impl<'a> Default for VideoProfileListInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + profile_count: Default::default(), + p_profiles: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> VideoProfileListInfoKHR<'a> { + pub fn profile_count(mut self, profile_count: u32) -> Self { + self.profile_count = profile_count; + self + } + pub fn p_profiles( + mut self, + p_profiles: &'a [crate::vk::VideoProfileInfoKHR<'a>], + ) -> Self { + self.profile_count = p_profiles.len() as _; + self.p_profiles = p_profiles.as_ptr(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceVideoFormatInfoKHR<'a> { @@ -265,6 +350,25 @@ pub(crate) mod reexport { pub image_usage: crate::vk::ImageUsageFlags, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for PhysicalDeviceVideoFormatInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR; + } + impl<'a> Default for PhysicalDeviceVideoFormatInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + image_usage: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceVideoFormatInfoKHR<'a> { + pub fn image_usage(mut self, image_usage: crate::vk::ImageUsageFlags) -> Self { + self.image_usage = image_usage; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct VideoFormatPropertiesKHR<'a> { @@ -278,6 +382,59 @@ pub(crate) mod reexport { pub image_usage_flags: crate::vk::ImageUsageFlags, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for VideoFormatPropertiesKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::VIDEO_FORMAT_PROPERTIES_KHR; + } + impl<'a> Default for VideoFormatPropertiesKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + format: Default::default(), + component_mapping: Default::default(), + image_create_flags: Default::default(), + image_type: Default::default(), + image_tiling: Default::default(), + image_usage_flags: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> VideoFormatPropertiesKHR<'a> { + pub fn format(mut self, format: crate::vk::Format) -> Self { + self.format = format; + self + } + pub fn component_mapping( + mut self, + component_mapping: crate::vk::ComponentMapping, + ) -> Self { + self.component_mapping = component_mapping; + self + } + pub fn image_create_flags( + mut self, + image_create_flags: crate::vk::ImageCreateFlags, + ) -> Self { + self.image_create_flags = image_create_flags; + self + } + pub fn image_type(mut self, image_type: crate::vk::ImageType) -> Self { + self.image_type = image_type; + self + } + pub fn image_tiling(mut self, image_tiling: crate::vk::ImageTiling) -> Self { + self.image_tiling = image_tiling; + self + } + pub fn image_usage_flags( + mut self, + image_usage_flags: crate::vk::ImageUsageFlags, + ) -> Self { + self.image_usage_flags = image_usage_flags; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct VideoProfileInfoKHR<'a> { @@ -289,6 +446,54 @@ pub(crate) mod reexport { pub chroma_bit_depth: crate::vk::VideoComponentBitDepthFlagsKHR, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for VideoProfileInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::VIDEO_PROFILE_INFO_KHR; + } + unsafe impl<'a> crate::Extends> + for VideoProfileInfoKHR<'a> {} + impl<'a> Default for VideoProfileInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + video_codec_operation: Default::default(), + chroma_subsampling: Default::default(), + luma_bit_depth: Default::default(), + chroma_bit_depth: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> VideoProfileInfoKHR<'a> { + pub fn video_codec_operation( + mut self, + video_codec_operation: crate::vk::VideoCodecOperationFlagBitsKHR, + ) -> Self { + self.video_codec_operation = video_codec_operation; + self + } + pub fn chroma_subsampling( + mut self, + chroma_subsampling: crate::vk::VideoChromaSubsamplingFlagsKHR, + ) -> Self { + self.chroma_subsampling = chroma_subsampling; + self + } + pub fn luma_bit_depth( + mut self, + luma_bit_depth: crate::vk::VideoComponentBitDepthFlagsKHR, + ) -> Self { + self.luma_bit_depth = luma_bit_depth; + self + } + pub fn chroma_bit_depth( + mut self, + chroma_bit_depth: crate::vk::VideoComponentBitDepthFlagsKHR, + ) -> Self { + self.chroma_bit_depth = chroma_bit_depth; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct VideoCapabilitiesKHR<'a> { @@ -305,6 +510,86 @@ pub(crate) mod reexport { pub std_header_version: crate::vk::ExtensionProperties, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for VideoCapabilitiesKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::VIDEO_CAPABILITIES_KHR; + } + impl<'a> Default for VideoCapabilitiesKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + flags: Default::default(), + min_bitstream_buffer_offset_alignment: Default::default(), + min_bitstream_buffer_size_alignment: Default::default(), + picture_access_granularity: Default::default(), + min_coded_extent: Default::default(), + max_coded_extent: Default::default(), + max_dpb_slots: Default::default(), + max_active_reference_pictures: Default::default(), + std_header_version: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> VideoCapabilitiesKHR<'a> { + pub fn flags(mut self, flags: crate::vk::VideoCapabilityFlagsKHR) -> Self { + self.flags = flags; + self + } + pub fn min_bitstream_buffer_offset_alignment( + mut self, + min_bitstream_buffer_offset_alignment: crate::vk::DeviceSize, + ) -> Self { + self.min_bitstream_buffer_offset_alignment = min_bitstream_buffer_offset_alignment; + self + } + pub fn min_bitstream_buffer_size_alignment( + mut self, + min_bitstream_buffer_size_alignment: crate::vk::DeviceSize, + ) -> Self { + self.min_bitstream_buffer_size_alignment = min_bitstream_buffer_size_alignment; + self + } + pub fn picture_access_granularity( + mut self, + picture_access_granularity: crate::vk::Extent2D, + ) -> Self { + self.picture_access_granularity = picture_access_granularity; + self + } + pub fn min_coded_extent( + mut self, + min_coded_extent: crate::vk::Extent2D, + ) -> Self { + self.min_coded_extent = min_coded_extent; + self + } + pub fn max_coded_extent( + mut self, + max_coded_extent: crate::vk::Extent2D, + ) -> Self { + self.max_coded_extent = max_coded_extent; + self + } + pub fn max_dpb_slots(mut self, max_dpb_slots: u32) -> Self { + self.max_dpb_slots = max_dpb_slots; + self + } + pub fn max_active_reference_pictures( + mut self, + max_active_reference_pictures: u32, + ) -> Self { + self.max_active_reference_pictures = max_active_reference_pictures; + self + } + pub fn std_header_version( + mut self, + std_header_version: crate::vk::ExtensionProperties, + ) -> Self { + self.std_header_version = std_header_version; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct VideoSessionMemoryRequirementsKHR<'a> { @@ -314,6 +599,34 @@ pub(crate) mod reexport { pub memory_requirements: crate::vk::MemoryRequirements, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for VideoSessionMemoryRequirementsKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::VIDEO_SESSION_MEMORY_REQUIREMENTS_KHR; + } + impl<'a> Default for VideoSessionMemoryRequirementsKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + memory_bind_index: Default::default(), + memory_requirements: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> VideoSessionMemoryRequirementsKHR<'a> { + pub fn memory_bind_index(mut self, memory_bind_index: u32) -> Self { + self.memory_bind_index = memory_bind_index; + self + } + pub fn memory_requirements( + mut self, + memory_requirements: crate::vk::MemoryRequirements, + ) -> Self { + self.memory_requirements = memory_requirements; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct BindVideoSessionMemoryInfoKHR<'a> { @@ -325,6 +638,40 @@ pub(crate) mod reexport { pub memory_size: crate::vk::DeviceSize, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for BindVideoSessionMemoryInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::BIND_VIDEO_SESSION_MEMORY_INFO_KHR; + } + impl<'a> Default for BindVideoSessionMemoryInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + memory_bind_index: Default::default(), + memory: Default::default(), + memory_offset: Default::default(), + memory_size: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> BindVideoSessionMemoryInfoKHR<'a> { + pub fn memory_bind_index(mut self, memory_bind_index: u32) -> Self { + self.memory_bind_index = memory_bind_index; + self + } + pub fn memory(mut self, memory: crate::vk::DeviceMemory) -> Self { + self.memory = memory; + self + } + pub fn memory_offset(mut self, memory_offset: crate::vk::DeviceSize) -> Self { + self.memory_offset = memory_offset; + self + } + pub fn memory_size(mut self, memory_size: crate::vk::DeviceSize) -> Self { + self.memory_size = memory_size; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct VideoPictureResourceInfoKHR<'a> { @@ -336,6 +683,43 @@ pub(crate) mod reexport { pub image_view_binding: crate::vk::ImageView, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for VideoPictureResourceInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::VIDEO_PICTURE_RESOURCE_INFO_KHR; + } + impl<'a> Default for VideoPictureResourceInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + coded_offset: Default::default(), + coded_extent: Default::default(), + base_array_layer: Default::default(), + image_view_binding: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> VideoPictureResourceInfoKHR<'a> { + pub fn coded_offset(mut self, coded_offset: crate::vk::Offset2D) -> Self { + self.coded_offset = coded_offset; + self + } + pub fn coded_extent(mut self, coded_extent: crate::vk::Extent2D) -> Self { + self.coded_extent = coded_extent; + self + } + pub fn base_array_layer(mut self, base_array_layer: u32) -> Self { + self.base_array_layer = base_array_layer; + self + } + pub fn image_view_binding( + mut self, + image_view_binding: crate::vk::ImageView, + ) -> Self { + self.image_view_binding = image_view_binding; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct VideoReferenceSlotInfoKHR<'a> { @@ -345,6 +729,33 @@ pub(crate) mod reexport { pub p_picture_resource: *const crate::vk::VideoPictureResourceInfoKHR<'a>, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for VideoReferenceSlotInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::VIDEO_REFERENCE_SLOT_INFO_KHR; + } + impl<'a> Default for VideoReferenceSlotInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + slot_index: Default::default(), + p_picture_resource: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> VideoReferenceSlotInfoKHR<'a> { + pub fn slot_index(mut self, slot_index: i32) -> Self { + self.slot_index = slot_index; + self + } + pub fn p_picture_resource( + mut self, + p_picture_resource: &'a crate::vk::VideoPictureResourceInfoKHR<'a>, + ) -> Self { + self.p_picture_resource = p_picture_resource; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct VideoSessionCreateInfoKHR<'a> { @@ -361,6 +772,80 @@ pub(crate) mod reexport { pub p_std_header_version: *const crate::vk::ExtensionProperties, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for VideoSessionCreateInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::VIDEO_SESSION_CREATE_INFO_KHR; + } + impl<'a> Default for VideoSessionCreateInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + queue_family_index: Default::default(), + flags: Default::default(), + p_video_profile: Default::default(), + picture_format: Default::default(), + max_coded_extent: Default::default(), + reference_picture_format: Default::default(), + max_dpb_slots: Default::default(), + max_active_reference_pictures: Default::default(), + p_std_header_version: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> VideoSessionCreateInfoKHR<'a> { + pub fn queue_family_index(mut self, queue_family_index: u32) -> Self { + self.queue_family_index = queue_family_index; + self + } + pub fn flags(mut self, flags: crate::vk::VideoSessionCreateFlagsKHR) -> Self { + self.flags = flags; + self + } + pub fn p_video_profile( + mut self, + p_video_profile: &'a crate::vk::VideoProfileInfoKHR<'a>, + ) -> Self { + self.p_video_profile = p_video_profile; + self + } + pub fn picture_format(mut self, picture_format: crate::vk::Format) -> Self { + self.picture_format = picture_format; + self + } + pub fn max_coded_extent( + mut self, + max_coded_extent: crate::vk::Extent2D, + ) -> Self { + self.max_coded_extent = max_coded_extent; + self + } + pub fn reference_picture_format( + mut self, + reference_picture_format: crate::vk::Format, + ) -> Self { + self.reference_picture_format = reference_picture_format; + self + } + pub fn max_dpb_slots(mut self, max_dpb_slots: u32) -> Self { + self.max_dpb_slots = max_dpb_slots; + self + } + pub fn max_active_reference_pictures( + mut self, + max_active_reference_pictures: u32, + ) -> Self { + self.max_active_reference_pictures = max_active_reference_pictures; + self + } + pub fn p_std_header_version( + mut self, + p_std_header_version: &'a crate::vk::ExtensionProperties, + ) -> Self { + self.p_std_header_version = p_std_header_version; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct VideoSessionParametersCreateInfoKHR<'a> { @@ -371,6 +856,45 @@ pub(crate) mod reexport { pub video_session: crate::vk::VideoSessionKHR, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for VideoSessionParametersCreateInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::VIDEO_SESSION_PARAMETERS_CREATE_INFO_KHR; + } + impl<'a> Default for VideoSessionParametersCreateInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + flags: Default::default(), + video_session_parameters_template: Default::default(), + video_session: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> VideoSessionParametersCreateInfoKHR<'a> { + pub fn flags( + mut self, + flags: crate::vk::VideoSessionParametersCreateFlagsKHR, + ) -> Self { + self.flags = flags; + self + } + pub fn video_session_parameters_template( + mut self, + video_session_parameters_template: crate::vk::VideoSessionParametersKHR, + ) -> Self { + self.video_session_parameters_template = video_session_parameters_template; + self + } + pub fn video_session( + mut self, + video_session: crate::vk::VideoSessionKHR, + ) -> Self { + self.video_session = video_session; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct VideoSessionParametersUpdateInfoKHR<'a> { @@ -379,6 +903,26 @@ pub(crate) mod reexport { pub update_sequence_count: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for VideoSessionParametersUpdateInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::VIDEO_SESSION_PARAMETERS_UPDATE_INFO_KHR; + } + impl<'a> Default for VideoSessionParametersUpdateInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + update_sequence_count: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> VideoSessionParametersUpdateInfoKHR<'a> { + pub fn update_sequence_count(mut self, update_sequence_count: u32) -> Self { + self.update_sequence_count = update_sequence_count; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct VideoBeginCodingInfoKHR<'a> { @@ -391,6 +935,55 @@ pub(crate) mod reexport { pub p_reference_slots: *const crate::vk::VideoReferenceSlotInfoKHR<'a>, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for VideoBeginCodingInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::VIDEO_BEGIN_CODING_INFO_KHR; + } + impl<'a> Default for VideoBeginCodingInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + flags: Default::default(), + video_session: Default::default(), + video_session_parameters: Default::default(), + reference_slot_count: Default::default(), + p_reference_slots: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> VideoBeginCodingInfoKHR<'a> { + pub fn flags(mut self, flags: crate::vk::VideoBeginCodingFlagsKHR) -> Self { + self.flags = flags; + self + } + pub fn video_session( + mut self, + video_session: crate::vk::VideoSessionKHR, + ) -> Self { + self.video_session = video_session; + self + } + pub fn video_session_parameters( + mut self, + video_session_parameters: crate::vk::VideoSessionParametersKHR, + ) -> Self { + self.video_session_parameters = video_session_parameters; + self + } + pub fn reference_slot_count(mut self, reference_slot_count: u32) -> Self { + self.reference_slot_count = reference_slot_count; + self + } + pub fn p_reference_slots( + mut self, + p_reference_slots: &'a [crate::vk::VideoReferenceSlotInfoKHR<'a>], + ) -> Self { + self.reference_slot_count = p_reference_slots.len() as _; + self.p_reference_slots = p_reference_slots.as_ptr(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct VideoEndCodingInfoKHR<'a> { @@ -399,6 +992,25 @@ pub(crate) mod reexport { pub flags: crate::vk::VideoEndCodingFlagsKHR, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for VideoEndCodingInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::VIDEO_END_CODING_INFO_KHR; + } + impl<'a> Default for VideoEndCodingInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + flags: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> VideoEndCodingInfoKHR<'a> { + pub fn flags(mut self, flags: crate::vk::VideoEndCodingFlagsKHR) -> Self { + self.flags = flags; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct VideoCodingControlInfoKHR<'a> { @@ -407,6 +1019,25 @@ pub(crate) mod reexport { pub flags: crate::vk::VideoCodingControlFlagsKHR, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for VideoCodingControlInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::VIDEO_CODING_CONTROL_INFO_KHR; + } + impl<'a> Default for VideoCodingControlInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + flags: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> VideoCodingControlInfoKHR<'a> { + pub fn flags(mut self, flags: crate::vk::VideoCodingControlFlagsKHR) -> Self { + self.flags = flags; + self + } + } ///Provided by [`khr::video_queue`](crate::khr::video_queue) impl crate::vk::QueryType { pub const RESULT_STATUS_ONLY_KHR: Self = Self(1000023000); @@ -561,7 +1192,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct VideoCodecOperationFlagBitsKHR(pub(crate) u32); ///Provided by [`khr::video_queue`](crate::khr::video_queue) impl VideoCodecOperationFlagBitsKHR { @@ -641,7 +1272,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct VideoCapabilityFlagBitsKHR(pub(crate) u32); ///Provided by [`khr::video_queue`](crate::khr::video_queue) impl VideoCapabilityFlagBitsKHR { @@ -734,7 +1365,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct VideoSessionCreateFlagBitsKHR(pub(crate) u32); ///Provided by [`khr::video_queue`](crate::khr::video_queue) impl VideoSessionCreateFlagBitsKHR { @@ -811,7 +1442,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct VideoSessionParametersCreateFlagBitsKHR(pub(crate) u32); #[repr(transparent)] #[derive(Clone, Copy)] @@ -1022,7 +1653,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct VideoCodingControlFlagBitsKHR(pub(crate) u32); ///Provided by [`khr::video_queue`](crate::khr::video_queue) impl VideoCodingControlFlagBitsKHR { @@ -1105,7 +1736,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct VideoChromaSubsamplingFlagBitsKHR(pub(crate) u32); ///Provided by [`khr::video_queue`](crate::khr::video_queue) impl VideoChromaSubsamplingFlagBitsKHR { @@ -1189,7 +1820,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct VideoComponentBitDepthFlagBitsKHR(pub(crate) u32); ///Provided by [`khr::video_queue`](crate::khr::video_queue) impl VideoComponentBitDepthFlagBitsKHR { diff --git a/ash-rewrite/src/generated/khr/wayland_surface.rs b/ash-rewrite/src/generated/khr/wayland_surface.rs index cbe1bceee..7a95d9332 100644 --- a/ash-rewrite/src/generated/khr/wayland_surface.rs +++ b/ash-rewrite/src/generated/khr/wayland_surface.rs @@ -65,6 +65,41 @@ pub(crate) mod reexport { pub surface: *mut crate::platform_types::wl_surface, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for WaylandSurfaceCreateInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::WAYLAND_SURFACE_CREATE_INFO_KHR; + } + impl<'a> Default for WaylandSurfaceCreateInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + flags: Default::default(), + display: Default::default(), + surface: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> WaylandSurfaceCreateInfoKHR<'a> { + pub fn flags(mut self, flags: crate::vk::WaylandSurfaceCreateFlagsKHR) -> Self { + self.flags = flags; + self + } + pub fn display( + mut self, + display: &'a mut crate::platform_types::wl_display, + ) -> Self { + self.display = display; + self + } + pub fn surface( + mut self, + surface: &'a mut crate::platform_types::wl_surface, + ) -> Self { + self.surface = surface; + self + } + } ///Provided by [`khr::wayland_surface`](crate::khr::wayland_surface) impl crate::vk::StructureType { pub const WAYLAND_SURFACE_CREATE_INFO_KHR: Self = Self(1000006000); diff --git a/ash-rewrite/src/generated/khr/win32_keyed_mutex.rs b/ash-rewrite/src/generated/khr/win32_keyed_mutex.rs index d98c2c421..bab4d34ae 100644 --- a/ash-rewrite/src/generated/khr/win32_keyed_mutex.rs +++ b/ash-rewrite/src/generated/khr/win32_keyed_mutex.rs @@ -15,6 +15,70 @@ pub struct Win32KeyedMutexAcquireReleaseInfoKHR<'a> { pub p_release_keys: *const u64, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> for Win32KeyedMutexAcquireReleaseInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR; +} +unsafe impl<'a> crate::Extends> +for Win32KeyedMutexAcquireReleaseInfoKHR<'a> {} +unsafe impl<'a> crate::Extends> +for Win32KeyedMutexAcquireReleaseInfoKHR<'a> {} +impl<'a> Default for Win32KeyedMutexAcquireReleaseInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + acquire_count: Default::default(), + p_acquire_syncs: Default::default(), + p_acquire_keys: Default::default(), + p_acquire_timeouts: Default::default(), + release_count: Default::default(), + p_release_syncs: Default::default(), + p_release_keys: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> Win32KeyedMutexAcquireReleaseInfoKHR<'a> { + pub fn acquire_count(mut self, acquire_count: u32) -> Self { + self.acquire_count = acquire_count; + self + } + pub fn p_acquire_syncs( + mut self, + p_acquire_syncs: &'a [crate::vk::DeviceMemory], + ) -> Self { + self.acquire_count = p_acquire_syncs.len() as _; + self.p_acquire_syncs = p_acquire_syncs.as_ptr(); + self + } + pub fn p_acquire_keys(mut self, p_acquire_keys: &'a [u64]) -> Self { + self.acquire_count = p_acquire_keys.len() as _; + self.p_acquire_keys = p_acquire_keys.as_ptr(); + self + } + pub fn p_acquire_timeouts(mut self, p_acquire_timeouts: &'a [u32]) -> Self { + self.acquire_count = p_acquire_timeouts.len() as _; + self.p_acquire_timeouts = p_acquire_timeouts.as_ptr(); + self + } + pub fn release_count(mut self, release_count: u32) -> Self { + self.release_count = release_count; + self + } + pub fn p_release_syncs( + mut self, + p_release_syncs: &'a [crate::vk::DeviceMemory], + ) -> Self { + self.release_count = p_release_syncs.len() as _; + self.p_release_syncs = p_release_syncs.as_ptr(); + self + } + pub fn p_release_keys(mut self, p_release_keys: &'a [u64]) -> Self { + self.release_count = p_release_keys.len() as _; + self.p_release_keys = p_release_keys.as_ptr(); + self + } +} ///Provided by [`khr::win32_keyed_mutex`](crate::khr::win32_keyed_mutex) impl crate::vk::StructureType { pub const WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR: Self = Self(1000075000); diff --git a/ash-rewrite/src/generated/khr/win32_surface.rs b/ash-rewrite/src/generated/khr/win32_surface.rs index aa89a68b1..ec081f034 100644 --- a/ash-rewrite/src/generated/khr/win32_surface.rs +++ b/ash-rewrite/src/generated/khr/win32_surface.rs @@ -64,6 +64,35 @@ pub(crate) mod reexport { pub hwnd: crate::platform_types::HWND, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for Win32SurfaceCreateInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::WIN32_SURFACE_CREATE_INFO_KHR; + } + impl<'a> Default for Win32SurfaceCreateInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + flags: Default::default(), + hinstance: Default::default(), + hwnd: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> Win32SurfaceCreateInfoKHR<'a> { + pub fn flags(mut self, flags: crate::vk::Win32SurfaceCreateFlagsKHR) -> Self { + self.flags = flags; + self + } + pub fn hinstance(mut self, hinstance: crate::platform_types::HINSTANCE) -> Self { + self.hinstance = hinstance; + self + } + pub fn hwnd(mut self, hwnd: crate::platform_types::HWND) -> Self { + self.hwnd = hwnd; + self + } + } ///Provided by [`khr::win32_surface`](crate::khr::win32_surface) impl crate::vk::StructureType { pub const WIN32_SURFACE_CREATE_INFO_KHR: Self = Self(1000009000); diff --git a/ash-rewrite/src/generated/khr/workgroup_memory_explicit_layout.rs b/ash-rewrite/src/generated/khr/workgroup_memory_explicit_layout.rs index dac7db5af..ed5e8514a 100644 --- a/ash-rewrite/src/generated/khr/workgroup_memory_explicit_layout.rs +++ b/ash-rewrite/src/generated/khr/workgroup_memory_explicit_layout.rs @@ -12,6 +12,60 @@ pub struct PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR<'a> { pub workgroup_memory_explicit_layout16_bit_access: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR<'a> {} +impl<'a> Default for PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + workgroup_memory_explicit_layout: Default::default(), + workgroup_memory_explicit_layout_scalar_block_layout: Default::default(), + workgroup_memory_explicit_layout8_bit_access: Default::default(), + workgroup_memory_explicit_layout16_bit_access: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR<'a> { + pub fn workgroup_memory_explicit_layout( + mut self, + workgroup_memory_explicit_layout: bool, + ) -> Self { + self.workgroup_memory_explicit_layout = workgroup_memory_explicit_layout.into(); + self + } + pub fn workgroup_memory_explicit_layout_scalar_block_layout( + mut self, + workgroup_memory_explicit_layout_scalar_block_layout: bool, + ) -> Self { + self.workgroup_memory_explicit_layout_scalar_block_layout = workgroup_memory_explicit_layout_scalar_block_layout + .into(); + self + } + pub fn workgroup_memory_explicit_layout8_bit_access( + mut self, + workgroup_memory_explicit_layout8_bit_access: bool, + ) -> Self { + self.workgroup_memory_explicit_layout8_bit_access = workgroup_memory_explicit_layout8_bit_access + .into(); + self + } + pub fn workgroup_memory_explicit_layout16_bit_access( + mut self, + workgroup_memory_explicit_layout16_bit_access: bool, + ) -> Self { + self.workgroup_memory_explicit_layout16_bit_access = workgroup_memory_explicit_layout16_bit_access + .into(); + self + } +} ///Provided by [`khr::workgroup_memory_explicit_layout`](crate::khr::workgroup_memory_explicit_layout) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR: Self = Self( diff --git a/ash-rewrite/src/generated/khr/xcb_surface.rs b/ash-rewrite/src/generated/khr/xcb_surface.rs index 286165be3..f344188d7 100644 --- a/ash-rewrite/src/generated/khr/xcb_surface.rs +++ b/ash-rewrite/src/generated/khr/xcb_surface.rs @@ -64,6 +64,38 @@ pub(crate) mod reexport { pub window: crate::platform_types::xcb_window_t, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for XcbSurfaceCreateInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::XCB_SURFACE_CREATE_INFO_KHR; + } + impl<'a> Default for XcbSurfaceCreateInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + flags: Default::default(), + connection: Default::default(), + window: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> XcbSurfaceCreateInfoKHR<'a> { + pub fn flags(mut self, flags: crate::vk::XcbSurfaceCreateFlagsKHR) -> Self { + self.flags = flags; + self + } + pub fn connection( + mut self, + connection: &'a mut crate::platform_types::xcb_connection_t, + ) -> Self { + self.connection = connection; + self + } + pub fn window(mut self, window: crate::platform_types::xcb_window_t) -> Self { + self.window = window; + self + } + } ///Provided by [`khr::xcb_surface`](crate::khr::xcb_surface) impl crate::vk::StructureType { pub const XCB_SURFACE_CREATE_INFO_KHR: Self = Self(1000005000); diff --git a/ash-rewrite/src/generated/khr/xlib_surface.rs b/ash-rewrite/src/generated/khr/xlib_surface.rs index 964784969..3d07a7bd7 100644 --- a/ash-rewrite/src/generated/khr/xlib_surface.rs +++ b/ash-rewrite/src/generated/khr/xlib_surface.rs @@ -66,6 +66,35 @@ pub(crate) mod reexport { pub window: crate::platform_types::Window, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for XlibSurfaceCreateInfoKHR<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::XLIB_SURFACE_CREATE_INFO_KHR; + } + impl<'a> Default for XlibSurfaceCreateInfoKHR<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + flags: Default::default(), + dpy: Default::default(), + window: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> XlibSurfaceCreateInfoKHR<'a> { + pub fn flags(mut self, flags: crate::vk::XlibSurfaceCreateFlagsKHR) -> Self { + self.flags = flags; + self + } + pub fn dpy(mut self, dpy: &'a mut crate::platform_types::Display) -> Self { + self.dpy = dpy; + self + } + pub fn window(mut self, window: crate::platform_types::Window) -> Self { + self.window = window; + self + } + } ///Provided by [`khr::xlib_surface`](crate::khr::xlib_surface) impl crate::vk::StructureType { pub const XLIB_SURFACE_CREATE_INFO_KHR: Self = Self(1000004000); diff --git a/ash-rewrite/src/generated/lunarg/direct_driver_loading.rs b/ash-rewrite/src/generated/lunarg/direct_driver_loading.rs index 17907645a..55d69ffe1 100644 --- a/ash-rewrite/src/generated/lunarg/direct_driver_loading.rs +++ b/ash-rewrite/src/generated/lunarg/direct_driver_loading.rs @@ -10,6 +10,33 @@ pub struct DirectDriverLoadingInfoLUNARG<'a> { pub pfn_get_instance_proc_addr: crate::vk::PFN_vkGetInstanceProcAddrLUNARG, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> for DirectDriverLoadingInfoLUNARG<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::DIRECT_DRIVER_LOADING_INFO_LUNARG; +} +impl<'a> Default for DirectDriverLoadingInfoLUNARG<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + flags: Default::default(), + pfn_get_instance_proc_addr: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> DirectDriverLoadingInfoLUNARG<'a> { + pub fn flags(mut self, flags: crate::vk::DirectDriverLoadingFlagsLUNARG) -> Self { + self.flags = flags; + self + } + pub fn pfn_get_instance_proc_addr( + mut self, + pfn_get_instance_proc_addr: crate::vk::PFN_vkGetInstanceProcAddrLUNARG, + ) -> Self { + self.pfn_get_instance_proc_addr = pfn_get_instance_proc_addr; + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct DirectDriverLoadingListLUNARG<'a> { @@ -20,6 +47,41 @@ pub struct DirectDriverLoadingListLUNARG<'a> { pub p_drivers: *const crate::vk::DirectDriverLoadingInfoLUNARG<'a>, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> for DirectDriverLoadingListLUNARG<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::DIRECT_DRIVER_LOADING_LIST_LUNARG; +} +unsafe impl<'a> crate::Extends> +for DirectDriverLoadingListLUNARG<'a> {} +impl<'a> Default for DirectDriverLoadingListLUNARG<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + mode: Default::default(), + driver_count: Default::default(), + p_drivers: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> DirectDriverLoadingListLUNARG<'a> { + pub fn mode(mut self, mode: crate::vk::DirectDriverLoadingModeLUNARG) -> Self { + self.mode = mode; + self + } + pub fn driver_count(mut self, driver_count: u32) -> Self { + self.driver_count = driver_count; + self + } + pub fn p_drivers( + mut self, + p_drivers: &'a [crate::vk::DirectDriverLoadingInfoLUNARG<'a>], + ) -> Self { + self.driver_count = p_drivers.len() as _; + self.p_drivers = p_drivers.as_ptr(); + self + } +} ///Provided by [`lunarg::direct_driver_loading`](crate::lunarg::direct_driver_loading) impl crate::vk::StructureType { pub const DIRECT_DRIVER_LOADING_INFO_LUNARG: Self = Self(1000459000); diff --git a/ash-rewrite/src/generated/mesa/image_alignment_control.rs b/ash-rewrite/src/generated/mesa/image_alignment_control.rs index e7e7c0e1a..0bbf562ac 100644 --- a/ash-rewrite/src/generated/mesa/image_alignment_control.rs +++ b/ash-rewrite/src/generated/mesa/image_alignment_control.rs @@ -9,6 +9,30 @@ pub struct PhysicalDeviceImageAlignmentControlFeaturesMESA<'a> { pub image_alignment_control: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceImageAlignmentControlFeaturesMESA<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceImageAlignmentControlFeaturesMESA<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceImageAlignmentControlFeaturesMESA<'a> {} +impl<'a> Default for PhysicalDeviceImageAlignmentControlFeaturesMESA<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + image_alignment_control: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceImageAlignmentControlFeaturesMESA<'a> { + pub fn image_alignment_control(mut self, image_alignment_control: bool) -> Self { + self.image_alignment_control = image_alignment_control.into(); + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceImageAlignmentControlPropertiesMESA<'a> { @@ -17,6 +41,31 @@ pub struct PhysicalDeviceImageAlignmentControlPropertiesMESA<'a> { pub supported_image_alignment_mask: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceImageAlignmentControlPropertiesMESA<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_PROPERTIES_MESA; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceImageAlignmentControlPropertiesMESA<'a> {} +impl<'a> Default for PhysicalDeviceImageAlignmentControlPropertiesMESA<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + supported_image_alignment_mask: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceImageAlignmentControlPropertiesMESA<'a> { + pub fn supported_image_alignment_mask( + mut self, + supported_image_alignment_mask: u32, + ) -> Self { + self.supported_image_alignment_mask = supported_image_alignment_mask; + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct ImageAlignmentControlCreateInfoMESA<'a> { @@ -25,6 +74,30 @@ pub struct ImageAlignmentControlCreateInfoMESA<'a> { pub maximum_requested_alignment: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> for ImageAlignmentControlCreateInfoMESA<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::IMAGE_ALIGNMENT_CONTROL_CREATE_INFO_MESA; +} +unsafe impl<'a> crate::Extends> +for ImageAlignmentControlCreateInfoMESA<'a> {} +impl<'a> Default for ImageAlignmentControlCreateInfoMESA<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + maximum_requested_alignment: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> ImageAlignmentControlCreateInfoMESA<'a> { + pub fn maximum_requested_alignment( + mut self, + maximum_requested_alignment: u32, + ) -> Self { + self.maximum_requested_alignment = maximum_requested_alignment; + self + } +} ///Provided by [`mesa::image_alignment_control`](crate::mesa::image_alignment_control) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA: Self = Self( diff --git a/ash-rewrite/src/generated/msft/layered_driver.rs b/ash-rewrite/src/generated/msft/layered_driver.rs index 22d56abc1..edcee51fa 100644 --- a/ash-rewrite/src/generated/msft/layered_driver.rs +++ b/ash-rewrite/src/generated/msft/layered_driver.rs @@ -9,6 +9,31 @@ pub struct PhysicalDeviceLayeredDriverPropertiesMSFT<'a> { pub underlying_api: crate::vk::LayeredDriverUnderlyingApiMSFT, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceLayeredDriverPropertiesMSFT<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_LAYERED_DRIVER_PROPERTIES_MSFT; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceLayeredDriverPropertiesMSFT<'a> {} +impl<'a> Default for PhysicalDeviceLayeredDriverPropertiesMSFT<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + underlying_api: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceLayeredDriverPropertiesMSFT<'a> { + pub fn underlying_api( + mut self, + underlying_api: crate::vk::LayeredDriverUnderlyingApiMSFT, + ) -> Self { + self.underlying_api = underlying_api; + self + } +} ///Provided by [`msft::layered_driver`](crate::msft::layered_driver) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_LAYERED_DRIVER_PROPERTIES_MSFT: Self = Self(1000530000); diff --git a/ash-rewrite/src/generated/mvk/ios_surface.rs b/ash-rewrite/src/generated/mvk/ios_surface.rs index 1f7190e0a..dea1cc931 100644 --- a/ash-rewrite/src/generated/mvk/ios_surface.rs +++ b/ash-rewrite/src/generated/mvk/ios_surface.rs @@ -46,6 +46,30 @@ pub(crate) mod reexport { pub p_view: *const core::ffi::c_void, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for IOSSurfaceCreateInfoMVK<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::IOS_SURFACE_CREATE_INFO_MVK; + } + impl<'a> Default for IOSSurfaceCreateInfoMVK<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + flags: Default::default(), + p_view: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> IOSSurfaceCreateInfoMVK<'a> { + pub fn flags(mut self, flags: crate::vk::IOSSurfaceCreateFlagsMVK) -> Self { + self.flags = flags; + self + } + pub fn p_view(mut self, p_view: &'a core::ffi::c_void) -> Self { + self.p_view = p_view; + self + } + } ///Provided by [`mvk::ios_surface`](crate::mvk::ios_surface) impl crate::vk::StructureType { pub const IOS_SURFACE_CREATE_INFO_MVK: Self = Self(1000122000); diff --git a/ash-rewrite/src/generated/mvk/macos_surface.rs b/ash-rewrite/src/generated/mvk/macos_surface.rs index bafb73d42..b5d282130 100644 --- a/ash-rewrite/src/generated/mvk/macos_surface.rs +++ b/ash-rewrite/src/generated/mvk/macos_surface.rs @@ -46,6 +46,30 @@ pub(crate) mod reexport { pub p_view: *const core::ffi::c_void, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for MacOSSurfaceCreateInfoMVK<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::MACOS_SURFACE_CREATE_INFO_MVK; + } + impl<'a> Default for MacOSSurfaceCreateInfoMVK<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + flags: Default::default(), + p_view: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> MacOSSurfaceCreateInfoMVK<'a> { + pub fn flags(mut self, flags: crate::vk::MacOSSurfaceCreateFlagsMVK) -> Self { + self.flags = flags; + self + } + pub fn p_view(mut self, p_view: &'a core::ffi::c_void) -> Self { + self.p_view = p_view; + self + } + } ///Provided by [`mvk::macos_surface`](crate::mvk::macos_surface) impl crate::vk::StructureType { pub const MACOS_SURFACE_CREATE_INFO_MVK: Self = Self(1000123000); diff --git a/ash-rewrite/src/generated/nn/vi_surface.rs b/ash-rewrite/src/generated/nn/vi_surface.rs index 0ebaf9079..a1712c466 100644 --- a/ash-rewrite/src/generated/nn/vi_surface.rs +++ b/ash-rewrite/src/generated/nn/vi_surface.rs @@ -46,6 +46,30 @@ pub(crate) mod reexport { pub window: *mut core::ffi::c_void, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for ViSurfaceCreateInfoNN<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::VI_SURFACE_CREATE_INFO_NN; + } + impl<'a> Default for ViSurfaceCreateInfoNN<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + flags: Default::default(), + window: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> ViSurfaceCreateInfoNN<'a> { + pub fn flags(mut self, flags: crate::vk::ViSurfaceCreateFlagsNN) -> Self { + self.flags = flags; + self + } + pub fn window(mut self, window: &'a mut core::ffi::c_void) -> Self { + self.window = window; + self + } + } ///Provided by [`nn::vi_surface`](crate::nn::vi_surface) impl crate::vk::StructureType { pub const VI_SURFACE_CREATE_INFO_NN: Self = Self(1000062000); diff --git a/ash-rewrite/src/generated/nv/clip_space_w_scaling.rs b/ash-rewrite/src/generated/nv/clip_space_w_scaling.rs index f6c5badb0..03bcafdec 100644 --- a/ash-rewrite/src/generated/nv/clip_space_w_scaling.rs +++ b/ash-rewrite/src/generated/nv/clip_space_w_scaling.rs @@ -38,11 +38,21 @@ impl DeviceFn { } pub(crate) mod reexport { #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct ViewportWScalingNV { pub xcoeff: core::ffi::c_float, pub ycoeff: core::ffi::c_float, } + impl ViewportWScalingNV { + pub fn xcoeff(mut self, xcoeff: core::ffi::c_float) -> Self { + self.xcoeff = xcoeff; + self + } + pub fn ycoeff(mut self, ycoeff: core::ffi::c_float) -> Self { + self.ycoeff = ycoeff; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PipelineViewportWScalingStateCreateInfoNV<'a> { @@ -53,6 +63,45 @@ pub(crate) mod reexport { pub p_viewport_w_scalings: *const crate::vk::ViewportWScalingNV, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PipelineViewportWScalingStateCreateInfoNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV; + } + unsafe impl<'a> crate::Extends> + for PipelineViewportWScalingStateCreateInfoNV<'a> {} + impl<'a> Default for PipelineViewportWScalingStateCreateInfoNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + viewport_w_scaling_enable: Default::default(), + viewport_count: Default::default(), + p_viewport_w_scalings: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PipelineViewportWScalingStateCreateInfoNV<'a> { + pub fn viewport_w_scaling_enable( + mut self, + viewport_w_scaling_enable: bool, + ) -> Self { + self.viewport_w_scaling_enable = viewport_w_scaling_enable.into(); + self + } + pub fn viewport_count(mut self, viewport_count: u32) -> Self { + self.viewport_count = viewport_count; + self + } + pub fn p_viewport_w_scalings( + mut self, + p_viewport_w_scalings: &'a [crate::vk::ViewportWScalingNV], + ) -> Self { + self.viewport_count = p_viewport_w_scalings.len() as _; + self.p_viewport_w_scalings = p_viewport_w_scalings.as_ptr(); + self + } + } ///Provided by [`nv::clip_space_w_scaling`](crate::nv::clip_space_w_scaling) impl crate::vk::StructureType { pub const PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV: Self = Self( diff --git a/ash-rewrite/src/generated/nv/cluster_acceleration_structure.rs b/ash-rewrite/src/generated/nv/cluster_acceleration_structure.rs index b98cbe2a4..5124cbac4 100644 --- a/ash-rewrite/src/generated/nv/cluster_acceleration_structure.rs +++ b/ash-rewrite/src/generated/nv/cluster_acceleration_structure.rs @@ -63,6 +63,33 @@ pub(crate) mod reexport { pub cluster_acceleration_structure: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceClusterAccelerationStructureFeaturesNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_FEATURES_NV; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceClusterAccelerationStructureFeaturesNV<'a> {} + unsafe impl<'a> crate::Extends> + for PhysicalDeviceClusterAccelerationStructureFeaturesNV<'a> {} + impl<'a> Default for PhysicalDeviceClusterAccelerationStructureFeaturesNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + cluster_acceleration_structure: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceClusterAccelerationStructureFeaturesNV<'a> { + pub fn cluster_acceleration_structure( + mut self, + cluster_acceleration_structure: bool, + ) -> Self { + self.cluster_acceleration_structure = cluster_acceleration_structure.into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceClusterAccelerationStructurePropertiesNV<'a> { @@ -78,12 +105,103 @@ pub(crate) mod reexport { pub max_cluster_geometry_index: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceClusterAccelerationStructurePropertiesNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_PROPERTIES_NV; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceClusterAccelerationStructurePropertiesNV<'a> {} + impl<'a> Default for PhysicalDeviceClusterAccelerationStructurePropertiesNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + max_vertices_per_cluster: Default::default(), + max_triangles_per_cluster: Default::default(), + cluster_scratch_byte_alignment: Default::default(), + cluster_byte_alignment: Default::default(), + cluster_template_byte_alignment: Default::default(), + cluster_bottom_level_byte_alignment: Default::default(), + cluster_template_bounds_byte_alignment: Default::default(), + max_cluster_geometry_index: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceClusterAccelerationStructurePropertiesNV<'a> { + pub fn max_vertices_per_cluster( + mut self, + max_vertices_per_cluster: u32, + ) -> Self { + self.max_vertices_per_cluster = max_vertices_per_cluster; + self + } + pub fn max_triangles_per_cluster( + mut self, + max_triangles_per_cluster: u32, + ) -> Self { + self.max_triangles_per_cluster = max_triangles_per_cluster; + self + } + pub fn cluster_scratch_byte_alignment( + mut self, + cluster_scratch_byte_alignment: u32, + ) -> Self { + self.cluster_scratch_byte_alignment = cluster_scratch_byte_alignment; + self + } + pub fn cluster_byte_alignment(mut self, cluster_byte_alignment: u32) -> Self { + self.cluster_byte_alignment = cluster_byte_alignment; + self + } + pub fn cluster_template_byte_alignment( + mut self, + cluster_template_byte_alignment: u32, + ) -> Self { + self.cluster_template_byte_alignment = cluster_template_byte_alignment; + self + } + pub fn cluster_bottom_level_byte_alignment( + mut self, + cluster_bottom_level_byte_alignment: u32, + ) -> Self { + self.cluster_bottom_level_byte_alignment = cluster_bottom_level_byte_alignment; + self + } + pub fn cluster_template_bounds_byte_alignment( + mut self, + cluster_template_bounds_byte_alignment: u32, + ) -> Self { + self.cluster_template_bounds_byte_alignment = cluster_template_bounds_byte_alignment; + self + } + pub fn max_cluster_geometry_index( + mut self, + max_cluster_geometry_index: u32, + ) -> Self { + self.max_cluster_geometry_index = max_cluster_geometry_index; + self + } + } #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct StridedDeviceAddressNV { pub start_address: crate::vk::DeviceAddress, pub stride_in_bytes: crate::vk::DeviceSize, } + impl StridedDeviceAddressNV { + pub fn start_address(mut self, start_address: crate::vk::DeviceAddress) -> Self { + self.start_address = start_address; + self + } + pub fn stride_in_bytes( + mut self, + stride_in_bytes: crate::vk::DeviceSize, + ) -> Self { + self.stride_in_bytes = stride_in_bytes; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct RayTracingPipelineClusterAccelerationStructureCreateInfoNV<'a> { @@ -92,32 +210,111 @@ pub(crate) mod reexport { pub allow_cluster_acceleration_structure: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for RayTracingPipelineClusterAccelerationStructureCreateInfoNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::RAY_TRACING_PIPELINE_CLUSTER_ACCELERATION_STRUCTURE_CREATE_INFO_NV; + } + unsafe impl<'a> crate::Extends> + for RayTracingPipelineClusterAccelerationStructureCreateInfoNV<'a> {} + impl<'a> Default for RayTracingPipelineClusterAccelerationStructureCreateInfoNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + allow_cluster_acceleration_structure: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> RayTracingPipelineClusterAccelerationStructureCreateInfoNV<'a> { + pub fn allow_cluster_acceleration_structure( + mut self, + allow_cluster_acceleration_structure: bool, + ) -> Self { + self.allow_cluster_acceleration_structure = allow_cluster_acceleration_structure + .into(); + self + } + } #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct ClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV { /**- `geometryIndex` @ `0..24` - `geometryFlags` @ `29..32`*/ pub bitfield0: u32, } + impl ClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV { + pub fn geometry_index(mut self, geometry_index: u32) -> Self { + let rest = self.bitfield0 & 0xFF000000; + self.bitfield0 = (geometry_index & 0x00FFFFFF) | rest; + self + } + pub fn geometry_flags(mut self, geometry_flags: u32) -> Self { + let rest = self.bitfield0 & 0x1FFFFFFF; + self.bitfield0 = ((geometry_flags << 29u32) & 0xE0000000) | rest; + self + } + } #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct ClusterAccelerationStructureMoveObjectsInfoNV { pub src_acceleration_structure: crate::vk::DeviceAddress, } + impl ClusterAccelerationStructureMoveObjectsInfoNV { + pub fn src_acceleration_structure( + mut self, + src_acceleration_structure: crate::vk::DeviceAddress, + ) -> Self { + self.src_acceleration_structure = src_acceleration_structure; + self + } + } #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct ClusterAccelerationStructureBuildClustersBottomLevelInfoNV { pub cluster_references_count: u32, pub cluster_references_stride: u32, pub cluster_references: crate::vk::DeviceAddress, } + impl ClusterAccelerationStructureBuildClustersBottomLevelInfoNV { + pub fn cluster_references_count( + mut self, + cluster_references_count: u32, + ) -> Self { + self.cluster_references_count = cluster_references_count; + self + } + pub fn cluster_references_stride( + mut self, + cluster_references_stride: u32, + ) -> Self { + self.cluster_references_stride = cluster_references_stride; + self + } + pub fn cluster_references( + mut self, + cluster_references: crate::vk::DeviceAddress, + ) -> Self { + self.cluster_references = cluster_references; + self + } + } #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct ClusterAccelerationStructureGetTemplateIndicesInfoNV { pub cluster_template_address: crate::vk::DeviceAddress, } + impl ClusterAccelerationStructureGetTemplateIndicesInfoNV { + pub fn cluster_template_address( + mut self, + cluster_template_address: crate::vk::DeviceAddress, + ) -> Self { + self.cluster_template_address = cluster_template_address; + self + } + } #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct ClusterAccelerationStructureBuildTriangleClusterInfoNV { pub cluster_id: u32, pub cluster_flags: crate::vk::ClusterAccelerationStructureClusterFlagsNV, @@ -138,8 +335,112 @@ pub(crate) mod reexport { pub opacity_micromap_array: crate::vk::DeviceAddress, pub opacity_micromap_index_buffer: crate::vk::DeviceAddress, } + impl ClusterAccelerationStructureBuildTriangleClusterInfoNV { + pub fn cluster_id(mut self, cluster_id: u32) -> Self { + self.cluster_id = cluster_id; + self + } + pub fn cluster_flags( + mut self, + cluster_flags: crate::vk::ClusterAccelerationStructureClusterFlagsNV, + ) -> Self { + self.cluster_flags = cluster_flags; + self + } + pub fn triangle_count(mut self, triangle_count: u32) -> Self { + let rest = self.bitfield0 & 0xFFFFFE00; + self.bitfield0 = (triangle_count & 0x000001FF) | rest; + self + } + pub fn vertex_count(mut self, vertex_count: u32) -> Self { + let rest = self.bitfield0 & 0xFFFC01FF; + self.bitfield0 = ((vertex_count << 9u32) & 0x0003FE00) | rest; + self + } + pub fn position_truncate_bit_count( + mut self, + position_truncate_bit_count: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFF03FFFF; + self.bitfield0 = ((position_truncate_bit_count << 18u32) & 0x00FC0000) + | rest; + self + } + pub fn index_type(mut self, index_type: u32) -> Self { + let rest = self.bitfield0 & 0xF0FFFFFF; + self.bitfield0 = ((index_type << 24u32) & 0x0F000000) | rest; + self + } + pub fn opacity_micromap_index_type( + mut self, + opacity_micromap_index_type: u32, + ) -> Self { + let rest = self.bitfield0 & 0x0FFFFFFF; + self.bitfield0 = ((opacity_micromap_index_type << 28u32) & 0xF0000000) + | rest; + self + } + pub fn base_geometry_index_and_geometry_flags( + mut self, + base_geometry_index_and_geometry_flags: crate::vk::ClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV, + ) -> Self { + self.base_geometry_index_and_geometry_flags = base_geometry_index_and_geometry_flags; + self + } + pub fn index_buffer_stride(mut self, index_buffer_stride: u16) -> Self { + self.index_buffer_stride = index_buffer_stride; + self + } + pub fn vertex_buffer_stride(mut self, vertex_buffer_stride: u16) -> Self { + self.vertex_buffer_stride = vertex_buffer_stride; + self + } + pub fn geometry_index_and_flags_buffer_stride( + mut self, + geometry_index_and_flags_buffer_stride: u16, + ) -> Self { + self.geometry_index_and_flags_buffer_stride = geometry_index_and_flags_buffer_stride; + self + } + pub fn opacity_micromap_index_buffer_stride( + mut self, + opacity_micromap_index_buffer_stride: u16, + ) -> Self { + self.opacity_micromap_index_buffer_stride = opacity_micromap_index_buffer_stride; + self + } + pub fn index_buffer(mut self, index_buffer: crate::vk::DeviceAddress) -> Self { + self.index_buffer = index_buffer; + self + } + pub fn vertex_buffer(mut self, vertex_buffer: crate::vk::DeviceAddress) -> Self { + self.vertex_buffer = vertex_buffer; + self + } + pub fn geometry_index_and_flags_buffer( + mut self, + geometry_index_and_flags_buffer: crate::vk::DeviceAddress, + ) -> Self { + self.geometry_index_and_flags_buffer = geometry_index_and_flags_buffer; + self + } + pub fn opacity_micromap_array( + mut self, + opacity_micromap_array: crate::vk::DeviceAddress, + ) -> Self { + self.opacity_micromap_array = opacity_micromap_array; + self + } + pub fn opacity_micromap_index_buffer( + mut self, + opacity_micromap_index_buffer: crate::vk::DeviceAddress, + ) -> Self { + self.opacity_micromap_index_buffer = opacity_micromap_index_buffer; + self + } + } #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV { pub cluster_id: u32, pub cluster_flags: crate::vk::ClusterAccelerationStructureClusterFlagsNV, @@ -161,8 +462,119 @@ pub(crate) mod reexport { pub opacity_micromap_index_buffer: crate::vk::DeviceAddress, pub instantiation_bounding_box_limit: crate::vk::DeviceAddress, } + impl ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV { + pub fn cluster_id(mut self, cluster_id: u32) -> Self { + self.cluster_id = cluster_id; + self + } + pub fn cluster_flags( + mut self, + cluster_flags: crate::vk::ClusterAccelerationStructureClusterFlagsNV, + ) -> Self { + self.cluster_flags = cluster_flags; + self + } + pub fn triangle_count(mut self, triangle_count: u32) -> Self { + let rest = self.bitfield0 & 0xFFFFFE00; + self.bitfield0 = (triangle_count & 0x000001FF) | rest; + self + } + pub fn vertex_count(mut self, vertex_count: u32) -> Self { + let rest = self.bitfield0 & 0xFFFC01FF; + self.bitfield0 = ((vertex_count << 9u32) & 0x0003FE00) | rest; + self + } + pub fn position_truncate_bit_count( + mut self, + position_truncate_bit_count: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFF03FFFF; + self.bitfield0 = ((position_truncate_bit_count << 18u32) & 0x00FC0000) + | rest; + self + } + pub fn index_type(mut self, index_type: u32) -> Self { + let rest = self.bitfield0 & 0xF0FFFFFF; + self.bitfield0 = ((index_type << 24u32) & 0x0F000000) | rest; + self + } + pub fn opacity_micromap_index_type( + mut self, + opacity_micromap_index_type: u32, + ) -> Self { + let rest = self.bitfield0 & 0x0FFFFFFF; + self.bitfield0 = ((opacity_micromap_index_type << 28u32) & 0xF0000000) + | rest; + self + } + pub fn base_geometry_index_and_geometry_flags( + mut self, + base_geometry_index_and_geometry_flags: crate::vk::ClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV, + ) -> Self { + self.base_geometry_index_and_geometry_flags = base_geometry_index_and_geometry_flags; + self + } + pub fn index_buffer_stride(mut self, index_buffer_stride: u16) -> Self { + self.index_buffer_stride = index_buffer_stride; + self + } + pub fn vertex_buffer_stride(mut self, vertex_buffer_stride: u16) -> Self { + self.vertex_buffer_stride = vertex_buffer_stride; + self + } + pub fn geometry_index_and_flags_buffer_stride( + mut self, + geometry_index_and_flags_buffer_stride: u16, + ) -> Self { + self.geometry_index_and_flags_buffer_stride = geometry_index_and_flags_buffer_stride; + self + } + pub fn opacity_micromap_index_buffer_stride( + mut self, + opacity_micromap_index_buffer_stride: u16, + ) -> Self { + self.opacity_micromap_index_buffer_stride = opacity_micromap_index_buffer_stride; + self + } + pub fn index_buffer(mut self, index_buffer: crate::vk::DeviceAddress) -> Self { + self.index_buffer = index_buffer; + self + } + pub fn vertex_buffer(mut self, vertex_buffer: crate::vk::DeviceAddress) -> Self { + self.vertex_buffer = vertex_buffer; + self + } + pub fn geometry_index_and_flags_buffer( + mut self, + geometry_index_and_flags_buffer: crate::vk::DeviceAddress, + ) -> Self { + self.geometry_index_and_flags_buffer = geometry_index_and_flags_buffer; + self + } + pub fn opacity_micromap_array( + mut self, + opacity_micromap_array: crate::vk::DeviceAddress, + ) -> Self { + self.opacity_micromap_array = opacity_micromap_array; + self + } + pub fn opacity_micromap_index_buffer( + mut self, + opacity_micromap_index_buffer: crate::vk::DeviceAddress, + ) -> Self { + self.opacity_micromap_index_buffer = opacity_micromap_index_buffer; + self + } + pub fn instantiation_bounding_box_limit( + mut self, + instantiation_bounding_box_limit: crate::vk::DeviceAddress, + ) -> Self { + self.instantiation_bounding_box_limit = instantiation_bounding_box_limit; + self + } + } #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct ClusterAccelerationStructureInstantiateClusterInfoNV { pub cluster_id_offset: u32, ///- `geometryIndexOffset` @ `0..24` @@ -170,6 +582,31 @@ pub(crate) mod reexport { pub cluster_template_address: crate::vk::DeviceAddress, pub vertex_buffer: crate::vk::StridedDeviceAddressNV, } + impl ClusterAccelerationStructureInstantiateClusterInfoNV { + pub fn cluster_id_offset(mut self, cluster_id_offset: u32) -> Self { + self.cluster_id_offset = cluster_id_offset; + self + } + pub fn geometry_index_offset(mut self, geometry_index_offset: u32) -> Self { + let rest = self.bitfield0 & 0xFF000000; + self.bitfield0 = (geometry_index_offset & 0x00FFFFFF) | rest; + self + } + pub fn cluster_template_address( + mut self, + cluster_template_address: crate::vk::DeviceAddress, + ) -> Self { + self.cluster_template_address = cluster_template_address; + self + } + pub fn vertex_buffer( + mut self, + vertex_buffer: crate::vk::StridedDeviceAddressNV, + ) -> Self { + self.vertex_buffer = vertex_buffer; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct ClusterAccelerationStructureClustersBottomLevelInputNV<'a> { @@ -179,6 +616,34 @@ pub(crate) mod reexport { pub max_cluster_count_per_acceleration_structure: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for ClusterAccelerationStructureClustersBottomLevelInputNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::CLUSTER_ACCELERATION_STRUCTURE_CLUSTERS_BOTTOM_LEVEL_INPUT_NV; + } + impl<'a> Default for ClusterAccelerationStructureClustersBottomLevelInputNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + max_total_cluster_count: Default::default(), + max_cluster_count_per_acceleration_structure: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> ClusterAccelerationStructureClustersBottomLevelInputNV<'a> { + pub fn max_total_cluster_count(mut self, max_total_cluster_count: u32) -> Self { + self.max_total_cluster_count = max_total_cluster_count; + self + } + pub fn max_cluster_count_per_acceleration_structure( + mut self, + max_cluster_count_per_acceleration_structure: u32, + ) -> Self { + self.max_cluster_count_per_acceleration_structure = max_cluster_count_per_acceleration_structure; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct ClusterAccelerationStructureTriangleClusterInputNV<'a> { @@ -194,6 +659,79 @@ pub(crate) mod reexport { pub min_position_truncate_bit_count: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for ClusterAccelerationStructureTriangleClusterInputNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::CLUSTER_ACCELERATION_STRUCTURE_TRIANGLE_CLUSTER_INPUT_NV; + } + impl<'a> Default for ClusterAccelerationStructureTriangleClusterInputNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + vertex_format: Default::default(), + max_geometry_index_value: Default::default(), + max_cluster_unique_geometry_count: Default::default(), + max_cluster_triangle_count: Default::default(), + max_cluster_vertex_count: Default::default(), + max_total_triangle_count: Default::default(), + max_total_vertex_count: Default::default(), + min_position_truncate_bit_count: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> ClusterAccelerationStructureTriangleClusterInputNV<'a> { + pub fn vertex_format(mut self, vertex_format: crate::vk::Format) -> Self { + self.vertex_format = vertex_format; + self + } + pub fn max_geometry_index_value( + mut self, + max_geometry_index_value: u32, + ) -> Self { + self.max_geometry_index_value = max_geometry_index_value; + self + } + pub fn max_cluster_unique_geometry_count( + mut self, + max_cluster_unique_geometry_count: u32, + ) -> Self { + self.max_cluster_unique_geometry_count = max_cluster_unique_geometry_count; + self + } + pub fn max_cluster_triangle_count( + mut self, + max_cluster_triangle_count: u32, + ) -> Self { + self.max_cluster_triangle_count = max_cluster_triangle_count; + self + } + pub fn max_cluster_vertex_count( + mut self, + max_cluster_vertex_count: u32, + ) -> Self { + self.max_cluster_vertex_count = max_cluster_vertex_count; + self + } + pub fn max_total_triangle_count( + mut self, + max_total_triangle_count: u32, + ) -> Self { + self.max_total_triangle_count = max_total_triangle_count; + self + } + pub fn max_total_vertex_count(mut self, max_total_vertex_count: u32) -> Self { + self.max_total_vertex_count = max_total_vertex_count; + self + } + pub fn min_position_truncate_bit_count( + mut self, + min_position_truncate_bit_count: u32, + ) -> Self { + self.min_position_truncate_bit_count = min_position_truncate_bit_count; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct ClusterAccelerationStructureMoveObjectsInputNV<'a> { @@ -204,6 +742,42 @@ pub(crate) mod reexport { pub max_moved_bytes: crate::vk::DeviceSize, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for ClusterAccelerationStructureMoveObjectsInputNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::CLUSTER_ACCELERATION_STRUCTURE_MOVE_OBJECTS_INPUT_NV; + } + impl<'a> Default for ClusterAccelerationStructureMoveObjectsInputNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + _type: Default::default(), + no_move_overlap: Default::default(), + max_moved_bytes: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> ClusterAccelerationStructureMoveObjectsInputNV<'a> { + pub fn _type( + mut self, + _type: crate::vk::ClusterAccelerationStructureTypeNV, + ) -> Self { + self._type = _type; + self + } + pub fn no_move_overlap(mut self, no_move_overlap: bool) -> Self { + self.no_move_overlap = no_move_overlap.into(); + self + } + pub fn max_moved_bytes( + mut self, + max_moved_bytes: crate::vk::DeviceSize, + ) -> Self { + self.max_moved_bytes = max_moved_bytes; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct ClusterAccelerationStructureInputInfoNV<'a> { @@ -216,6 +790,61 @@ pub(crate) mod reexport { pub op_input: crate::vk::ClusterAccelerationStructureOpInputNV<'a>, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for ClusterAccelerationStructureInputInfoNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::CLUSTER_ACCELERATION_STRUCTURE_INPUT_INFO_NV; + } + impl<'a> Default for ClusterAccelerationStructureInputInfoNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + max_acceleration_structure_count: Default::default(), + flags: Default::default(), + op_type: Default::default(), + op_mode: Default::default(), + op_input: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> ClusterAccelerationStructureInputInfoNV<'a> { + pub fn max_acceleration_structure_count( + mut self, + max_acceleration_structure_count: u32, + ) -> Self { + self.max_acceleration_structure_count = max_acceleration_structure_count; + self + } + pub fn flags( + mut self, + flags: crate::vk::BuildAccelerationStructureFlagsKHR, + ) -> Self { + self.flags = flags; + self + } + pub fn op_type( + mut self, + op_type: crate::vk::ClusterAccelerationStructureOpTypeNV, + ) -> Self { + self.op_type = op_type; + self + } + pub fn op_mode( + mut self, + op_mode: crate::vk::ClusterAccelerationStructureOpModeNV, + ) -> Self { + self.op_mode = op_mode; + self + } + pub fn op_input( + mut self, + op_input: crate::vk::ClusterAccelerationStructureOpInputNV<'a>, + ) -> Self { + self.op_input = op_input; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct ClusterAccelerationStructureCommandsInfoNV<'a> { @@ -231,6 +860,82 @@ pub(crate) mod reexport { pub address_resolution_flags: crate::vk::ClusterAccelerationStructureAddressResolutionFlagsNV, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for ClusterAccelerationStructureCommandsInfoNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::CLUSTER_ACCELERATION_STRUCTURE_COMMANDS_INFO_NV; + } + impl<'a> Default for ClusterAccelerationStructureCommandsInfoNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + input: Default::default(), + dst_implicit_data: Default::default(), + scratch_data: Default::default(), + dst_addresses_array: Default::default(), + dst_sizes_array: Default::default(), + src_infos_array: Default::default(), + src_infos_count: Default::default(), + address_resolution_flags: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> ClusterAccelerationStructureCommandsInfoNV<'a> { + pub fn input( + mut self, + input: crate::vk::ClusterAccelerationStructureInputInfoNV<'a>, + ) -> Self { + self.input = input; + self + } + pub fn dst_implicit_data( + mut self, + dst_implicit_data: crate::vk::DeviceAddress, + ) -> Self { + self.dst_implicit_data = dst_implicit_data; + self + } + pub fn scratch_data(mut self, scratch_data: crate::vk::DeviceAddress) -> Self { + self.scratch_data = scratch_data; + self + } + pub fn dst_addresses_array( + mut self, + dst_addresses_array: crate::vk::StridedDeviceAddressRegionKHR, + ) -> Self { + self.dst_addresses_array = dst_addresses_array; + self + } + pub fn dst_sizes_array( + mut self, + dst_sizes_array: crate::vk::StridedDeviceAddressRegionKHR, + ) -> Self { + self.dst_sizes_array = dst_sizes_array; + self + } + pub fn src_infos_array( + mut self, + src_infos_array: crate::vk::StridedDeviceAddressRegionKHR, + ) -> Self { + self.src_infos_array = src_infos_array; + self + } + pub fn src_infos_count( + mut self, + src_infos_count: crate::vk::DeviceAddress, + ) -> Self { + self.src_infos_count = src_infos_count; + self + } + pub fn address_resolution_flags( + mut self, + address_resolution_flags: crate::vk::ClusterAccelerationStructureAddressResolutionFlagsNV, + ) -> Self { + self.address_resolution_flags = address_resolution_flags; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub union ClusterAccelerationStructureOpInputNV<'a> { @@ -244,6 +949,11 @@ pub(crate) mod reexport { 'a, >, } + impl<'a> Default for ClusterAccelerationStructureOpInputNV<'a> { + fn default() -> Self { + unsafe { core::mem::zeroed() } + } + } ///Provided by [`nv::cluster_acceleration_structure`](crate::nv::cluster_acceleration_structure) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_FEATURES_NV: Self = Self( @@ -408,7 +1118,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct ClusterAccelerationStructureGeometryFlagBitsNV(pub(crate) u32); ///Provided by [`nv::cluster_acceleration_structure`](crate::nv::cluster_acceleration_structure) impl ClusterAccelerationStructureGeometryFlagBitsNV { @@ -488,7 +1198,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct ClusterAccelerationStructureClusterFlagBitsNV(pub(crate) u32); ///Provided by [`nv::cluster_acceleration_structure`](crate::nv::cluster_acceleration_structure) impl ClusterAccelerationStructureClusterFlagBitsNV { @@ -592,7 +1302,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct ClusterAccelerationStructureAddressResolutionFlagBitsNV(pub(crate) u32); ///Provided by [`nv::cluster_acceleration_structure`](crate::nv::cluster_acceleration_structure) impl ClusterAccelerationStructureAddressResolutionFlagBitsNV { @@ -685,7 +1395,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct ClusterAccelerationStructureIndexFormatFlagBitsNV(pub(crate) u32); ///Provided by [`nv::cluster_acceleration_structure`](crate::nv::cluster_acceleration_structure) impl ClusterAccelerationStructureIndexFormatFlagBitsNV { diff --git a/ash-rewrite/src/generated/nv/command_buffer_inheritance.rs b/ash-rewrite/src/generated/nv/command_buffer_inheritance.rs index 4343bbc48..4f91a287e 100644 --- a/ash-rewrite/src/generated/nv/command_buffer_inheritance.rs +++ b/ash-rewrite/src/generated/nv/command_buffer_inheritance.rs @@ -9,6 +9,33 @@ pub struct PhysicalDeviceCommandBufferInheritanceFeaturesNV<'a> { pub command_buffer_inheritance: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceCommandBufferInheritanceFeaturesNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_COMMAND_BUFFER_INHERITANCE_FEATURES_NV; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceCommandBufferInheritanceFeaturesNV<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceCommandBufferInheritanceFeaturesNV<'a> {} +impl<'a> Default for PhysicalDeviceCommandBufferInheritanceFeaturesNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + command_buffer_inheritance: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceCommandBufferInheritanceFeaturesNV<'a> { + pub fn command_buffer_inheritance( + mut self, + command_buffer_inheritance: bool, + ) -> Self { + self.command_buffer_inheritance = command_buffer_inheritance.into(); + self + } +} ///Provided by [`nv::command_buffer_inheritance`](crate::nv::command_buffer_inheritance) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_COMMAND_BUFFER_INHERITANCE_FEATURES_NV: Self = Self( diff --git a/ash-rewrite/src/generated/nv/compute_occupancy_priority.rs b/ash-rewrite/src/generated/nv/compute_occupancy_priority.rs index a848b1b57..de378890c 100644 --- a/ash-rewrite/src/generated/nv/compute_occupancy_priority.rs +++ b/ash-rewrite/src/generated/nv/compute_occupancy_priority.rs @@ -44,6 +44,37 @@ pub(crate) mod reexport { pub occupancy_throttling: core::ffi::c_float, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for ComputeOccupancyPriorityParametersNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::COMPUTE_OCCUPANCY_PRIORITY_PARAMETERS_NV; + } + impl<'a> Default for ComputeOccupancyPriorityParametersNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + occupancy_priority: Default::default(), + occupancy_throttling: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> ComputeOccupancyPriorityParametersNV<'a> { + pub fn occupancy_priority( + mut self, + occupancy_priority: core::ffi::c_float, + ) -> Self { + self.occupancy_priority = occupancy_priority; + self + } + pub fn occupancy_throttling( + mut self, + occupancy_throttling: core::ffi::c_float, + ) -> Self { + self.occupancy_throttling = occupancy_throttling; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceComputeOccupancyPriorityFeaturesNV<'a> { @@ -52,6 +83,33 @@ pub(crate) mod reexport { pub compute_occupancy_priority: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceComputeOccupancyPriorityFeaturesNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_COMPUTE_OCCUPANCY_PRIORITY_FEATURES_NV; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceComputeOccupancyPriorityFeaturesNV<'a> {} + unsafe impl<'a> crate::Extends> + for PhysicalDeviceComputeOccupancyPriorityFeaturesNV<'a> {} + impl<'a> Default for PhysicalDeviceComputeOccupancyPriorityFeaturesNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + compute_occupancy_priority: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceComputeOccupancyPriorityFeaturesNV<'a> { + pub fn compute_occupancy_priority( + mut self, + compute_occupancy_priority: bool, + ) -> Self { + self.compute_occupancy_priority = compute_occupancy_priority.into(); + self + } + } ///Provided by [`nv::compute_occupancy_priority`](crate::nv::compute_occupancy_priority) impl crate::vk::StructureType { pub const COMPUTE_OCCUPANCY_PRIORITY_PARAMETERS_NV: Self = Self(1000645000); diff --git a/ash-rewrite/src/generated/nv/cooperative_matrix.rs b/ash-rewrite/src/generated/nv/cooperative_matrix.rs index 860c2e016..438da832e 100644 --- a/ash-rewrite/src/generated/nv/cooperative_matrix.rs +++ b/ash-rewrite/src/generated/nv/cooperative_matrix.rs @@ -47,6 +47,39 @@ pub(crate) mod reexport { pub cooperative_matrix_robust_buffer_access: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceCooperativeMatrixFeaturesNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceCooperativeMatrixFeaturesNV<'a> {} + unsafe impl<'a> crate::Extends> + for PhysicalDeviceCooperativeMatrixFeaturesNV<'a> {} + impl<'a> Default for PhysicalDeviceCooperativeMatrixFeaturesNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + cooperative_matrix: Default::default(), + cooperative_matrix_robust_buffer_access: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceCooperativeMatrixFeaturesNV<'a> { + pub fn cooperative_matrix(mut self, cooperative_matrix: bool) -> Self { + self.cooperative_matrix = cooperative_matrix.into(); + self + } + pub fn cooperative_matrix_robust_buffer_access( + mut self, + cooperative_matrix_robust_buffer_access: bool, + ) -> Self { + self.cooperative_matrix_robust_buffer_access = cooperative_matrix_robust_buffer_access + .into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceCooperativeMatrixPropertiesNV<'a> { @@ -55,6 +88,31 @@ pub(crate) mod reexport { pub cooperative_matrix_supported_stages: crate::vk::ShaderStageFlags, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceCooperativeMatrixPropertiesNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceCooperativeMatrixPropertiesNV<'a> {} + impl<'a> Default for PhysicalDeviceCooperativeMatrixPropertiesNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + cooperative_matrix_supported_stages: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceCooperativeMatrixPropertiesNV<'a> { + pub fn cooperative_matrix_supported_stages( + mut self, + cooperative_matrix_supported_stages: crate::vk::ShaderStageFlags, + ) -> Self { + self.cooperative_matrix_supported_stages = cooperative_matrix_supported_stages; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct CooperativeMatrixPropertiesNV<'a> { @@ -70,6 +128,60 @@ pub(crate) mod reexport { pub scope: crate::vk::ScopeNV, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for CooperativeMatrixPropertiesNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::COOPERATIVE_MATRIX_PROPERTIES_NV; + } + impl<'a> Default for CooperativeMatrixPropertiesNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + m_size: Default::default(), + n_size: Default::default(), + k_size: Default::default(), + a_type: Default::default(), + b_type: Default::default(), + c_type: Default::default(), + d_type: Default::default(), + scope: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> CooperativeMatrixPropertiesNV<'a> { + pub fn m_size(mut self, m_size: u32) -> Self { + self.m_size = m_size; + self + } + pub fn n_size(mut self, n_size: u32) -> Self { + self.n_size = n_size; + self + } + pub fn k_size(mut self, k_size: u32) -> Self { + self.k_size = k_size; + self + } + pub fn a_type(mut self, a_type: crate::vk::ComponentTypeNV) -> Self { + self.a_type = a_type; + self + } + pub fn b_type(mut self, b_type: crate::vk::ComponentTypeNV) -> Self { + self.b_type = b_type; + self + } + pub fn c_type(mut self, c_type: crate::vk::ComponentTypeNV) -> Self { + self.c_type = c_type; + self + } + pub fn d_type(mut self, d_type: crate::vk::ComponentTypeNV) -> Self { + self.d_type = d_type; + self + } + pub fn scope(mut self, scope: crate::vk::ScopeNV) -> Self { + self.scope = scope; + self + } + } ///Provided by [`nv::cooperative_matrix`](crate::nv::cooperative_matrix) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV: Self = Self( diff --git a/ash-rewrite/src/generated/nv/cooperative_matrix2.rs b/ash-rewrite/src/generated/nv/cooperative_matrix2.rs index a3f051f74..5941653a4 100644 --- a/ash-rewrite/src/generated/nv/cooperative_matrix2.rs +++ b/ash-rewrite/src/generated/nv/cooperative_matrix2.rs @@ -56,6 +56,85 @@ pub(crate) mod reexport { pub cooperative_matrix_block_loads: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceCooperativeMatrix2FeaturesNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_FEATURES_NV; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceCooperativeMatrix2FeaturesNV<'a> {} + unsafe impl<'a> crate::Extends> + for PhysicalDeviceCooperativeMatrix2FeaturesNV<'a> {} + impl<'a> Default for PhysicalDeviceCooperativeMatrix2FeaturesNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + cooperative_matrix_workgroup_scope: Default::default(), + cooperative_matrix_flexible_dimensions: Default::default(), + cooperative_matrix_reductions: Default::default(), + cooperative_matrix_conversions: Default::default(), + cooperative_matrix_per_element_operations: Default::default(), + cooperative_matrix_tensor_addressing: Default::default(), + cooperative_matrix_block_loads: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceCooperativeMatrix2FeaturesNV<'a> { + pub fn cooperative_matrix_workgroup_scope( + mut self, + cooperative_matrix_workgroup_scope: bool, + ) -> Self { + self.cooperative_matrix_workgroup_scope = cooperative_matrix_workgroup_scope + .into(); + self + } + pub fn cooperative_matrix_flexible_dimensions( + mut self, + cooperative_matrix_flexible_dimensions: bool, + ) -> Self { + self.cooperative_matrix_flexible_dimensions = cooperative_matrix_flexible_dimensions + .into(); + self + } + pub fn cooperative_matrix_reductions( + mut self, + cooperative_matrix_reductions: bool, + ) -> Self { + self.cooperative_matrix_reductions = cooperative_matrix_reductions.into(); + self + } + pub fn cooperative_matrix_conversions( + mut self, + cooperative_matrix_conversions: bool, + ) -> Self { + self.cooperative_matrix_conversions = cooperative_matrix_conversions.into(); + self + } + pub fn cooperative_matrix_per_element_operations( + mut self, + cooperative_matrix_per_element_operations: bool, + ) -> Self { + self.cooperative_matrix_per_element_operations = cooperative_matrix_per_element_operations + .into(); + self + } + pub fn cooperative_matrix_tensor_addressing( + mut self, + cooperative_matrix_tensor_addressing: bool, + ) -> Self { + self.cooperative_matrix_tensor_addressing = cooperative_matrix_tensor_addressing + .into(); + self + } + pub fn cooperative_matrix_block_loads( + mut self, + cooperative_matrix_block_loads: bool, + ) -> Self { + self.cooperative_matrix_block_loads = cooperative_matrix_block_loads.into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceCooperativeMatrix2PropertiesNV<'a> { @@ -66,6 +145,47 @@ pub(crate) mod reexport { pub cooperative_matrix_workgroup_scope_reserved_shared_memory: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceCooperativeMatrix2PropertiesNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_PROPERTIES_NV; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceCooperativeMatrix2PropertiesNV<'a> {} + impl<'a> Default for PhysicalDeviceCooperativeMatrix2PropertiesNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + cooperative_matrix_workgroup_scope_max_workgroup_size: Default::default(), + cooperative_matrix_flexible_dimensions_max_dimension: Default::default(), + cooperative_matrix_workgroup_scope_reserved_shared_memory: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceCooperativeMatrix2PropertiesNV<'a> { + pub fn cooperative_matrix_workgroup_scope_max_workgroup_size( + mut self, + cooperative_matrix_workgroup_scope_max_workgroup_size: u32, + ) -> Self { + self.cooperative_matrix_workgroup_scope_max_workgroup_size = cooperative_matrix_workgroup_scope_max_workgroup_size; + self + } + pub fn cooperative_matrix_flexible_dimensions_max_dimension( + mut self, + cooperative_matrix_flexible_dimensions_max_dimension: u32, + ) -> Self { + self.cooperative_matrix_flexible_dimensions_max_dimension = cooperative_matrix_flexible_dimensions_max_dimension; + self + } + pub fn cooperative_matrix_workgroup_scope_reserved_shared_memory( + mut self, + cooperative_matrix_workgroup_scope_reserved_shared_memory: u32, + ) -> Self { + self.cooperative_matrix_workgroup_scope_reserved_shared_memory = cooperative_matrix_workgroup_scope_reserved_shared_memory; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct CooperativeMatrixFlexibleDimensionsPropertiesNV<'a> { @@ -83,6 +203,71 @@ pub(crate) mod reexport { pub workgroup_invocations: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for CooperativeMatrixFlexibleDimensionsPropertiesNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::COOPERATIVE_MATRIX_FLEXIBLE_DIMENSIONS_PROPERTIES_NV; + } + impl<'a> Default for CooperativeMatrixFlexibleDimensionsPropertiesNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + m_granularity: Default::default(), + n_granularity: Default::default(), + k_granularity: Default::default(), + a_type: Default::default(), + b_type: Default::default(), + c_type: Default::default(), + result_type: Default::default(), + saturating_accumulation: Default::default(), + scope: Default::default(), + workgroup_invocations: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> CooperativeMatrixFlexibleDimensionsPropertiesNV<'a> { + pub fn m_granularity(mut self, m_granularity: u32) -> Self { + self.m_granularity = m_granularity; + self + } + pub fn n_granularity(mut self, n_granularity: u32) -> Self { + self.n_granularity = n_granularity; + self + } + pub fn k_granularity(mut self, k_granularity: u32) -> Self { + self.k_granularity = k_granularity; + self + } + pub fn a_type(mut self, a_type: crate::vk::ComponentTypeKHR) -> Self { + self.a_type = a_type; + self + } + pub fn b_type(mut self, b_type: crate::vk::ComponentTypeKHR) -> Self { + self.b_type = b_type; + self + } + pub fn c_type(mut self, c_type: crate::vk::ComponentTypeKHR) -> Self { + self.c_type = c_type; + self + } + pub fn result_type(mut self, result_type: crate::vk::ComponentTypeKHR) -> Self { + self.result_type = result_type; + self + } + pub fn saturating_accumulation(mut self, saturating_accumulation: bool) -> Self { + self.saturating_accumulation = saturating_accumulation.into(); + self + } + pub fn scope(mut self, scope: crate::vk::ScopeKHR) -> Self { + self.scope = scope; + self + } + pub fn workgroup_invocations(mut self, workgroup_invocations: u32) -> Self { + self.workgroup_invocations = workgroup_invocations; + self + } + } ///Provided by [`nv::cooperative_matrix2`](crate::nv::cooperative_matrix2) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_FEATURES_NV: Self = Self( diff --git a/ash-rewrite/src/generated/nv/cooperative_vector.rs b/ash-rewrite/src/generated/nv/cooperative_vector.rs index 2bc8fa59a..920a5ca6e 100644 --- a/ash-rewrite/src/generated/nv/cooperative_vector.rs +++ b/ash-rewrite/src/generated/nv/cooperative_vector.rs @@ -96,6 +96,38 @@ pub(crate) mod reexport { pub cooperative_vector_training: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceCooperativeVectorFeaturesNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_COOPERATIVE_VECTOR_FEATURES_NV; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceCooperativeVectorFeaturesNV<'a> {} + unsafe impl<'a> crate::Extends> + for PhysicalDeviceCooperativeVectorFeaturesNV<'a> {} + impl<'a> Default for PhysicalDeviceCooperativeVectorFeaturesNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + cooperative_vector: Default::default(), + cooperative_vector_training: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceCooperativeVectorFeaturesNV<'a> { + pub fn cooperative_vector(mut self, cooperative_vector: bool) -> Self { + self.cooperative_vector = cooperative_vector.into(); + self + } + pub fn cooperative_vector_training( + mut self, + cooperative_vector_training: bool, + ) -> Self { + self.cooperative_vector_training = cooperative_vector_training.into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct CooperativeVectorPropertiesNV<'a> { @@ -109,6 +141,59 @@ pub(crate) mod reexport { pub transpose: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for CooperativeVectorPropertiesNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::COOPERATIVE_VECTOR_PROPERTIES_NV; + } + impl<'a> Default for CooperativeVectorPropertiesNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + input_type: Default::default(), + input_interpretation: Default::default(), + matrix_interpretation: Default::default(), + bias_interpretation: Default::default(), + result_type: Default::default(), + transpose: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> CooperativeVectorPropertiesNV<'a> { + pub fn input_type(mut self, input_type: crate::vk::ComponentTypeKHR) -> Self { + self.input_type = input_type; + self + } + pub fn input_interpretation( + mut self, + input_interpretation: crate::vk::ComponentTypeKHR, + ) -> Self { + self.input_interpretation = input_interpretation; + self + } + pub fn matrix_interpretation( + mut self, + matrix_interpretation: crate::vk::ComponentTypeKHR, + ) -> Self { + self.matrix_interpretation = matrix_interpretation; + self + } + pub fn bias_interpretation( + mut self, + bias_interpretation: crate::vk::ComponentTypeKHR, + ) -> Self { + self.bias_interpretation = bias_interpretation; + self + } + pub fn result_type(mut self, result_type: crate::vk::ComponentTypeKHR) -> Self { + self.result_type = result_type; + self + } + pub fn transpose(mut self, transpose: bool) -> Self { + self.transpose = transpose.into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceCooperativeVectorPropertiesNV<'a> { @@ -120,6 +205,57 @@ pub(crate) mod reexport { pub max_cooperative_vector_components: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceCooperativeVectorPropertiesNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_COOPERATIVE_VECTOR_PROPERTIES_NV; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceCooperativeVectorPropertiesNV<'a> {} + impl<'a> Default for PhysicalDeviceCooperativeVectorPropertiesNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + cooperative_vector_supported_stages: Default::default(), + cooperative_vector_training_float16_accumulation: Default::default(), + cooperative_vector_training_float32_accumulation: Default::default(), + max_cooperative_vector_components: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceCooperativeVectorPropertiesNV<'a> { + pub fn cooperative_vector_supported_stages( + mut self, + cooperative_vector_supported_stages: crate::vk::ShaderStageFlags, + ) -> Self { + self.cooperative_vector_supported_stages = cooperative_vector_supported_stages; + self + } + pub fn cooperative_vector_training_float16_accumulation( + mut self, + cooperative_vector_training_float16_accumulation: bool, + ) -> Self { + self.cooperative_vector_training_float16_accumulation = cooperative_vector_training_float16_accumulation + .into(); + self + } + pub fn cooperative_vector_training_float32_accumulation( + mut self, + cooperative_vector_training_float32_accumulation: bool, + ) -> Self { + self.cooperative_vector_training_float32_accumulation = cooperative_vector_training_float32_accumulation + .into(); + self + } + pub fn max_cooperative_vector_components( + mut self, + max_cooperative_vector_components: u32, + ) -> Self { + self.max_cooperative_vector_components = max_cooperative_vector_components; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct ConvertCooperativeVectorMatrixInfoNV<'a> { @@ -139,6 +275,96 @@ pub(crate) mod reexport { pub dst_stride: usize, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for ConvertCooperativeVectorMatrixInfoNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::CONVERT_COOPERATIVE_VECTOR_MATRIX_INFO_NV; + } + impl<'a> Default for ConvertCooperativeVectorMatrixInfoNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + src_size: Default::default(), + src_data: Default::default(), + p_dst_size: Default::default(), + dst_data: Default::default(), + src_component_type: Default::default(), + dst_component_type: Default::default(), + num_rows: Default::default(), + num_columns: Default::default(), + src_layout: Default::default(), + src_stride: Default::default(), + dst_layout: Default::default(), + dst_stride: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> ConvertCooperativeVectorMatrixInfoNV<'a> { + pub fn src_size(mut self, src_size: usize) -> Self { + self.src_size = src_size; + self + } + pub fn src_data( + mut self, + src_data: crate::vk::DeviceOrHostAddressConstKHR, + ) -> Self { + self.src_data = src_data; + self + } + pub fn p_dst_size(mut self, p_dst_size: &'a mut usize) -> Self { + self.p_dst_size = p_dst_size; + self + } + pub fn dst_data(mut self, dst_data: crate::vk::DeviceOrHostAddressKHR) -> Self { + self.dst_data = dst_data; + self + } + pub fn src_component_type( + mut self, + src_component_type: crate::vk::ComponentTypeKHR, + ) -> Self { + self.src_component_type = src_component_type; + self + } + pub fn dst_component_type( + mut self, + dst_component_type: crate::vk::ComponentTypeKHR, + ) -> Self { + self.dst_component_type = dst_component_type; + self + } + pub fn num_rows(mut self, num_rows: u32) -> Self { + self.num_rows = num_rows; + self + } + pub fn num_columns(mut self, num_columns: u32) -> Self { + self.num_columns = num_columns; + self + } + pub fn src_layout( + mut self, + src_layout: crate::vk::CooperativeVectorMatrixLayoutNV, + ) -> Self { + self.src_layout = src_layout; + self + } + pub fn src_stride(mut self, src_stride: usize) -> Self { + self.src_stride = src_stride; + self + } + pub fn dst_layout( + mut self, + dst_layout: crate::vk::CooperativeVectorMatrixLayoutNV, + ) -> Self { + self.dst_layout = dst_layout; + self + } + pub fn dst_stride(mut self, dst_stride: usize) -> Self { + self.dst_stride = dst_stride; + self + } + } ///Provided by [`nv::cooperative_vector`](crate::nv::cooperative_vector) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_COOPERATIVE_VECTOR_FEATURES_NV: Self = Self( diff --git a/ash-rewrite/src/generated/nv/copy_memory_indirect.rs b/ash-rewrite/src/generated/nv/copy_memory_indirect.rs index 4e757aac4..396d852c4 100644 --- a/ash-rewrite/src/generated/nv/copy_memory_indirect.rs +++ b/ash-rewrite/src/generated/nv/copy_memory_indirect.rs @@ -65,6 +65,30 @@ pub(crate) mod reexport { pub indirect_copy: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceCopyMemoryIndirectFeaturesNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceCopyMemoryIndirectFeaturesNV<'a> {} + unsafe impl<'a> crate::Extends> + for PhysicalDeviceCopyMemoryIndirectFeaturesNV<'a> {} + impl<'a> Default for PhysicalDeviceCopyMemoryIndirectFeaturesNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + indirect_copy: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceCopyMemoryIndirectFeaturesNV<'a> { + pub fn indirect_copy(mut self, indirect_copy: bool) -> Self { + self.indirect_copy = indirect_copy.into(); + self + } + } pub type CopyMemoryIndirectCommandNV = crate::vk::CopyMemoryIndirectCommandKHR; pub type CopyMemoryToImageIndirectCommandNV = crate::vk::CopyMemoryToImageIndirectCommandKHR; pub type PhysicalDeviceCopyMemoryIndirectPropertiesNV<'a> = crate::vk::PhysicalDeviceCopyMemoryIndirectPropertiesKHR< diff --git a/ash-rewrite/src/generated/nv/corner_sampled_image.rs b/ash-rewrite/src/generated/nv/corner_sampled_image.rs index 45850117e..ccdfe46f2 100644 --- a/ash-rewrite/src/generated/nv/corner_sampled_image.rs +++ b/ash-rewrite/src/generated/nv/corner_sampled_image.rs @@ -9,6 +9,30 @@ pub struct PhysicalDeviceCornerSampledImageFeaturesNV<'a> { pub corner_sampled_image: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceCornerSampledImageFeaturesNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceCornerSampledImageFeaturesNV<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceCornerSampledImageFeaturesNV<'a> {} +impl<'a> Default for PhysicalDeviceCornerSampledImageFeaturesNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + corner_sampled_image: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceCornerSampledImageFeaturesNV<'a> { + pub fn corner_sampled_image(mut self, corner_sampled_image: bool) -> Self { + self.corner_sampled_image = corner_sampled_image.into(); + self + } +} ///Provided by [`nv::corner_sampled_image`](crate::nv::corner_sampled_image) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV: Self = Self(1000050000); diff --git a/ash-rewrite/src/generated/nv/coverage_reduction_mode.rs b/ash-rewrite/src/generated/nv/coverage_reduction_mode.rs index d03ad38aa..a3a1a0c24 100644 --- a/ash-rewrite/src/generated/nv/coverage_reduction_mode.rs +++ b/ash-rewrite/src/generated/nv/coverage_reduction_mode.rs @@ -48,6 +48,30 @@ pub(crate) mod reexport { pub coverage_reduction_mode: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceCoverageReductionModeFeaturesNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceCoverageReductionModeFeaturesNV<'a> {} + unsafe impl<'a> crate::Extends> + for PhysicalDeviceCoverageReductionModeFeaturesNV<'a> {} + impl<'a> Default for PhysicalDeviceCoverageReductionModeFeaturesNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + coverage_reduction_mode: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceCoverageReductionModeFeaturesNV<'a> { + pub fn coverage_reduction_mode(mut self, coverage_reduction_mode: bool) -> Self { + self.coverage_reduction_mode = coverage_reduction_mode.into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PipelineCoverageReductionStateCreateInfoNV<'a> { @@ -57,6 +81,39 @@ pub(crate) mod reexport { pub coverage_reduction_mode: crate::vk::CoverageReductionModeNV, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PipelineCoverageReductionStateCreateInfoNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV; + } + unsafe impl<'a> crate::Extends> + for PipelineCoverageReductionStateCreateInfoNV<'a> {} + impl<'a> Default for PipelineCoverageReductionStateCreateInfoNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + flags: Default::default(), + coverage_reduction_mode: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PipelineCoverageReductionStateCreateInfoNV<'a> { + pub fn flags( + mut self, + flags: crate::vk::PipelineCoverageReductionStateCreateFlagsNV, + ) -> Self { + self.flags = flags; + self + } + pub fn coverage_reduction_mode( + mut self, + coverage_reduction_mode: crate::vk::CoverageReductionModeNV, + ) -> Self { + self.coverage_reduction_mode = coverage_reduction_mode; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct FramebufferMixedSamplesCombinationNV<'a> { @@ -68,6 +125,53 @@ pub(crate) mod reexport { pub color_samples: crate::vk::SampleCountFlags, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for FramebufferMixedSamplesCombinationNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::FRAMEBUFFER_MIXED_SAMPLES_COMBINATION_NV; + } + impl<'a> Default for FramebufferMixedSamplesCombinationNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + coverage_reduction_mode: Default::default(), + rasterization_samples: Default::default(), + depth_stencil_samples: Default::default(), + color_samples: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> FramebufferMixedSamplesCombinationNV<'a> { + pub fn coverage_reduction_mode( + mut self, + coverage_reduction_mode: crate::vk::CoverageReductionModeNV, + ) -> Self { + self.coverage_reduction_mode = coverage_reduction_mode; + self + } + pub fn rasterization_samples( + mut self, + rasterization_samples: crate::vk::SampleCountFlagBits, + ) -> Self { + self.rasterization_samples = rasterization_samples; + self + } + pub fn depth_stencil_samples( + mut self, + depth_stencil_samples: crate::vk::SampleCountFlags, + ) -> Self { + self.depth_stencil_samples = depth_stencil_samples; + self + } + pub fn color_samples( + mut self, + color_samples: crate::vk::SampleCountFlags, + ) -> Self { + self.color_samples = color_samples; + self + } + } ///Provided by [`nv::coverage_reduction_mode`](crate::nv::coverage_reduction_mode) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV: Self = Self( diff --git a/ash-rewrite/src/generated/nv/cuda_kernel_launch.rs b/ash-rewrite/src/generated/nv/cuda_kernel_launch.rs index 98dc5c3af..a94eeb87d 100644 --- a/ash-rewrite/src/generated/nv/cuda_kernel_launch.rs +++ b/ash-rewrite/src/generated/nv/cuda_kernel_launch.rs @@ -127,6 +127,31 @@ pub(crate) mod reexport { pub p_data: *const core::ffi::c_void, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for CudaModuleCreateInfoNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::CUDA_MODULE_CREATE_INFO_NV; + } + impl<'a> Default for CudaModuleCreateInfoNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + data_size: Default::default(), + p_data: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> CudaModuleCreateInfoNV<'a> { + pub fn data_size(mut self, data_size: usize) -> Self { + self.data_size = data_size; + self + } + pub fn p_data(mut self, p_data: &'a [u8]) -> Self { + self.data_size = p_data.len() as _; + self.p_data = p_data.as_ptr().cast(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct CudaFunctionCreateInfoNV<'a> { @@ -136,6 +161,37 @@ pub(crate) mod reexport { pub p_name: *const core::ffi::c_char, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for CudaFunctionCreateInfoNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::CUDA_FUNCTION_CREATE_INFO_NV; + } + impl<'a> Default for CudaFunctionCreateInfoNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + module: Default::default(), + p_name: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> CudaFunctionCreateInfoNV<'a> { + pub fn module(mut self, module: crate::vk::CudaModuleNV) -> Self { + self.module = module; + self + } + pub fn p_name(mut self, p_name: &'a core::ffi::CStr) -> Self { + self.p_name = p_name.as_ptr(); + self + } + pub unsafe fn p_name_as_c_str(&self) -> Option<&core::ffi::CStr> { + if self.p_name.is_null() { + None + } else { + Some(unsafe { core::ffi::CStr::from_ptr(self.p_name) }) + } + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct CudaLaunchInfoNV<'a> { @@ -155,6 +211,82 @@ pub(crate) mod reexport { pub p_extras: *const *const core::ffi::c_void, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for CudaLaunchInfoNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::CUDA_LAUNCH_INFO_NV; + } + impl<'a> Default for CudaLaunchInfoNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + function: Default::default(), + grid_dim_x: Default::default(), + grid_dim_y: Default::default(), + grid_dim_z: Default::default(), + block_dim_x: Default::default(), + block_dim_y: Default::default(), + block_dim_z: Default::default(), + shared_mem_bytes: Default::default(), + param_count: Default::default(), + p_params: Default::default(), + extra_count: Default::default(), + p_extras: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> CudaLaunchInfoNV<'a> { + pub fn function(mut self, function: crate::vk::CudaFunctionNV) -> Self { + self.function = function; + self + } + pub fn grid_dim_x(mut self, grid_dim_x: u32) -> Self { + self.grid_dim_x = grid_dim_x; + self + } + pub fn grid_dim_y(mut self, grid_dim_y: u32) -> Self { + self.grid_dim_y = grid_dim_y; + self + } + pub fn grid_dim_z(mut self, grid_dim_z: u32) -> Self { + self.grid_dim_z = grid_dim_z; + self + } + pub fn block_dim_x(mut self, block_dim_x: u32) -> Self { + self.block_dim_x = block_dim_x; + self + } + pub fn block_dim_y(mut self, block_dim_y: u32) -> Self { + self.block_dim_y = block_dim_y; + self + } + pub fn block_dim_z(mut self, block_dim_z: u32) -> Self { + self.block_dim_z = block_dim_z; + self + } + pub fn shared_mem_bytes(mut self, shared_mem_bytes: u32) -> Self { + self.shared_mem_bytes = shared_mem_bytes; + self + } + pub fn param_count(mut self, param_count: usize) -> Self { + self.param_count = param_count; + self + } + pub fn p_params(mut self, p_params: &'a [*const core::ffi::c_void]) -> Self { + self.param_count = p_params.len() as _; + self.p_params = p_params.as_ptr(); + self + } + pub fn extra_count(mut self, extra_count: usize) -> Self { + self.extra_count = extra_count; + self + } + pub fn p_extras(mut self, p_extras: &'a [*const core::ffi::c_void]) -> Self { + self.extra_count = p_extras.len() as _; + self.p_extras = p_extras.as_ptr(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceCudaKernelLaunchFeaturesNV<'a> { @@ -163,6 +295,33 @@ pub(crate) mod reexport { pub cuda_kernel_launch_features: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceCudaKernelLaunchFeaturesNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_FEATURES_NV; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceCudaKernelLaunchFeaturesNV<'a> {} + unsafe impl<'a> crate::Extends> + for PhysicalDeviceCudaKernelLaunchFeaturesNV<'a> {} + impl<'a> Default for PhysicalDeviceCudaKernelLaunchFeaturesNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + cuda_kernel_launch_features: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceCudaKernelLaunchFeaturesNV<'a> { + pub fn cuda_kernel_launch_features( + mut self, + cuda_kernel_launch_features: bool, + ) -> Self { + self.cuda_kernel_launch_features = cuda_kernel_launch_features.into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceCudaKernelLaunchPropertiesNV<'a> { @@ -172,6 +331,39 @@ pub(crate) mod reexport { pub compute_capability_major: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceCudaKernelLaunchPropertiesNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_PROPERTIES_NV; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceCudaKernelLaunchPropertiesNV<'a> {} + impl<'a> Default for PhysicalDeviceCudaKernelLaunchPropertiesNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + compute_capability_minor: Default::default(), + compute_capability_major: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceCudaKernelLaunchPropertiesNV<'a> { + pub fn compute_capability_minor( + mut self, + compute_capability_minor: u32, + ) -> Self { + self.compute_capability_minor = compute_capability_minor; + self + } + pub fn compute_capability_major( + mut self, + compute_capability_major: u32, + ) -> Self { + self.compute_capability_major = compute_capability_major; + self + } + } ///Provided by [`nv::cuda_kernel_launch`](crate::nv::cuda_kernel_launch) impl crate::vk::StructureType { pub const CUDA_MODULE_CREATE_INFO_NV: Self = Self(1000307000); diff --git a/ash-rewrite/src/generated/nv/dedicated_allocation.rs b/ash-rewrite/src/generated/nv/dedicated_allocation.rs index 393432d7d..1b4225112 100644 --- a/ash-rewrite/src/generated/nv/dedicated_allocation.rs +++ b/ash-rewrite/src/generated/nv/dedicated_allocation.rs @@ -9,6 +9,27 @@ pub struct DedicatedAllocationImageCreateInfoNV<'a> { pub dedicated_allocation: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> for DedicatedAllocationImageCreateInfoNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV; +} +unsafe impl<'a> crate::Extends> +for DedicatedAllocationImageCreateInfoNV<'a> {} +impl<'a> Default for DedicatedAllocationImageCreateInfoNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + dedicated_allocation: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> DedicatedAllocationImageCreateInfoNV<'a> { + pub fn dedicated_allocation(mut self, dedicated_allocation: bool) -> Self { + self.dedicated_allocation = dedicated_allocation.into(); + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct DedicatedAllocationBufferCreateInfoNV<'a> { @@ -17,6 +38,28 @@ pub struct DedicatedAllocationBufferCreateInfoNV<'a> { pub dedicated_allocation: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for DedicatedAllocationBufferCreateInfoNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV; +} +unsafe impl<'a> crate::Extends> +for DedicatedAllocationBufferCreateInfoNV<'a> {} +impl<'a> Default for DedicatedAllocationBufferCreateInfoNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + dedicated_allocation: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> DedicatedAllocationBufferCreateInfoNV<'a> { + pub fn dedicated_allocation(mut self, dedicated_allocation: bool) -> Self { + self.dedicated_allocation = dedicated_allocation.into(); + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct DedicatedAllocationMemoryAllocateInfoNV<'a> { @@ -26,6 +69,33 @@ pub struct DedicatedAllocationMemoryAllocateInfoNV<'a> { pub buffer: crate::vk::Buffer, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for DedicatedAllocationMemoryAllocateInfoNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV; +} +unsafe impl<'a> crate::Extends> +for DedicatedAllocationMemoryAllocateInfoNV<'a> {} +impl<'a> Default for DedicatedAllocationMemoryAllocateInfoNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + image: Default::default(), + buffer: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> DedicatedAllocationMemoryAllocateInfoNV<'a> { + pub fn image(mut self, image: crate::vk::Image) -> Self { + self.image = image; + self + } + pub fn buffer(mut self, buffer: crate::vk::Buffer) -> Self { + self.buffer = buffer; + self + } +} ///Provided by [`nv::dedicated_allocation`](crate::nv::dedicated_allocation) impl crate::vk::StructureType { pub const DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV: Self = Self(1000026000); diff --git a/ash-rewrite/src/generated/nv/dedicated_allocation_image_aliasing.rs b/ash-rewrite/src/generated/nv/dedicated_allocation_image_aliasing.rs index 3b1b937be..e6fa0f2ac 100644 --- a/ash-rewrite/src/generated/nv/dedicated_allocation_image_aliasing.rs +++ b/ash-rewrite/src/generated/nv/dedicated_allocation_image_aliasing.rs @@ -9,6 +9,34 @@ pub struct PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV<'a> { pub dedicated_allocation_image_aliasing: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV<'a> {} +impl<'a> Default for PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + dedicated_allocation_image_aliasing: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV<'a> { + pub fn dedicated_allocation_image_aliasing( + mut self, + dedicated_allocation_image_aliasing: bool, + ) -> Self { + self.dedicated_allocation_image_aliasing = dedicated_allocation_image_aliasing + .into(); + self + } +} ///Provided by [`nv::dedicated_allocation_image_aliasing`](crate::nv::dedicated_allocation_image_aliasing) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV: Self = Self( diff --git a/ash-rewrite/src/generated/nv/descriptor_pool_overallocation.rs b/ash-rewrite/src/generated/nv/descriptor_pool_overallocation.rs index 251e95a70..9614dc8fd 100644 --- a/ash-rewrite/src/generated/nv/descriptor_pool_overallocation.rs +++ b/ash-rewrite/src/generated/nv/descriptor_pool_overallocation.rs @@ -9,6 +9,33 @@ pub struct PhysicalDeviceDescriptorPoolOverallocationFeaturesNV<'a> { pub descriptor_pool_overallocation: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceDescriptorPoolOverallocationFeaturesNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceDescriptorPoolOverallocationFeaturesNV<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceDescriptorPoolOverallocationFeaturesNV<'a> {} +impl<'a> Default for PhysicalDeviceDescriptorPoolOverallocationFeaturesNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + descriptor_pool_overallocation: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceDescriptorPoolOverallocationFeaturesNV<'a> { + pub fn descriptor_pool_overallocation( + mut self, + descriptor_pool_overallocation: bool, + ) -> Self { + self.descriptor_pool_overallocation = descriptor_pool_overallocation.into(); + self + } +} ///Provided by [`nv::descriptor_pool_overallocation`](crate::nv::descriptor_pool_overallocation) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV: Self = Self( diff --git a/ash-rewrite/src/generated/nv/device_diagnostic_checkpoints.rs b/ash-rewrite/src/generated/nv/device_diagnostic_checkpoints.rs index 756a7d2e8..e6d22f9b4 100644 --- a/ash-rewrite/src/generated/nv/device_diagnostic_checkpoints.rs +++ b/ash-rewrite/src/generated/nv/device_diagnostic_checkpoints.rs @@ -75,6 +75,31 @@ pub(crate) mod reexport { pub checkpoint_execution_stage_mask: crate::vk::PipelineStageFlags, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for QueueFamilyCheckpointPropertiesNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV; + } + unsafe impl<'a> crate::Extends> + for QueueFamilyCheckpointPropertiesNV<'a> {} + impl<'a> Default for QueueFamilyCheckpointPropertiesNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + checkpoint_execution_stage_mask: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> QueueFamilyCheckpointPropertiesNV<'a> { + pub fn checkpoint_execution_stage_mask( + mut self, + checkpoint_execution_stage_mask: crate::vk::PipelineStageFlags, + ) -> Self { + self.checkpoint_execution_stage_mask = checkpoint_execution_stage_mask; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct CheckpointDataNV<'a> { @@ -84,6 +109,33 @@ pub(crate) mod reexport { pub p_checkpoint_marker: *mut core::ffi::c_void, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for CheckpointDataNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::CHECKPOINT_DATA_NV; + } + impl<'a> Default for CheckpointDataNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + stage: Default::default(), + p_checkpoint_marker: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> CheckpointDataNV<'a> { + pub fn stage(mut self, stage: crate::vk::PipelineStageFlagBits) -> Self { + self.stage = stage; + self + } + pub fn p_checkpoint_marker( + mut self, + p_checkpoint_marker: &'a mut core::ffi::c_void, + ) -> Self { + self.p_checkpoint_marker = p_checkpoint_marker; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct QueueFamilyCheckpointProperties2NV<'a> { @@ -92,6 +144,31 @@ pub(crate) mod reexport { pub checkpoint_execution_stage_mask: crate::vk::PipelineStageFlags2, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for QueueFamilyCheckpointProperties2NV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV; + } + unsafe impl<'a> crate::Extends> + for QueueFamilyCheckpointProperties2NV<'a> {} + impl<'a> Default for QueueFamilyCheckpointProperties2NV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + checkpoint_execution_stage_mask: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> QueueFamilyCheckpointProperties2NV<'a> { + pub fn checkpoint_execution_stage_mask( + mut self, + checkpoint_execution_stage_mask: crate::vk::PipelineStageFlags2, + ) -> Self { + self.checkpoint_execution_stage_mask = checkpoint_execution_stage_mask; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct CheckpointData2NV<'a> { @@ -101,6 +178,33 @@ pub(crate) mod reexport { pub p_checkpoint_marker: *mut core::ffi::c_void, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for CheckpointData2NV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::CHECKPOINT_DATA_2_NV; + } + impl<'a> Default for CheckpointData2NV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + stage: Default::default(), + p_checkpoint_marker: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> CheckpointData2NV<'a> { + pub fn stage(mut self, stage: crate::vk::PipelineStageFlags2) -> Self { + self.stage = stage; + self + } + pub fn p_checkpoint_marker( + mut self, + p_checkpoint_marker: &'a mut core::ffi::c_void, + ) -> Self { + self.p_checkpoint_marker = p_checkpoint_marker; + self + } + } ///Provided by [`nv::device_diagnostic_checkpoints`](crate::nv::device_diagnostic_checkpoints) impl crate::vk::StructureType { pub const CHECKPOINT_DATA_NV: Self = Self(1000206000); diff --git a/ash-rewrite/src/generated/nv/device_diagnostics_config.rs b/ash-rewrite/src/generated/nv/device_diagnostics_config.rs index 2cd8fd619..e03261ab8 100644 --- a/ash-rewrite/src/generated/nv/device_diagnostics_config.rs +++ b/ash-rewrite/src/generated/nv/device_diagnostics_config.rs @@ -9,6 +9,30 @@ pub struct PhysicalDeviceDiagnosticsConfigFeaturesNV<'a> { pub diagnostics_config: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceDiagnosticsConfigFeaturesNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceDiagnosticsConfigFeaturesNV<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceDiagnosticsConfigFeaturesNV<'a> {} +impl<'a> Default for PhysicalDeviceDiagnosticsConfigFeaturesNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + diagnostics_config: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceDiagnosticsConfigFeaturesNV<'a> { + pub fn diagnostics_config(mut self, diagnostics_config: bool) -> Self { + self.diagnostics_config = diagnostics_config.into(); + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct DeviceDiagnosticsConfigCreateInfoNV<'a> { @@ -17,6 +41,27 @@ pub struct DeviceDiagnosticsConfigCreateInfoNV<'a> { pub flags: crate::vk::DeviceDiagnosticsConfigFlagsNV, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> for DeviceDiagnosticsConfigCreateInfoNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV; +} +unsafe impl<'a> crate::Extends> +for DeviceDiagnosticsConfigCreateInfoNV<'a> {} +impl<'a> Default for DeviceDiagnosticsConfigCreateInfoNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + flags: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> DeviceDiagnosticsConfigCreateInfoNV<'a> { + pub fn flags(mut self, flags: crate::vk::DeviceDiagnosticsConfigFlagsNV) -> Self { + self.flags = flags; + self + } +} ///Provided by [`nv::device_diagnostics_config`](crate::nv::device_diagnostics_config) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV: Self = Self(1000300000); @@ -102,7 +147,7 @@ impl core::ops::Not for DeviceDiagnosticsConfigFlagsNV { } } #[repr(transparent)] -#[derive(Clone, Copy)] +#[derive(Clone, Copy, Default)] pub struct DeviceDiagnosticsConfigFlagBitsNV(pub(crate) u32); ///Provided by [`nv::device_diagnostics_config`](crate::nv::device_diagnostics_config) impl DeviceDiagnosticsConfigFlagBitsNV { diff --git a/ash-rewrite/src/generated/nv/device_generated_commands.rs b/ash-rewrite/src/generated/nv/device_generated_commands.rs index 2e8eed503..32231a859 100644 --- a/ash-rewrite/src/generated/nv/device_generated_commands.rs +++ b/ash-rewrite/src/generated/nv/device_generated_commands.rs @@ -125,6 +125,33 @@ pub(crate) mod reexport { pub device_generated_commands: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceDeviceGeneratedCommandsFeaturesNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceDeviceGeneratedCommandsFeaturesNV<'a> {} + unsafe impl<'a> crate::Extends> + for PhysicalDeviceDeviceGeneratedCommandsFeaturesNV<'a> {} + impl<'a> Default for PhysicalDeviceDeviceGeneratedCommandsFeaturesNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + device_generated_commands: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceDeviceGeneratedCommandsFeaturesNV<'a> { + pub fn device_generated_commands( + mut self, + device_generated_commands: bool, + ) -> Self { + self.device_generated_commands = device_generated_commands.into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceDeviceGeneratedCommandsPropertiesNV<'a> { @@ -141,6 +168,95 @@ pub(crate) mod reexport { pub min_indirect_commands_buffer_offset_alignment: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceDeviceGeneratedCommandsPropertiesNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceDeviceGeneratedCommandsPropertiesNV<'a> {} + impl<'a> Default for PhysicalDeviceDeviceGeneratedCommandsPropertiesNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + max_graphics_shader_group_count: Default::default(), + max_indirect_sequence_count: Default::default(), + max_indirect_commands_token_count: Default::default(), + max_indirect_commands_stream_count: Default::default(), + max_indirect_commands_token_offset: Default::default(), + max_indirect_commands_stream_stride: Default::default(), + min_sequences_count_buffer_offset_alignment: Default::default(), + min_sequences_index_buffer_offset_alignment: Default::default(), + min_indirect_commands_buffer_offset_alignment: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceDeviceGeneratedCommandsPropertiesNV<'a> { + pub fn max_graphics_shader_group_count( + mut self, + max_graphics_shader_group_count: u32, + ) -> Self { + self.max_graphics_shader_group_count = max_graphics_shader_group_count; + self + } + pub fn max_indirect_sequence_count( + mut self, + max_indirect_sequence_count: u32, + ) -> Self { + self.max_indirect_sequence_count = max_indirect_sequence_count; + self + } + pub fn max_indirect_commands_token_count( + mut self, + max_indirect_commands_token_count: u32, + ) -> Self { + self.max_indirect_commands_token_count = max_indirect_commands_token_count; + self + } + pub fn max_indirect_commands_stream_count( + mut self, + max_indirect_commands_stream_count: u32, + ) -> Self { + self.max_indirect_commands_stream_count = max_indirect_commands_stream_count; + self + } + pub fn max_indirect_commands_token_offset( + mut self, + max_indirect_commands_token_offset: u32, + ) -> Self { + self.max_indirect_commands_token_offset = max_indirect_commands_token_offset; + self + } + pub fn max_indirect_commands_stream_stride( + mut self, + max_indirect_commands_stream_stride: u32, + ) -> Self { + self.max_indirect_commands_stream_stride = max_indirect_commands_stream_stride; + self + } + pub fn min_sequences_count_buffer_offset_alignment( + mut self, + min_sequences_count_buffer_offset_alignment: u32, + ) -> Self { + self.min_sequences_count_buffer_offset_alignment = min_sequences_count_buffer_offset_alignment; + self + } + pub fn min_sequences_index_buffer_offset_alignment( + mut self, + min_sequences_index_buffer_offset_alignment: u32, + ) -> Self { + self.min_sequences_index_buffer_offset_alignment = min_sequences_index_buffer_offset_alignment; + self + } + pub fn min_indirect_commands_buffer_offset_alignment( + mut self, + min_indirect_commands_buffer_offset_alignment: u32, + ) -> Self { + self.min_indirect_commands_buffer_offset_alignment = min_indirect_commands_buffer_offset_alignment; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct GraphicsShaderGroupCreateInfoNV<'a> { @@ -156,6 +272,50 @@ pub(crate) mod reexport { >, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for GraphicsShaderGroupCreateInfoNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::GRAPHICS_SHADER_GROUP_CREATE_INFO_NV; + } + impl<'a> Default for GraphicsShaderGroupCreateInfoNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + stage_count: Default::default(), + p_stages: Default::default(), + p_vertex_input_state: Default::default(), + p_tessellation_state: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> GraphicsShaderGroupCreateInfoNV<'a> { + pub fn stage_count(mut self, stage_count: u32) -> Self { + self.stage_count = stage_count; + self + } + pub fn p_stages( + mut self, + p_stages: &'a [crate::vk::PipelineShaderStageCreateInfo<'a>], + ) -> Self { + self.stage_count = p_stages.len() as _; + self.p_stages = p_stages.as_ptr(); + self + } + pub fn p_vertex_input_state( + mut self, + p_vertex_input_state: &'a crate::vk::PipelineVertexInputStateCreateInfo<'a>, + ) -> Self { + self.p_vertex_input_state = p_vertex_input_state; + self + } + pub fn p_tessellation_state( + mut self, + p_tessellation_state: &'a crate::vk::PipelineTessellationStateCreateInfo<'a>, + ) -> Self { + self.p_tessellation_state = p_tessellation_state; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct GraphicsPipelineShaderGroupsCreateInfoNV<'a> { @@ -167,36 +327,134 @@ pub(crate) mod reexport { pub p_pipelines: *const crate::vk::Pipeline, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for GraphicsPipelineShaderGroupsCreateInfoNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV; + } + unsafe impl<'a> crate::Extends> + for GraphicsPipelineShaderGroupsCreateInfoNV<'a> {} + impl<'a> Default for GraphicsPipelineShaderGroupsCreateInfoNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + group_count: Default::default(), + p_groups: Default::default(), + pipeline_count: Default::default(), + p_pipelines: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> GraphicsPipelineShaderGroupsCreateInfoNV<'a> { + pub fn group_count(mut self, group_count: u32) -> Self { + self.group_count = group_count; + self + } + pub fn p_groups( + mut self, + p_groups: &'a [crate::vk::GraphicsShaderGroupCreateInfoNV<'a>], + ) -> Self { + self.group_count = p_groups.len() as _; + self.p_groups = p_groups.as_ptr(); + self + } + pub fn pipeline_count(mut self, pipeline_count: u32) -> Self { + self.pipeline_count = pipeline_count; + self + } + pub fn p_pipelines(mut self, p_pipelines: &'a [crate::vk::Pipeline]) -> Self { + self.pipeline_count = p_pipelines.len() as _; + self.p_pipelines = p_pipelines.as_ptr(); + self + } + } #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct BindShaderGroupIndirectCommandNV { pub group_index: u32, } + impl BindShaderGroupIndirectCommandNV { + pub fn group_index(mut self, group_index: u32) -> Self { + self.group_index = group_index; + self + } + } #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct BindIndexBufferIndirectCommandNV { pub buffer_address: crate::vk::DeviceAddress, pub size: u32, pub index_type: crate::vk::IndexType, } + impl BindIndexBufferIndirectCommandNV { + pub fn buffer_address( + mut self, + buffer_address: crate::vk::DeviceAddress, + ) -> Self { + self.buffer_address = buffer_address; + self + } + pub fn size(mut self, size: u32) -> Self { + self.size = size; + self + } + pub fn index_type(mut self, index_type: crate::vk::IndexType) -> Self { + self.index_type = index_type; + self + } + } #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct BindVertexBufferIndirectCommandNV { pub buffer_address: crate::vk::DeviceAddress, pub size: u32, pub stride: u32, } + impl BindVertexBufferIndirectCommandNV { + pub fn buffer_address( + mut self, + buffer_address: crate::vk::DeviceAddress, + ) -> Self { + self.buffer_address = buffer_address; + self + } + pub fn size(mut self, size: u32) -> Self { + self.size = size; + self + } + pub fn stride(mut self, stride: u32) -> Self { + self.stride = stride; + self + } + } #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct SetStateFlagsIndirectCommandNV { pub data: u32, } + impl SetStateFlagsIndirectCommandNV { + pub fn data(mut self, data: u32) -> Self { + self.data = data; + self + } + } #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct IndirectCommandsStreamNV { pub buffer: crate::vk::Buffer, pub offset: crate::vk::DeviceSize, } + impl IndirectCommandsStreamNV { + pub fn buffer(mut self, buffer: crate::vk::Buffer) -> Self { + self.buffer = buffer; + self + } + pub fn offset(mut self, offset: crate::vk::DeviceSize) -> Self { + self.offset = offset; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct IndirectCommandsLayoutTokenNV<'a> { @@ -217,6 +475,102 @@ pub(crate) mod reexport { pub p_index_type_values: *const u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for IndirectCommandsLayoutTokenNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::INDIRECT_COMMANDS_LAYOUT_TOKEN_NV; + } + impl<'a> Default for IndirectCommandsLayoutTokenNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + token_type: Default::default(), + stream: Default::default(), + offset: Default::default(), + vertex_binding_unit: Default::default(), + vertex_dynamic_stride: Default::default(), + pushconstant_pipeline_layout: Default::default(), + pushconstant_shader_stage_flags: Default::default(), + pushconstant_offset: Default::default(), + pushconstant_size: Default::default(), + indirect_state_flags: Default::default(), + index_type_count: Default::default(), + p_index_types: Default::default(), + p_index_type_values: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> IndirectCommandsLayoutTokenNV<'a> { + pub fn token_type( + mut self, + token_type: crate::vk::IndirectCommandsTokenTypeNV, + ) -> Self { + self.token_type = token_type; + self + } + pub fn stream(mut self, stream: u32) -> Self { + self.stream = stream; + self + } + pub fn offset(mut self, offset: u32) -> Self { + self.offset = offset; + self + } + pub fn vertex_binding_unit(mut self, vertex_binding_unit: u32) -> Self { + self.vertex_binding_unit = vertex_binding_unit; + self + } + pub fn vertex_dynamic_stride(mut self, vertex_dynamic_stride: bool) -> Self { + self.vertex_dynamic_stride = vertex_dynamic_stride.into(); + self + } + pub fn pushconstant_pipeline_layout( + mut self, + pushconstant_pipeline_layout: crate::vk::PipelineLayout, + ) -> Self { + self.pushconstant_pipeline_layout = pushconstant_pipeline_layout; + self + } + pub fn pushconstant_shader_stage_flags( + mut self, + pushconstant_shader_stage_flags: crate::vk::ShaderStageFlags, + ) -> Self { + self.pushconstant_shader_stage_flags = pushconstant_shader_stage_flags; + self + } + pub fn pushconstant_offset(mut self, pushconstant_offset: u32) -> Self { + self.pushconstant_offset = pushconstant_offset; + self + } + pub fn pushconstant_size(mut self, pushconstant_size: u32) -> Self { + self.pushconstant_size = pushconstant_size; + self + } + pub fn indirect_state_flags( + mut self, + indirect_state_flags: crate::vk::IndirectStateFlagsNV, + ) -> Self { + self.indirect_state_flags = indirect_state_flags; + self + } + pub fn index_type_count(mut self, index_type_count: u32) -> Self { + self.index_type_count = index_type_count; + self + } + pub fn p_index_types( + mut self, + p_index_types: &'a [crate::vk::IndexType], + ) -> Self { + self.index_type_count = p_index_types.len() as _; + self.p_index_types = p_index_types.as_ptr(); + self + } + pub fn p_index_type_values(mut self, p_index_type_values: &'a [u32]) -> Self { + self.index_type_count = p_index_type_values.len() as _; + self.p_index_type_values = p_index_type_values.as_ptr(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct IndirectCommandsLayoutCreateInfoNV<'a> { @@ -230,6 +584,62 @@ pub(crate) mod reexport { pub p_stream_strides: *const u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for IndirectCommandsLayoutCreateInfoNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NV; + } + impl<'a> Default for IndirectCommandsLayoutCreateInfoNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + flags: Default::default(), + pipeline_bind_point: Default::default(), + token_count: Default::default(), + p_tokens: Default::default(), + stream_count: Default::default(), + p_stream_strides: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> IndirectCommandsLayoutCreateInfoNV<'a> { + pub fn flags( + mut self, + flags: crate::vk::IndirectCommandsLayoutUsageFlagsNV, + ) -> Self { + self.flags = flags; + self + } + pub fn pipeline_bind_point( + mut self, + pipeline_bind_point: crate::vk::PipelineBindPoint, + ) -> Self { + self.pipeline_bind_point = pipeline_bind_point; + self + } + pub fn token_count(mut self, token_count: u32) -> Self { + self.token_count = token_count; + self + } + pub fn p_tokens( + mut self, + p_tokens: &'a [crate::vk::IndirectCommandsLayoutTokenNV<'a>], + ) -> Self { + self.token_count = p_tokens.len() as _; + self.p_tokens = p_tokens.as_ptr(); + self + } + pub fn stream_count(mut self, stream_count: u32) -> Self { + self.stream_count = stream_count; + self + } + pub fn p_stream_strides(mut self, p_stream_strides: &'a [u32]) -> Self { + self.stream_count = p_stream_strides.len() as _; + self.p_stream_strides = p_stream_strides.as_ptr(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct GeneratedCommandsInfoNV<'a> { @@ -250,6 +660,116 @@ pub(crate) mod reexport { pub sequences_index_offset: crate::vk::DeviceSize, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for GeneratedCommandsInfoNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::GENERATED_COMMANDS_INFO_NV; + } + impl<'a> Default for GeneratedCommandsInfoNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + pipeline_bind_point: Default::default(), + pipeline: Default::default(), + indirect_commands_layout: Default::default(), + stream_count: Default::default(), + p_streams: Default::default(), + sequences_count: Default::default(), + preprocess_buffer: Default::default(), + preprocess_offset: Default::default(), + preprocess_size: Default::default(), + sequences_count_buffer: Default::default(), + sequences_count_offset: Default::default(), + sequences_index_buffer: Default::default(), + sequences_index_offset: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> GeneratedCommandsInfoNV<'a> { + pub fn pipeline_bind_point( + mut self, + pipeline_bind_point: crate::vk::PipelineBindPoint, + ) -> Self { + self.pipeline_bind_point = pipeline_bind_point; + self + } + pub fn pipeline(mut self, pipeline: crate::vk::Pipeline) -> Self { + self.pipeline = pipeline; + self + } + pub fn indirect_commands_layout( + mut self, + indirect_commands_layout: crate::vk::IndirectCommandsLayoutNV, + ) -> Self { + self.indirect_commands_layout = indirect_commands_layout; + self + } + pub fn stream_count(mut self, stream_count: u32) -> Self { + self.stream_count = stream_count; + self + } + pub fn p_streams( + mut self, + p_streams: &'a [crate::vk::IndirectCommandsStreamNV], + ) -> Self { + self.stream_count = p_streams.len() as _; + self.p_streams = p_streams.as_ptr(); + self + } + pub fn sequences_count(mut self, sequences_count: u32) -> Self { + self.sequences_count = sequences_count; + self + } + pub fn preprocess_buffer( + mut self, + preprocess_buffer: crate::vk::Buffer, + ) -> Self { + self.preprocess_buffer = preprocess_buffer; + self + } + pub fn preprocess_offset( + mut self, + preprocess_offset: crate::vk::DeviceSize, + ) -> Self { + self.preprocess_offset = preprocess_offset; + self + } + pub fn preprocess_size( + mut self, + preprocess_size: crate::vk::DeviceSize, + ) -> Self { + self.preprocess_size = preprocess_size; + self + } + pub fn sequences_count_buffer( + mut self, + sequences_count_buffer: crate::vk::Buffer, + ) -> Self { + self.sequences_count_buffer = sequences_count_buffer; + self + } + pub fn sequences_count_offset( + mut self, + sequences_count_offset: crate::vk::DeviceSize, + ) -> Self { + self.sequences_count_offset = sequences_count_offset; + self + } + pub fn sequences_index_buffer( + mut self, + sequences_index_buffer: crate::vk::Buffer, + ) -> Self { + self.sequences_index_buffer = sequences_index_buffer; + self + } + pub fn sequences_index_offset( + mut self, + sequences_index_offset: crate::vk::DeviceSize, + ) -> Self { + self.sequences_index_offset = sequences_index_offset; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct GeneratedCommandsMemoryRequirementsInfoNV<'a> { @@ -261,6 +781,47 @@ pub(crate) mod reexport { pub max_sequences_count: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for GeneratedCommandsMemoryRequirementsInfoNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_NV; + } + impl<'a> Default for GeneratedCommandsMemoryRequirementsInfoNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + pipeline_bind_point: Default::default(), + pipeline: Default::default(), + indirect_commands_layout: Default::default(), + max_sequences_count: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> GeneratedCommandsMemoryRequirementsInfoNV<'a> { + pub fn pipeline_bind_point( + mut self, + pipeline_bind_point: crate::vk::PipelineBindPoint, + ) -> Self { + self.pipeline_bind_point = pipeline_bind_point; + self + } + pub fn pipeline(mut self, pipeline: crate::vk::Pipeline) -> Self { + self.pipeline = pipeline; + self + } + pub fn indirect_commands_layout( + mut self, + indirect_commands_layout: crate::vk::IndirectCommandsLayoutNV, + ) -> Self { + self.indirect_commands_layout = indirect_commands_layout; + self + } + pub fn max_sequences_count(mut self, max_sequences_count: u32) -> Self { + self.max_sequences_count = max_sequences_count; + self + } + } ///Provided by [`nv::device_generated_commands`](crate::nv::device_generated_commands) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV: Self = Self( @@ -397,7 +958,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct IndirectCommandsLayoutUsageFlagBitsNV(pub(crate) u32); ///Provided by [`nv::device_generated_commands`](crate::nv::device_generated_commands) impl IndirectCommandsLayoutUsageFlagBitsNV { @@ -476,7 +1037,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct IndirectStateFlagBitsNV(pub(crate) u32); ///Provided by [`nv::device_generated_commands`](crate::nv::device_generated_commands) impl IndirectStateFlagBitsNV { diff --git a/ash-rewrite/src/generated/nv/device_generated_commands_compute.rs b/ash-rewrite/src/generated/nv/device_generated_commands_compute.rs index 787d2b3da..3acc98c93 100644 --- a/ash-rewrite/src/generated/nv/device_generated_commands_compute.rs +++ b/ash-rewrite/src/generated/nv/device_generated_commands_compute.rs @@ -77,6 +77,44 @@ pub(crate) mod reexport { pub pipeline_device_address_capture_replay: crate::vk::DeviceAddress, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for ComputePipelineIndirectBufferInfoNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::COMPUTE_PIPELINE_INDIRECT_BUFFER_INFO_NV; + } + unsafe impl<'a> crate::Extends> + for ComputePipelineIndirectBufferInfoNV<'a> {} + impl<'a> Default for ComputePipelineIndirectBufferInfoNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + device_address: Default::default(), + size: Default::default(), + pipeline_device_address_capture_replay: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> ComputePipelineIndirectBufferInfoNV<'a> { + pub fn device_address( + mut self, + device_address: crate::vk::DeviceAddress, + ) -> Self { + self.device_address = device_address; + self + } + pub fn size(mut self, size: crate::vk::DeviceSize) -> Self { + self.size = size; + self + } + pub fn pipeline_device_address_capture_replay( + mut self, + pipeline_device_address_capture_replay: crate::vk::DeviceAddress, + ) -> Self { + self.pipeline_device_address_capture_replay = pipeline_device_address_capture_replay; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV<'a> { @@ -87,6 +125,51 @@ pub(crate) mod reexport { pub device_generated_compute_capture_replay: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES_NV; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV<'a> {} + unsafe impl<'a> crate::Extends> + for PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV<'a> {} + impl<'a> Default for PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + device_generated_compute: Default::default(), + device_generated_compute_pipelines: Default::default(), + device_generated_compute_capture_replay: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV<'a> { + pub fn device_generated_compute( + mut self, + device_generated_compute: bool, + ) -> Self { + self.device_generated_compute = device_generated_compute.into(); + self + } + pub fn device_generated_compute_pipelines( + mut self, + device_generated_compute_pipelines: bool, + ) -> Self { + self.device_generated_compute_pipelines = device_generated_compute_pipelines + .into(); + self + } + pub fn device_generated_compute_capture_replay( + mut self, + device_generated_compute_capture_replay: bool, + ) -> Self { + self.device_generated_compute_capture_replay = device_generated_compute_capture_replay + .into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PipelineIndirectDeviceAddressInfoNV<'a> { @@ -96,11 +179,48 @@ pub(crate) mod reexport { pub pipeline: crate::vk::Pipeline, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PipelineIndirectDeviceAddressInfoNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PIPELINE_INDIRECT_DEVICE_ADDRESS_INFO_NV; + } + impl<'a> Default for PipelineIndirectDeviceAddressInfoNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + pipeline_bind_point: Default::default(), + pipeline: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PipelineIndirectDeviceAddressInfoNV<'a> { + pub fn pipeline_bind_point( + mut self, + pipeline_bind_point: crate::vk::PipelineBindPoint, + ) -> Self { + self.pipeline_bind_point = pipeline_bind_point; + self + } + pub fn pipeline(mut self, pipeline: crate::vk::Pipeline) -> Self { + self.pipeline = pipeline; + self + } + } #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct BindPipelineIndirectCommandNV { pub pipeline_address: crate::vk::DeviceAddress, } + impl BindPipelineIndirectCommandNV { + pub fn pipeline_address( + mut self, + pipeline_address: crate::vk::DeviceAddress, + ) -> Self { + self.pipeline_address = pipeline_address; + self + } + } ///Provided by [`nv::device_generated_commands_compute`](crate::nv::device_generated_commands_compute) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES_NV: Self = Self( diff --git a/ash-rewrite/src/generated/nv/displacement_micromap.rs b/ash-rewrite/src/generated/nv/displacement_micromap.rs index f9252644e..d947dfc50 100644 --- a/ash-rewrite/src/generated/nv/displacement_micromap.rs +++ b/ash-rewrite/src/generated/nv/displacement_micromap.rs @@ -9,6 +9,30 @@ pub struct PhysicalDeviceDisplacementMicromapFeaturesNV<'a> { pub displacement_micromap: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceDisplacementMicromapFeaturesNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_FEATURES_NV; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceDisplacementMicromapFeaturesNV<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceDisplacementMicromapFeaturesNV<'a> {} +impl<'a> Default for PhysicalDeviceDisplacementMicromapFeaturesNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + displacement_micromap: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceDisplacementMicromapFeaturesNV<'a> { + pub fn displacement_micromap(mut self, displacement_micromap: bool) -> Self { + self.displacement_micromap = displacement_micromap.into(); + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceDisplacementMicromapPropertiesNV<'a> { @@ -17,6 +41,31 @@ pub struct PhysicalDeviceDisplacementMicromapPropertiesNV<'a> { pub max_displacement_micromap_subdivision_level: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceDisplacementMicromapPropertiesNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_PROPERTIES_NV; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceDisplacementMicromapPropertiesNV<'a> {} +impl<'a> Default for PhysicalDeviceDisplacementMicromapPropertiesNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + max_displacement_micromap_subdivision_level: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceDisplacementMicromapPropertiesNV<'a> { + pub fn max_displacement_micromap_subdivision_level( + mut self, + max_displacement_micromap_subdivision_level: u32, + ) -> Self { + self.max_displacement_micromap_subdivision_level = max_displacement_micromap_subdivision_level; + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct AccelerationStructureTrianglesDisplacementMicromapNV<'a> { @@ -40,6 +89,140 @@ pub struct AccelerationStructureTrianglesDisplacementMicromapNV<'a> { pub micromap: crate::vk::MicromapEXT, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for AccelerationStructureTrianglesDisplacementMicromapNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::ACCELERATION_STRUCTURE_TRIANGLES_DISPLACEMENT_MICROMAP_NV; +} +unsafe impl< + 'a, +> crate::Extends> +for AccelerationStructureTrianglesDisplacementMicromapNV<'a> {} +impl<'a> Default for AccelerationStructureTrianglesDisplacementMicromapNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + displacement_bias_and_scale_format: Default::default(), + displacement_vector_format: Default::default(), + displacement_bias_and_scale_buffer: Default::default(), + displacement_bias_and_scale_stride: Default::default(), + displacement_vector_buffer: Default::default(), + displacement_vector_stride: Default::default(), + displaced_micromap_primitive_flags: Default::default(), + displaced_micromap_primitive_flags_stride: Default::default(), + index_type: Default::default(), + index_buffer: Default::default(), + index_stride: Default::default(), + base_triangle: Default::default(), + usage_counts_count: Default::default(), + p_usage_counts: Default::default(), + pp_usage_counts: Default::default(), + micromap: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> AccelerationStructureTrianglesDisplacementMicromapNV<'a> { + pub fn displacement_bias_and_scale_format( + mut self, + displacement_bias_and_scale_format: crate::vk::Format, + ) -> Self { + self.displacement_bias_and_scale_format = displacement_bias_and_scale_format; + self + } + pub fn displacement_vector_format( + mut self, + displacement_vector_format: crate::vk::Format, + ) -> Self { + self.displacement_vector_format = displacement_vector_format; + self + } + pub fn displacement_bias_and_scale_buffer( + mut self, + displacement_bias_and_scale_buffer: crate::vk::DeviceOrHostAddressConstKHR, + ) -> Self { + self.displacement_bias_and_scale_buffer = displacement_bias_and_scale_buffer; + self + } + pub fn displacement_bias_and_scale_stride( + mut self, + displacement_bias_and_scale_stride: crate::vk::DeviceSize, + ) -> Self { + self.displacement_bias_and_scale_stride = displacement_bias_and_scale_stride; + self + } + pub fn displacement_vector_buffer( + mut self, + displacement_vector_buffer: crate::vk::DeviceOrHostAddressConstKHR, + ) -> Self { + self.displacement_vector_buffer = displacement_vector_buffer; + self + } + pub fn displacement_vector_stride( + mut self, + displacement_vector_stride: crate::vk::DeviceSize, + ) -> Self { + self.displacement_vector_stride = displacement_vector_stride; + self + } + pub fn displaced_micromap_primitive_flags( + mut self, + displaced_micromap_primitive_flags: crate::vk::DeviceOrHostAddressConstKHR, + ) -> Self { + self.displaced_micromap_primitive_flags = displaced_micromap_primitive_flags; + self + } + pub fn displaced_micromap_primitive_flags_stride( + mut self, + displaced_micromap_primitive_flags_stride: crate::vk::DeviceSize, + ) -> Self { + self.displaced_micromap_primitive_flags_stride = displaced_micromap_primitive_flags_stride; + self + } + pub fn index_type(mut self, index_type: crate::vk::IndexType) -> Self { + self.index_type = index_type; + self + } + pub fn index_buffer( + mut self, + index_buffer: crate::vk::DeviceOrHostAddressConstKHR, + ) -> Self { + self.index_buffer = index_buffer; + self + } + pub fn index_stride(mut self, index_stride: crate::vk::DeviceSize) -> Self { + self.index_stride = index_stride; + self + } + pub fn base_triangle(mut self, base_triangle: u32) -> Self { + self.base_triangle = base_triangle; + self + } + pub fn usage_counts_count(mut self, usage_counts_count: u32) -> Self { + self.usage_counts_count = usage_counts_count; + self + } + pub fn p_usage_counts( + mut self, + p_usage_counts: &'a [crate::vk::MicromapUsageEXT], + ) -> Self { + self.usage_counts_count = p_usage_counts.len() as _; + self.p_usage_counts = p_usage_counts.as_ptr(); + self + } + pub fn pp_usage_counts( + mut self, + pp_usage_counts: &'a [&'a crate::vk::MicromapUsageEXT], + ) -> Self { + self.usage_counts_count = pp_usage_counts.len() as _; + self.pp_usage_counts = pp_usage_counts.as_ptr().cast(); + self + } + pub fn micromap(mut self, micromap: crate::vk::MicromapEXT) -> Self { + self.micromap = micromap; + self + } +} ///Provided by [`nv::displacement_micromap`](crate::nv::displacement_micromap) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_FEATURES_NV: Self = Self(1000397000); diff --git a/ash-rewrite/src/generated/nv/display_stereo.rs b/ash-rewrite/src/generated/nv/display_stereo.rs index bc823404f..5353d245f 100644 --- a/ash-rewrite/src/generated/nv/display_stereo.rs +++ b/ash-rewrite/src/generated/nv/display_stereo.rs @@ -9,6 +9,30 @@ pub struct DisplaySurfaceStereoCreateInfoNV<'a> { pub stereo_type: crate::vk::DisplaySurfaceStereoTypeNV, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> for DisplaySurfaceStereoCreateInfoNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::DISPLAY_SURFACE_STEREO_CREATE_INFO_NV; +} +unsafe impl<'a> crate::Extends> +for DisplaySurfaceStereoCreateInfoNV<'a> {} +impl<'a> Default for DisplaySurfaceStereoCreateInfoNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + stereo_type: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> DisplaySurfaceStereoCreateInfoNV<'a> { + pub fn stereo_type( + mut self, + stereo_type: crate::vk::DisplaySurfaceStereoTypeNV, + ) -> Self { + self.stereo_type = stereo_type; + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct DisplayModeStereoPropertiesNV<'a> { @@ -17,6 +41,27 @@ pub struct DisplayModeStereoPropertiesNV<'a> { pub hdmi3_d_supported: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> for DisplayModeStereoPropertiesNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::DISPLAY_MODE_STEREO_PROPERTIES_NV; +} +unsafe impl<'a> crate::Extends> +for DisplayModeStereoPropertiesNV<'a> {} +impl<'a> Default for DisplayModeStereoPropertiesNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + hdmi3_d_supported: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> DisplayModeStereoPropertiesNV<'a> { + pub fn hdmi3_d_supported(mut self, hdmi3_d_supported: bool) -> Self { + self.hdmi3_d_supported = hdmi3_d_supported.into(); + self + } +} ///Provided by [`nv::display_stereo`](crate::nv::display_stereo) impl crate::vk::StructureType { pub const DISPLAY_SURFACE_STEREO_CREATE_INFO_NV: Self = Self(1000551000); diff --git a/ash-rewrite/src/generated/nv/extended_sparse_address_space.rs b/ash-rewrite/src/generated/nv/extended_sparse_address_space.rs index fc60a169a..44b97f5fd 100644 --- a/ash-rewrite/src/generated/nv/extended_sparse_address_space.rs +++ b/ash-rewrite/src/generated/nv/extended_sparse_address_space.rs @@ -9,6 +9,33 @@ pub struct PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV<'a> { pub extended_sparse_address_space: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES_NV; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV<'a> {} +impl<'a> Default for PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + extended_sparse_address_space: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV<'a> { + pub fn extended_sparse_address_space( + mut self, + extended_sparse_address_space: bool, + ) -> Self { + self.extended_sparse_address_space = extended_sparse_address_space.into(); + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceExtendedSparseAddressSpacePropertiesNV<'a> { @@ -19,6 +46,47 @@ pub struct PhysicalDeviceExtendedSparseAddressSpacePropertiesNV<'a> { pub extended_sparse_buffer_usage_flags: crate::vk::BufferUsageFlags, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceExtendedSparseAddressSpacePropertiesNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_PROPERTIES_NV; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceExtendedSparseAddressSpacePropertiesNV<'a> {} +impl<'a> Default for PhysicalDeviceExtendedSparseAddressSpacePropertiesNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + extended_sparse_address_space_size: Default::default(), + extended_sparse_image_usage_flags: Default::default(), + extended_sparse_buffer_usage_flags: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceExtendedSparseAddressSpacePropertiesNV<'a> { + pub fn extended_sparse_address_space_size( + mut self, + extended_sparse_address_space_size: crate::vk::DeviceSize, + ) -> Self { + self.extended_sparse_address_space_size = extended_sparse_address_space_size; + self + } + pub fn extended_sparse_image_usage_flags( + mut self, + extended_sparse_image_usage_flags: crate::vk::ImageUsageFlags, + ) -> Self { + self.extended_sparse_image_usage_flags = extended_sparse_image_usage_flags; + self + } + pub fn extended_sparse_buffer_usage_flags( + mut self, + extended_sparse_buffer_usage_flags: crate::vk::BufferUsageFlags, + ) -> Self { + self.extended_sparse_buffer_usage_flags = extended_sparse_buffer_usage_flags; + self + } +} ///Provided by [`nv::extended_sparse_address_space`](crate::nv::extended_sparse_address_space) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES_NV: Self = Self( diff --git a/ash-rewrite/src/generated/nv/external_compute_queue.rs b/ash-rewrite/src/generated/nv/external_compute_queue.rs index faa897d49..e7f836f7e 100644 --- a/ash-rewrite/src/generated/nv/external_compute_queue.rs +++ b/ash-rewrite/src/generated/nv/external_compute_queue.rs @@ -95,6 +95,31 @@ pub(crate) mod reexport { pub reserved_external_queues: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for ExternalComputeQueueDeviceCreateInfoNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::EXTERNAL_COMPUTE_QUEUE_DEVICE_CREATE_INFO_NV; + } + unsafe impl<'a> crate::Extends> + for ExternalComputeQueueDeviceCreateInfoNV<'a> {} + impl<'a> Default for ExternalComputeQueueDeviceCreateInfoNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + reserved_external_queues: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> ExternalComputeQueueDeviceCreateInfoNV<'a> { + pub fn reserved_external_queues( + mut self, + reserved_external_queues: u32, + ) -> Self { + self.reserved_external_queues = reserved_external_queues; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct ExternalComputeQueueCreateInfoNV<'a> { @@ -103,6 +128,25 @@ pub(crate) mod reexport { pub preferred_queue: crate::vk::Queue, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for ExternalComputeQueueCreateInfoNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::EXTERNAL_COMPUTE_QUEUE_CREATE_INFO_NV; + } + impl<'a> Default for ExternalComputeQueueCreateInfoNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + preferred_queue: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> ExternalComputeQueueCreateInfoNV<'a> { + pub fn preferred_queue(mut self, preferred_queue: crate::vk::Queue) -> Self { + self.preferred_queue = preferred_queue; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct ExternalComputeQueueDataParamsNV<'a> { @@ -111,6 +155,25 @@ pub(crate) mod reexport { pub device_index: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for ExternalComputeQueueDataParamsNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::EXTERNAL_COMPUTE_QUEUE_DATA_PARAMS_NV; + } + impl<'a> Default for ExternalComputeQueueDataParamsNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + device_index: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> ExternalComputeQueueDataParamsNV<'a> { + pub fn device_index(mut self, device_index: u32) -> Self { + self.device_index = device_index; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceExternalComputeQueuePropertiesNV<'a> { @@ -120,6 +183,33 @@ pub(crate) mod reexport { pub max_external_queues: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceExternalComputeQueuePropertiesNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_EXTERNAL_COMPUTE_QUEUE_PROPERTIES_NV; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceExternalComputeQueuePropertiesNV<'a> {} + impl<'a> Default for PhysicalDeviceExternalComputeQueuePropertiesNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + external_data_size: Default::default(), + max_external_queues: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceExternalComputeQueuePropertiesNV<'a> { + pub fn external_data_size(mut self, external_data_size: u32) -> Self { + self.external_data_size = external_data_size; + self + } + pub fn max_external_queues(mut self, max_external_queues: u32) -> Self { + self.max_external_queues = max_external_queues; + self + } + } ///Provided by [`nv::external_compute_queue`](crate::nv::external_compute_queue) impl crate::vk::StructureType { pub const EXTERNAL_COMPUTE_QUEUE_DEVICE_CREATE_INFO_NV: Self = Self(1000556000); diff --git a/ash-rewrite/src/generated/nv/external_memory.rs b/ash-rewrite/src/generated/nv/external_memory.rs index 2d2ff4939..cb7df8dc3 100644 --- a/ash-rewrite/src/generated/nv/external_memory.rs +++ b/ash-rewrite/src/generated/nv/external_memory.rs @@ -9,6 +9,30 @@ pub struct ExternalMemoryImageCreateInfoNV<'a> { pub handle_types: crate::vk::ExternalMemoryHandleTypeFlagsNV, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> for ExternalMemoryImageCreateInfoNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV; +} +unsafe impl<'a> crate::Extends> +for ExternalMemoryImageCreateInfoNV<'a> {} +impl<'a> Default for ExternalMemoryImageCreateInfoNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + handle_types: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> ExternalMemoryImageCreateInfoNV<'a> { + pub fn handle_types( + mut self, + handle_types: crate::vk::ExternalMemoryHandleTypeFlagsNV, + ) -> Self { + self.handle_types = handle_types; + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct ExportMemoryAllocateInfoNV<'a> { @@ -17,6 +41,30 @@ pub struct ExportMemoryAllocateInfoNV<'a> { pub handle_types: crate::vk::ExternalMemoryHandleTypeFlagsNV, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> for ExportMemoryAllocateInfoNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::EXPORT_MEMORY_ALLOCATE_INFO_NV; +} +unsafe impl<'a> crate::Extends> +for ExportMemoryAllocateInfoNV<'a> {} +impl<'a> Default for ExportMemoryAllocateInfoNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + handle_types: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> ExportMemoryAllocateInfoNV<'a> { + pub fn handle_types( + mut self, + handle_types: crate::vk::ExternalMemoryHandleTypeFlagsNV, + ) -> Self { + self.handle_types = handle_types; + self + } +} ///Provided by [`nv::external_memory`](crate::nv::external_memory) impl crate::vk::StructureType { pub const EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV: Self = Self(1000056000); diff --git a/ash-rewrite/src/generated/nv/external_memory_capabilities.rs b/ash-rewrite/src/generated/nv/external_memory_capabilities.rs index 5043e4226..4348b8540 100644 --- a/ash-rewrite/src/generated/nv/external_memory_capabilities.rs +++ b/ash-rewrite/src/generated/nv/external_memory_capabilities.rs @@ -44,13 +44,43 @@ impl InstanceFn { } pub(crate) mod reexport { #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct ExternalImageFormatPropertiesNV { pub image_format_properties: crate::vk::ImageFormatProperties, pub external_memory_features: crate::vk::ExternalMemoryFeatureFlagsNV, pub export_from_imported_handle_types: crate::vk::ExternalMemoryHandleTypeFlagsNV, pub compatible_handle_types: crate::vk::ExternalMemoryHandleTypeFlagsNV, } + impl ExternalImageFormatPropertiesNV { + pub fn image_format_properties( + mut self, + image_format_properties: crate::vk::ImageFormatProperties, + ) -> Self { + self.image_format_properties = image_format_properties; + self + } + pub fn external_memory_features( + mut self, + external_memory_features: crate::vk::ExternalMemoryFeatureFlagsNV, + ) -> Self { + self.external_memory_features = external_memory_features; + self + } + pub fn export_from_imported_handle_types( + mut self, + export_from_imported_handle_types: crate::vk::ExternalMemoryHandleTypeFlagsNV, + ) -> Self { + self.export_from_imported_handle_types = export_from_imported_handle_types; + self + } + pub fn compatible_handle_types( + mut self, + compatible_handle_types: crate::vk::ExternalMemoryHandleTypeFlagsNV, + ) -> Self { + self.compatible_handle_types = compatible_handle_types; + self + } + } #[repr(transparent)] #[derive(Clone, Copy)] pub struct ExternalMemoryHandleTypeFlagsNV(u32); @@ -131,7 +161,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct ExternalMemoryHandleTypeFlagBitsNV(pub(crate) u32); ///Provided by [`nv::external_memory_capabilities`](crate::nv::external_memory_capabilities) impl ExternalMemoryHandleTypeFlagBitsNV { @@ -217,7 +247,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct ExternalMemoryFeatureFlagBitsNV(pub(crate) u32); ///Provided by [`nv::external_memory_capabilities`](crate::nv::external_memory_capabilities) impl ExternalMemoryFeatureFlagBitsNV { diff --git a/ash-rewrite/src/generated/nv/external_memory_rdma.rs b/ash-rewrite/src/generated/nv/external_memory_rdma.rs index 0051c3e2f..8600fa4d0 100644 --- a/ash-rewrite/src/generated/nv/external_memory_rdma.rs +++ b/ash-rewrite/src/generated/nv/external_memory_rdma.rs @@ -44,6 +44,30 @@ pub(crate) mod reexport { pub external_memory_rdma: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceExternalMemoryRDMAFeaturesNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceExternalMemoryRDMAFeaturesNV<'a> {} + unsafe impl<'a> crate::Extends> + for PhysicalDeviceExternalMemoryRDMAFeaturesNV<'a> {} + impl<'a> Default for PhysicalDeviceExternalMemoryRDMAFeaturesNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + external_memory_rdma: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceExternalMemoryRDMAFeaturesNV<'a> { + pub fn external_memory_rdma(mut self, external_memory_rdma: bool) -> Self { + self.external_memory_rdma = external_memory_rdma.into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct MemoryGetRemoteAddressInfoNV<'a> { @@ -53,6 +77,33 @@ pub(crate) mod reexport { pub handle_type: crate::vk::ExternalMemoryHandleTypeFlagBits, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for MemoryGetRemoteAddressInfoNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::MEMORY_GET_REMOTE_ADDRESS_INFO_NV; + } + impl<'a> Default for MemoryGetRemoteAddressInfoNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + memory: Default::default(), + handle_type: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> MemoryGetRemoteAddressInfoNV<'a> { + pub fn memory(mut self, memory: crate::vk::DeviceMemory) -> Self { + self.memory = memory; + self + } + pub fn handle_type( + mut self, + handle_type: crate::vk::ExternalMemoryHandleTypeFlagBits, + ) -> Self { + self.handle_type = handle_type; + self + } + } ///Provided by [`nv::external_memory_rdma`](crate::nv::external_memory_rdma) impl crate::vk::StructureType { pub const MEMORY_GET_REMOTE_ADDRESS_INFO_NV: Self = Self(1000371000); diff --git a/ash-rewrite/src/generated/nv/external_memory_win32.rs b/ash-rewrite/src/generated/nv/external_memory_win32.rs index 578008ae3..5ceda9be7 100644 --- a/ash-rewrite/src/generated/nv/external_memory_win32.rs +++ b/ash-rewrite/src/generated/nv/external_memory_win32.rs @@ -46,6 +46,35 @@ pub(crate) mod reexport { pub handle: crate::platform_types::HANDLE, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for ImportMemoryWin32HandleInfoNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::IMPORT_MEMORY_WIN32_HANDLE_INFO_NV; + } + unsafe impl<'a> crate::Extends> + for ImportMemoryWin32HandleInfoNV<'a> {} + impl<'a> Default for ImportMemoryWin32HandleInfoNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + handle_type: Default::default(), + handle: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> ImportMemoryWin32HandleInfoNV<'a> { + pub fn handle_type( + mut self, + handle_type: crate::vk::ExternalMemoryHandleTypeFlagsNV, + ) -> Self { + self.handle_type = handle_type; + self + } + pub fn handle(mut self, handle: crate::platform_types::HANDLE) -> Self { + self.handle = handle; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct ExportMemoryWin32HandleInfoNV<'a> { @@ -55,6 +84,35 @@ pub(crate) mod reexport { pub dw_access: crate::platform_types::DWORD, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for ExportMemoryWin32HandleInfoNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::EXPORT_MEMORY_WIN32_HANDLE_INFO_NV; + } + unsafe impl<'a> crate::Extends> + for ExportMemoryWin32HandleInfoNV<'a> {} + impl<'a> Default for ExportMemoryWin32HandleInfoNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + p_attributes: Default::default(), + dw_access: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> ExportMemoryWin32HandleInfoNV<'a> { + pub fn p_attributes( + mut self, + p_attributes: &'a crate::platform_types::SECURITY_ATTRIBUTES, + ) -> Self { + self.p_attributes = p_attributes; + self + } + pub fn dw_access(mut self, dw_access: crate::platform_types::DWORD) -> Self { + self.dw_access = dw_access; + self + } + } ///Provided by [`nv::external_memory_win32`](crate::nv::external_memory_win32) impl crate::vk::StructureType { pub const IMPORT_MEMORY_WIN32_HANDLE_INFO_NV: Self = Self(1000057000); diff --git a/ash-rewrite/src/generated/nv/fragment_coverage_to_color.rs b/ash-rewrite/src/generated/nv/fragment_coverage_to_color.rs index e168e5454..6250ebdbc 100644 --- a/ash-rewrite/src/generated/nv/fragment_coverage_to_color.rs +++ b/ash-rewrite/src/generated/nv/fragment_coverage_to_color.rs @@ -11,6 +11,44 @@ pub struct PipelineCoverageToColorStateCreateInfoNV<'a> { pub coverage_to_color_location: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PipelineCoverageToColorStateCreateInfoNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV; +} +unsafe impl<'a> crate::Extends> +for PipelineCoverageToColorStateCreateInfoNV<'a> {} +impl<'a> Default for PipelineCoverageToColorStateCreateInfoNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + flags: Default::default(), + coverage_to_color_enable: Default::default(), + coverage_to_color_location: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PipelineCoverageToColorStateCreateInfoNV<'a> { + pub fn flags( + mut self, + flags: crate::vk::PipelineCoverageToColorStateCreateFlagsNV, + ) -> Self { + self.flags = flags; + self + } + pub fn coverage_to_color_enable(mut self, coverage_to_color_enable: bool) -> Self { + self.coverage_to_color_enable = coverage_to_color_enable.into(); + self + } + pub fn coverage_to_color_location( + mut self, + coverage_to_color_location: u32, + ) -> Self { + self.coverage_to_color_location = coverage_to_color_location; + self + } +} ///Provided by [`nv::fragment_coverage_to_color`](crate::nv::fragment_coverage_to_color) impl crate::vk::StructureType { pub const PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV: Self = Self(1000149000); diff --git a/ash-rewrite/src/generated/nv/fragment_shading_rate_enums.rs b/ash-rewrite/src/generated/nv/fragment_shading_rate_enums.rs index 50f9259b5..7baea28a8 100644 --- a/ash-rewrite/src/generated/nv/fragment_shading_rate_enums.rs +++ b/ash-rewrite/src/generated/nv/fragment_shading_rate_enums.rs @@ -46,6 +46,51 @@ pub(crate) mod reexport { pub no_invocation_fragment_shading_rates: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceFragmentShadingRateEnumsFeaturesNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceFragmentShadingRateEnumsFeaturesNV<'a> {} + unsafe impl<'a> crate::Extends> + for PhysicalDeviceFragmentShadingRateEnumsFeaturesNV<'a> {} + impl<'a> Default for PhysicalDeviceFragmentShadingRateEnumsFeaturesNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + fragment_shading_rate_enums: Default::default(), + supersample_fragment_shading_rates: Default::default(), + no_invocation_fragment_shading_rates: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceFragmentShadingRateEnumsFeaturesNV<'a> { + pub fn fragment_shading_rate_enums( + mut self, + fragment_shading_rate_enums: bool, + ) -> Self { + self.fragment_shading_rate_enums = fragment_shading_rate_enums.into(); + self + } + pub fn supersample_fragment_shading_rates( + mut self, + supersample_fragment_shading_rates: bool, + ) -> Self { + self.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, + ) -> Self { + self.no_invocation_fragment_shading_rates = no_invocation_fragment_shading_rates + .into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceFragmentShadingRateEnumsPropertiesNV<'a> { @@ -54,6 +99,31 @@ pub(crate) mod reexport { pub max_fragment_shading_rate_invocation_count: crate::vk::SampleCountFlagBits, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceFragmentShadingRateEnumsPropertiesNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceFragmentShadingRateEnumsPropertiesNV<'a> {} + impl<'a> Default for PhysicalDeviceFragmentShadingRateEnumsPropertiesNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + max_fragment_shading_rate_invocation_count: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceFragmentShadingRateEnumsPropertiesNV<'a> { + pub fn max_fragment_shading_rate_invocation_count( + mut self, + max_fragment_shading_rate_invocation_count: crate::vk::SampleCountFlagBits, + ) -> Self { + self.max_fragment_shading_rate_invocation_count = max_fragment_shading_rate_invocation_count; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PipelineFragmentShadingRateEnumStateCreateInfoNV<'a> { @@ -64,6 +134,47 @@ pub(crate) mod reexport { pub combiner_ops: [crate::vk::FragmentShadingRateCombinerOpKHR; 2 as _], pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PipelineFragmentShadingRateEnumStateCreateInfoNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV; + } + unsafe impl<'a> crate::Extends> + for PipelineFragmentShadingRateEnumStateCreateInfoNV<'a> {} + impl<'a> Default for PipelineFragmentShadingRateEnumStateCreateInfoNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + shading_rate_type: Default::default(), + shading_rate: Default::default(), + combiner_ops: unsafe { core::mem::zeroed() }, + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PipelineFragmentShadingRateEnumStateCreateInfoNV<'a> { + pub fn shading_rate_type( + mut self, + shading_rate_type: crate::vk::FragmentShadingRateTypeNV, + ) -> Self { + self.shading_rate_type = shading_rate_type; + self + } + pub fn shading_rate( + mut self, + shading_rate: crate::vk::FragmentShadingRateNV, + ) -> Self { + self.shading_rate = shading_rate; + self + } + pub fn combiner_ops( + mut self, + combiner_ops: [crate::vk::FragmentShadingRateCombinerOpKHR; 2 as _], + ) -> Self { + self.combiner_ops = combiner_ops; + self + } + } ///Provided by [`nv::fragment_shading_rate_enums`](crate::nv::fragment_shading_rate_enums) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV: Self = Self( diff --git a/ash-rewrite/src/generated/nv/framebuffer_mixed_samples.rs b/ash-rewrite/src/generated/nv/framebuffer_mixed_samples.rs index cf263e210..7eed9cbaa 100644 --- a/ash-rewrite/src/generated/nv/framebuffer_mixed_samples.rs +++ b/ash-rewrite/src/generated/nv/framebuffer_mixed_samples.rs @@ -13,6 +13,64 @@ pub struct PipelineCoverageModulationStateCreateInfoNV<'a> { pub p_coverage_modulation_table: *const core::ffi::c_float, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PipelineCoverageModulationStateCreateInfoNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV; +} +unsafe impl<'a> crate::Extends> +for PipelineCoverageModulationStateCreateInfoNV<'a> {} +impl<'a> Default for PipelineCoverageModulationStateCreateInfoNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + flags: Default::default(), + coverage_modulation_mode: Default::default(), + coverage_modulation_table_enable: Default::default(), + coverage_modulation_table_count: Default::default(), + p_coverage_modulation_table: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PipelineCoverageModulationStateCreateInfoNV<'a> { + pub fn flags( + mut self, + flags: crate::vk::PipelineCoverageModulationStateCreateFlagsNV, + ) -> Self { + self.flags = flags; + self + } + pub fn coverage_modulation_mode( + mut self, + coverage_modulation_mode: crate::vk::CoverageModulationModeNV, + ) -> Self { + self.coverage_modulation_mode = coverage_modulation_mode; + self + } + pub fn coverage_modulation_table_enable( + mut self, + coverage_modulation_table_enable: bool, + ) -> Self { + self.coverage_modulation_table_enable = coverage_modulation_table_enable.into(); + self + } + pub fn coverage_modulation_table_count( + mut self, + coverage_modulation_table_count: u32, + ) -> Self { + self.coverage_modulation_table_count = coverage_modulation_table_count; + self + } + pub fn p_coverage_modulation_table( + mut self, + p_coverage_modulation_table: &'a [core::ffi::c_float], + ) -> Self { + self.coverage_modulation_table_count = p_coverage_modulation_table.len() as _; + self.p_coverage_modulation_table = p_coverage_modulation_table.as_ptr(); + self + } +} pub type AttachmentSampleCountInfoNV<'a> = crate::vk::AttachmentSampleCountInfoAMD<'a>; ///Provided by [`nv::framebuffer_mixed_samples`](crate::nv::framebuffer_mixed_samples) impl crate::vk::StructureType { diff --git a/ash-rewrite/src/generated/nv/inherited_viewport_scissor.rs b/ash-rewrite/src/generated/nv/inherited_viewport_scissor.rs index 5384ab62a..069a473d8 100644 --- a/ash-rewrite/src/generated/nv/inherited_viewport_scissor.rs +++ b/ash-rewrite/src/generated/nv/inherited_viewport_scissor.rs @@ -9,6 +9,33 @@ pub struct PhysicalDeviceInheritedViewportScissorFeaturesNV<'a> { pub inherited_viewport_scissor2_d: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceInheritedViewportScissorFeaturesNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceInheritedViewportScissorFeaturesNV<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceInheritedViewportScissorFeaturesNV<'a> {} +impl<'a> Default for PhysicalDeviceInheritedViewportScissorFeaturesNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + inherited_viewport_scissor2_d: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceInheritedViewportScissorFeaturesNV<'a> { + pub fn inherited_viewport_scissor2_d( + mut self, + inherited_viewport_scissor2_d: bool, + ) -> Self { + self.inherited_viewport_scissor2_d = inherited_viewport_scissor2_d.into(); + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct CommandBufferInheritanceViewportScissorInfoNV<'a> { @@ -19,6 +46,41 @@ pub struct CommandBufferInheritanceViewportScissorInfoNV<'a> { pub p_viewport_depths: *const crate::vk::Viewport, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for CommandBufferInheritanceViewportScissorInfoNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV; +} +unsafe impl<'a> crate::Extends> +for CommandBufferInheritanceViewportScissorInfoNV<'a> {} +impl<'a> Default for CommandBufferInheritanceViewportScissorInfoNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + viewport_scissor2_d: Default::default(), + viewport_depth_count: Default::default(), + p_viewport_depths: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> CommandBufferInheritanceViewportScissorInfoNV<'a> { + pub fn viewport_scissor2_d(mut self, viewport_scissor2_d: bool) -> Self { + self.viewport_scissor2_d = viewport_scissor2_d.into(); + self + } + pub fn viewport_depth_count(mut self, viewport_depth_count: u32) -> Self { + self.viewport_depth_count = viewport_depth_count; + self + } + pub fn p_viewport_depths( + mut self, + p_viewport_depths: &'a crate::vk::Viewport, + ) -> Self { + self.p_viewport_depths = p_viewport_depths; + self + } +} ///Provided by [`nv::inherited_viewport_scissor`](crate::nv::inherited_viewport_scissor) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV: Self = Self( diff --git a/ash-rewrite/src/generated/nv/linear_color_attachment.rs b/ash-rewrite/src/generated/nv/linear_color_attachment.rs index 3e338ea0a..bb3bd9aa8 100644 --- a/ash-rewrite/src/generated/nv/linear_color_attachment.rs +++ b/ash-rewrite/src/generated/nv/linear_color_attachment.rs @@ -9,6 +9,30 @@ pub struct PhysicalDeviceLinearColorAttachmentFeaturesNV<'a> { pub linear_color_attachment: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceLinearColorAttachmentFeaturesNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceLinearColorAttachmentFeaturesNV<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceLinearColorAttachmentFeaturesNV<'a> {} +impl<'a> Default for PhysicalDeviceLinearColorAttachmentFeaturesNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + linear_color_attachment: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceLinearColorAttachmentFeaturesNV<'a> { + pub fn linear_color_attachment(mut self, linear_color_attachment: bool) -> Self { + self.linear_color_attachment = linear_color_attachment.into(); + self + } +} ///Provided by [`nv::linear_color_attachment`](crate::nv::linear_color_attachment) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV: Self = Self( diff --git a/ash-rewrite/src/generated/nv/low_latency.rs b/ash-rewrite/src/generated/nv/low_latency.rs index 1a26edce4..9cc46ebb3 100644 --- a/ash-rewrite/src/generated/nv/low_latency.rs +++ b/ash-rewrite/src/generated/nv/low_latency.rs @@ -9,6 +9,30 @@ pub struct QueryLowLatencySupportNV<'a> { pub p_queried_low_latency_data: *mut core::ffi::c_void, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> for QueryLowLatencySupportNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::QUERY_LOW_LATENCY_SUPPORT_NV; +} +unsafe impl<'a> crate::Extends> +for QueryLowLatencySupportNV<'a> {} +impl<'a> Default for QueryLowLatencySupportNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + p_queried_low_latency_data: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> QueryLowLatencySupportNV<'a> { + pub fn p_queried_low_latency_data( + mut self, + p_queried_low_latency_data: &'a mut core::ffi::c_void, + ) -> Self { + self.p_queried_low_latency_data = p_queried_low_latency_data; + self + } +} ///Provided by [`nv::low_latency`](crate::nv::low_latency) impl crate::vk::StructureType { pub const QUERY_LOW_LATENCY_SUPPORT_NV: Self = Self(1000310000); diff --git a/ash-rewrite/src/generated/nv/low_latency2.rs b/ash-rewrite/src/generated/nv/low_latency2.rs index 1b9d56e7f..d6511ca72 100644 --- a/ash-rewrite/src/generated/nv/low_latency2.rs +++ b/ash-rewrite/src/generated/nv/low_latency2.rs @@ -109,6 +109,35 @@ pub(crate) mod reexport { pub minimum_interval_us: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for LatencySleepModeInfoNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::LATENCY_SLEEP_MODE_INFO_NV; + } + impl<'a> Default for LatencySleepModeInfoNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + low_latency_mode: Default::default(), + low_latency_boost: Default::default(), + minimum_interval_us: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> LatencySleepModeInfoNV<'a> { + pub fn low_latency_mode(mut self, low_latency_mode: bool) -> Self { + self.low_latency_mode = low_latency_mode.into(); + self + } + pub fn low_latency_boost(mut self, low_latency_boost: bool) -> Self { + self.low_latency_boost = low_latency_boost.into(); + self + } + pub fn minimum_interval_us(mut self, minimum_interval_us: u32) -> Self { + self.minimum_interval_us = minimum_interval_us; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct LatencySleepInfoNV<'a> { @@ -118,6 +147,33 @@ pub(crate) mod reexport { pub value: u64, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for LatencySleepInfoNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::LATENCY_SLEEP_INFO_NV; + } + impl<'a> Default for LatencySleepInfoNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + signal_semaphore: Default::default(), + value: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> LatencySleepInfoNV<'a> { + pub fn signal_semaphore( + mut self, + signal_semaphore: crate::vk::Semaphore, + ) -> Self { + self.signal_semaphore = signal_semaphore; + self + } + pub fn value(mut self, value: u64) -> Self { + self.value = value; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct SetLatencyMarkerInfoNV<'a> { @@ -127,6 +183,30 @@ pub(crate) mod reexport { pub marker: crate::vk::LatencyMarkerNV, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for SetLatencyMarkerInfoNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::SET_LATENCY_MARKER_INFO_NV; + } + impl<'a> Default for SetLatencyMarkerInfoNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + present_id: Default::default(), + marker: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> SetLatencyMarkerInfoNV<'a> { + pub fn present_id(mut self, present_id: u64) -> Self { + self.present_id = present_id; + self + } + pub fn marker(mut self, marker: crate::vk::LatencyMarkerNV) -> Self { + self.marker = marker; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct GetLatencyMarkerInfoNV<'a> { @@ -136,6 +216,34 @@ pub(crate) mod reexport { pub p_timings: *mut crate::vk::LatencyTimingsFrameReportNV<'a>, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for GetLatencyMarkerInfoNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::GET_LATENCY_MARKER_INFO_NV; + } + impl<'a> Default for GetLatencyMarkerInfoNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + timing_count: Default::default(), + p_timings: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> GetLatencyMarkerInfoNV<'a> { + pub fn timing_count(mut self, timing_count: u32) -> Self { + self.timing_count = timing_count; + self + } + pub fn p_timings( + mut self, + p_timings: &'a mut [crate::vk::LatencyTimingsFrameReportNV<'a>], + ) -> Self { + self.timing_count = p_timings.len() as _; + self.p_timings = p_timings.as_mut_ptr(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct LatencyTimingsFrameReportNV<'a> { @@ -157,6 +265,105 @@ pub(crate) mod reexport { pub gpu_render_end_time_us: u64, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for LatencyTimingsFrameReportNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::LATENCY_TIMINGS_FRAME_REPORT_NV; + } + impl<'a> Default for LatencyTimingsFrameReportNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + present_id: Default::default(), + input_sample_time_us: Default::default(), + sim_start_time_us: Default::default(), + sim_end_time_us: Default::default(), + render_submit_start_time_us: Default::default(), + render_submit_end_time_us: Default::default(), + present_start_time_us: Default::default(), + present_end_time_us: Default::default(), + driver_start_time_us: Default::default(), + driver_end_time_us: Default::default(), + os_render_queue_start_time_us: Default::default(), + os_render_queue_end_time_us: Default::default(), + gpu_render_start_time_us: Default::default(), + gpu_render_end_time_us: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> LatencyTimingsFrameReportNV<'a> { + pub fn present_id(mut self, present_id: u64) -> Self { + self.present_id = present_id; + self + } + pub fn input_sample_time_us(mut self, input_sample_time_us: u64) -> Self { + self.input_sample_time_us = input_sample_time_us; + self + } + pub fn sim_start_time_us(mut self, sim_start_time_us: u64) -> Self { + self.sim_start_time_us = sim_start_time_us; + self + } + pub fn sim_end_time_us(mut self, sim_end_time_us: u64) -> Self { + self.sim_end_time_us = sim_end_time_us; + self + } + pub fn render_submit_start_time_us( + mut self, + render_submit_start_time_us: u64, + ) -> Self { + self.render_submit_start_time_us = render_submit_start_time_us; + self + } + pub fn render_submit_end_time_us( + mut self, + render_submit_end_time_us: u64, + ) -> Self { + self.render_submit_end_time_us = render_submit_end_time_us; + self + } + pub fn present_start_time_us(mut self, present_start_time_us: u64) -> Self { + self.present_start_time_us = present_start_time_us; + self + } + pub fn present_end_time_us(mut self, present_end_time_us: u64) -> Self { + self.present_end_time_us = present_end_time_us; + self + } + pub fn driver_start_time_us(mut self, driver_start_time_us: u64) -> Self { + self.driver_start_time_us = driver_start_time_us; + self + } + pub fn driver_end_time_us(mut self, driver_end_time_us: u64) -> Self { + self.driver_end_time_us = driver_end_time_us; + self + } + pub fn os_render_queue_start_time_us( + mut self, + os_render_queue_start_time_us: u64, + ) -> Self { + self.os_render_queue_start_time_us = os_render_queue_start_time_us; + self + } + pub fn os_render_queue_end_time_us( + mut self, + os_render_queue_end_time_us: u64, + ) -> Self { + self.os_render_queue_end_time_us = os_render_queue_end_time_us; + self + } + pub fn gpu_render_start_time_us( + mut self, + gpu_render_start_time_us: u64, + ) -> Self { + self.gpu_render_start_time_us = gpu_render_start_time_us; + self + } + pub fn gpu_render_end_time_us(mut self, gpu_render_end_time_us: u64) -> Self { + self.gpu_render_end_time_us = gpu_render_end_time_us; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct OutOfBandQueueTypeInfoNV<'a> { @@ -165,6 +372,28 @@ pub(crate) mod reexport { pub queue_type: crate::vk::OutOfBandQueueTypeNV, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for OutOfBandQueueTypeInfoNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::OUT_OF_BAND_QUEUE_TYPE_INFO_NV; + } + impl<'a> Default for OutOfBandQueueTypeInfoNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + queue_type: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> OutOfBandQueueTypeInfoNV<'a> { + pub fn queue_type( + mut self, + queue_type: crate::vk::OutOfBandQueueTypeNV, + ) -> Self { + self.queue_type = queue_type; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct LatencySubmissionPresentIdNV<'a> { @@ -173,6 +402,29 @@ pub(crate) mod reexport { pub present_id: u64, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for LatencySubmissionPresentIdNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::LATENCY_SUBMISSION_PRESENT_ID_NV; + } + unsafe impl<'a> crate::Extends> + for LatencySubmissionPresentIdNV<'a> {} + unsafe impl<'a> crate::Extends> + for LatencySubmissionPresentIdNV<'a> {} + impl<'a> Default for LatencySubmissionPresentIdNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + present_id: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> LatencySubmissionPresentIdNV<'a> { + pub fn present_id(mut self, present_id: u64) -> Self { + self.present_id = present_id; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct SwapchainLatencyCreateInfoNV<'a> { @@ -181,6 +433,27 @@ pub(crate) mod reexport { pub latency_mode_enable: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for SwapchainLatencyCreateInfoNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::SWAPCHAIN_LATENCY_CREATE_INFO_NV; + } + unsafe impl<'a> crate::Extends> + for SwapchainLatencyCreateInfoNV<'a> {} + impl<'a> Default for SwapchainLatencyCreateInfoNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + latency_mode_enable: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> SwapchainLatencyCreateInfoNV<'a> { + pub fn latency_mode_enable(mut self, latency_mode_enable: bool) -> Self { + self.latency_mode_enable = latency_mode_enable.into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct LatencySurfaceCapabilitiesNV<'a> { @@ -190,6 +463,36 @@ pub(crate) mod reexport { pub p_present_modes: *mut crate::vk::PresentModeKHR, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for LatencySurfaceCapabilitiesNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::LATENCY_SURFACE_CAPABILITIES_NV; + } + unsafe impl<'a> crate::Extends> + for LatencySurfaceCapabilitiesNV<'a> {} + impl<'a> Default for LatencySurfaceCapabilitiesNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + present_mode_count: Default::default(), + p_present_modes: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> LatencySurfaceCapabilitiesNV<'a> { + pub fn present_mode_count(mut self, present_mode_count: u32) -> Self { + self.present_mode_count = present_mode_count; + self + } + pub fn p_present_modes( + mut self, + p_present_modes: &'a mut [crate::vk::PresentModeKHR], + ) -> Self { + self.present_mode_count = p_present_modes.len() as _; + self.p_present_modes = p_present_modes.as_mut_ptr(); + self + } + } ///Provided by [`nv::low_latency2`](crate::nv::low_latency2) impl crate::vk::StructureType { pub const LATENCY_SLEEP_MODE_INFO_NV: Self = Self(1000505000); diff --git a/ash-rewrite/src/generated/nv/memory_decompression.rs b/ash-rewrite/src/generated/nv/memory_decompression.rs index abcf7be5f..f36d16b1d 100644 --- a/ash-rewrite/src/generated/nv/memory_decompression.rs +++ b/ash-rewrite/src/generated/nv/memory_decompression.rs @@ -54,7 +54,7 @@ impl DeviceFn { } pub(crate) mod reexport { #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct DecompressMemoryRegionNV { pub src_address: crate::vk::DeviceAddress, pub dst_address: crate::vk::DeviceAddress, @@ -62,6 +62,37 @@ pub(crate) mod reexport { pub decompressed_size: crate::vk::DeviceSize, pub decompression_method: crate::vk::MemoryDecompressionMethodFlagsEXT, } + impl DecompressMemoryRegionNV { + pub fn src_address(mut self, src_address: crate::vk::DeviceAddress) -> Self { + self.src_address = src_address; + self + } + pub fn dst_address(mut self, dst_address: crate::vk::DeviceAddress) -> Self { + self.dst_address = dst_address; + self + } + pub fn compressed_size( + mut self, + compressed_size: crate::vk::DeviceSize, + ) -> Self { + self.compressed_size = compressed_size; + self + } + pub fn decompressed_size( + mut self, + decompressed_size: crate::vk::DeviceSize, + ) -> Self { + self.decompressed_size = decompressed_size; + self + } + pub fn decompression_method( + mut self, + decompression_method: crate::vk::MemoryDecompressionMethodFlagsEXT, + ) -> Self { + self.decompression_method = decompression_method; + self + } + } pub type PhysicalDeviceMemoryDecompressionFeaturesNV<'a> = crate::vk::PhysicalDeviceMemoryDecompressionFeaturesEXT< 'a, >; diff --git a/ash-rewrite/src/generated/nv/mesh_shader.rs b/ash-rewrite/src/generated/nv/mesh_shader.rs index 62965b50f..4b8a40115 100644 --- a/ash-rewrite/src/generated/nv/mesh_shader.rs +++ b/ash-rewrite/src/generated/nv/mesh_shader.rs @@ -83,6 +83,35 @@ pub(crate) mod reexport { pub mesh_shader: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceMeshShaderFeaturesNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceMeshShaderFeaturesNV<'a> {} + unsafe impl<'a> crate::Extends> + for PhysicalDeviceMeshShaderFeaturesNV<'a> {} + impl<'a> Default for PhysicalDeviceMeshShaderFeaturesNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + task_shader: Default::default(), + mesh_shader: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceMeshShaderFeaturesNV<'a> { + pub fn task_shader(mut self, task_shader: bool) -> Self { + self.task_shader = task_shader.into(); + self + } + pub fn mesh_shader(mut self, mesh_shader: bool) -> Self { + self.mesh_shader = mesh_shader.into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceMeshShaderPropertiesNV<'a> { @@ -103,12 +132,140 @@ pub(crate) mod reexport { pub mesh_output_per_primitive_granularity: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceMeshShaderPropertiesNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceMeshShaderPropertiesNV<'a> {} + impl<'a> Default for PhysicalDeviceMeshShaderPropertiesNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + max_draw_mesh_tasks_count: Default::default(), + max_task_work_group_invocations: Default::default(), + max_task_work_group_size: unsafe { core::mem::zeroed() }, + max_task_total_memory_size: Default::default(), + max_task_output_count: Default::default(), + max_mesh_work_group_invocations: Default::default(), + max_mesh_work_group_size: unsafe { core::mem::zeroed() }, + max_mesh_total_memory_size: Default::default(), + max_mesh_output_vertices: Default::default(), + max_mesh_output_primitives: Default::default(), + max_mesh_multiview_view_count: Default::default(), + mesh_output_per_vertex_granularity: Default::default(), + mesh_output_per_primitive_granularity: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceMeshShaderPropertiesNV<'a> { + pub fn max_draw_mesh_tasks_count( + mut self, + max_draw_mesh_tasks_count: u32, + ) -> Self { + self.max_draw_mesh_tasks_count = max_draw_mesh_tasks_count; + self + } + pub fn max_task_work_group_invocations( + mut self, + max_task_work_group_invocations: u32, + ) -> Self { + self.max_task_work_group_invocations = max_task_work_group_invocations; + self + } + pub fn max_task_work_group_size( + mut self, + max_task_work_group_size: [u32; 3 as _], + ) -> Self { + self.max_task_work_group_size = max_task_work_group_size; + self + } + pub fn max_task_total_memory_size( + mut self, + max_task_total_memory_size: u32, + ) -> Self { + self.max_task_total_memory_size = max_task_total_memory_size; + self + } + pub fn max_task_output_count(mut self, max_task_output_count: u32) -> Self { + self.max_task_output_count = max_task_output_count; + self + } + pub fn max_mesh_work_group_invocations( + mut self, + max_mesh_work_group_invocations: u32, + ) -> Self { + self.max_mesh_work_group_invocations = max_mesh_work_group_invocations; + self + } + pub fn max_mesh_work_group_size( + mut self, + max_mesh_work_group_size: [u32; 3 as _], + ) -> Self { + self.max_mesh_work_group_size = max_mesh_work_group_size; + self + } + pub fn max_mesh_total_memory_size( + mut self, + max_mesh_total_memory_size: u32, + ) -> Self { + self.max_mesh_total_memory_size = max_mesh_total_memory_size; + self + } + pub fn max_mesh_output_vertices( + mut self, + max_mesh_output_vertices: u32, + ) -> Self { + self.max_mesh_output_vertices = max_mesh_output_vertices; + self + } + pub fn max_mesh_output_primitives( + mut self, + max_mesh_output_primitives: u32, + ) -> Self { + self.max_mesh_output_primitives = max_mesh_output_primitives; + self + } + pub fn max_mesh_multiview_view_count( + mut self, + max_mesh_multiview_view_count: u32, + ) -> Self { + self.max_mesh_multiview_view_count = max_mesh_multiview_view_count; + self + } + pub fn mesh_output_per_vertex_granularity( + mut self, + mesh_output_per_vertex_granularity: u32, + ) -> Self { + self.mesh_output_per_vertex_granularity = mesh_output_per_vertex_granularity; + self + } + pub fn mesh_output_per_primitive_granularity( + mut self, + mesh_output_per_primitive_granularity: u32, + ) -> Self { + self.mesh_output_per_primitive_granularity = mesh_output_per_primitive_granularity; + self + } + } #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct DrawMeshTasksIndirectCommandNV { pub task_count: u32, pub first_task: u32, } + impl DrawMeshTasksIndirectCommandNV { + pub fn task_count(mut self, task_count: u32) -> Self { + self.task_count = task_count; + self + } + pub fn first_task(mut self, first_task: u32) -> Self { + self.first_task = first_task; + self + } + } ///Provided by [`nv::mesh_shader`](crate::nv::mesh_shader) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV: Self = Self(1000202000); diff --git a/ash-rewrite/src/generated/nv/optical_flow.rs b/ash-rewrite/src/generated/nv/optical_flow.rs index 248fb088f..3e3203ed1 100644 --- a/ash-rewrite/src/generated/nv/optical_flow.rs +++ b/ash-rewrite/src/generated/nv/optical_flow.rs @@ -130,6 +130,30 @@ pub(crate) mod reexport { pub optical_flow: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceOpticalFlowFeaturesNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceOpticalFlowFeaturesNV<'a> {} + unsafe impl<'a> crate::Extends> + for PhysicalDeviceOpticalFlowFeaturesNV<'a> {} + impl<'a> Default for PhysicalDeviceOpticalFlowFeaturesNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + optical_flow: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceOpticalFlowFeaturesNV<'a> { + pub fn optical_flow(mut self, optical_flow: bool) -> Self { + self.optical_flow = optical_flow.into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceOpticalFlowPropertiesNV<'a> { @@ -148,6 +172,90 @@ pub(crate) mod reexport { pub max_num_regions_of_interest: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceOpticalFlowPropertiesNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceOpticalFlowPropertiesNV<'a> {} + impl<'a> Default for PhysicalDeviceOpticalFlowPropertiesNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + supported_output_grid_sizes: Default::default(), + supported_hint_grid_sizes: Default::default(), + hint_supported: Default::default(), + cost_supported: Default::default(), + bidirectional_flow_supported: Default::default(), + global_flow_supported: Default::default(), + min_width: Default::default(), + min_height: Default::default(), + max_width: Default::default(), + max_height: Default::default(), + max_num_regions_of_interest: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceOpticalFlowPropertiesNV<'a> { + pub fn supported_output_grid_sizes( + mut self, + supported_output_grid_sizes: crate::vk::OpticalFlowGridSizeFlagsNV, + ) -> Self { + self.supported_output_grid_sizes = supported_output_grid_sizes; + self + } + pub fn supported_hint_grid_sizes( + mut self, + supported_hint_grid_sizes: crate::vk::OpticalFlowGridSizeFlagsNV, + ) -> Self { + self.supported_hint_grid_sizes = supported_hint_grid_sizes; + self + } + pub fn hint_supported(mut self, hint_supported: bool) -> Self { + self.hint_supported = hint_supported.into(); + self + } + pub fn cost_supported(mut self, cost_supported: bool) -> Self { + self.cost_supported = cost_supported.into(); + self + } + pub fn bidirectional_flow_supported( + mut self, + bidirectional_flow_supported: bool, + ) -> Self { + self.bidirectional_flow_supported = bidirectional_flow_supported.into(); + self + } + pub fn global_flow_supported(mut self, global_flow_supported: bool) -> Self { + self.global_flow_supported = global_flow_supported.into(); + self + } + pub fn min_width(mut self, min_width: u32) -> Self { + self.min_width = min_width; + self + } + pub fn min_height(mut self, min_height: u32) -> Self { + self.min_height = min_height; + self + } + pub fn max_width(mut self, max_width: u32) -> Self { + self.max_width = max_width; + self + } + pub fn max_height(mut self, max_height: u32) -> Self { + self.max_height = max_height; + self + } + pub fn max_num_regions_of_interest( + mut self, + max_num_regions_of_interest: u32, + ) -> Self { + self.max_num_regions_of_interest = max_num_regions_of_interest; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct OpticalFlowImageFormatInfoNV<'a> { @@ -156,6 +264,29 @@ pub(crate) mod reexport { pub usage: crate::vk::OpticalFlowUsageFlagsNV, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for OpticalFlowImageFormatInfoNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV; + } + unsafe impl<'a> crate::Extends> + for OpticalFlowImageFormatInfoNV<'a> {} + unsafe impl<'a> crate::Extends> + for OpticalFlowImageFormatInfoNV<'a> {} + impl<'a> Default for OpticalFlowImageFormatInfoNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + usage: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> OpticalFlowImageFormatInfoNV<'a> { + pub fn usage(mut self, usage: crate::vk::OpticalFlowUsageFlagsNV) -> Self { + self.usage = usage; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct OpticalFlowImageFormatPropertiesNV<'a> { @@ -164,6 +295,26 @@ pub(crate) mod reexport { pub format: crate::vk::Format, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for OpticalFlowImageFormatPropertiesNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::OPTICAL_FLOW_IMAGE_FORMAT_PROPERTIES_NV; + } + impl<'a> Default for OpticalFlowImageFormatPropertiesNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + format: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> OpticalFlowImageFormatPropertiesNV<'a> { + pub fn format(mut self, format: crate::vk::Format) -> Self { + self.format = format; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct OpticalFlowSessionCreateInfoNV<'a> { @@ -180,6 +331,80 @@ pub(crate) mod reexport { pub flags: crate::vk::OpticalFlowSessionCreateFlagsNV, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for OpticalFlowSessionCreateInfoNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::OPTICAL_FLOW_SESSION_CREATE_INFO_NV; + } + impl<'a> Default for OpticalFlowSessionCreateInfoNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + width: Default::default(), + height: Default::default(), + image_format: Default::default(), + flow_vector_format: Default::default(), + cost_format: Default::default(), + output_grid_size: Default::default(), + hint_grid_size: Default::default(), + performance_level: Default::default(), + flags: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> OpticalFlowSessionCreateInfoNV<'a> { + pub fn width(mut self, width: u32) -> Self { + self.width = width; + self + } + pub fn height(mut self, height: u32) -> Self { + self.height = height; + self + } + pub fn image_format(mut self, image_format: crate::vk::Format) -> Self { + self.image_format = image_format; + self + } + pub fn flow_vector_format( + mut self, + flow_vector_format: crate::vk::Format, + ) -> Self { + self.flow_vector_format = flow_vector_format; + self + } + pub fn cost_format(mut self, cost_format: crate::vk::Format) -> Self { + self.cost_format = cost_format; + self + } + pub fn output_grid_size( + mut self, + output_grid_size: crate::vk::OpticalFlowGridSizeFlagsNV, + ) -> Self { + self.output_grid_size = output_grid_size; + self + } + pub fn hint_grid_size( + mut self, + hint_grid_size: crate::vk::OpticalFlowGridSizeFlagsNV, + ) -> Self { + self.hint_grid_size = hint_grid_size; + self + } + pub fn performance_level( + mut self, + performance_level: crate::vk::OpticalFlowPerformanceLevelNV, + ) -> Self { + self.performance_level = performance_level; + self + } + pub fn flags( + mut self, + flags: crate::vk::OpticalFlowSessionCreateFlagsNV, + ) -> Self { + self.flags = flags; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct OpticalFlowSessionCreatePrivateDataInfoNV<'a> { @@ -190,6 +415,38 @@ pub(crate) mod reexport { pub p_private_data: *const core::ffi::c_void, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for OpticalFlowSessionCreatePrivateDataInfoNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::OPTICAL_FLOW_SESSION_CREATE_PRIVATE_DATA_INFO_NV; + } + unsafe impl<'a> crate::Extends> + for OpticalFlowSessionCreatePrivateDataInfoNV<'a> {} + impl<'a> Default for OpticalFlowSessionCreatePrivateDataInfoNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + id: Default::default(), + size: Default::default(), + p_private_data: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> OpticalFlowSessionCreatePrivateDataInfoNV<'a> { + pub fn id(mut self, id: u32) -> Self { + self.id = id; + self + } + pub fn size(mut self, size: u32) -> Self { + self.size = size; + self + } + pub fn p_private_data(mut self, p_private_data: &'a core::ffi::c_void) -> Self { + self.p_private_data = p_private_data; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct OpticalFlowExecuteInfoNV<'a> { @@ -200,6 +457,36 @@ pub(crate) mod reexport { pub p_regions: *const crate::vk::Rect2D, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for OpticalFlowExecuteInfoNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::OPTICAL_FLOW_EXECUTE_INFO_NV; + } + impl<'a> Default for OpticalFlowExecuteInfoNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + flags: Default::default(), + region_count: Default::default(), + p_regions: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> OpticalFlowExecuteInfoNV<'a> { + pub fn flags(mut self, flags: crate::vk::OpticalFlowExecuteFlagsNV) -> Self { + self.flags = flags; + self + } + pub fn region_count(mut self, region_count: u32) -> Self { + self.region_count = region_count; + self + } + pub fn p_regions(mut self, p_regions: &'a [crate::vk::Rect2D]) -> Self { + self.region_count = p_regions.len() as _; + self.p_regions = p_regions.as_ptr(); + self + } + } ///Provided by [`nv::optical_flow`](crate::nv::optical_flow) impl crate::vk::Format { pub const R16G16_SFIXED5_NV: Self = Self(1000464000); @@ -355,7 +642,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct OpticalFlowGridSizeFlagBitsNV(pub(crate) u32); ///Provided by [`nv::optical_flow`](crate::nv::optical_flow) impl OpticalFlowGridSizeFlagBitsNV { @@ -441,7 +728,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct OpticalFlowUsageFlagBitsNV(pub(crate) u32); ///Provided by [`nv::optical_flow`](crate::nv::optical_flow) impl OpticalFlowUsageFlagBitsNV { @@ -535,7 +822,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct OpticalFlowSessionCreateFlagBitsNV(pub(crate) u32); ///Provided by [`nv::optical_flow`](crate::nv::optical_flow) impl OpticalFlowSessionCreateFlagBitsNV { @@ -616,7 +903,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct OpticalFlowExecuteFlagBitsNV(pub(crate) u32); ///Provided by [`nv::optical_flow`](crate::nv::optical_flow) impl OpticalFlowExecuteFlagBitsNV { diff --git a/ash-rewrite/src/generated/nv/partitioned_acceleration_structure.rs b/ash-rewrite/src/generated/nv/partitioned_acceleration_structure.rs index 245c53379..413eebeba 100644 --- a/ash-rewrite/src/generated/nv/partitioned_acceleration_structure.rs +++ b/ash-rewrite/src/generated/nv/partitioned_acceleration_structure.rs @@ -65,6 +65,34 @@ pub(crate) mod reexport { pub partitioned_acceleration_structure: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDevicePartitionedAccelerationStructureFeaturesNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_FEATURES_NV; + } + unsafe impl<'a> crate::Extends> + for PhysicalDevicePartitionedAccelerationStructureFeaturesNV<'a> {} + unsafe impl<'a> crate::Extends> + for PhysicalDevicePartitionedAccelerationStructureFeaturesNV<'a> {} + impl<'a> Default for PhysicalDevicePartitionedAccelerationStructureFeaturesNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + partitioned_acceleration_structure: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDevicePartitionedAccelerationStructureFeaturesNV<'a> { + pub fn partitioned_acceleration_structure( + mut self, + partitioned_acceleration_structure: bool, + ) -> Self { + self.partitioned_acceleration_structure = partitioned_acceleration_structure + .into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDevicePartitionedAccelerationStructurePropertiesNV<'a> { @@ -73,13 +101,52 @@ pub(crate) mod reexport { pub max_partition_count: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDevicePartitionedAccelerationStructurePropertiesNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_PROPERTIES_NV; + } + unsafe impl<'a> crate::Extends> + for PhysicalDevicePartitionedAccelerationStructurePropertiesNV<'a> {} + impl<'a> Default for PhysicalDevicePartitionedAccelerationStructurePropertiesNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + max_partition_count: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDevicePartitionedAccelerationStructurePropertiesNV<'a> { + pub fn max_partition_count(mut self, max_partition_count: u32) -> Self { + self.max_partition_count = max_partition_count; + self + } + } #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct BuildPartitionedAccelerationStructureIndirectCommandNV { pub op_type: crate::vk::PartitionedAccelerationStructureOpTypeNV, pub arg_count: u32, pub arg_data: crate::vk::StridedDeviceAddressNV, } + impl BuildPartitionedAccelerationStructureIndirectCommandNV { + pub fn op_type( + mut self, + op_type: crate::vk::PartitionedAccelerationStructureOpTypeNV, + ) -> Self { + self.op_type = op_type; + self + } + pub fn arg_count(mut self, arg_count: u32) -> Self { + self.arg_count = arg_count; + self + } + pub fn arg_data(mut self, arg_data: crate::vk::StridedDeviceAddressNV) -> Self { + self.arg_data = arg_data; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PartitionedAccelerationStructureFlagsNV<'a> { @@ -88,6 +155,33 @@ pub(crate) mod reexport { pub enable_partition_translation: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PartitionedAccelerationStructureFlagsNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PARTITIONED_ACCELERATION_STRUCTURE_FLAGS_NV; + } + unsafe impl< + 'a, + > crate::Extends> + for PartitionedAccelerationStructureFlagsNV<'a> {} + impl<'a> Default for PartitionedAccelerationStructureFlagsNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + enable_partition_translation: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PartitionedAccelerationStructureFlagsNV<'a> { + pub fn enable_partition_translation( + mut self, + enable_partition_translation: bool, + ) -> Self { + self.enable_partition_translation = enable_partition_translation.into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PartitionedAccelerationStructureWriteInstanceDataNV { @@ -101,19 +195,125 @@ pub(crate) mod reexport { pub partition_index: u32, pub acceleration_structure: crate::vk::DeviceAddress, } + impl Default for PartitionedAccelerationStructureWriteInstanceDataNV { + fn default() -> Self { + Self { + transform: Default::default(), + explicit_aabb: unsafe { core::mem::zeroed() }, + instance_id: Default::default(), + instance_mask: Default::default(), + instance_contribution_to_hit_group_index: Default::default(), + instance_flags: Default::default(), + instance_index: Default::default(), + partition_index: Default::default(), + acceleration_structure: Default::default(), + } + } + } + impl PartitionedAccelerationStructureWriteInstanceDataNV { + pub fn transform(mut self, transform: crate::vk::TransformMatrixKHR) -> Self { + self.transform = transform; + self + } + pub fn explicit_aabb( + mut self, + explicit_aabb: [core::ffi::c_float; 6 as _], + ) -> Self { + self.explicit_aabb = explicit_aabb; + self + } + pub fn instance_id(mut self, instance_id: u32) -> Self { + self.instance_id = instance_id; + self + } + pub fn instance_mask(mut self, instance_mask: u32) -> Self { + self.instance_mask = instance_mask; + self + } + pub fn instance_contribution_to_hit_group_index( + mut self, + instance_contribution_to_hit_group_index: u32, + ) -> Self { + self.instance_contribution_to_hit_group_index = instance_contribution_to_hit_group_index; + self + } + pub fn instance_flags( + mut self, + instance_flags: crate::vk::PartitionedAccelerationStructureInstanceFlagsNV, + ) -> Self { + self.instance_flags = instance_flags; + self + } + pub fn instance_index(mut self, instance_index: u32) -> Self { + self.instance_index = instance_index; + self + } + pub fn partition_index(mut self, partition_index: u32) -> Self { + self.partition_index = partition_index; + self + } + pub fn acceleration_structure( + mut self, + acceleration_structure: crate::vk::DeviceAddress, + ) -> Self { + self.acceleration_structure = acceleration_structure; + self + } + } #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct PartitionedAccelerationStructureUpdateInstanceDataNV { pub instance_index: u32, pub instance_contribution_to_hit_group_index: u32, pub acceleration_structure: crate::vk::DeviceAddress, } + impl PartitionedAccelerationStructureUpdateInstanceDataNV { + pub fn instance_index(mut self, instance_index: u32) -> Self { + self.instance_index = instance_index; + self + } + pub fn instance_contribution_to_hit_group_index( + mut self, + instance_contribution_to_hit_group_index: u32, + ) -> Self { + self.instance_contribution_to_hit_group_index = instance_contribution_to_hit_group_index; + self + } + pub fn acceleration_structure( + mut self, + acceleration_structure: crate::vk::DeviceAddress, + ) -> Self { + self.acceleration_structure = acceleration_structure; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PartitionedAccelerationStructureWritePartitionTranslationDataNV { pub partition_index: u32, pub partition_translation: [core::ffi::c_float; 3 as _], } + impl Default for PartitionedAccelerationStructureWritePartitionTranslationDataNV { + fn default() -> Self { + Self { + partition_index: Default::default(), + partition_translation: unsafe { core::mem::zeroed() }, + } + } + } + impl PartitionedAccelerationStructureWritePartitionTranslationDataNV { + pub fn partition_index(mut self, partition_index: u32) -> Self { + self.partition_index = partition_index; + self + } + pub fn partition_translation( + mut self, + partition_translation: [core::ffi::c_float; 3 as _], + ) -> Self { + self.partition_translation = partition_translation; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct WriteDescriptorSetPartitionedAccelerationStructureNV<'a> { @@ -123,6 +323,40 @@ pub(crate) mod reexport { pub p_acceleration_structures: *const crate::vk::DeviceAddress, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for WriteDescriptorSetPartitionedAccelerationStructureNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::WRITE_DESCRIPTOR_SET_PARTITIONED_ACCELERATION_STRUCTURE_NV; + } + unsafe impl<'a> crate::Extends> + for WriteDescriptorSetPartitionedAccelerationStructureNV<'a> {} + impl<'a> Default for WriteDescriptorSetPartitionedAccelerationStructureNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + acceleration_structure_count: Default::default(), + p_acceleration_structures: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> WriteDescriptorSetPartitionedAccelerationStructureNV<'a> { + pub fn acceleration_structure_count( + mut self, + acceleration_structure_count: u32, + ) -> Self { + self.acceleration_structure_count = acceleration_structure_count; + self + } + pub fn p_acceleration_structures( + mut self, + p_acceleration_structures: &'a [crate::vk::DeviceAddress], + ) -> Self { + self.acceleration_structure_count = p_acceleration_structures.len() as _; + self.p_acceleration_structures = p_acceleration_structures.as_ptr(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PartitionedAccelerationStructureInstancesInputNV<'a> { @@ -135,6 +369,55 @@ pub(crate) mod reexport { pub max_instance_in_global_partition_count: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PartitionedAccelerationStructureInstancesInputNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PARTITIONED_ACCELERATION_STRUCTURE_INSTANCES_INPUT_NV; + } + impl<'a> Default for PartitionedAccelerationStructureInstancesInputNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + flags: Default::default(), + instance_count: Default::default(), + max_instance_per_partition_count: Default::default(), + partition_count: Default::default(), + max_instance_in_global_partition_count: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PartitionedAccelerationStructureInstancesInputNV<'a> { + pub fn flags( + mut self, + flags: crate::vk::BuildAccelerationStructureFlagsKHR, + ) -> Self { + self.flags = flags; + self + } + pub fn instance_count(mut self, instance_count: u32) -> Self { + self.instance_count = instance_count; + self + } + pub fn max_instance_per_partition_count( + mut self, + max_instance_per_partition_count: u32, + ) -> Self { + self.max_instance_per_partition_count = max_instance_per_partition_count; + self + } + pub fn partition_count(mut self, partition_count: u32) -> Self { + self.partition_count = partition_count; + self + } + pub fn max_instance_in_global_partition_count( + mut self, + max_instance_in_global_partition_count: u32, + ) -> Self { + self.max_instance_in_global_partition_count = max_instance_in_global_partition_count; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct BuildPartitionedAccelerationStructureInfoNV<'a> { @@ -148,6 +431,63 @@ pub(crate) mod reexport { pub src_infos_count: crate::vk::DeviceAddress, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for BuildPartitionedAccelerationStructureInfoNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::BUILD_PARTITIONED_ACCELERATION_STRUCTURE_INFO_NV; + } + impl<'a> Default for BuildPartitionedAccelerationStructureInfoNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + input: Default::default(), + src_acceleration_structure_data: Default::default(), + dst_acceleration_structure_data: Default::default(), + scratch_data: Default::default(), + src_infos: Default::default(), + src_infos_count: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> BuildPartitionedAccelerationStructureInfoNV<'a> { + pub fn input( + mut self, + input: crate::vk::PartitionedAccelerationStructureInstancesInputNV<'a>, + ) -> Self { + self.input = input; + self + } + pub fn src_acceleration_structure_data( + mut self, + src_acceleration_structure_data: crate::vk::DeviceAddress, + ) -> Self { + self.src_acceleration_structure_data = src_acceleration_structure_data; + self + } + pub fn dst_acceleration_structure_data( + mut self, + dst_acceleration_structure_data: crate::vk::DeviceAddress, + ) -> Self { + self.dst_acceleration_structure_data = dst_acceleration_structure_data; + self + } + pub fn scratch_data(mut self, scratch_data: crate::vk::DeviceAddress) -> Self { + self.scratch_data = scratch_data; + self + } + pub fn src_infos(mut self, src_infos: crate::vk::DeviceAddress) -> Self { + self.src_infos = src_infos; + self + } + pub fn src_infos_count( + mut self, + src_infos_count: crate::vk::DeviceAddress, + ) -> Self { + self.src_infos_count = src_infos_count; + self + } + } ///Provided by [`nv::partitioned_acceleration_structure`](crate::nv::partitioned_acceleration_structure) impl crate::vk::DescriptorType { pub const PARTITIONED_ACCELERATION_STRUCTURE_NV: Self = Self(1000570000); @@ -275,7 +615,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct PartitionedAccelerationStructureInstanceFlagBitsNV(pub(crate) u32); ///Provided by [`nv::partitioned_acceleration_structure`](crate::nv::partitioned_acceleration_structure) impl PartitionedAccelerationStructureInstanceFlagBitsNV { diff --git a/ash-rewrite/src/generated/nv/per_stage_descriptor_set.rs b/ash-rewrite/src/generated/nv/per_stage_descriptor_set.rs index 418442dc3..dc7e2816e 100644 --- a/ash-rewrite/src/generated/nv/per_stage_descriptor_set.rs +++ b/ash-rewrite/src/generated/nv/per_stage_descriptor_set.rs @@ -10,6 +10,35 @@ pub struct PhysicalDevicePerStageDescriptorSetFeaturesNV<'a> { pub dynamic_pipeline_layout: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDevicePerStageDescriptorSetFeaturesNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV; +} +unsafe impl<'a> crate::Extends> +for PhysicalDevicePerStageDescriptorSetFeaturesNV<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDevicePerStageDescriptorSetFeaturesNV<'a> {} +impl<'a> Default for PhysicalDevicePerStageDescriptorSetFeaturesNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + per_stage_descriptor_set: Default::default(), + dynamic_pipeline_layout: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDevicePerStageDescriptorSetFeaturesNV<'a> { + pub fn per_stage_descriptor_set(mut self, per_stage_descriptor_set: bool) -> Self { + self.per_stage_descriptor_set = per_stage_descriptor_set.into(); + self + } + pub fn dynamic_pipeline_layout(mut self, dynamic_pipeline_layout: bool) -> Self { + self.dynamic_pipeline_layout = dynamic_pipeline_layout.into(); + self + } +} ///Provided by [`nv::per_stage_descriptor_set`](crate::nv::per_stage_descriptor_set) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV: Self = Self( diff --git a/ash-rewrite/src/generated/nv/present_barrier.rs b/ash-rewrite/src/generated/nv/present_barrier.rs index 267732df4..00be9f1c6 100644 --- a/ash-rewrite/src/generated/nv/present_barrier.rs +++ b/ash-rewrite/src/generated/nv/present_barrier.rs @@ -9,6 +9,30 @@ pub struct PhysicalDevicePresentBarrierFeaturesNV<'a> { pub present_barrier: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDevicePresentBarrierFeaturesNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV; +} +unsafe impl<'a> crate::Extends> +for PhysicalDevicePresentBarrierFeaturesNV<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDevicePresentBarrierFeaturesNV<'a> {} +impl<'a> Default for PhysicalDevicePresentBarrierFeaturesNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + present_barrier: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDevicePresentBarrierFeaturesNV<'a> { + pub fn present_barrier(mut self, present_barrier: bool) -> Self { + self.present_barrier = present_barrier.into(); + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct SurfaceCapabilitiesPresentBarrierNV<'a> { @@ -17,6 +41,27 @@ pub struct SurfaceCapabilitiesPresentBarrierNV<'a> { pub present_barrier_supported: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> for SurfaceCapabilitiesPresentBarrierNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::SURFACE_CAPABILITIES_PRESENT_BARRIER_NV; +} +unsafe impl<'a> crate::Extends> +for SurfaceCapabilitiesPresentBarrierNV<'a> {} +impl<'a> Default for SurfaceCapabilitiesPresentBarrierNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + present_barrier_supported: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> SurfaceCapabilitiesPresentBarrierNV<'a> { + pub fn present_barrier_supported(mut self, present_barrier_supported: bool) -> Self { + self.present_barrier_supported = present_barrier_supported.into(); + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct SwapchainPresentBarrierCreateInfoNV<'a> { @@ -25,6 +70,27 @@ pub struct SwapchainPresentBarrierCreateInfoNV<'a> { pub present_barrier_enable: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> for SwapchainPresentBarrierCreateInfoNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::SWAPCHAIN_PRESENT_BARRIER_CREATE_INFO_NV; +} +unsafe impl<'a> crate::Extends> +for SwapchainPresentBarrierCreateInfoNV<'a> {} +impl<'a> Default for SwapchainPresentBarrierCreateInfoNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + present_barrier_enable: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> SwapchainPresentBarrierCreateInfoNV<'a> { + pub fn present_barrier_enable(mut self, present_barrier_enable: bool) -> Self { + self.present_barrier_enable = present_barrier_enable.into(); + self + } +} ///Provided by [`nv::present_barrier`](crate::nv::present_barrier) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV: Self = Self(1000292000); diff --git a/ash-rewrite/src/generated/nv/present_metering.rs b/ash-rewrite/src/generated/nv/present_metering.rs index d5de5b695..286f437dd 100644 --- a/ash-rewrite/src/generated/nv/present_metering.rs +++ b/ash-rewrite/src/generated/nv/present_metering.rs @@ -10,6 +10,32 @@ pub struct SetPresentConfigNV<'a> { pub present_config_feedback: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> for SetPresentConfigNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::SET_PRESENT_CONFIG_NV; +} +unsafe impl<'a> crate::Extends> +for SetPresentConfigNV<'a> {} +impl<'a> Default for SetPresentConfigNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + num_frames_per_batch: Default::default(), + present_config_feedback: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> SetPresentConfigNV<'a> { + pub fn num_frames_per_batch(mut self, num_frames_per_batch: u32) -> Self { + self.num_frames_per_batch = num_frames_per_batch; + self + } + pub fn present_config_feedback(mut self, present_config_feedback: u32) -> Self { + self.present_config_feedback = present_config_feedback; + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDevicePresentMeteringFeaturesNV<'a> { @@ -18,6 +44,30 @@ pub struct PhysicalDevicePresentMeteringFeaturesNV<'a> { pub present_metering: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDevicePresentMeteringFeaturesNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_PRESENT_METERING_FEATURES_NV; +} +unsafe impl<'a> crate::Extends> +for PhysicalDevicePresentMeteringFeaturesNV<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDevicePresentMeteringFeaturesNV<'a> {} +impl<'a> Default for PhysicalDevicePresentMeteringFeaturesNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + present_metering: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDevicePresentMeteringFeaturesNV<'a> { + pub fn present_metering(mut self, present_metering: bool) -> Self { + self.present_metering = present_metering.into(); + self + } +} ///Provided by [`nv::present_metering`](crate::nv::present_metering) impl crate::vk::StructureType { pub const SET_PRESENT_CONFIG_NV: Self = Self(1000613000); diff --git a/ash-rewrite/src/generated/nv/push_constant_bank.rs b/ash-rewrite/src/generated/nv/push_constant_bank.rs index adec9539c..9bae170f3 100644 --- a/ash-rewrite/src/generated/nv/push_constant_bank.rs +++ b/ash-rewrite/src/generated/nv/push_constant_bank.rs @@ -9,6 +9,33 @@ pub struct PushConstantBankInfoNV<'a> { pub bank: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> for PushConstantBankInfoNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PUSH_CONSTANT_BANK_INFO_NV; +} +unsafe impl<'a> crate::Extends> +for PushConstantBankInfoNV<'a> {} +unsafe impl<'a> crate::Extends> +for PushConstantBankInfoNV<'a> {} +unsafe impl<'a> crate::Extends> +for PushConstantBankInfoNV<'a> {} +unsafe impl<'a> crate::Extends> +for PushConstantBankInfoNV<'a> {} +impl<'a> Default for PushConstantBankInfoNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + bank: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PushConstantBankInfoNV<'a> { + pub fn bank(mut self, bank: u32) -> Self { + self.bank = bank; + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDevicePushConstantBankFeaturesNV<'a> { @@ -17,6 +44,30 @@ pub struct PhysicalDevicePushConstantBankFeaturesNV<'a> { pub push_constant_bank: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDevicePushConstantBankFeaturesNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_PUSH_CONSTANT_BANK_FEATURES_NV; +} +unsafe impl<'a> crate::Extends> +for PhysicalDevicePushConstantBankFeaturesNV<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDevicePushConstantBankFeaturesNV<'a> {} +impl<'a> Default for PhysicalDevicePushConstantBankFeaturesNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + push_constant_bank: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDevicePushConstantBankFeaturesNV<'a> { + pub fn push_constant_bank(mut self, push_constant_bank: bool) -> Self { + self.push_constant_bank = push_constant_bank.into(); + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDevicePushConstantBankPropertiesNV<'a> { @@ -28,6 +79,55 @@ pub struct PhysicalDevicePushConstantBankPropertiesNV<'a> { pub max_compute_push_data_banks: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDevicePushConstantBankPropertiesNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_PUSH_CONSTANT_BANK_PROPERTIES_NV; +} +unsafe impl<'a> crate::Extends> +for PhysicalDevicePushConstantBankPropertiesNV<'a> {} +impl<'a> Default for PhysicalDevicePushConstantBankPropertiesNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + max_graphics_push_constant_banks: Default::default(), + max_compute_push_constant_banks: Default::default(), + max_graphics_push_data_banks: Default::default(), + max_compute_push_data_banks: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDevicePushConstantBankPropertiesNV<'a> { + pub fn max_graphics_push_constant_banks( + mut self, + max_graphics_push_constant_banks: u32, + ) -> Self { + self.max_graphics_push_constant_banks = max_graphics_push_constant_banks; + self + } + pub fn max_compute_push_constant_banks( + mut self, + max_compute_push_constant_banks: u32, + ) -> Self { + self.max_compute_push_constant_banks = max_compute_push_constant_banks; + self + } + pub fn max_graphics_push_data_banks( + mut self, + max_graphics_push_data_banks: u32, + ) -> Self { + self.max_graphics_push_data_banks = max_graphics_push_data_banks; + self + } + pub fn max_compute_push_data_banks( + mut self, + max_compute_push_data_banks: u32, + ) -> Self { + self.max_compute_push_data_banks = max_compute_push_data_banks; + self + } +} ///Provided by [`nv::push_constant_bank`](crate::nv::push_constant_bank) impl crate::vk::StructureType { pub const PUSH_CONSTANT_BANK_INFO_NV: Self = Self(1000580000); diff --git a/ash-rewrite/src/generated/nv/raw_access_chains.rs b/ash-rewrite/src/generated/nv/raw_access_chains.rs index 76b3115ea..e0c99b8a7 100644 --- a/ash-rewrite/src/generated/nv/raw_access_chains.rs +++ b/ash-rewrite/src/generated/nv/raw_access_chains.rs @@ -9,6 +9,30 @@ pub struct PhysicalDeviceRawAccessChainsFeaturesNV<'a> { pub shader_raw_access_chains: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceRawAccessChainsFeaturesNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceRawAccessChainsFeaturesNV<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceRawAccessChainsFeaturesNV<'a> {} +impl<'a> Default for PhysicalDeviceRawAccessChainsFeaturesNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + shader_raw_access_chains: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceRawAccessChainsFeaturesNV<'a> { + pub fn shader_raw_access_chains(mut self, shader_raw_access_chains: bool) -> Self { + self.shader_raw_access_chains = shader_raw_access_chains.into(); + self + } +} ///Provided by [`nv::raw_access_chains`](crate::nv::raw_access_chains) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV: Self = Self(1000555000); diff --git a/ash-rewrite/src/generated/nv/ray_tracing.rs b/ash-rewrite/src/generated/nv/ray_tracing.rs index a10d1f60d..a90d1dc4b 100644 --- a/ash-rewrite/src/generated/nv/ray_tracing.rs +++ b/ash-rewrite/src/generated/nv/ray_tracing.rs @@ -258,6 +258,46 @@ pub(crate) mod reexport { pub intersection_shader: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for RayTracingShaderGroupCreateInfoNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV; + } + impl<'a> Default for RayTracingShaderGroupCreateInfoNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + _type: Default::default(), + general_shader: Default::default(), + closest_hit_shader: Default::default(), + any_hit_shader: Default::default(), + intersection_shader: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> RayTracingShaderGroupCreateInfoNV<'a> { + pub fn _type(mut self, _type: crate::vk::RayTracingShaderGroupTypeKHR) -> Self { + self._type = _type; + self + } + pub fn general_shader(mut self, general_shader: u32) -> Self { + self.general_shader = general_shader; + self + } + pub fn closest_hit_shader(mut self, closest_hit_shader: u32) -> Self { + self.closest_hit_shader = closest_hit_shader; + self + } + pub fn any_hit_shader(mut self, any_hit_shader: u32) -> Self { + self.any_hit_shader = any_hit_shader; + self + } + pub fn intersection_shader(mut self, intersection_shader: u32) -> Self { + self.intersection_shader = intersection_shader; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct RayTracingPipelineCreateInfoNV<'a> { @@ -274,6 +314,76 @@ pub(crate) mod reexport { pub base_pipeline_index: i32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for RayTracingPipelineCreateInfoNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::RAY_TRACING_PIPELINE_CREATE_INFO_NV; + } + impl<'a> Default for RayTracingPipelineCreateInfoNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + flags: Default::default(), + stage_count: Default::default(), + p_stages: Default::default(), + group_count: Default::default(), + p_groups: Default::default(), + max_recursion_depth: Default::default(), + layout: Default::default(), + base_pipeline_handle: Default::default(), + base_pipeline_index: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> RayTracingPipelineCreateInfoNV<'a> { + pub fn flags(mut self, flags: crate::vk::PipelineCreateFlags) -> Self { + self.flags = flags; + self + } + pub fn stage_count(mut self, stage_count: u32) -> Self { + self.stage_count = stage_count; + self + } + pub fn p_stages( + mut self, + p_stages: &'a [crate::vk::PipelineShaderStageCreateInfo<'a>], + ) -> Self { + self.stage_count = p_stages.len() as _; + self.p_stages = p_stages.as_ptr(); + self + } + pub fn group_count(mut self, group_count: u32) -> Self { + self.group_count = group_count; + self + } + pub fn p_groups( + mut self, + p_groups: &'a [crate::vk::RayTracingShaderGroupCreateInfoNV<'a>], + ) -> Self { + self.group_count = p_groups.len() as _; + self.p_groups = p_groups.as_ptr(); + self + } + pub fn max_recursion_depth(mut self, max_recursion_depth: u32) -> Self { + self.max_recursion_depth = max_recursion_depth; + self + } + pub fn layout(mut self, layout: crate::vk::PipelineLayout) -> Self { + self.layout = layout; + self + } + pub fn base_pipeline_handle( + mut self, + base_pipeline_handle: crate::vk::Pipeline, + ) -> Self { + self.base_pipeline_handle = base_pipeline_handle; + self + } + pub fn base_pipeline_index(mut self, base_pipeline_index: i32) -> Self { + self.base_pipeline_index = base_pipeline_index; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct GeometryTrianglesNV<'a> { @@ -292,6 +402,78 @@ pub(crate) mod reexport { pub transform_offset: crate::vk::DeviceSize, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for GeometryTrianglesNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::GEOMETRY_TRIANGLES_NV; + } + impl<'a> Default for GeometryTrianglesNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + vertex_data: Default::default(), + vertex_offset: Default::default(), + vertex_count: Default::default(), + vertex_stride: Default::default(), + vertex_format: Default::default(), + index_data: Default::default(), + index_offset: Default::default(), + index_count: Default::default(), + index_type: Default::default(), + transform_data: Default::default(), + transform_offset: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> GeometryTrianglesNV<'a> { + pub fn vertex_data(mut self, vertex_data: crate::vk::Buffer) -> Self { + self.vertex_data = vertex_data; + self + } + pub fn vertex_offset(mut self, vertex_offset: crate::vk::DeviceSize) -> Self { + self.vertex_offset = vertex_offset; + self + } + pub fn vertex_count(mut self, vertex_count: u32) -> Self { + self.vertex_count = vertex_count; + self + } + pub fn vertex_stride(mut self, vertex_stride: crate::vk::DeviceSize) -> Self { + self.vertex_stride = vertex_stride; + self + } + pub fn vertex_format(mut self, vertex_format: crate::vk::Format) -> Self { + self.vertex_format = vertex_format; + self + } + pub fn index_data(mut self, index_data: crate::vk::Buffer) -> Self { + self.index_data = index_data; + self + } + pub fn index_offset(mut self, index_offset: crate::vk::DeviceSize) -> Self { + self.index_offset = index_offset; + self + } + pub fn index_count(mut self, index_count: u32) -> Self { + self.index_count = index_count; + self + } + pub fn index_type(mut self, index_type: crate::vk::IndexType) -> Self { + self.index_type = index_type; + self + } + pub fn transform_data(mut self, transform_data: crate::vk::Buffer) -> Self { + self.transform_data = transform_data; + self + } + pub fn transform_offset( + mut self, + transform_offset: crate::vk::DeviceSize, + ) -> Self { + self.transform_offset = transform_offset; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct GeometryAABBNV<'a> { @@ -303,13 +485,60 @@ pub(crate) mod reexport { pub offset: crate::vk::DeviceSize, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for GeometryAABBNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::GEOMETRY_AABB_NV; + } + impl<'a> Default for GeometryAABBNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + aabb_data: Default::default(), + num_aab_bs: Default::default(), + stride: Default::default(), + offset: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> GeometryAABBNV<'a> { + pub fn aabb_data(mut self, aabb_data: crate::vk::Buffer) -> Self { + self.aabb_data = aabb_data; + self + } + pub fn num_aab_bs(mut self, num_aab_bs: u32) -> Self { + self.num_aab_bs = num_aab_bs; + self + } + pub fn stride(mut self, stride: u32) -> Self { + self.stride = stride; + self + } + pub fn offset(mut self, offset: crate::vk::DeviceSize) -> Self { + self.offset = offset; + self + } + } #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct GeometryDataNV<'a> { pub triangles: crate::vk::GeometryTrianglesNV<'a>, pub aabbs: crate::vk::GeometryAABBNV<'a>, pub _marker: ::core::marker::PhantomData<&'a ()>, } + impl<'a> GeometryDataNV<'a> { + pub fn triangles( + mut self, + triangles: crate::vk::GeometryTrianglesNV<'a>, + ) -> Self { + self.triangles = triangles; + self + } + pub fn aabbs(mut self, aabbs: crate::vk::GeometryAABBNV<'a>) -> Self { + self.aabbs = aabbs; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct GeometryNV<'a> { @@ -320,6 +549,38 @@ pub(crate) mod reexport { pub flags: crate::vk::GeometryFlagsKHR, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for GeometryNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::GEOMETRY_NV; + } + impl<'a> Default for GeometryNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + geometry_type: Default::default(), + geometry: Default::default(), + flags: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> GeometryNV<'a> { + pub fn geometry_type( + mut self, + geometry_type: crate::vk::GeometryTypeKHR, + ) -> Self { + self.geometry_type = geometry_type; + self + } + pub fn geometry(mut self, geometry: crate::vk::GeometryDataNV<'a>) -> Self { + self.geometry = geometry; + self + } + pub fn flags(mut self, flags: crate::vk::GeometryFlagsKHR) -> Self { + self.flags = flags; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct AccelerationStructureInfoNV<'a> { @@ -332,6 +593,52 @@ pub(crate) mod reexport { pub p_geometries: *const crate::vk::GeometryNV<'a>, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for AccelerationStructureInfoNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::ACCELERATION_STRUCTURE_INFO_NV; + } + impl<'a> Default for AccelerationStructureInfoNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + _type: Default::default(), + flags: Default::default(), + instance_count: Default::default(), + geometry_count: Default::default(), + p_geometries: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> AccelerationStructureInfoNV<'a> { + pub fn _type(mut self, _type: crate::vk::AccelerationStructureTypeNV) -> Self { + self._type = _type; + self + } + pub fn flags( + mut self, + flags: crate::vk::BuildAccelerationStructureFlagsKHR, + ) -> Self { + self.flags = flags; + self + } + pub fn instance_count(mut self, instance_count: u32) -> Self { + self.instance_count = instance_count; + self + } + pub fn geometry_count(mut self, geometry_count: u32) -> Self { + self.geometry_count = geometry_count; + self + } + pub fn p_geometries( + mut self, + p_geometries: &'a [crate::vk::GeometryNV<'a>], + ) -> Self { + self.geometry_count = p_geometries.len() as _; + self.p_geometries = p_geometries.as_ptr(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct AccelerationStructureCreateInfoNV<'a> { @@ -341,6 +648,31 @@ pub(crate) mod reexport { pub info: crate::vk::AccelerationStructureInfoNV<'a>, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for AccelerationStructureCreateInfoNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::ACCELERATION_STRUCTURE_CREATE_INFO_NV; + } + impl<'a> Default for AccelerationStructureCreateInfoNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + compacted_size: Default::default(), + info: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> AccelerationStructureCreateInfoNV<'a> { + pub fn compacted_size(mut self, compacted_size: crate::vk::DeviceSize) -> Self { + self.compacted_size = compacted_size; + self + } + pub fn info(mut self, info: crate::vk::AccelerationStructureInfoNV<'a>) -> Self { + self.info = info; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct BindAccelerationStructureMemoryInfoNV<'a> { @@ -353,6 +685,50 @@ pub(crate) mod reexport { pub p_device_indices: *const u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for BindAccelerationStructureMemoryInfoNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NV; + } + impl<'a> Default for BindAccelerationStructureMemoryInfoNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + acceleration_structure: Default::default(), + memory: Default::default(), + memory_offset: Default::default(), + device_index_count: Default::default(), + p_device_indices: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> BindAccelerationStructureMemoryInfoNV<'a> { + pub fn acceleration_structure( + mut self, + acceleration_structure: crate::vk::AccelerationStructureNV, + ) -> Self { + self.acceleration_structure = acceleration_structure; + self + } + pub fn memory(mut self, memory: crate::vk::DeviceMemory) -> Self { + self.memory = memory; + self + } + pub fn memory_offset(mut self, memory_offset: crate::vk::DeviceSize) -> Self { + self.memory_offset = memory_offset; + self + } + pub fn device_index_count(mut self, device_index_count: u32) -> Self { + self.device_index_count = device_index_count; + self + } + pub fn p_device_indices(mut self, p_device_indices: &'a [u32]) -> Self { + self.device_index_count = p_device_indices.len() as _; + self.p_device_indices = p_device_indices.as_ptr(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct WriteDescriptorSetAccelerationStructureNV<'a> { @@ -362,6 +738,40 @@ pub(crate) mod reexport { pub p_acceleration_structures: *const crate::vk::AccelerationStructureNV, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for WriteDescriptorSetAccelerationStructureNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV; + } + unsafe impl<'a> crate::Extends> + for WriteDescriptorSetAccelerationStructureNV<'a> {} + impl<'a> Default for WriteDescriptorSetAccelerationStructureNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + acceleration_structure_count: Default::default(), + p_acceleration_structures: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> WriteDescriptorSetAccelerationStructureNV<'a> { + pub fn acceleration_structure_count( + mut self, + acceleration_structure_count: u32, + ) -> Self { + self.acceleration_structure_count = acceleration_structure_count; + self + } + pub fn p_acceleration_structures( + mut self, + p_acceleration_structures: &'a [crate::vk::AccelerationStructureNV], + ) -> Self { + self.acceleration_structure_count = p_acceleration_structures.len() as _; + self.p_acceleration_structures = p_acceleration_structures.as_ptr(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct AccelerationStructureMemoryRequirementsInfoNV<'a> { @@ -371,6 +781,37 @@ pub(crate) mod reexport { pub acceleration_structure: crate::vk::AccelerationStructureNV, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for AccelerationStructureMemoryRequirementsInfoNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV; + } + impl<'a> Default for AccelerationStructureMemoryRequirementsInfoNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + _type: Default::default(), + acceleration_structure: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> AccelerationStructureMemoryRequirementsInfoNV<'a> { + pub fn _type( + mut self, + _type: crate::vk::AccelerationStructureMemoryRequirementsTypeNV, + ) -> Self { + self._type = _type; + self + } + pub fn acceleration_structure( + mut self, + acceleration_structure: crate::vk::AccelerationStructureNV, + ) -> Self { + self.acceleration_structure = acceleration_structure; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceRayTracingPropertiesNV<'a> { @@ -386,6 +827,72 @@ pub(crate) mod reexport { pub max_descriptor_set_acceleration_structures: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceRayTracingPropertiesNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceRayTracingPropertiesNV<'a> {} + impl<'a> Default for PhysicalDeviceRayTracingPropertiesNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + shader_group_handle_size: Default::default(), + max_recursion_depth: Default::default(), + max_shader_group_stride: Default::default(), + shader_group_base_alignment: Default::default(), + max_geometry_count: Default::default(), + max_instance_count: Default::default(), + max_triangle_count: Default::default(), + max_descriptor_set_acceleration_structures: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceRayTracingPropertiesNV<'a> { + pub fn shader_group_handle_size( + mut self, + shader_group_handle_size: u32, + ) -> Self { + self.shader_group_handle_size = shader_group_handle_size; + self + } + pub fn max_recursion_depth(mut self, max_recursion_depth: u32) -> Self { + self.max_recursion_depth = max_recursion_depth; + self + } + pub fn max_shader_group_stride(mut self, max_shader_group_stride: u32) -> Self { + self.max_shader_group_stride = max_shader_group_stride; + self + } + pub fn shader_group_base_alignment( + mut self, + shader_group_base_alignment: u32, + ) -> Self { + self.shader_group_base_alignment = shader_group_base_alignment; + self + } + pub fn max_geometry_count(mut self, max_geometry_count: u64) -> Self { + self.max_geometry_count = max_geometry_count; + self + } + pub fn max_instance_count(mut self, max_instance_count: u64) -> Self { + self.max_instance_count = max_instance_count; + self + } + pub fn max_triangle_count(mut self, max_triangle_count: u64) -> Self { + self.max_triangle_count = max_triangle_count; + self + } + pub fn max_descriptor_set_acceleration_structures( + mut self, + max_descriptor_set_acceleration_structures: u32, + ) -> Self { + self.max_descriptor_set_acceleration_structures = max_descriptor_set_acceleration_structures; + self + } + } pub type AabbPositionsNV = crate::vk::AabbPositionsKHR; pub type TransformMatrixNV = crate::vk::TransformMatrixKHR; pub type AccelerationStructureInstanceNV = crate::vk::AccelerationStructureInstanceKHR; diff --git a/ash-rewrite/src/generated/nv/ray_tracing_invocation_reorder.rs b/ash-rewrite/src/generated/nv/ray_tracing_invocation_reorder.rs index a200d874e..bb91dbd3c 100644 --- a/ash-rewrite/src/generated/nv/ray_tracing_invocation_reorder.rs +++ b/ash-rewrite/src/generated/nv/ray_tracing_invocation_reorder.rs @@ -9,6 +9,33 @@ pub struct PhysicalDeviceRayTracingInvocationReorderFeaturesNV<'a> { pub ray_tracing_invocation_reorder: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceRayTracingInvocationReorderFeaturesNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceRayTracingInvocationReorderFeaturesNV<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceRayTracingInvocationReorderFeaturesNV<'a> {} +impl<'a> Default for PhysicalDeviceRayTracingInvocationReorderFeaturesNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + ray_tracing_invocation_reorder: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceRayTracingInvocationReorderFeaturesNV<'a> { + pub fn ray_tracing_invocation_reorder( + mut self, + ray_tracing_invocation_reorder: bool, + ) -> Self { + self.ray_tracing_invocation_reorder = ray_tracing_invocation_reorder.into(); + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceRayTracingInvocationReorderPropertiesNV<'a> { @@ -17,6 +44,31 @@ pub struct PhysicalDeviceRayTracingInvocationReorderPropertiesNV<'a> { pub ray_tracing_invocation_reorder_reordering_hint: crate::vk::RayTracingInvocationReorderModeEXT, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceRayTracingInvocationReorderPropertiesNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceRayTracingInvocationReorderPropertiesNV<'a> {} +impl<'a> Default for PhysicalDeviceRayTracingInvocationReorderPropertiesNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + ray_tracing_invocation_reorder_reordering_hint: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceRayTracingInvocationReorderPropertiesNV<'a> { + pub fn ray_tracing_invocation_reorder_reordering_hint( + mut self, + ray_tracing_invocation_reorder_reordering_hint: crate::vk::RayTracingInvocationReorderModeEXT, + ) -> Self { + self.ray_tracing_invocation_reorder_reordering_hint = ray_tracing_invocation_reorder_reordering_hint; + self + } +} ///Provided by [`nv::ray_tracing_invocation_reorder`](crate::nv::ray_tracing_invocation_reorder) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV: Self = Self( diff --git a/ash-rewrite/src/generated/nv/ray_tracing_linear_swept_spheres.rs b/ash-rewrite/src/generated/nv/ray_tracing_linear_swept_spheres.rs index 458b25182..6224a6ba2 100644 --- a/ash-rewrite/src/generated/nv/ray_tracing_linear_swept_spheres.rs +++ b/ash-rewrite/src/generated/nv/ray_tracing_linear_swept_spheres.rs @@ -19,6 +19,93 @@ pub struct AccelerationStructureGeometryLinearSweptSpheresDataNV<'a> { pub end_caps_mode: crate::vk::RayTracingLssPrimitiveEndCapsModeNV, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for AccelerationStructureGeometryLinearSweptSpheresDataNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::ACCELERATION_STRUCTURE_GEOMETRY_LINEAR_SWEPT_SPHERES_DATA_NV; +} +unsafe impl<'a> crate::Extends> +for AccelerationStructureGeometryLinearSweptSpheresDataNV<'a> {} +impl<'a> Default for AccelerationStructureGeometryLinearSweptSpheresDataNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + vertex_format: Default::default(), + vertex_data: Default::default(), + vertex_stride: Default::default(), + radius_format: Default::default(), + radius_data: Default::default(), + radius_stride: Default::default(), + index_type: Default::default(), + index_data: Default::default(), + index_stride: Default::default(), + indexing_mode: Default::default(), + end_caps_mode: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> AccelerationStructureGeometryLinearSweptSpheresDataNV<'a> { + pub fn vertex_format(mut self, vertex_format: crate::vk::Format) -> Self { + self.vertex_format = vertex_format; + self + } + pub fn vertex_data( + mut self, + vertex_data: crate::vk::DeviceOrHostAddressConstKHR, + ) -> Self { + self.vertex_data = vertex_data; + self + } + pub fn vertex_stride(mut self, vertex_stride: crate::vk::DeviceSize) -> Self { + self.vertex_stride = vertex_stride; + self + } + pub fn radius_format(mut self, radius_format: crate::vk::Format) -> Self { + self.radius_format = radius_format; + self + } + pub fn radius_data( + mut self, + radius_data: crate::vk::DeviceOrHostAddressConstKHR, + ) -> Self { + self.radius_data = radius_data; + self + } + pub fn radius_stride(mut self, radius_stride: crate::vk::DeviceSize) -> Self { + self.radius_stride = radius_stride; + self + } + pub fn index_type(mut self, index_type: crate::vk::IndexType) -> Self { + self.index_type = index_type; + self + } + pub fn index_data( + mut self, + index_data: crate::vk::DeviceOrHostAddressConstKHR, + ) -> Self { + self.index_data = index_data; + self + } + pub fn index_stride(mut self, index_stride: crate::vk::DeviceSize) -> Self { + self.index_stride = index_stride; + self + } + pub fn indexing_mode( + mut self, + indexing_mode: crate::vk::RayTracingLssIndexingModeNV, + ) -> Self { + self.indexing_mode = indexing_mode; + self + } + pub fn end_caps_mode( + mut self, + end_caps_mode: crate::vk::RayTracingLssPrimitiveEndCapsModeNV, + ) -> Self { + self.end_caps_mode = end_caps_mode; + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct AccelerationStructureGeometrySpheresDataNV<'a> { @@ -35,6 +122,77 @@ pub struct AccelerationStructureGeometrySpheresDataNV<'a> { pub index_stride: crate::vk::DeviceSize, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for AccelerationStructureGeometrySpheresDataNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::ACCELERATION_STRUCTURE_GEOMETRY_SPHERES_DATA_NV; +} +unsafe impl<'a> crate::Extends> +for AccelerationStructureGeometrySpheresDataNV<'a> {} +impl<'a> Default for AccelerationStructureGeometrySpheresDataNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + vertex_format: Default::default(), + vertex_data: Default::default(), + vertex_stride: Default::default(), + radius_format: Default::default(), + radius_data: Default::default(), + radius_stride: Default::default(), + index_type: Default::default(), + index_data: Default::default(), + index_stride: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> AccelerationStructureGeometrySpheresDataNV<'a> { + pub fn vertex_format(mut self, vertex_format: crate::vk::Format) -> Self { + self.vertex_format = vertex_format; + self + } + pub fn vertex_data( + mut self, + vertex_data: crate::vk::DeviceOrHostAddressConstKHR, + ) -> Self { + self.vertex_data = vertex_data; + self + } + pub fn vertex_stride(mut self, vertex_stride: crate::vk::DeviceSize) -> Self { + self.vertex_stride = vertex_stride; + self + } + pub fn radius_format(mut self, radius_format: crate::vk::Format) -> Self { + self.radius_format = radius_format; + self + } + pub fn radius_data( + mut self, + radius_data: crate::vk::DeviceOrHostAddressConstKHR, + ) -> Self { + self.radius_data = radius_data; + self + } + pub fn radius_stride(mut self, radius_stride: crate::vk::DeviceSize) -> Self { + self.radius_stride = radius_stride; + self + } + pub fn index_type(mut self, index_type: crate::vk::IndexType) -> Self { + self.index_type = index_type; + self + } + pub fn index_data( + mut self, + index_data: crate::vk::DeviceOrHostAddressConstKHR, + ) -> Self { + self.index_data = index_data; + self + } + pub fn index_stride(mut self, index_stride: crate::vk::DeviceSize) -> Self { + self.index_stride = index_stride; + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV<'a> { @@ -44,6 +202,35 @@ pub struct PhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV<'a> { pub linear_swept_spheres: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_RAY_TRACING_LINEAR_SWEPT_SPHERES_FEATURES_NV; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV<'a> {} +impl<'a> Default for PhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + spheres: Default::default(), + linear_swept_spheres: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV<'a> { + pub fn spheres(mut self, spheres: bool) -> Self { + self.spheres = spheres.into(); + self + } + pub fn linear_swept_spheres(mut self, linear_swept_spheres: bool) -> Self { + self.linear_swept_spheres = linear_swept_spheres.into(); + self + } +} ///Provided by [`nv::ray_tracing_linear_swept_spheres`](crate::nv::ray_tracing_linear_swept_spheres) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_RAY_TRACING_LINEAR_SWEPT_SPHERES_FEATURES_NV: Self = Self( diff --git a/ash-rewrite/src/generated/nv/ray_tracing_motion_blur.rs b/ash-rewrite/src/generated/nv/ray_tracing_motion_blur.rs index b2eedc5c3..2ae44b48a 100644 --- a/ash-rewrite/src/generated/nv/ray_tracing_motion_blur.rs +++ b/ash-rewrite/src/generated/nv/ray_tracing_motion_blur.rs @@ -10,6 +10,39 @@ pub struct PhysicalDeviceRayTracingMotionBlurFeaturesNV<'a> { pub ray_tracing_motion_blur_pipeline_trace_rays_indirect: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceRayTracingMotionBlurFeaturesNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceRayTracingMotionBlurFeaturesNV<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceRayTracingMotionBlurFeaturesNV<'a> {} +impl<'a> Default for PhysicalDeviceRayTracingMotionBlurFeaturesNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + ray_tracing_motion_blur: Default::default(), + ray_tracing_motion_blur_pipeline_trace_rays_indirect: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceRayTracingMotionBlurFeaturesNV<'a> { + pub fn ray_tracing_motion_blur(mut self, ray_tracing_motion_blur: bool) -> Self { + self.ray_tracing_motion_blur = ray_tracing_motion_blur.into(); + self + } + pub fn ray_tracing_motion_blur_pipeline_trace_rays_indirect( + mut self, + ray_tracing_motion_blur_pipeline_trace_rays_indirect: bool, + ) -> Self { + self.ray_tracing_motion_blur_pipeline_trace_rays_indirect = ray_tracing_motion_blur_pipeline_trace_rays_indirect + .into(); + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct AccelerationStructureGeometryMotionTrianglesDataNV<'a> { @@ -18,6 +51,33 @@ pub struct AccelerationStructureGeometryMotionTrianglesDataNV<'a> { pub vertex_data: crate::vk::DeviceOrHostAddressConstKHR, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for AccelerationStructureGeometryMotionTrianglesDataNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV; +} +unsafe impl< + 'a, +> crate::Extends> +for AccelerationStructureGeometryMotionTrianglesDataNV<'a> {} +impl<'a> Default for AccelerationStructureGeometryMotionTrianglesDataNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + vertex_data: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> AccelerationStructureGeometryMotionTrianglesDataNV<'a> { + pub fn vertex_data( + mut self, + vertex_data: crate::vk::DeviceOrHostAddressConstKHR, + ) -> Self { + self.vertex_data = vertex_data; + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct AccelerationStructureMotionInfoNV<'a> { @@ -27,8 +87,37 @@ pub struct AccelerationStructureMotionInfoNV<'a> { pub flags: crate::vk::AccelerationStructureMotionInfoFlagsNV, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> for AccelerationStructureMotionInfoNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::ACCELERATION_STRUCTURE_MOTION_INFO_NV; +} +unsafe impl<'a> crate::Extends> +for AccelerationStructureMotionInfoNV<'a> {} +impl<'a> Default for AccelerationStructureMotionInfoNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + max_instances: Default::default(), + flags: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> AccelerationStructureMotionInfoNV<'a> { + pub fn max_instances(mut self, max_instances: u32) -> Self { + self.max_instances = max_instances; + self + } + pub fn flags( + mut self, + flags: crate::vk::AccelerationStructureMotionInfoFlagsNV, + ) -> Self { + self.flags = flags; + self + } +} #[repr(C)] -#[derive(Clone, Copy)] +#[derive(Clone, Copy, Default)] pub struct SRTDataNV { pub sx: core::ffi::c_float, pub a: core::ffi::c_float, @@ -47,8 +136,74 @@ pub struct SRTDataNV { pub ty: core::ffi::c_float, pub tz: core::ffi::c_float, } +impl SRTDataNV { + pub fn sx(mut self, sx: core::ffi::c_float) -> Self { + self.sx = sx; + self + } + pub fn a(mut self, a: core::ffi::c_float) -> Self { + self.a = a; + self + } + pub fn b(mut self, b: core::ffi::c_float) -> Self { + self.b = b; + self + } + pub fn pvx(mut self, pvx: core::ffi::c_float) -> Self { + self.pvx = pvx; + self + } + pub fn sy(mut self, sy: core::ffi::c_float) -> Self { + self.sy = sy; + self + } + pub fn c(mut self, c: core::ffi::c_float) -> Self { + self.c = c; + self + } + pub fn pvy(mut self, pvy: core::ffi::c_float) -> Self { + self.pvy = pvy; + self + } + pub fn sz(mut self, sz: core::ffi::c_float) -> Self { + self.sz = sz; + self + } + pub fn pvz(mut self, pvz: core::ffi::c_float) -> Self { + self.pvz = pvz; + self + } + pub fn qx(mut self, qx: core::ffi::c_float) -> Self { + self.qx = qx; + self + } + pub fn qy(mut self, qy: core::ffi::c_float) -> Self { + self.qy = qy; + self + } + pub fn qz(mut self, qz: core::ffi::c_float) -> Self { + self.qz = qz; + self + } + pub fn qw(mut self, qw: core::ffi::c_float) -> Self { + self.qw = qw; + self + } + pub fn tx(mut self, tx: core::ffi::c_float) -> Self { + self.tx = tx; + self + } + pub fn ty(mut self, ty: core::ffi::c_float) -> Self { + self.ty = ty; + self + } + pub fn tz(mut self, tz: core::ffi::c_float) -> Self { + self.tz = tz; + self + } +} #[repr(C)] -#[derive(Clone, Copy)] +#[derive(Clone, Copy, Default)] pub struct AccelerationStructureSRTMotionInstanceNV { pub transform_t0: crate::vk::SRTDataNV, pub transform_t1: crate::vk::SRTDataNV, @@ -60,8 +215,49 @@ pub struct AccelerationStructureSRTMotionInstanceNV { pub bitfield1: u32, pub acceleration_structure_reference: u64, } +impl AccelerationStructureSRTMotionInstanceNV { + pub fn transform_t0(mut self, transform_t0: crate::vk::SRTDataNV) -> Self { + self.transform_t0 = transform_t0; + self + } + pub fn transform_t1(mut self, transform_t1: crate::vk::SRTDataNV) -> Self { + self.transform_t1 = transform_t1; + self + } + pub fn instance_custom_index(mut self, instance_custom_index: u32) -> Self { + let rest = self.bitfield0 & 0xFF000000; + self.bitfield0 = (instance_custom_index & 0x00FFFFFF) | rest; + self + } + pub fn mask(mut self, mask: u32) -> Self { + let rest = self.bitfield0 & 0x00FFFFFF; + self.bitfield0 = ((mask << 24u32) & 0xFF000000) | rest; + self + } + pub fn instance_shader_binding_table_record_offset( + mut self, + instance_shader_binding_table_record_offset: u32, + ) -> Self { + let rest = self.bitfield1 & 0xFF000000; + self.bitfield1 = (instance_shader_binding_table_record_offset & 0x00FFFFFF) + | rest; + self + } + pub fn flags(mut self, flags: u32) -> Self { + let rest = self.bitfield1 & 0x00FFFFFF; + self.bitfield1 = ((flags << 24u32) & 0xFF000000) | rest; + self + } + pub fn acceleration_structure_reference( + mut self, + acceleration_structure_reference: u64, + ) -> Self { + self.acceleration_structure_reference = acceleration_structure_reference; + self + } +} #[repr(C)] -#[derive(Clone, Copy)] +#[derive(Clone, Copy, Default)] pub struct AccelerationStructureMatrixMotionInstanceNV { pub transform_t0: crate::vk::TransformMatrixKHR, pub transform_t1: crate::vk::TransformMatrixKHR, @@ -73,13 +269,77 @@ pub struct AccelerationStructureMatrixMotionInstanceNV { pub bitfield1: u32, pub acceleration_structure_reference: u64, } +impl AccelerationStructureMatrixMotionInstanceNV { + pub fn transform_t0(mut self, transform_t0: crate::vk::TransformMatrixKHR) -> Self { + self.transform_t0 = transform_t0; + self + } + pub fn transform_t1(mut self, transform_t1: crate::vk::TransformMatrixKHR) -> Self { + self.transform_t1 = transform_t1; + self + } + pub fn instance_custom_index(mut self, instance_custom_index: u32) -> Self { + let rest = self.bitfield0 & 0xFF000000; + self.bitfield0 = (instance_custom_index & 0x00FFFFFF) | rest; + self + } + pub fn mask(mut self, mask: u32) -> Self { + let rest = self.bitfield0 & 0x00FFFFFF; + self.bitfield0 = ((mask << 24u32) & 0xFF000000) | rest; + self + } + pub fn instance_shader_binding_table_record_offset( + mut self, + instance_shader_binding_table_record_offset: u32, + ) -> Self { + let rest = self.bitfield1 & 0xFF000000; + self.bitfield1 = (instance_shader_binding_table_record_offset & 0x00FFFFFF) + | rest; + self + } + pub fn flags(mut self, flags: u32) -> Self { + let rest = self.bitfield1 & 0x00FFFFFF; + self.bitfield1 = ((flags << 24u32) & 0xFF000000) | rest; + self + } + pub fn acceleration_structure_reference( + mut self, + acceleration_structure_reference: u64, + ) -> Self { + self.acceleration_structure_reference = acceleration_structure_reference; + self + } +} #[repr(C)] -#[derive(Clone, Copy)] +#[derive(Clone, Copy, Default)] pub struct AccelerationStructureMotionInstanceNV { pub _type: crate::vk::AccelerationStructureMotionInstanceTypeNV, pub flags: crate::vk::AccelerationStructureMotionInstanceFlagsNV, pub data: crate::vk::AccelerationStructureMotionInstanceDataNV, } +impl AccelerationStructureMotionInstanceNV { + pub fn _type( + mut self, + _type: crate::vk::AccelerationStructureMotionInstanceTypeNV, + ) -> Self { + self._type = _type; + self + } + pub fn flags( + mut self, + flags: crate::vk::AccelerationStructureMotionInstanceFlagsNV, + ) -> Self { + self.flags = flags; + self + } + pub fn data( + mut self, + data: crate::vk::AccelerationStructureMotionInstanceDataNV, + ) -> Self { + self.data = data; + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub union AccelerationStructureMotionInstanceDataNV { @@ -87,6 +347,11 @@ pub union AccelerationStructureMotionInstanceDataNV { pub matrix_motion_instance: crate::vk::AccelerationStructureMatrixMotionInstanceNV, pub srt_motion_instance: crate::vk::AccelerationStructureSRTMotionInstanceNV, } +impl Default for AccelerationStructureMotionInstanceDataNV { + fn default() -> Self { + unsafe { core::mem::zeroed() } + } +} ///Provided by [`nv::ray_tracing_motion_blur`](crate::nv::ray_tracing_motion_blur) impl crate::vk::StructureType { pub const ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV: Self = Self( diff --git a/ash-rewrite/src/generated/nv/ray_tracing_validation.rs b/ash-rewrite/src/generated/nv/ray_tracing_validation.rs index 4c083aff9..c2b5389da 100644 --- a/ash-rewrite/src/generated/nv/ray_tracing_validation.rs +++ b/ash-rewrite/src/generated/nv/ray_tracing_validation.rs @@ -9,6 +9,30 @@ pub struct PhysicalDeviceRayTracingValidationFeaturesNV<'a> { pub ray_tracing_validation: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceRayTracingValidationFeaturesNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceRayTracingValidationFeaturesNV<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceRayTracingValidationFeaturesNV<'a> {} +impl<'a> Default for PhysicalDeviceRayTracingValidationFeaturesNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + ray_tracing_validation: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceRayTracingValidationFeaturesNV<'a> { + pub fn ray_tracing_validation(mut self, ray_tracing_validation: bool) -> Self { + self.ray_tracing_validation = ray_tracing_validation.into(); + self + } +} ///Provided by [`nv::ray_tracing_validation`](crate::nv::ray_tracing_validation) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV: Self = Self( diff --git a/ash-rewrite/src/generated/nv/representative_fragment_test.rs b/ash-rewrite/src/generated/nv/representative_fragment_test.rs index 2f46be449..140f73189 100644 --- a/ash-rewrite/src/generated/nv/representative_fragment_test.rs +++ b/ash-rewrite/src/generated/nv/representative_fragment_test.rs @@ -9,6 +9,33 @@ pub struct PhysicalDeviceRepresentativeFragmentTestFeaturesNV<'a> { pub representative_fragment_test: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceRepresentativeFragmentTestFeaturesNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceRepresentativeFragmentTestFeaturesNV<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceRepresentativeFragmentTestFeaturesNV<'a> {} +impl<'a> Default for PhysicalDeviceRepresentativeFragmentTestFeaturesNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + representative_fragment_test: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceRepresentativeFragmentTestFeaturesNV<'a> { + pub fn representative_fragment_test( + mut self, + representative_fragment_test: bool, + ) -> Self { + self.representative_fragment_test = representative_fragment_test.into(); + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct PipelineRepresentativeFragmentTestStateCreateInfoNV<'a> { @@ -17,6 +44,32 @@ pub struct PipelineRepresentativeFragmentTestStateCreateInfoNV<'a> { pub representative_fragment_test_enable: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PipelineRepresentativeFragmentTestStateCreateInfoNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV; +} +unsafe impl<'a> crate::Extends> +for PipelineRepresentativeFragmentTestStateCreateInfoNV<'a> {} +impl<'a> Default for PipelineRepresentativeFragmentTestStateCreateInfoNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + representative_fragment_test_enable: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PipelineRepresentativeFragmentTestStateCreateInfoNV<'a> { + pub fn representative_fragment_test_enable( + mut self, + representative_fragment_test_enable: bool, + ) -> Self { + self.representative_fragment_test_enable = representative_fragment_test_enable + .into(); + self + } +} ///Provided by [`nv::representative_fragment_test`](crate::nv::representative_fragment_test) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV: Self = Self( diff --git a/ash-rewrite/src/generated/nv/scissor_exclusive.rs b/ash-rewrite/src/generated/nv/scissor_exclusive.rs index 0f3b5ea1f..7533cee6b 100644 --- a/ash-rewrite/src/generated/nv/scissor_exclusive.rs +++ b/ash-rewrite/src/generated/nv/scissor_exclusive.rs @@ -62,6 +62,30 @@ pub(crate) mod reexport { pub exclusive_scissor: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceExclusiveScissorFeaturesNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceExclusiveScissorFeaturesNV<'a> {} + unsafe impl<'a> crate::Extends> + for PhysicalDeviceExclusiveScissorFeaturesNV<'a> {} + impl<'a> Default for PhysicalDeviceExclusiveScissorFeaturesNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + exclusive_scissor: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceExclusiveScissorFeaturesNV<'a> { + pub fn exclusive_scissor(mut self, exclusive_scissor: bool) -> Self { + self.exclusive_scissor = exclusive_scissor.into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PipelineViewportExclusiveScissorStateCreateInfoNV<'a> { @@ -71,6 +95,37 @@ pub(crate) mod reexport { pub p_exclusive_scissors: *const crate::vk::Rect2D, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PipelineViewportExclusiveScissorStateCreateInfoNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV; + } + unsafe impl<'a> crate::Extends> + for PipelineViewportExclusiveScissorStateCreateInfoNV<'a> {} + impl<'a> Default for PipelineViewportExclusiveScissorStateCreateInfoNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + exclusive_scissor_count: Default::default(), + p_exclusive_scissors: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PipelineViewportExclusiveScissorStateCreateInfoNV<'a> { + pub fn exclusive_scissor_count(mut self, exclusive_scissor_count: u32) -> Self { + self.exclusive_scissor_count = exclusive_scissor_count; + self + } + pub fn p_exclusive_scissors( + mut self, + p_exclusive_scissors: &'a [crate::vk::Rect2D], + ) -> Self { + self.exclusive_scissor_count = p_exclusive_scissors.len() as _; + self.p_exclusive_scissors = p_exclusive_scissors.as_ptr(); + self + } + } ///Provided by [`nv::scissor_exclusive`](crate::nv::scissor_exclusive) impl crate::vk::StructureType { pub const PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV: Self = Self( diff --git a/ash-rewrite/src/generated/nv/shader_atomic_float16_vector.rs b/ash-rewrite/src/generated/nv/shader_atomic_float16_vector.rs index deaedbd09..31f12bb3c 100644 --- a/ash-rewrite/src/generated/nv/shader_atomic_float16_vector.rs +++ b/ash-rewrite/src/generated/nv/shader_atomic_float16_vector.rs @@ -9,6 +9,33 @@ pub struct PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV<'a> { pub shader_float16_vector_atomics: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV<'a> {} +impl<'a> Default for PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + shader_float16_vector_atomics: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV<'a> { + pub fn shader_float16_vector_atomics( + mut self, + shader_float16_vector_atomics: bool, + ) -> Self { + self.shader_float16_vector_atomics = shader_float16_vector_atomics.into(); + self + } +} ///Provided by [`nv::shader_atomic_float16_vector`](crate::nv::shader_atomic_float16_vector) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV: Self = Self( diff --git a/ash-rewrite/src/generated/nv/shader_image_footprint.rs b/ash-rewrite/src/generated/nv/shader_image_footprint.rs index a8fec1d7f..35c2879fa 100644 --- a/ash-rewrite/src/generated/nv/shader_image_footprint.rs +++ b/ash-rewrite/src/generated/nv/shader_image_footprint.rs @@ -9,6 +9,30 @@ pub struct PhysicalDeviceShaderImageFootprintFeaturesNV<'a> { pub image_footprint: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceShaderImageFootprintFeaturesNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceShaderImageFootprintFeaturesNV<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceShaderImageFootprintFeaturesNV<'a> {} +impl<'a> Default for PhysicalDeviceShaderImageFootprintFeaturesNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + image_footprint: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceShaderImageFootprintFeaturesNV<'a> { + pub fn image_footprint(mut self, image_footprint: bool) -> Self { + self.image_footprint = image_footprint.into(); + self + } +} ///Provided by [`nv::shader_image_footprint`](crate::nv::shader_image_footprint) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV: Self = Self( diff --git a/ash-rewrite/src/generated/nv/shader_sm_builtins.rs b/ash-rewrite/src/generated/nv/shader_sm_builtins.rs index 574b347d4..8c190e4c6 100644 --- a/ash-rewrite/src/generated/nv/shader_sm_builtins.rs +++ b/ash-rewrite/src/generated/nv/shader_sm_builtins.rs @@ -10,6 +10,33 @@ pub struct PhysicalDeviceShaderSMBuiltinsPropertiesNV<'a> { pub shader_warps_per_sm: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceShaderSMBuiltinsPropertiesNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceShaderSMBuiltinsPropertiesNV<'a> {} +impl<'a> Default for PhysicalDeviceShaderSMBuiltinsPropertiesNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + shader_sm_count: Default::default(), + shader_warps_per_sm: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceShaderSMBuiltinsPropertiesNV<'a> { + pub fn shader_sm_count(mut self, shader_sm_count: u32) -> Self { + self.shader_sm_count = shader_sm_count; + self + } + pub fn shader_warps_per_sm(mut self, shader_warps_per_sm: u32) -> Self { + self.shader_warps_per_sm = shader_warps_per_sm; + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceShaderSMBuiltinsFeaturesNV<'a> { @@ -18,6 +45,30 @@ pub struct PhysicalDeviceShaderSMBuiltinsFeaturesNV<'a> { pub shader_sm_builtins: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceShaderSMBuiltinsFeaturesNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceShaderSMBuiltinsFeaturesNV<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceShaderSMBuiltinsFeaturesNV<'a> {} +impl<'a> Default for PhysicalDeviceShaderSMBuiltinsFeaturesNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + shader_sm_builtins: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceShaderSMBuiltinsFeaturesNV<'a> { + pub fn shader_sm_builtins(mut self, shader_sm_builtins: bool) -> Self { + self.shader_sm_builtins = shader_sm_builtins.into(); + self + } +} ///Provided by [`nv::shader_sm_builtins`](crate::nv::shader_sm_builtins) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV: Self = Self(1000154000); diff --git a/ash-rewrite/src/generated/nv/shading_rate_image.rs b/ash-rewrite/src/generated/nv/shading_rate_image.rs index f70fa573d..f26aa4fbc 100644 --- a/ash-rewrite/src/generated/nv/shading_rate_image.rs +++ b/ash-rewrite/src/generated/nv/shading_rate_image.rs @@ -71,12 +71,31 @@ impl DeviceFn { } pub(crate) mod reexport { #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct ShadingRatePaletteNV<'a> { pub shading_rate_palette_entry_count: u32, pub p_shading_rate_palette_entries: *const crate::vk::ShadingRatePaletteEntryNV, pub _marker: ::core::marker::PhantomData<&'a ()>, } + impl<'a> ShadingRatePaletteNV<'a> { + pub fn shading_rate_palette_entry_count( + mut self, + shading_rate_palette_entry_count: u32, + ) -> Self { + self.shading_rate_palette_entry_count = shading_rate_palette_entry_count; + self + } + pub fn p_shading_rate_palette_entries( + mut self, + p_shading_rate_palette_entries: &'a [crate::vk::ShadingRatePaletteEntryNV], + ) -> Self { + self.shading_rate_palette_entry_count = p_shading_rate_palette_entries.len() + as _; + self.p_shading_rate_palette_entries = p_shading_rate_palette_entries + .as_ptr(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PipelineViewportShadingRateImageStateCreateInfoNV<'a> { @@ -87,6 +106,45 @@ pub(crate) mod reexport { pub p_shading_rate_palettes: *const crate::vk::ShadingRatePaletteNV<'a>, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PipelineViewportShadingRateImageStateCreateInfoNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV; + } + unsafe impl<'a> crate::Extends> + for PipelineViewportShadingRateImageStateCreateInfoNV<'a> {} + impl<'a> Default for PipelineViewportShadingRateImageStateCreateInfoNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + shading_rate_image_enable: Default::default(), + viewport_count: Default::default(), + p_shading_rate_palettes: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PipelineViewportShadingRateImageStateCreateInfoNV<'a> { + pub fn shading_rate_image_enable( + mut self, + shading_rate_image_enable: bool, + ) -> Self { + self.shading_rate_image_enable = shading_rate_image_enable.into(); + self + } + pub fn viewport_count(mut self, viewport_count: u32) -> Self { + self.viewport_count = viewport_count; + self + } + pub fn p_shading_rate_palettes( + mut self, + p_shading_rate_palettes: &'a [crate::vk::ShadingRatePaletteNV<'a>], + ) -> Self { + self.viewport_count = p_shading_rate_palettes.len() as _; + self.p_shading_rate_palettes = p_shading_rate_palettes.as_ptr(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceShadingRateImageFeaturesNV<'a> { @@ -96,6 +154,39 @@ pub(crate) mod reexport { pub shading_rate_coarse_sample_order: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceShadingRateImageFeaturesNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceShadingRateImageFeaturesNV<'a> {} + unsafe impl<'a> crate::Extends> + for PhysicalDeviceShadingRateImageFeaturesNV<'a> {} + impl<'a> Default for PhysicalDeviceShadingRateImageFeaturesNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + shading_rate_image: Default::default(), + shading_rate_coarse_sample_order: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceShadingRateImageFeaturesNV<'a> { + pub fn shading_rate_image(mut self, shading_rate_image: bool) -> Self { + self.shading_rate_image = shading_rate_image.into(); + self + } + pub fn shading_rate_coarse_sample_order( + mut self, + shading_rate_coarse_sample_order: bool, + ) -> Self { + self.shading_rate_coarse_sample_order = shading_rate_coarse_sample_order + .into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceShadingRateImagePropertiesNV<'a> { @@ -106,15 +197,70 @@ pub(crate) mod reexport { pub shading_rate_max_coarse_samples: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceShadingRateImagePropertiesNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceShadingRateImagePropertiesNV<'a> {} + impl<'a> Default for PhysicalDeviceShadingRateImagePropertiesNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + shading_rate_texel_size: Default::default(), + shading_rate_palette_size: Default::default(), + shading_rate_max_coarse_samples: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceShadingRateImagePropertiesNV<'a> { + pub fn shading_rate_texel_size( + mut self, + shading_rate_texel_size: crate::vk::Extent2D, + ) -> Self { + self.shading_rate_texel_size = shading_rate_texel_size; + self + } + pub fn shading_rate_palette_size( + mut self, + shading_rate_palette_size: u32, + ) -> Self { + self.shading_rate_palette_size = shading_rate_palette_size; + self + } + pub fn shading_rate_max_coarse_samples( + mut self, + shading_rate_max_coarse_samples: u32, + ) -> Self { + self.shading_rate_max_coarse_samples = shading_rate_max_coarse_samples; + self + } + } #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct CoarseSampleLocationNV { pub pixel_x: u32, pub pixel_y: u32, pub sample: u32, } + impl CoarseSampleLocationNV { + pub fn pixel_x(mut self, pixel_x: u32) -> Self { + self.pixel_x = pixel_x; + self + } + pub fn pixel_y(mut self, pixel_y: u32) -> Self { + self.pixel_y = pixel_y; + self + } + pub fn sample(mut self, sample: u32) -> Self { + self.sample = sample; + self + } + } #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct CoarseSampleOrderCustomNV<'a> { pub shading_rate: crate::vk::ShadingRatePaletteEntryNV, pub sample_count: u32, @@ -122,6 +268,31 @@ pub(crate) mod reexport { pub p_sample_locations: *const crate::vk::CoarseSampleLocationNV, pub _marker: ::core::marker::PhantomData<&'a ()>, } + impl<'a> CoarseSampleOrderCustomNV<'a> { + pub fn shading_rate( + mut self, + shading_rate: crate::vk::ShadingRatePaletteEntryNV, + ) -> Self { + self.shading_rate = shading_rate; + self + } + pub fn sample_count(mut self, sample_count: u32) -> Self { + self.sample_count = sample_count; + self + } + pub fn sample_location_count(mut self, sample_location_count: u32) -> Self { + self.sample_location_count = sample_location_count; + self + } + pub fn p_sample_locations( + mut self, + p_sample_locations: &'a [crate::vk::CoarseSampleLocationNV], + ) -> Self { + self.sample_location_count = p_sample_locations.len() as _; + self.p_sample_locations = p_sample_locations.as_ptr(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PipelineViewportCoarseSampleOrderStateCreateInfoNV<'a> { @@ -132,6 +303,48 @@ pub(crate) mod reexport { pub p_custom_sample_orders: *const crate::vk::CoarseSampleOrderCustomNV<'a>, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PipelineViewportCoarseSampleOrderStateCreateInfoNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV; + } + unsafe impl<'a> crate::Extends> + for PipelineViewportCoarseSampleOrderStateCreateInfoNV<'a> {} + impl<'a> Default for PipelineViewportCoarseSampleOrderStateCreateInfoNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + sample_order_type: Default::default(), + custom_sample_order_count: Default::default(), + p_custom_sample_orders: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PipelineViewportCoarseSampleOrderStateCreateInfoNV<'a> { + pub fn sample_order_type( + mut self, + sample_order_type: crate::vk::CoarseSampleOrderTypeNV, + ) -> Self { + self.sample_order_type = sample_order_type; + self + } + pub fn custom_sample_order_count( + mut self, + custom_sample_order_count: u32, + ) -> Self { + self.custom_sample_order_count = custom_sample_order_count; + self + } + pub fn p_custom_sample_orders( + mut self, + p_custom_sample_orders: &'a [crate::vk::CoarseSampleOrderCustomNV<'a>], + ) -> Self { + self.custom_sample_order_count = p_custom_sample_orders.len() as _; + self.p_custom_sample_orders = p_custom_sample_orders.as_ptr(); + self + } + } ///Provided by [`nv::shading_rate_image`](crate::nv::shading_rate_image) impl crate::vk::ImageLayout { pub const SHADING_RATE_OPTIMAL_NV: Self = Self::FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR; diff --git a/ash-rewrite/src/generated/nv/viewport_swizzle.rs b/ash-rewrite/src/generated/nv/viewport_swizzle.rs index e8af95bbe..42284c4f1 100644 --- a/ash-rewrite/src/generated/nv/viewport_swizzle.rs +++ b/ash-rewrite/src/generated/nv/viewport_swizzle.rs @@ -2,13 +2,31 @@ #![cfg_attr(rustfmt, rustfmt_skip)] //![Vulkan Manual Page](https://docs.vulkan.org/refpages/latest/refpages/source/VK_NV_viewport_swizzle.html) · Extension `VK_NV_viewport_swizzle` #[repr(C)] -#[derive(Clone, Copy)] +#[derive(Clone, Copy, Default)] pub struct ViewportSwizzleNV { pub x: crate::vk::ViewportCoordinateSwizzleNV, pub y: crate::vk::ViewportCoordinateSwizzleNV, pub z: crate::vk::ViewportCoordinateSwizzleNV, pub w: crate::vk::ViewportCoordinateSwizzleNV, } +impl ViewportSwizzleNV { + pub fn x(mut self, x: crate::vk::ViewportCoordinateSwizzleNV) -> Self { + self.x = x; + self + } + pub fn y(mut self, y: crate::vk::ViewportCoordinateSwizzleNV) -> Self { + self.y = y; + self + } + pub fn z(mut self, z: crate::vk::ViewportCoordinateSwizzleNV) -> Self { + self.z = z; + self + } + pub fn w(mut self, w: crate::vk::ViewportCoordinateSwizzleNV) -> Self { + self.w = w; + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct PipelineViewportSwizzleStateCreateInfoNV<'a> { @@ -19,6 +37,45 @@ pub struct PipelineViewportSwizzleStateCreateInfoNV<'a> { pub p_viewport_swizzles: *const crate::vk::ViewportSwizzleNV, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PipelineViewportSwizzleStateCreateInfoNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV; +} +unsafe impl<'a> crate::Extends> +for PipelineViewportSwizzleStateCreateInfoNV<'a> {} +impl<'a> Default for PipelineViewportSwizzleStateCreateInfoNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + flags: Default::default(), + viewport_count: Default::default(), + p_viewport_swizzles: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PipelineViewportSwizzleStateCreateInfoNV<'a> { + pub fn flags( + mut self, + flags: crate::vk::PipelineViewportSwizzleStateCreateFlagsNV, + ) -> Self { + self.flags = flags; + self + } + pub fn viewport_count(mut self, viewport_count: u32) -> Self { + self.viewport_count = viewport_count; + self + } + pub fn p_viewport_swizzles( + mut self, + p_viewport_swizzles: &'a [crate::vk::ViewportSwizzleNV], + ) -> Self { + self.viewport_count = p_viewport_swizzles.len() as _; + self.p_viewport_swizzles = p_viewport_swizzles.as_ptr(); + self + } +} ///Provided by [`nv::viewport_swizzle`](crate::nv::viewport_swizzle) impl crate::vk::StructureType { pub const PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV: Self = Self(1000098000); diff --git a/ash-rewrite/src/generated/nv/win32_keyed_mutex.rs b/ash-rewrite/src/generated/nv/win32_keyed_mutex.rs index a2b40c3a3..45c06a48e 100644 --- a/ash-rewrite/src/generated/nv/win32_keyed_mutex.rs +++ b/ash-rewrite/src/generated/nv/win32_keyed_mutex.rs @@ -15,6 +15,73 @@ pub struct Win32KeyedMutexAcquireReleaseInfoNV<'a> { pub p_release_keys: *const u64, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> for Win32KeyedMutexAcquireReleaseInfoNV<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV; +} +unsafe impl<'a> crate::Extends> +for Win32KeyedMutexAcquireReleaseInfoNV<'a> {} +unsafe impl<'a> crate::Extends> +for Win32KeyedMutexAcquireReleaseInfoNV<'a> {} +impl<'a> Default for Win32KeyedMutexAcquireReleaseInfoNV<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + acquire_count: Default::default(), + p_acquire_syncs: Default::default(), + p_acquire_keys: Default::default(), + p_acquire_timeout_milliseconds: Default::default(), + release_count: Default::default(), + p_release_syncs: Default::default(), + p_release_keys: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> Win32KeyedMutexAcquireReleaseInfoNV<'a> { + pub fn acquire_count(mut self, acquire_count: u32) -> Self { + self.acquire_count = acquire_count; + self + } + pub fn p_acquire_syncs( + mut self, + p_acquire_syncs: &'a [crate::vk::DeviceMemory], + ) -> Self { + self.acquire_count = p_acquire_syncs.len() as _; + self.p_acquire_syncs = p_acquire_syncs.as_ptr(); + self + } + pub fn p_acquire_keys(mut self, p_acquire_keys: &'a [u64]) -> Self { + self.acquire_count = p_acquire_keys.len() as _; + self.p_acquire_keys = p_acquire_keys.as_ptr(); + self + } + pub fn p_acquire_timeout_milliseconds( + mut self, + p_acquire_timeout_milliseconds: &'a [u32], + ) -> Self { + self.acquire_count = p_acquire_timeout_milliseconds.len() as _; + self.p_acquire_timeout_milliseconds = p_acquire_timeout_milliseconds.as_ptr(); + self + } + pub fn release_count(mut self, release_count: u32) -> Self { + self.release_count = release_count; + self + } + pub fn p_release_syncs( + mut self, + p_release_syncs: &'a [crate::vk::DeviceMemory], + ) -> Self { + self.release_count = p_release_syncs.len() as _; + self.p_release_syncs = p_release_syncs.as_ptr(); + self + } + pub fn p_release_keys(mut self, p_release_keys: &'a [u64]) -> Self { + self.release_count = p_release_keys.len() as _; + self.p_release_keys = p_release_keys.as_ptr(); + self + } +} ///Provided by [`nv::win32_keyed_mutex`](crate::nv::win32_keyed_mutex) impl crate::vk::StructureType { pub const WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV: Self = Self(1000058000); diff --git a/ash-rewrite/src/generated/nvx/binary_import.rs b/ash-rewrite/src/generated/nvx/binary_import.rs index b146b2d23..faa57f152 100644 --- a/ash-rewrite/src/generated/nvx/binary_import.rs +++ b/ash-rewrite/src/generated/nvx/binary_import.rs @@ -110,6 +110,31 @@ pub(crate) mod reexport { pub p_data: *const core::ffi::c_void, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for CuModuleCreateInfoNVX<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::CU_MODULE_CREATE_INFO_NVX; + } + impl<'a> Default for CuModuleCreateInfoNVX<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + data_size: Default::default(), + p_data: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> CuModuleCreateInfoNVX<'a> { + pub fn data_size(mut self, data_size: usize) -> Self { + self.data_size = data_size; + self + } + pub fn p_data(mut self, p_data: &'a [u8]) -> Self { + self.data_size = p_data.len() as _; + self.p_data = p_data.as_ptr().cast(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct CuModuleTexturingModeCreateInfoNVX<'a> { @@ -118,6 +143,28 @@ pub(crate) mod reexport { pub use64bit_texturing: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for CuModuleTexturingModeCreateInfoNVX<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::CU_MODULE_TEXTURING_MODE_CREATE_INFO_NVX; + } + unsafe impl<'a> crate::Extends> + for CuModuleTexturingModeCreateInfoNVX<'a> {} + impl<'a> Default for CuModuleTexturingModeCreateInfoNVX<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + use64bit_texturing: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> CuModuleTexturingModeCreateInfoNVX<'a> { + pub fn use64bit_texturing(mut self, use64bit_texturing: bool) -> Self { + self.use64bit_texturing = use64bit_texturing.into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct CuFunctionCreateInfoNVX<'a> { @@ -127,6 +174,37 @@ pub(crate) mod reexport { pub p_name: *const core::ffi::c_char, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for CuFunctionCreateInfoNVX<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::CU_FUNCTION_CREATE_INFO_NVX; + } + impl<'a> Default for CuFunctionCreateInfoNVX<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + module: Default::default(), + p_name: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> CuFunctionCreateInfoNVX<'a> { + pub fn module(mut self, module: crate::vk::CuModuleNVX) -> Self { + self.module = module; + self + } + pub fn p_name(mut self, p_name: &'a core::ffi::CStr) -> Self { + self.p_name = p_name.as_ptr(); + self + } + pub unsafe fn p_name_as_c_str(&self) -> Option<&core::ffi::CStr> { + if self.p_name.is_null() { + None + } else { + Some(unsafe { core::ffi::CStr::from_ptr(self.p_name) }) + } + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct CuLaunchInfoNVX<'a> { @@ -146,6 +224,82 @@ pub(crate) mod reexport { pub p_extras: *const *const core::ffi::c_void, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for CuLaunchInfoNVX<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::CU_LAUNCH_INFO_NVX; + } + impl<'a> Default for CuLaunchInfoNVX<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + function: Default::default(), + grid_dim_x: Default::default(), + grid_dim_y: Default::default(), + grid_dim_z: Default::default(), + block_dim_x: Default::default(), + block_dim_y: Default::default(), + block_dim_z: Default::default(), + shared_mem_bytes: Default::default(), + param_count: Default::default(), + p_params: Default::default(), + extra_count: Default::default(), + p_extras: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> CuLaunchInfoNVX<'a> { + pub fn function(mut self, function: crate::vk::CuFunctionNVX) -> Self { + self.function = function; + self + } + pub fn grid_dim_x(mut self, grid_dim_x: u32) -> Self { + self.grid_dim_x = grid_dim_x; + self + } + pub fn grid_dim_y(mut self, grid_dim_y: u32) -> Self { + self.grid_dim_y = grid_dim_y; + self + } + pub fn grid_dim_z(mut self, grid_dim_z: u32) -> Self { + self.grid_dim_z = grid_dim_z; + self + } + pub fn block_dim_x(mut self, block_dim_x: u32) -> Self { + self.block_dim_x = block_dim_x; + self + } + pub fn block_dim_y(mut self, block_dim_y: u32) -> Self { + self.block_dim_y = block_dim_y; + self + } + pub fn block_dim_z(mut self, block_dim_z: u32) -> Self { + self.block_dim_z = block_dim_z; + self + } + pub fn shared_mem_bytes(mut self, shared_mem_bytes: u32) -> Self { + self.shared_mem_bytes = shared_mem_bytes; + self + } + pub fn param_count(mut self, param_count: usize) -> Self { + self.param_count = param_count; + self + } + pub fn p_params(mut self, p_params: &'a [*const core::ffi::c_void]) -> Self { + self.param_count = p_params.len() as _; + self.p_params = p_params.as_ptr(); + self + } + pub fn extra_count(mut self, extra_count: usize) -> Self { + self.extra_count = extra_count; + self + } + pub fn p_extras(mut self, p_extras: &'a [*const core::ffi::c_void]) -> Self { + self.extra_count = p_extras.len() as _; + self.p_extras = p_extras.as_ptr(); + self + } + } ///Provided by [`nvx::binary_import`](crate::nvx::binary_import) impl crate::vk::StructureType { pub const CU_MODULE_CREATE_INFO_NVX: Self = Self(1000029000); diff --git a/ash-rewrite/src/generated/nvx/image_view_handle.rs b/ash-rewrite/src/generated/nvx/image_view_handle.rs index a2dcce234..a425b55b4 100644 --- a/ash-rewrite/src/generated/nvx/image_view_handle.rs +++ b/ash-rewrite/src/generated/nvx/image_view_handle.rs @@ -92,6 +92,38 @@ pub(crate) mod reexport { pub sampler: crate::vk::Sampler, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for ImageViewHandleInfoNVX<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::IMAGE_VIEW_HANDLE_INFO_NVX; + } + impl<'a> Default for ImageViewHandleInfoNVX<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + image_view: Default::default(), + descriptor_type: Default::default(), + sampler: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> ImageViewHandleInfoNVX<'a> { + pub fn image_view(mut self, image_view: crate::vk::ImageView) -> Self { + self.image_view = image_view; + self + } + pub fn descriptor_type( + mut self, + descriptor_type: crate::vk::DescriptorType, + ) -> Self { + self.descriptor_type = descriptor_type; + self + } + pub fn sampler(mut self, sampler: crate::vk::Sampler) -> Self { + self.sampler = sampler; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct ImageViewAddressPropertiesNVX<'a> { @@ -101,6 +133,33 @@ pub(crate) mod reexport { pub size: crate::vk::DeviceSize, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for ImageViewAddressPropertiesNVX<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::IMAGE_VIEW_ADDRESS_PROPERTIES_NVX; + } + impl<'a> Default for ImageViewAddressPropertiesNVX<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + device_address: Default::default(), + size: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> ImageViewAddressPropertiesNVX<'a> { + pub fn device_address( + mut self, + device_address: crate::vk::DeviceAddress, + ) -> Self { + self.device_address = device_address; + self + } + pub fn size(mut self, size: crate::vk::DeviceSize) -> Self { + self.size = size; + self + } + } ///Provided by [`nvx::image_view_handle`](crate::nvx::image_view_handle) impl crate::vk::StructureType { pub const IMAGE_VIEW_HANDLE_INFO_NVX: Self = Self(1000030000); diff --git a/ash-rewrite/src/generated/nvx/multiview_per_view_attributes.rs b/ash-rewrite/src/generated/nvx/multiview_per_view_attributes.rs index e163f627b..37d56b366 100644 --- a/ash-rewrite/src/generated/nvx/multiview_per_view_attributes.rs +++ b/ash-rewrite/src/generated/nvx/multiview_per_view_attributes.rs @@ -9,6 +9,31 @@ pub struct PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX<'a> { pub per_view_position_all_components: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX<'a> {} +impl<'a> Default for PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + per_view_position_all_components: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX<'a> { + pub fn per_view_position_all_components( + mut self, + per_view_position_all_components: bool, + ) -> Self { + self.per_view_position_all_components = per_view_position_all_components.into(); + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct MultiviewPerViewAttributesInfoNVX<'a> { @@ -18,6 +43,40 @@ pub struct MultiviewPerViewAttributesInfoNVX<'a> { pub per_view_attributes_position_x_only: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> for MultiviewPerViewAttributesInfoNVX<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX; +} +unsafe impl<'a> crate::Extends> +for MultiviewPerViewAttributesInfoNVX<'a> {} +unsafe impl<'a> crate::Extends> +for MultiviewPerViewAttributesInfoNVX<'a> {} +unsafe impl<'a> crate::Extends> +for MultiviewPerViewAttributesInfoNVX<'a> {} +impl<'a> Default for MultiviewPerViewAttributesInfoNVX<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + per_view_attributes: Default::default(), + per_view_attributes_position_x_only: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> MultiviewPerViewAttributesInfoNVX<'a> { + pub fn per_view_attributes(mut self, per_view_attributes: bool) -> Self { + self.per_view_attributes = per_view_attributes.into(); + self + } + pub fn per_view_attributes_position_x_only( + mut self, + per_view_attributes_position_x_only: bool, + ) -> Self { + self.per_view_attributes_position_x_only = per_view_attributes_position_x_only + .into(); + self + } +} ///Provided by [`nvx::multiview_per_view_attributes`](crate::nvx::multiview_per_view_attributes) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX: Self = Self( diff --git a/ash-rewrite/src/generated/ohos/external_memory.rs b/ash-rewrite/src/generated/ohos/external_memory.rs index 94d68a1f4..9ac03c246 100644 --- a/ash-rewrite/src/generated/ohos/external_memory.rs +++ b/ash-rewrite/src/generated/ohos/external_memory.rs @@ -60,6 +60,30 @@ pub(crate) mod reexport { pub ohos_native_buffer_usage: u64, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for NativeBufferUsageOHOS<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::NATIVE_BUFFER_USAGE_OHOS; + } + unsafe impl<'a> crate::Extends> + for NativeBufferUsageOHOS<'a> {} + impl<'a> Default for NativeBufferUsageOHOS<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + ohos_native_buffer_usage: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> NativeBufferUsageOHOS<'a> { + pub fn ohos_native_buffer_usage( + mut self, + ohos_native_buffer_usage: u64, + ) -> Self { + self.ohos_native_buffer_usage = ohos_native_buffer_usage; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct NativeBufferPropertiesOHOS<'a> { @@ -69,6 +93,33 @@ pub(crate) mod reexport { pub memory_type_bits: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for NativeBufferPropertiesOHOS<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::NATIVE_BUFFER_PROPERTIES_OHOS; + } + impl<'a> Default for NativeBufferPropertiesOHOS<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + allocation_size: Default::default(), + memory_type_bits: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> NativeBufferPropertiesOHOS<'a> { + pub fn allocation_size( + mut self, + allocation_size: crate::vk::DeviceSize, + ) -> Self { + self.allocation_size = allocation_size; + self + } + pub fn memory_type_bits(mut self, memory_type_bits: u32) -> Self { + self.memory_type_bits = memory_type_bits; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct NativeBufferFormatPropertiesOHOS<'a> { @@ -84,6 +135,80 @@ pub(crate) mod reexport { pub suggested_y_chroma_offset: crate::vk::ChromaLocation, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for NativeBufferFormatPropertiesOHOS<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::NATIVE_BUFFER_FORMAT_PROPERTIES_OHOS; + } + unsafe impl<'a> crate::Extends> + for NativeBufferFormatPropertiesOHOS<'a> {} + impl<'a> Default for NativeBufferFormatPropertiesOHOS<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + format: Default::default(), + external_format: Default::default(), + format_features: Default::default(), + sampler_ycbcr_conversion_components: Default::default(), + suggested_ycbcr_model: Default::default(), + suggested_ycbcr_range: Default::default(), + suggested_x_chroma_offset: Default::default(), + suggested_y_chroma_offset: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> NativeBufferFormatPropertiesOHOS<'a> { + pub fn format(mut self, format: crate::vk::Format) -> Self { + self.format = format; + self + } + pub fn external_format(mut self, external_format: u64) -> Self { + self.external_format = external_format; + self + } + pub fn format_features( + mut self, + format_features: crate::vk::FormatFeatureFlags, + ) -> Self { + self.format_features = format_features; + self + } + pub fn sampler_ycbcr_conversion_components( + mut self, + sampler_ycbcr_conversion_components: crate::vk::ComponentMapping, + ) -> Self { + self.sampler_ycbcr_conversion_components = sampler_ycbcr_conversion_components; + self + } + pub fn suggested_ycbcr_model( + mut self, + suggested_ycbcr_model: crate::vk::SamplerYcbcrModelConversion, + ) -> Self { + self.suggested_ycbcr_model = suggested_ycbcr_model; + self + } + pub fn suggested_ycbcr_range( + mut self, + suggested_ycbcr_range: crate::vk::SamplerYcbcrRange, + ) -> Self { + self.suggested_ycbcr_range = suggested_ycbcr_range; + self + } + pub fn suggested_x_chroma_offset( + mut self, + suggested_x_chroma_offset: crate::vk::ChromaLocation, + ) -> Self { + self.suggested_x_chroma_offset = suggested_x_chroma_offset; + self + } + pub fn suggested_y_chroma_offset( + mut self, + suggested_y_chroma_offset: crate::vk::ChromaLocation, + ) -> Self { + self.suggested_y_chroma_offset = suggested_y_chroma_offset; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct ImportNativeBufferInfoOHOS<'a> { @@ -92,6 +217,30 @@ pub(crate) mod reexport { pub buffer: *mut crate::platform_types::OH_NativeBuffer, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for ImportNativeBufferInfoOHOS<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::IMPORT_NATIVE_BUFFER_INFO_OHOS; + } + unsafe impl<'a> crate::Extends> + for ImportNativeBufferInfoOHOS<'a> {} + impl<'a> Default for ImportNativeBufferInfoOHOS<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + buffer: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> ImportNativeBufferInfoOHOS<'a> { + pub fn buffer( + mut self, + buffer: &'a mut crate::platform_types::OH_NativeBuffer, + ) -> Self { + self.buffer = buffer; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct MemoryGetNativeBufferInfoOHOS<'a> { @@ -100,6 +249,25 @@ pub(crate) mod reexport { pub memory: crate::vk::DeviceMemory, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for MemoryGetNativeBufferInfoOHOS<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::MEMORY_GET_NATIVE_BUFFER_INFO_OHOS; + } + impl<'a> Default for MemoryGetNativeBufferInfoOHOS<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + memory: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> MemoryGetNativeBufferInfoOHOS<'a> { + pub fn memory(mut self, memory: crate::vk::DeviceMemory) -> Self { + self.memory = memory; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct ExternalFormatOHOS<'a> { @@ -108,6 +276,35 @@ pub(crate) mod reexport { pub external_format: u64, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for ExternalFormatOHOS<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::EXTERNAL_FORMAT_OHOS; + } + unsafe impl<'a> crate::Extends> + for ExternalFormatOHOS<'a> {} + unsafe impl<'a> crate::Extends> + for ExternalFormatOHOS<'a> {} + unsafe impl<'a> crate::Extends> + for ExternalFormatOHOS<'a> {} + unsafe impl<'a> crate::Extends> + for ExternalFormatOHOS<'a> {} + unsafe impl<'a> crate::Extends> + for ExternalFormatOHOS<'a> {} + impl<'a> Default for ExternalFormatOHOS<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + external_format: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> ExternalFormatOHOS<'a> { + pub fn external_format(mut self, external_format: u64) -> Self { + self.external_format = external_format; + self + } + } ///Provided by [`ohos::external_memory`](crate::ohos::external_memory) impl crate::vk::StructureType { pub const NATIVE_BUFFER_USAGE_OHOS: Self = Self(1000452000); diff --git a/ash-rewrite/src/generated/ohos/surface.rs b/ash-rewrite/src/generated/ohos/surface.rs index 6b125bc07..d394d4204 100644 --- a/ash-rewrite/src/generated/ohos/surface.rs +++ b/ash-rewrite/src/generated/ohos/surface.rs @@ -46,6 +46,33 @@ pub(crate) mod reexport { pub window: *mut crate::platform_types::OHNativeWindow, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for SurfaceCreateInfoOHOS<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::SURFACE_CREATE_INFO_OHOS; + } + impl<'a> Default for SurfaceCreateInfoOHOS<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + flags: Default::default(), + window: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> SurfaceCreateInfoOHOS<'a> { + pub fn flags(mut self, flags: crate::vk::SurfaceCreateFlagsOHOS) -> Self { + self.flags = flags; + self + } + pub fn window( + mut self, + window: &'a mut crate::platform_types::OHNativeWindow, + ) -> Self { + self.window = window; + self + } + } ///Provided by [`ohos::surface`](crate::ohos::surface) impl crate::vk::StructureType { pub const SURFACE_CREATE_INFO_OHOS: Self = Self(1000685000); diff --git a/ash-rewrite/src/generated/qcom/cooperative_matrix_conversion.rs b/ash-rewrite/src/generated/qcom/cooperative_matrix_conversion.rs index 2e3b4cda4..fcc284c7b 100644 --- a/ash-rewrite/src/generated/qcom/cooperative_matrix_conversion.rs +++ b/ash-rewrite/src/generated/qcom/cooperative_matrix_conversion.rs @@ -9,6 +9,33 @@ pub struct PhysicalDeviceCooperativeMatrixConversionFeaturesQCOM<'a> { pub cooperative_matrix_conversion: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceCooperativeMatrixConversionFeaturesQCOM<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_COOPERATIVE_MATRIX_CONVERSION_FEATURES_QCOM; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceCooperativeMatrixConversionFeaturesQCOM<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceCooperativeMatrixConversionFeaturesQCOM<'a> {} +impl<'a> Default for PhysicalDeviceCooperativeMatrixConversionFeaturesQCOM<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + cooperative_matrix_conversion: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceCooperativeMatrixConversionFeaturesQCOM<'a> { + pub fn cooperative_matrix_conversion( + mut self, + cooperative_matrix_conversion: bool, + ) -> Self { + self.cooperative_matrix_conversion = cooperative_matrix_conversion.into(); + self + } +} ///Provided by [`qcom::cooperative_matrix_conversion`](crate::qcom::cooperative_matrix_conversion) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_COOPERATIVE_MATRIX_CONVERSION_FEATURES_QCOM: Self = Self( diff --git a/ash-rewrite/src/generated/qcom/data_graph_model.rs b/ash-rewrite/src/generated/qcom/data_graph_model.rs index 0ded02ab6..29576a3cc 100644 --- a/ash-rewrite/src/generated/qcom/data_graph_model.rs +++ b/ash-rewrite/src/generated/qcom/data_graph_model.rs @@ -11,6 +11,49 @@ pub struct PipelineCacheHeaderVersionDataGraphQCOM { pub toolchain_version: [u32; crate::vk::DATA_GRAPH_MODEL_TOOLCHAIN_VERSION_LENGTH_QCOM as _], } +impl Default for PipelineCacheHeaderVersionDataGraphQCOM { + fn default() -> Self { + Self { + header_size: Default::default(), + header_version: Default::default(), + cache_type: Default::default(), + cache_version: Default::default(), + toolchain_version: unsafe { core::mem::zeroed() }, + } + } +} +impl PipelineCacheHeaderVersionDataGraphQCOM { + pub fn header_size(mut self, header_size: u32) -> Self { + self.header_size = header_size; + self + } + pub fn header_version( + mut self, + header_version: crate::vk::PipelineCacheHeaderVersion, + ) -> Self { + self.header_version = header_version; + self + } + pub fn cache_type( + mut self, + cache_type: crate::vk::DataGraphModelCacheTypeQCOM, + ) -> Self { + self.cache_type = cache_type; + self + } + pub fn cache_version(mut self, cache_version: u32) -> Self { + self.cache_version = cache_version; + self + } + pub fn toolchain_version( + mut self, + toolchain_version: [u32; crate::vk::DATA_GRAPH_MODEL_TOOLCHAIN_VERSION_LENGTH_QCOM + as _], + ) -> Self { + self.toolchain_version = toolchain_version; + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct DataGraphPipelineBuiltinModelCreateInfoQCOM<'a> { @@ -19,6 +62,31 @@ pub struct DataGraphPipelineBuiltinModelCreateInfoQCOM<'a> { pub p_operation: *const crate::vk::PhysicalDeviceDataGraphOperationSupportARM, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for DataGraphPipelineBuiltinModelCreateInfoQCOM<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::DATA_GRAPH_PIPELINE_BUILTIN_MODEL_CREATE_INFO_QCOM; +} +unsafe impl<'a> crate::Extends> +for DataGraphPipelineBuiltinModelCreateInfoQCOM<'a> {} +impl<'a> Default for DataGraphPipelineBuiltinModelCreateInfoQCOM<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + p_operation: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> DataGraphPipelineBuiltinModelCreateInfoQCOM<'a> { + pub fn p_operation( + mut self, + p_operation: &'a crate::vk::PhysicalDeviceDataGraphOperationSupportARM, + ) -> Self { + self.p_operation = p_operation; + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceDataGraphModelFeaturesQCOM<'a> { @@ -27,6 +95,30 @@ pub struct PhysicalDeviceDataGraphModelFeaturesQCOM<'a> { pub data_graph_model: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceDataGraphModelFeaturesQCOM<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_DATA_GRAPH_MODEL_FEATURES_QCOM; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceDataGraphModelFeaturesQCOM<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceDataGraphModelFeaturesQCOM<'a> {} +impl<'a> Default for PhysicalDeviceDataGraphModelFeaturesQCOM<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + data_graph_model: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceDataGraphModelFeaturesQCOM<'a> { + pub fn data_graph_model(mut self, data_graph_model: bool) -> Self { + self.data_graph_model = data_graph_model.into(); + self + } +} ///Provided by [`qcom::data_graph_model`](crate::qcom::data_graph_model) impl crate::vk::PipelineCacheHeaderVersion { pub const DATA_GRAPH_QCOM: Self = Self(1000629000); diff --git a/ash-rewrite/src/generated/qcom/filter_cubic_clamp.rs b/ash-rewrite/src/generated/qcom/filter_cubic_clamp.rs index 791406233..40ccdbfd5 100644 --- a/ash-rewrite/src/generated/qcom/filter_cubic_clamp.rs +++ b/ash-rewrite/src/generated/qcom/filter_cubic_clamp.rs @@ -9,6 +9,29 @@ pub struct PhysicalDeviceCubicClampFeaturesQCOM<'a> { pub cubic_range_clamp: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> for PhysicalDeviceCubicClampFeaturesQCOM<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_CUBIC_CLAMP_FEATURES_QCOM; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceCubicClampFeaturesQCOM<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceCubicClampFeaturesQCOM<'a> {} +impl<'a> Default for PhysicalDeviceCubicClampFeaturesQCOM<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + cubic_range_clamp: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceCubicClampFeaturesQCOM<'a> { + pub fn cubic_range_clamp(mut self, cubic_range_clamp: bool) -> Self { + self.cubic_range_clamp = cubic_range_clamp.into(); + self + } +} ///Provided by [`qcom::filter_cubic_clamp`](crate::qcom::filter_cubic_clamp) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_CUBIC_CLAMP_FEATURES_QCOM: Self = Self(1000521000); diff --git a/ash-rewrite/src/generated/qcom/filter_cubic_weights.rs b/ash-rewrite/src/generated/qcom/filter_cubic_weights.rs index 86a3e5643..12417cf15 100644 --- a/ash-rewrite/src/generated/qcom/filter_cubic_weights.rs +++ b/ash-rewrite/src/generated/qcom/filter_cubic_weights.rs @@ -9,6 +9,30 @@ pub struct PhysicalDeviceCubicWeightsFeaturesQCOM<'a> { pub selectable_cubic_weights: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceCubicWeightsFeaturesQCOM<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_CUBIC_WEIGHTS_FEATURES_QCOM; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceCubicWeightsFeaturesQCOM<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceCubicWeightsFeaturesQCOM<'a> {} +impl<'a> Default for PhysicalDeviceCubicWeightsFeaturesQCOM<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + selectable_cubic_weights: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceCubicWeightsFeaturesQCOM<'a> { + pub fn selectable_cubic_weights(mut self, selectable_cubic_weights: bool) -> Self { + self.selectable_cubic_weights = selectable_cubic_weights.into(); + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct SamplerCubicWeightsCreateInfoQCOM<'a> { @@ -17,6 +41,30 @@ pub struct SamplerCubicWeightsCreateInfoQCOM<'a> { pub cubic_weights: crate::vk::CubicFilterWeightsQCOM, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> for SamplerCubicWeightsCreateInfoQCOM<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::SAMPLER_CUBIC_WEIGHTS_CREATE_INFO_QCOM; +} +unsafe impl<'a> crate::Extends> +for SamplerCubicWeightsCreateInfoQCOM<'a> {} +impl<'a> Default for SamplerCubicWeightsCreateInfoQCOM<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + cubic_weights: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> SamplerCubicWeightsCreateInfoQCOM<'a> { + pub fn cubic_weights( + mut self, + cubic_weights: crate::vk::CubicFilterWeightsQCOM, + ) -> Self { + self.cubic_weights = cubic_weights; + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct BlitImageCubicWeightsInfoQCOM<'a> { @@ -25,6 +73,30 @@ pub struct BlitImageCubicWeightsInfoQCOM<'a> { pub cubic_weights: crate::vk::CubicFilterWeightsQCOM, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> for BlitImageCubicWeightsInfoQCOM<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::BLIT_IMAGE_CUBIC_WEIGHTS_INFO_QCOM; +} +unsafe impl<'a> crate::Extends> +for BlitImageCubicWeightsInfoQCOM<'a> {} +impl<'a> Default for BlitImageCubicWeightsInfoQCOM<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + cubic_weights: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> BlitImageCubicWeightsInfoQCOM<'a> { + pub fn cubic_weights( + mut self, + cubic_weights: crate::vk::CubicFilterWeightsQCOM, + ) -> Self { + self.cubic_weights = cubic_weights; + self + } +} ///Provided by [`qcom::filter_cubic_weights`](crate::qcom::filter_cubic_weights) impl crate::vk::StructureType { pub const SAMPLER_CUBIC_WEIGHTS_CREATE_INFO_QCOM: Self = Self(1000519000); diff --git a/ash-rewrite/src/generated/qcom/image_processing.rs b/ash-rewrite/src/generated/qcom/image_processing.rs index 8932c38a9..4702ddb23 100644 --- a/ash-rewrite/src/generated/qcom/image_processing.rs +++ b/ash-rewrite/src/generated/qcom/image_processing.rs @@ -11,6 +11,37 @@ pub struct ImageViewSampleWeightCreateInfoQCOM<'a> { pub num_phases: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> for ImageViewSampleWeightCreateInfoQCOM<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM; +} +unsafe impl<'a> crate::Extends> +for ImageViewSampleWeightCreateInfoQCOM<'a> {} +impl<'a> Default for ImageViewSampleWeightCreateInfoQCOM<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + filter_center: Default::default(), + filter_size: Default::default(), + num_phases: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> ImageViewSampleWeightCreateInfoQCOM<'a> { + pub fn filter_center(mut self, filter_center: crate::vk::Offset2D) -> Self { + self.filter_center = filter_center; + self + } + pub fn filter_size(mut self, filter_size: crate::vk::Extent2D) -> Self { + self.filter_size = filter_size; + self + } + pub fn num_phases(mut self, num_phases: u32) -> Self { + self.num_phases = num_phases; + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceImageProcessingFeaturesQCOM<'a> { @@ -21,6 +52,40 @@ pub struct PhysicalDeviceImageProcessingFeaturesQCOM<'a> { pub texture_block_match: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceImageProcessingFeaturesQCOM<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceImageProcessingFeaturesQCOM<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceImageProcessingFeaturesQCOM<'a> {} +impl<'a> Default for PhysicalDeviceImageProcessingFeaturesQCOM<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + texture_sample_weighted: Default::default(), + texture_box_filter: Default::default(), + texture_block_match: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceImageProcessingFeaturesQCOM<'a> { + pub fn texture_sample_weighted(mut self, texture_sample_weighted: bool) -> Self { + self.texture_sample_weighted = texture_sample_weighted.into(); + self + } + pub fn texture_box_filter(mut self, texture_box_filter: bool) -> Self { + self.texture_box_filter = texture_box_filter.into(); + self + } + pub fn texture_block_match(mut self, texture_block_match: bool) -> Self { + self.texture_block_match = texture_block_match.into(); + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceImageProcessingPropertiesQCOM<'a> { @@ -32,6 +97,52 @@ pub struct PhysicalDeviceImageProcessingPropertiesQCOM<'a> { pub max_box_filter_block_size: crate::vk::Extent2D, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceImageProcessingPropertiesQCOM<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceImageProcessingPropertiesQCOM<'a> {} +impl<'a> Default for PhysicalDeviceImageProcessingPropertiesQCOM<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + max_weight_filter_phases: Default::default(), + max_weight_filter_dimension: Default::default(), + max_block_match_region: Default::default(), + max_box_filter_block_size: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceImageProcessingPropertiesQCOM<'a> { + pub fn max_weight_filter_phases(mut self, max_weight_filter_phases: u32) -> Self { + self.max_weight_filter_phases = max_weight_filter_phases; + self + } + pub fn max_weight_filter_dimension( + mut self, + max_weight_filter_dimension: crate::vk::Extent2D, + ) -> Self { + self.max_weight_filter_dimension = max_weight_filter_dimension; + self + } + pub fn max_block_match_region( + mut self, + max_block_match_region: crate::vk::Extent2D, + ) -> Self { + self.max_block_match_region = max_block_match_region; + self + } + pub fn max_box_filter_block_size( + mut self, + max_box_filter_block_size: crate::vk::Extent2D, + ) -> Self { + self.max_box_filter_block_size = max_box_filter_block_size; + self + } +} ///Provided by [`qcom::image_processing`](crate::qcom::image_processing) impl crate::vk::DescriptorType { pub const SAMPLE_WEIGHT_IMAGE_QCOM: Self = Self(1000440000); diff --git a/ash-rewrite/src/generated/qcom/image_processing2.rs b/ash-rewrite/src/generated/qcom/image_processing2.rs index cba338b4e..ddad7846e 100644 --- a/ash-rewrite/src/generated/qcom/image_processing2.rs +++ b/ash-rewrite/src/generated/qcom/image_processing2.rs @@ -9,6 +9,30 @@ pub struct PhysicalDeviceImageProcessing2FeaturesQCOM<'a> { pub texture_block_match2: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceImageProcessing2FeaturesQCOM<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_IMAGE_PROCESSING_2_FEATURES_QCOM; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceImageProcessing2FeaturesQCOM<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceImageProcessing2FeaturesQCOM<'a> {} +impl<'a> Default for PhysicalDeviceImageProcessing2FeaturesQCOM<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + texture_block_match2: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceImageProcessing2FeaturesQCOM<'a> { + pub fn texture_block_match2(mut self, texture_block_match2: bool) -> Self { + self.texture_block_match2 = texture_block_match2.into(); + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceImageProcessing2PropertiesQCOM<'a> { @@ -17,6 +41,31 @@ pub struct PhysicalDeviceImageProcessing2PropertiesQCOM<'a> { pub max_block_match_window: crate::vk::Extent2D, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceImageProcessing2PropertiesQCOM<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_IMAGE_PROCESSING_2_PROPERTIES_QCOM; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceImageProcessing2PropertiesQCOM<'a> {} +impl<'a> Default for PhysicalDeviceImageProcessing2PropertiesQCOM<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + max_block_match_window: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceImageProcessing2PropertiesQCOM<'a> { + pub fn max_block_match_window( + mut self, + max_block_match_window: crate::vk::Extent2D, + ) -> Self { + self.max_block_match_window = max_block_match_window; + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct SamplerBlockMatchWindowCreateInfoQCOM<'a> { @@ -26,6 +75,36 @@ pub struct SamplerBlockMatchWindowCreateInfoQCOM<'a> { pub window_compare_mode: crate::vk::BlockMatchWindowCompareModeQCOM, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for SamplerBlockMatchWindowCreateInfoQCOM<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::SAMPLER_BLOCK_MATCH_WINDOW_CREATE_INFO_QCOM; +} +unsafe impl<'a> crate::Extends> +for SamplerBlockMatchWindowCreateInfoQCOM<'a> {} +impl<'a> Default for SamplerBlockMatchWindowCreateInfoQCOM<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + window_extent: Default::default(), + window_compare_mode: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> SamplerBlockMatchWindowCreateInfoQCOM<'a> { + pub fn window_extent(mut self, window_extent: crate::vk::Extent2D) -> Self { + self.window_extent = window_extent; + self + } + pub fn window_compare_mode( + mut self, + window_compare_mode: crate::vk::BlockMatchWindowCompareModeQCOM, + ) -> Self { + self.window_compare_mode = window_compare_mode; + self + } +} ///Provided by [`qcom::image_processing2`](crate::qcom::image_processing2) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_IMAGE_PROCESSING_2_FEATURES_QCOM: Self = Self(1000518000); diff --git a/ash-rewrite/src/generated/qcom/multiview_per_view_render_areas.rs b/ash-rewrite/src/generated/qcom/multiview_per_view_render_areas.rs index 289669a38..4b40db48a 100644 --- a/ash-rewrite/src/generated/qcom/multiview_per_view_render_areas.rs +++ b/ash-rewrite/src/generated/qcom/multiview_per_view_render_areas.rs @@ -9,6 +9,33 @@ pub struct PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM<'a> { pub multiview_per_view_render_areas: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM<'a> {} +impl<'a> Default for PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + multiview_per_view_render_areas: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM<'a> { + pub fn multiview_per_view_render_areas( + mut self, + multiview_per_view_render_areas: bool, + ) -> Self { + self.multiview_per_view_render_areas = multiview_per_view_render_areas.into(); + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM<'a> { @@ -18,6 +45,42 @@ pub struct MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM<'a> { pub p_per_view_render_areas: *const crate::vk::Rect2D, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM; +} +unsafe impl<'a> crate::Extends> +for MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM<'a> {} +unsafe impl<'a> crate::Extends> +for MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM<'a> {} +impl<'a> Default for MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + per_view_render_area_count: Default::default(), + p_per_view_render_areas: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM<'a> { + pub fn per_view_render_area_count( + mut self, + per_view_render_area_count: u32, + ) -> Self { + self.per_view_render_area_count = per_view_render_area_count; + self + } + pub fn p_per_view_render_areas( + mut self, + p_per_view_render_areas: &'a [crate::vk::Rect2D], + ) -> Self { + self.per_view_render_area_count = p_per_view_render_areas.len() as _; + self.p_per_view_render_areas = p_per_view_render_areas.as_ptr(); + self + } +} ///Provided by [`qcom::multiview_per_view_render_areas`](crate::qcom::multiview_per_view_render_areas) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM: Self = Self( diff --git a/ash-rewrite/src/generated/qcom/multiview_per_view_viewports.rs b/ash-rewrite/src/generated/qcom/multiview_per_view_viewports.rs index 217d05538..e35c4b77c 100644 --- a/ash-rewrite/src/generated/qcom/multiview_per_view_viewports.rs +++ b/ash-rewrite/src/generated/qcom/multiview_per_view_viewports.rs @@ -9,6 +9,33 @@ pub struct PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM<'a> { pub multiview_per_view_viewports: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM<'a> {} +impl<'a> Default for PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + multiview_per_view_viewports: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM<'a> { + pub fn multiview_per_view_viewports( + mut self, + multiview_per_view_viewports: bool, + ) -> Self { + self.multiview_per_view_viewports = multiview_per_view_viewports.into(); + self + } +} ///Provided by [`qcom::multiview_per_view_viewports`](crate::qcom::multiview_per_view_viewports) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM: Self = Self( diff --git a/ash-rewrite/src/generated/qcom/queue_perf_hint.rs b/ash-rewrite/src/generated/qcom/queue_perf_hint.rs index eaa8239da..8725a46b4 100644 --- a/ash-rewrite/src/generated/qcom/queue_perf_hint.rs +++ b/ash-rewrite/src/generated/qcom/queue_perf_hint.rs @@ -44,6 +44,30 @@ pub(crate) mod reexport { pub scale: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for PerfHintInfoQCOM<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PERF_HINT_INFO_QCOM; + } + impl<'a> Default for PerfHintInfoQCOM<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + _type: Default::default(), + scale: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PerfHintInfoQCOM<'a> { + pub fn _type(mut self, _type: crate::vk::PerfHintTypeQCOM) -> Self { + self._type = _type; + self + } + pub fn scale(mut self, scale: u32) -> Self { + self.scale = scale; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceQueuePerfHintFeaturesQCOM<'a> { @@ -52,6 +76,30 @@ pub(crate) mod reexport { pub queue_perf_hint: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceQueuePerfHintFeaturesQCOM<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_QUEUE_PERF_HINT_FEATURES_QCOM; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceQueuePerfHintFeaturesQCOM<'a> {} + unsafe impl<'a> crate::Extends> + for PhysicalDeviceQueuePerfHintFeaturesQCOM<'a> {} + impl<'a> Default for PhysicalDeviceQueuePerfHintFeaturesQCOM<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + queue_perf_hint: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceQueuePerfHintFeaturesQCOM<'a> { + pub fn queue_perf_hint(mut self, queue_perf_hint: bool) -> Self { + self.queue_perf_hint = queue_perf_hint.into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceQueuePerfHintPropertiesQCOM<'a> { @@ -60,6 +108,31 @@ pub(crate) mod reexport { pub supported_queues: crate::vk::QueueFlags, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceQueuePerfHintPropertiesQCOM<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_QUEUE_PERF_HINT_PROPERTIES_QCOM; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceQueuePerfHintPropertiesQCOM<'a> {} + impl<'a> Default for PhysicalDeviceQueuePerfHintPropertiesQCOM<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + supported_queues: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceQueuePerfHintPropertiesQCOM<'a> { + pub fn supported_queues( + mut self, + supported_queues: crate::vk::QueueFlags, + ) -> Self { + self.supported_queues = supported_queues; + self + } + } ///Provided by [`qcom::queue_perf_hint`](crate::qcom::queue_perf_hint) impl crate::vk::StructureType { pub const PERF_HINT_INFO_QCOM: Self = Self(1000302000); diff --git a/ash-rewrite/src/generated/qcom/render_pass_transform.rs b/ash-rewrite/src/generated/qcom/render_pass_transform.rs index e6c779866..71be3eb35 100644 --- a/ash-rewrite/src/generated/qcom/render_pass_transform.rs +++ b/ash-rewrite/src/generated/qcom/render_pass_transform.rs @@ -9,6 +9,30 @@ pub struct RenderPassTransformBeginInfoQCOM<'a> { pub transform: crate::vk::SurfaceTransformFlagBitsKHR, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> for RenderPassTransformBeginInfoQCOM<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM; +} +unsafe impl<'a> crate::Extends> +for RenderPassTransformBeginInfoQCOM<'a> {} +impl<'a> Default for RenderPassTransformBeginInfoQCOM<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + transform: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> RenderPassTransformBeginInfoQCOM<'a> { + pub fn transform( + mut self, + transform: crate::vk::SurfaceTransformFlagBitsKHR, + ) -> Self { + self.transform = transform; + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct CommandBufferInheritanceRenderPassTransformInfoQCOM<'a> { @@ -18,6 +42,36 @@ pub struct CommandBufferInheritanceRenderPassTransformInfoQCOM<'a> { pub render_area: crate::vk::Rect2D, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for CommandBufferInheritanceRenderPassTransformInfoQCOM<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM; +} +unsafe impl<'a> crate::Extends> +for CommandBufferInheritanceRenderPassTransformInfoQCOM<'a> {} +impl<'a> Default for CommandBufferInheritanceRenderPassTransformInfoQCOM<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + transform: Default::default(), + render_area: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> CommandBufferInheritanceRenderPassTransformInfoQCOM<'a> { + pub fn transform( + mut self, + transform: crate::vk::SurfaceTransformFlagBitsKHR, + ) -> Self { + self.transform = transform; + self + } + pub fn render_area(mut self, render_area: crate::vk::Rect2D) -> Self { + self.render_area = render_area; + self + } +} ///Provided by [`qcom::render_pass_transform`](crate::qcom::render_pass_transform) impl crate::vk::StructureType { pub const COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM: Self = Self( diff --git a/ash-rewrite/src/generated/qcom/rotated_copy_commands.rs b/ash-rewrite/src/generated/qcom/rotated_copy_commands.rs index 5ec36e3a6..d5b9d16ad 100644 --- a/ash-rewrite/src/generated/qcom/rotated_copy_commands.rs +++ b/ash-rewrite/src/generated/qcom/rotated_copy_commands.rs @@ -9,6 +9,34 @@ pub struct CopyCommandTransformInfoQCOM<'a> { pub transform: crate::vk::SurfaceTransformFlagBitsKHR, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> for CopyCommandTransformInfoQCOM<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::COPY_COMMAND_TRANSFORM_INFO_QCOM; +} +unsafe impl<'a> crate::Extends> +for CopyCommandTransformInfoQCOM<'a> {} +unsafe impl<'a> crate::Extends> +for CopyCommandTransformInfoQCOM<'a> {} +unsafe impl<'a> crate::Extends> +for CopyCommandTransformInfoQCOM<'a> {} +impl<'a> Default for CopyCommandTransformInfoQCOM<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + transform: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> CopyCommandTransformInfoQCOM<'a> { + pub fn transform( + mut self, + transform: crate::vk::SurfaceTransformFlagBitsKHR, + ) -> Self { + self.transform = transform; + self + } +} ///Provided by [`qcom::rotated_copy_commands`](crate::qcom::rotated_copy_commands) impl crate::vk::StructureType { pub const COPY_COMMAND_TRANSFORM_INFO_QCOM: Self = Self(1000333000); diff --git a/ash-rewrite/src/generated/qcom/tile_memory_heap.rs b/ash-rewrite/src/generated/qcom/tile_memory_heap.rs index ba313b6a5..8bf34a4f6 100644 --- a/ash-rewrite/src/generated/qcom/tile_memory_heap.rs +++ b/ash-rewrite/src/generated/qcom/tile_memory_heap.rs @@ -43,6 +43,27 @@ pub(crate) mod reexport { pub memory: crate::vk::DeviceMemory, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for TileMemoryBindInfoQCOM<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::TILE_MEMORY_BIND_INFO_QCOM; + } + unsafe impl<'a> crate::Extends> + for TileMemoryBindInfoQCOM<'a> {} + impl<'a> Default for TileMemoryBindInfoQCOM<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + memory: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> TileMemoryBindInfoQCOM<'a> { + pub fn memory(mut self, memory: crate::vk::DeviceMemory) -> Self { + self.memory = memory; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceTileMemoryHeapFeaturesQCOM<'a> { @@ -51,6 +72,30 @@ pub(crate) mod reexport { pub tile_memory_heap: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceTileMemoryHeapFeaturesQCOM<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_TILE_MEMORY_HEAP_FEATURES_QCOM; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceTileMemoryHeapFeaturesQCOM<'a> {} + unsafe impl<'a> crate::Extends> + for PhysicalDeviceTileMemoryHeapFeaturesQCOM<'a> {} + impl<'a> Default for PhysicalDeviceTileMemoryHeapFeaturesQCOM<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + tile_memory_heap: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceTileMemoryHeapFeaturesQCOM<'a> { + pub fn tile_memory_heap(mut self, tile_memory_heap: bool) -> Self { + self.tile_memory_heap = tile_memory_heap.into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceTileMemoryHeapPropertiesQCOM<'a> { @@ -60,6 +105,33 @@ pub(crate) mod reexport { pub tile_buffer_transfers: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceTileMemoryHeapPropertiesQCOM<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_TILE_MEMORY_HEAP_PROPERTIES_QCOM; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceTileMemoryHeapPropertiesQCOM<'a> {} + impl<'a> Default for PhysicalDeviceTileMemoryHeapPropertiesQCOM<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + queue_submit_boundary: Default::default(), + tile_buffer_transfers: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceTileMemoryHeapPropertiesQCOM<'a> { + pub fn queue_submit_boundary(mut self, queue_submit_boundary: bool) -> Self { + self.queue_submit_boundary = queue_submit_boundary.into(); + self + } + pub fn tile_buffer_transfers(mut self, tile_buffer_transfers: bool) -> Self { + self.tile_buffer_transfers = tile_buffer_transfers.into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct TileMemorySizeInfoQCOM<'a> { @@ -68,6 +140,31 @@ pub(crate) mod reexport { pub size: crate::vk::DeviceSize, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for TileMemorySizeInfoQCOM<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::TILE_MEMORY_SIZE_INFO_QCOM; + } + unsafe impl<'a> crate::Extends> + for TileMemorySizeInfoQCOM<'a> {} + unsafe impl<'a> crate::Extends> + for TileMemorySizeInfoQCOM<'a> {} + unsafe impl<'a> crate::Extends> + for TileMemorySizeInfoQCOM<'a> {} + impl<'a> Default for TileMemorySizeInfoQCOM<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + size: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> TileMemorySizeInfoQCOM<'a> { + pub fn size(mut self, size: crate::vk::DeviceSize) -> Self { + self.size = size; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct TileMemoryRequirementsQCOM<'a> { @@ -77,6 +174,32 @@ pub(crate) mod reexport { pub alignment: crate::vk::DeviceSize, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for TileMemoryRequirementsQCOM<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::TILE_MEMORY_REQUIREMENTS_QCOM; + } + unsafe impl<'a> crate::Extends> + for TileMemoryRequirementsQCOM<'a> {} + impl<'a> Default for TileMemoryRequirementsQCOM<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + size: Default::default(), + alignment: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> TileMemoryRequirementsQCOM<'a> { + pub fn size(mut self, size: crate::vk::DeviceSize) -> Self { + self.size = size; + self + } + pub fn alignment(mut self, alignment: crate::vk::DeviceSize) -> Self { + self.alignment = alignment; + self + } + } ///Provided by [`qcom::tile_memory_heap`](crate::qcom::tile_memory_heap) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_TILE_MEMORY_HEAP_FEATURES_QCOM: Self = Self( diff --git a/ash-rewrite/src/generated/qcom/tile_properties.rs b/ash-rewrite/src/generated/qcom/tile_properties.rs index 23fecd7aa..b1fc7aca5 100644 --- a/ash-rewrite/src/generated/qcom/tile_properties.rs +++ b/ash-rewrite/src/generated/qcom/tile_properties.rs @@ -61,6 +61,30 @@ pub(crate) mod reexport { pub tile_properties: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceTilePropertiesFeaturesQCOM<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceTilePropertiesFeaturesQCOM<'a> {} + unsafe impl<'a> crate::Extends> + for PhysicalDeviceTilePropertiesFeaturesQCOM<'a> {} + impl<'a> Default for PhysicalDeviceTilePropertiesFeaturesQCOM<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + tile_properties: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceTilePropertiesFeaturesQCOM<'a> { + pub fn tile_properties(mut self, tile_properties: bool) -> Self { + self.tile_properties = tile_properties.into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct TilePropertiesQCOM<'a> { @@ -71,6 +95,35 @@ pub(crate) mod reexport { pub origin: crate::vk::Offset2D, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for TilePropertiesQCOM<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::TILE_PROPERTIES_QCOM; + } + impl<'a> Default for TilePropertiesQCOM<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + tile_size: Default::default(), + apron_size: Default::default(), + origin: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> TilePropertiesQCOM<'a> { + pub fn tile_size(mut self, tile_size: crate::vk::Extent3D) -> Self { + self.tile_size = tile_size; + self + } + pub fn apron_size(mut self, apron_size: crate::vk::Extent2D) -> Self { + self.apron_size = apron_size; + self + } + pub fn origin(mut self, origin: crate::vk::Offset2D) -> Self { + self.origin = origin; + self + } + } ///Provided by [`qcom::tile_properties`](crate::qcom::tile_properties) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM: Self = Self(1000484000); diff --git a/ash-rewrite/src/generated/qcom/tile_shading.rs b/ash-rewrite/src/generated/qcom/tile_shading.rs index e0c05c80c..0d52146ed 100644 --- a/ash-rewrite/src/generated/qcom/tile_shading.rs +++ b/ash-rewrite/src/generated/qcom/tile_shading.rs @@ -86,6 +86,130 @@ pub(crate) mod reexport { pub tile_shading_image_processing: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceTileShadingFeaturesQCOM<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_TILE_SHADING_FEATURES_QCOM; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceTileShadingFeaturesQCOM<'a> {} + unsafe impl<'a> crate::Extends> + for PhysicalDeviceTileShadingFeaturesQCOM<'a> {} + impl<'a> Default for PhysicalDeviceTileShadingFeaturesQCOM<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + tile_shading: Default::default(), + tile_shading_fragment_stage: Default::default(), + tile_shading_color_attachments: Default::default(), + tile_shading_depth_attachments: Default::default(), + tile_shading_stencil_attachments: Default::default(), + tile_shading_input_attachments: Default::default(), + tile_shading_sampled_attachments: Default::default(), + tile_shading_per_tile_draw: Default::default(), + tile_shading_per_tile_dispatch: Default::default(), + tile_shading_dispatch_tile: Default::default(), + tile_shading_apron: Default::default(), + tile_shading_anisotropic_apron: Default::default(), + tile_shading_atomic_ops: Default::default(), + tile_shading_image_processing: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceTileShadingFeaturesQCOM<'a> { + pub fn tile_shading(mut self, tile_shading: bool) -> Self { + self.tile_shading = tile_shading.into(); + self + } + pub fn tile_shading_fragment_stage( + mut self, + tile_shading_fragment_stage: bool, + ) -> Self { + self.tile_shading_fragment_stage = tile_shading_fragment_stage.into(); + self + } + pub fn tile_shading_color_attachments( + mut self, + tile_shading_color_attachments: bool, + ) -> Self { + self.tile_shading_color_attachments = tile_shading_color_attachments.into(); + self + } + pub fn tile_shading_depth_attachments( + mut self, + tile_shading_depth_attachments: bool, + ) -> Self { + self.tile_shading_depth_attachments = tile_shading_depth_attachments.into(); + self + } + pub fn tile_shading_stencil_attachments( + mut self, + tile_shading_stencil_attachments: bool, + ) -> Self { + self.tile_shading_stencil_attachments = tile_shading_stencil_attachments + .into(); + self + } + pub fn tile_shading_input_attachments( + mut self, + tile_shading_input_attachments: bool, + ) -> Self { + self.tile_shading_input_attachments = tile_shading_input_attachments.into(); + self + } + pub fn tile_shading_sampled_attachments( + mut self, + tile_shading_sampled_attachments: bool, + ) -> Self { + self.tile_shading_sampled_attachments = tile_shading_sampled_attachments + .into(); + self + } + pub fn tile_shading_per_tile_draw( + mut self, + tile_shading_per_tile_draw: bool, + ) -> Self { + self.tile_shading_per_tile_draw = tile_shading_per_tile_draw.into(); + self + } + pub fn tile_shading_per_tile_dispatch( + mut self, + tile_shading_per_tile_dispatch: bool, + ) -> Self { + self.tile_shading_per_tile_dispatch = tile_shading_per_tile_dispatch.into(); + self + } + pub fn tile_shading_dispatch_tile( + mut self, + tile_shading_dispatch_tile: bool, + ) -> Self { + self.tile_shading_dispatch_tile = tile_shading_dispatch_tile.into(); + self + } + pub fn tile_shading_apron(mut self, tile_shading_apron: bool) -> Self { + self.tile_shading_apron = tile_shading_apron.into(); + self + } + pub fn tile_shading_anisotropic_apron( + mut self, + tile_shading_anisotropic_apron: bool, + ) -> Self { + self.tile_shading_anisotropic_apron = tile_shading_anisotropic_apron.into(); + self + } + pub fn tile_shading_atomic_ops(mut self, tile_shading_atomic_ops: bool) -> Self { + self.tile_shading_atomic_ops = tile_shading_atomic_ops.into(); + self + } + pub fn tile_shading_image_processing( + mut self, + tile_shading_image_processing: bool, + ) -> Self { + self.tile_shading_image_processing = tile_shading_image_processing.into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceTileShadingPropertiesQCOM<'a> { @@ -97,6 +221,49 @@ pub(crate) mod reexport { pub max_tile_shading_rate: crate::vk::Extent2D, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceTileShadingPropertiesQCOM<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_TILE_SHADING_PROPERTIES_QCOM; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceTileShadingPropertiesQCOM<'a> {} + impl<'a> Default for PhysicalDeviceTileShadingPropertiesQCOM<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + max_apron_size: Default::default(), + prefer_non_coherent: Default::default(), + tile_granularity: Default::default(), + max_tile_shading_rate: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceTileShadingPropertiesQCOM<'a> { + pub fn max_apron_size(mut self, max_apron_size: u32) -> Self { + self.max_apron_size = max_apron_size; + self + } + pub fn prefer_non_coherent(mut self, prefer_non_coherent: bool) -> Self { + self.prefer_non_coherent = prefer_non_coherent.into(); + self + } + pub fn tile_granularity( + mut self, + tile_granularity: crate::vk::Extent2D, + ) -> Self { + self.tile_granularity = tile_granularity; + self + } + pub fn max_tile_shading_rate( + mut self, + max_tile_shading_rate: crate::vk::Extent2D, + ) -> Self { + self.max_tile_shading_rate = max_tile_shading_rate; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct RenderPassTileShadingCreateInfoQCOM<'a> { @@ -106,6 +273,42 @@ pub(crate) mod reexport { pub tile_apron_size: crate::vk::Extent2D, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for RenderPassTileShadingCreateInfoQCOM<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::RENDER_PASS_TILE_SHADING_CREATE_INFO_QCOM; + } + unsafe impl<'a> crate::Extends> + for RenderPassTileShadingCreateInfoQCOM<'a> {} + unsafe impl<'a> crate::Extends> + for RenderPassTileShadingCreateInfoQCOM<'a> {} + unsafe impl<'a> crate::Extends> + for RenderPassTileShadingCreateInfoQCOM<'a> {} + unsafe impl<'a> crate::Extends> + for RenderPassTileShadingCreateInfoQCOM<'a> {} + impl<'a> Default for RenderPassTileShadingCreateInfoQCOM<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + flags: Default::default(), + tile_apron_size: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> RenderPassTileShadingCreateInfoQCOM<'a> { + pub fn flags( + mut self, + flags: crate::vk::TileShadingRenderPassFlagsQCOM, + ) -> Self { + self.flags = flags; + self + } + pub fn tile_apron_size(mut self, tile_apron_size: crate::vk::Extent2D) -> Self { + self.tile_apron_size = tile_apron_size; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PerTileBeginInfoQCOM<'a> { @@ -113,6 +316,19 @@ pub(crate) mod reexport { pub p_next: *const core::ffi::c_void, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for PerTileBeginInfoQCOM<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PER_TILE_BEGIN_INFO_QCOM; + } + impl<'a> Default for PerTileBeginInfoQCOM<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PerTileBeginInfoQCOM<'a> {} #[repr(C)] #[derive(Clone, Copy)] pub struct PerTileEndInfoQCOM<'a> { @@ -120,6 +336,19 @@ pub(crate) mod reexport { pub p_next: *const core::ffi::c_void, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for PerTileEndInfoQCOM<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PER_TILE_END_INFO_QCOM; + } + impl<'a> Default for PerTileEndInfoQCOM<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PerTileEndInfoQCOM<'a> {} #[repr(C)] #[derive(Clone, Copy)] pub struct DispatchTileInfoQCOM<'a> { @@ -127,6 +356,19 @@ pub(crate) mod reexport { pub p_next: *const core::ffi::c_void, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for DispatchTileInfoQCOM<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::DISPATCH_TILE_INFO_QCOM; + } + impl<'a> Default for DispatchTileInfoQCOM<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> DispatchTileInfoQCOM<'a> {} ///Provided by [`qcom::tile_shading`](crate::qcom::tile_shading) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_TILE_SHADING_FEATURES_QCOM: Self = Self(1000309000); @@ -219,7 +461,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct TileShadingRenderPassFlagBitsQCOM(pub(crate) u32); ///Provided by [`qcom::tile_shading`](crate::qcom::tile_shading) impl TileShadingRenderPassFlagBitsQCOM { diff --git a/ash-rewrite/src/generated/qcom/ycbcr_degamma.rs b/ash-rewrite/src/generated/qcom/ycbcr_degamma.rs index d2060c603..7c66eaa4b 100644 --- a/ash-rewrite/src/generated/qcom/ycbcr_degamma.rs +++ b/ash-rewrite/src/generated/qcom/ycbcr_degamma.rs @@ -9,6 +9,30 @@ pub struct PhysicalDeviceYcbcrDegammaFeaturesQCOM<'a> { pub ycbcr_degamma: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceYcbcrDegammaFeaturesQCOM<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_YCBCR_DEGAMMA_FEATURES_QCOM; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceYcbcrDegammaFeaturesQCOM<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceYcbcrDegammaFeaturesQCOM<'a> {} +impl<'a> Default for PhysicalDeviceYcbcrDegammaFeaturesQCOM<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + ycbcr_degamma: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceYcbcrDegammaFeaturesQCOM<'a> { + pub fn ycbcr_degamma(mut self, ycbcr_degamma: bool) -> Self { + self.ycbcr_degamma = ycbcr_degamma.into(); + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM<'a> { @@ -18,6 +42,33 @@ pub struct SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM<'a> { pub enable_cb_cr_degamma: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::SAMPLER_YCBCR_CONVERSION_YCBCR_DEGAMMA_CREATE_INFO_QCOM; +} +unsafe impl<'a> crate::Extends> +for SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM<'a> {} +impl<'a> Default for SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + enable_y_degamma: Default::default(), + enable_cb_cr_degamma: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM<'a> { + pub fn enable_y_degamma(mut self, enable_y_degamma: bool) -> Self { + self.enable_y_degamma = enable_y_degamma.into(); + self + } + pub fn enable_cb_cr_degamma(mut self, enable_cb_cr_degamma: bool) -> Self { + self.enable_cb_cr_degamma = enable_cb_cr_degamma.into(); + self + } +} ///Provided by [`qcom::ycbcr_degamma`](crate::qcom::ycbcr_degamma) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_YCBCR_DEGAMMA_FEATURES_QCOM: Self = Self(1000520000); diff --git a/ash-rewrite/src/generated/qnx/external_memory_screen_buffer.rs b/ash-rewrite/src/generated/qnx/external_memory_screen_buffer.rs index 14c1f4ce7..361fc5a0e 100644 --- a/ash-rewrite/src/generated/qnx/external_memory_screen_buffer.rs +++ b/ash-rewrite/src/generated/qnx/external_memory_screen_buffer.rs @@ -44,6 +44,30 @@ pub(crate) mod reexport { pub buffer: *mut crate::platform_types::_screen_buffer, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for ImportScreenBufferInfoQNX<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::IMPORT_SCREEN_BUFFER_INFO_QNX; + } + unsafe impl<'a> crate::Extends> + for ImportScreenBufferInfoQNX<'a> {} + impl<'a> Default for ImportScreenBufferInfoQNX<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + buffer: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> ImportScreenBufferInfoQNX<'a> { + pub fn buffer( + mut self, + buffer: &'a mut crate::platform_types::_screen_buffer, + ) -> Self { + self.buffer = buffer; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct ScreenBufferPropertiesQNX<'a> { @@ -53,6 +77,33 @@ pub(crate) mod reexport { pub memory_type_bits: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for ScreenBufferPropertiesQNX<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::SCREEN_BUFFER_PROPERTIES_QNX; + } + impl<'a> Default for ScreenBufferPropertiesQNX<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + allocation_size: Default::default(), + memory_type_bits: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> ScreenBufferPropertiesQNX<'a> { + pub fn allocation_size( + mut self, + allocation_size: crate::vk::DeviceSize, + ) -> Self { + self.allocation_size = allocation_size; + self + } + pub fn memory_type_bits(mut self, memory_type_bits: u32) -> Self { + self.memory_type_bits = memory_type_bits; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct ScreenBufferFormatPropertiesQNX<'a> { @@ -69,6 +120,85 @@ pub(crate) mod reexport { pub suggested_y_chroma_offset: crate::vk::ChromaLocation, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for ScreenBufferFormatPropertiesQNX<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::SCREEN_BUFFER_FORMAT_PROPERTIES_QNX; + } + unsafe impl<'a> crate::Extends> + for ScreenBufferFormatPropertiesQNX<'a> {} + impl<'a> Default for ScreenBufferFormatPropertiesQNX<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + format: Default::default(), + external_format: Default::default(), + screen_usage: Default::default(), + format_features: Default::default(), + sampler_ycbcr_conversion_components: Default::default(), + suggested_ycbcr_model: Default::default(), + suggested_ycbcr_range: Default::default(), + suggested_x_chroma_offset: Default::default(), + suggested_y_chroma_offset: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> ScreenBufferFormatPropertiesQNX<'a> { + pub fn format(mut self, format: crate::vk::Format) -> Self { + self.format = format; + self + } + pub fn external_format(mut self, external_format: u64) -> Self { + self.external_format = external_format; + self + } + pub fn screen_usage(mut self, screen_usage: u64) -> Self { + self.screen_usage = screen_usage; + self + } + pub fn format_features( + mut self, + format_features: crate::vk::FormatFeatureFlags, + ) -> Self { + self.format_features = format_features; + self + } + pub fn sampler_ycbcr_conversion_components( + mut self, + sampler_ycbcr_conversion_components: crate::vk::ComponentMapping, + ) -> Self { + self.sampler_ycbcr_conversion_components = sampler_ycbcr_conversion_components; + self + } + pub fn suggested_ycbcr_model( + mut self, + suggested_ycbcr_model: crate::vk::SamplerYcbcrModelConversion, + ) -> Self { + self.suggested_ycbcr_model = suggested_ycbcr_model; + self + } + pub fn suggested_ycbcr_range( + mut self, + suggested_ycbcr_range: crate::vk::SamplerYcbcrRange, + ) -> Self { + self.suggested_ycbcr_range = suggested_ycbcr_range; + self + } + pub fn suggested_x_chroma_offset( + mut self, + suggested_x_chroma_offset: crate::vk::ChromaLocation, + ) -> Self { + self.suggested_x_chroma_offset = suggested_x_chroma_offset; + self + } + pub fn suggested_y_chroma_offset( + mut self, + suggested_y_chroma_offset: crate::vk::ChromaLocation, + ) -> Self { + self.suggested_y_chroma_offset = suggested_y_chroma_offset; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct ExternalFormatQNX<'a> { @@ -77,6 +207,29 @@ pub(crate) mod reexport { pub external_format: u64, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for ExternalFormatQNX<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::EXTERNAL_FORMAT_QNX; + } + unsafe impl<'a> crate::Extends> + for ExternalFormatQNX<'a> {} + unsafe impl<'a> crate::Extends> + for ExternalFormatQNX<'a> {} + impl<'a> Default for ExternalFormatQNX<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + external_format: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> ExternalFormatQNX<'a> { + pub fn external_format(mut self, external_format: u64) -> Self { + self.external_format = external_format; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX<'a> { @@ -85,6 +238,30 @@ pub(crate) mod reexport { pub screen_buffer_import: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_EXTERNAL_MEMORY_SCREEN_BUFFER_FEATURES_QNX; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX<'a> {} + unsafe impl<'a> crate::Extends> + for PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX<'a> {} + impl<'a> Default for PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + screen_buffer_import: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX<'a> { + pub fn screen_buffer_import(mut self, screen_buffer_import: bool) -> Self { + self.screen_buffer_import = screen_buffer_import.into(); + self + } + } ///Provided by [`qnx::external_memory_screen_buffer`](crate::qnx::external_memory_screen_buffer) impl crate::vk::StructureType { pub const SCREEN_BUFFER_PROPERTIES_QNX: Self = Self(1000529000); diff --git a/ash-rewrite/src/generated/qnx/screen_surface.rs b/ash-rewrite/src/generated/qnx/screen_surface.rs index d86248e62..f54a3ac9d 100644 --- a/ash-rewrite/src/generated/qnx/screen_surface.rs +++ b/ash-rewrite/src/generated/qnx/screen_surface.rs @@ -65,6 +65,41 @@ pub(crate) mod reexport { pub window: *mut crate::platform_types::_screen_window, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for ScreenSurfaceCreateInfoQNX<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::SCREEN_SURFACE_CREATE_INFO_QNX; + } + impl<'a> Default for ScreenSurfaceCreateInfoQNX<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + flags: Default::default(), + context: Default::default(), + window: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> ScreenSurfaceCreateInfoQNX<'a> { + pub fn flags(mut self, flags: crate::vk::ScreenSurfaceCreateFlagsQNX) -> Self { + self.flags = flags; + self + } + pub fn context( + mut self, + context: &'a mut crate::platform_types::_screen_context, + ) -> Self { + self.context = context; + self + } + pub fn window( + mut self, + window: &'a mut crate::platform_types::_screen_window, + ) -> Self { + self.window = window; + self + } + } ///Provided by [`qnx::screen_surface`](crate::qnx::screen_surface) impl crate::vk::StructureType { pub const SCREEN_SURFACE_CREATE_INFO_QNX: Self = Self(1000378000); diff --git a/ash-rewrite/src/generated/sec/amigo_profiling.rs b/ash-rewrite/src/generated/sec/amigo_profiling.rs index adddf7f42..c74f1a2c1 100644 --- a/ash-rewrite/src/generated/sec/amigo_profiling.rs +++ b/ash-rewrite/src/generated/sec/amigo_profiling.rs @@ -9,6 +9,30 @@ pub struct PhysicalDeviceAmigoProfilingFeaturesSEC<'a> { pub amigo_profiling: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceAmigoProfilingFeaturesSEC<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_AMIGO_PROFILING_FEATURES_SEC; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceAmigoProfilingFeaturesSEC<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceAmigoProfilingFeaturesSEC<'a> {} +impl<'a> Default for PhysicalDeviceAmigoProfilingFeaturesSEC<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + amigo_profiling: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceAmigoProfilingFeaturesSEC<'a> { + pub fn amigo_profiling(mut self, amigo_profiling: bool) -> Self { + self.amigo_profiling = amigo_profiling.into(); + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct AmigoProfilingSubmitInfoSEC<'a> { @@ -18,6 +42,32 @@ pub struct AmigoProfilingSubmitInfoSEC<'a> { pub swap_buffer_timestamp: u64, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> for AmigoProfilingSubmitInfoSEC<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::AMIGO_PROFILING_SUBMIT_INFO_SEC; +} +unsafe impl<'a> crate::Extends> +for AmigoProfilingSubmitInfoSEC<'a> {} +impl<'a> Default for AmigoProfilingSubmitInfoSEC<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + first_draw_timestamp: Default::default(), + swap_buffer_timestamp: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> AmigoProfilingSubmitInfoSEC<'a> { + pub fn first_draw_timestamp(mut self, first_draw_timestamp: u64) -> Self { + self.first_draw_timestamp = first_draw_timestamp; + self + } + pub fn swap_buffer_timestamp(mut self, swap_buffer_timestamp: u64) -> Self { + self.swap_buffer_timestamp = swap_buffer_timestamp; + self + } +} ///Provided by [`sec::amigo_profiling`](crate::sec::amigo_profiling) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_AMIGO_PROFILING_FEATURES_SEC: Self = Self(1000485000); diff --git a/ash-rewrite/src/generated/sec/pipeline_cache_incremental_mode.rs b/ash-rewrite/src/generated/sec/pipeline_cache_incremental_mode.rs index 41c5b9c51..07c291212 100644 --- a/ash-rewrite/src/generated/sec/pipeline_cache_incremental_mode.rs +++ b/ash-rewrite/src/generated/sec/pipeline_cache_incremental_mode.rs @@ -9,6 +9,33 @@ pub struct PhysicalDevicePipelineCacheIncrementalModeFeaturesSEC<'a> { pub pipeline_cache_incremental_mode: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDevicePipelineCacheIncrementalModeFeaturesSEC<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_PIPELINE_CACHE_INCREMENTAL_MODE_FEATURES_SEC; +} +unsafe impl<'a> crate::Extends> +for PhysicalDevicePipelineCacheIncrementalModeFeaturesSEC<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDevicePipelineCacheIncrementalModeFeaturesSEC<'a> {} +impl<'a> Default for PhysicalDevicePipelineCacheIncrementalModeFeaturesSEC<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + pipeline_cache_incremental_mode: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDevicePipelineCacheIncrementalModeFeaturesSEC<'a> { + pub fn pipeline_cache_incremental_mode( + mut self, + pipeline_cache_incremental_mode: bool, + ) -> Self { + self.pipeline_cache_incremental_mode = pipeline_cache_incremental_mode.into(); + self + } +} ///Provided by [`sec::pipeline_cache_incremental_mode`](crate::sec::pipeline_cache_incremental_mode) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_PIPELINE_CACHE_INCREMENTAL_MODE_FEATURES_SEC: Self = Self( diff --git a/ash-rewrite/src/generated/sec/throttle_hint.rs b/ash-rewrite/src/generated/sec/throttle_hint.rs index d8a1a635c..17c877b82 100644 --- a/ash-rewrite/src/generated/sec/throttle_hint.rs +++ b/ash-rewrite/src/generated/sec/throttle_hint.rs @@ -9,6 +9,30 @@ pub struct PhysicalDeviceThrottleHintFeaturesSEC<'a> { pub throttle_hint: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceThrottleHintFeaturesSEC<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_THROTTLE_HINT_FEATURES_SEC; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceThrottleHintFeaturesSEC<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceThrottleHintFeaturesSEC<'a> {} +impl<'a> Default for PhysicalDeviceThrottleHintFeaturesSEC<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + throttle_hint: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceThrottleHintFeaturesSEC<'a> { + pub fn throttle_hint(mut self, throttle_hint: bool) -> Self { + self.throttle_hint = throttle_hint.into(); + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct ThrottleHintSubmitInfoSEC<'a> { @@ -17,6 +41,30 @@ pub struct ThrottleHintSubmitInfoSEC<'a> { pub throttle_hint: crate::vk::ThrottleHintTypeSEC, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> for ThrottleHintSubmitInfoSEC<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::THROTTLE_HINT_SUBMIT_INFO_SEC; +} +unsafe impl<'a> crate::Extends> +for ThrottleHintSubmitInfoSEC<'a> {} +impl<'a> Default for ThrottleHintSubmitInfoSEC<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + throttle_hint: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> ThrottleHintSubmitInfoSEC<'a> { + pub fn throttle_hint( + mut self, + throttle_hint: crate::vk::ThrottleHintTypeSEC, + ) -> Self { + self.throttle_hint = throttle_hint; + self + } +} ///Provided by [`sec::throttle_hint`](crate::sec::throttle_hint) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_THROTTLE_HINT_FEATURES_SEC: Self = Self(1000674000); diff --git a/ash-rewrite/src/generated/sec/ubm_surface.rs b/ash-rewrite/src/generated/sec/ubm_surface.rs index 0ffde38e2..830adefa8 100644 --- a/ash-rewrite/src/generated/sec/ubm_surface.rs +++ b/ash-rewrite/src/generated/sec/ubm_surface.rs @@ -63,6 +63,41 @@ pub(crate) mod reexport { pub surface: *mut crate::platform_types::ubm_surface, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for UbmSurfaceCreateInfoSEC<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::UBM_SURFACE_CREATE_INFO_SEC; + } + impl<'a> Default for UbmSurfaceCreateInfoSEC<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + flags: Default::default(), + device: Default::default(), + surface: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> UbmSurfaceCreateInfoSEC<'a> { + pub fn flags(mut self, flags: crate::vk::UbmSurfaceCreateFlagsSEC) -> Self { + self.flags = flags; + self + } + pub fn device( + mut self, + device: &'a mut crate::platform_types::ubm_device, + ) -> Self { + self.device = device; + self + } + pub fn surface( + mut self, + surface: &'a mut crate::platform_types::ubm_surface, + ) -> Self { + self.surface = surface; + self + } + } ///Provided by [`sec::ubm_surface`](crate::sec::ubm_surface) impl crate::vk::StructureType { pub const UBM_SURFACE_CREATE_INFO_SEC: Self = Self(1000664000); diff --git a/ash-rewrite/src/generated/valve/descriptor_set_host_mapping.rs b/ash-rewrite/src/generated/valve/descriptor_set_host_mapping.rs index b7160838e..6960802b9 100644 --- a/ash-rewrite/src/generated/valve/descriptor_set_host_mapping.rs +++ b/ash-rewrite/src/generated/valve/descriptor_set_host_mapping.rs @@ -60,6 +60,33 @@ pub(crate) mod reexport { pub descriptor_set_host_mapping: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE<'a> {} + unsafe impl<'a> crate::Extends> + for PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE<'a> {} + impl<'a> Default for PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + descriptor_set_host_mapping: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE<'a> { + pub fn descriptor_set_host_mapping( + mut self, + descriptor_set_host_mapping: bool, + ) -> Self { + self.descriptor_set_host_mapping = descriptor_set_host_mapping.into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct DescriptorSetBindingReferenceVALVE<'a> { @@ -69,6 +96,34 @@ pub(crate) mod reexport { pub binding: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for DescriptorSetBindingReferenceVALVE<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::DESCRIPTOR_SET_BINDING_REFERENCE_VALVE; + } + impl<'a> Default for DescriptorSetBindingReferenceVALVE<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + descriptor_set_layout: Default::default(), + binding: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> DescriptorSetBindingReferenceVALVE<'a> { + pub fn descriptor_set_layout( + mut self, + descriptor_set_layout: crate::vk::DescriptorSetLayout, + ) -> Self { + self.descriptor_set_layout = descriptor_set_layout; + self + } + pub fn binding(mut self, binding: u32) -> Self { + self.binding = binding; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct DescriptorSetLayoutHostMappingInfoVALVE<'a> { @@ -78,6 +133,31 @@ pub(crate) mod reexport { pub descriptor_size: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for DescriptorSetLayoutHostMappingInfoVALVE<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::DESCRIPTOR_SET_LAYOUT_HOST_MAPPING_INFO_VALVE; + } + impl<'a> Default for DescriptorSetLayoutHostMappingInfoVALVE<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + descriptor_offset: Default::default(), + descriptor_size: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> DescriptorSetLayoutHostMappingInfoVALVE<'a> { + pub fn descriptor_offset(mut self, descriptor_offset: usize) -> Self { + self.descriptor_offset = descriptor_offset; + self + } + pub fn descriptor_size(mut self, descriptor_size: u32) -> Self { + self.descriptor_size = descriptor_size; + self + } + } ///Provided by [`valve::descriptor_set_host_mapping`](crate::valve::descriptor_set_host_mapping) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE: Self = Self( diff --git a/ash-rewrite/src/generated/valve/fragment_density_map_layered.rs b/ash-rewrite/src/generated/valve/fragment_density_map_layered.rs index 29bb5bb52..8af79c633 100644 --- a/ash-rewrite/src/generated/valve/fragment_density_map_layered.rs +++ b/ash-rewrite/src/generated/valve/fragment_density_map_layered.rs @@ -9,6 +9,31 @@ pub struct PhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE<'a> { pub max_fragment_density_map_layers: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_PROPERTIES_VALVE; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE<'a> {} +impl<'a> Default for PhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + max_fragment_density_map_layers: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE<'a> { + pub fn max_fragment_density_map_layers( + mut self, + max_fragment_density_map_layers: u32, + ) -> Self { + self.max_fragment_density_map_layers = max_fragment_density_map_layers; + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE<'a> { @@ -17,6 +42,33 @@ pub struct PhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE<'a> { pub fragment_density_map_layered: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_FEATURES_VALVE; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE<'a> {} +impl<'a> Default for PhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + fragment_density_map_layered: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE<'a> { + pub fn fragment_density_map_layered( + mut self, + fragment_density_map_layered: bool, + ) -> Self { + self.fragment_density_map_layered = fragment_density_map_layered.into(); + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct PipelineFragmentDensityMapLayeredCreateInfoVALVE<'a> { @@ -25,6 +77,31 @@ pub struct PipelineFragmentDensityMapLayeredCreateInfoVALVE<'a> { pub max_fragment_density_map_layers: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PipelineFragmentDensityMapLayeredCreateInfoVALVE<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PIPELINE_FRAGMENT_DENSITY_MAP_LAYERED_CREATE_INFO_VALVE; +} +unsafe impl<'a> crate::Extends> +for PipelineFragmentDensityMapLayeredCreateInfoVALVE<'a> {} +impl<'a> Default for PipelineFragmentDensityMapLayeredCreateInfoVALVE<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + max_fragment_density_map_layers: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PipelineFragmentDensityMapLayeredCreateInfoVALVE<'a> { + pub fn max_fragment_density_map_layers( + mut self, + max_fragment_density_map_layers: u32, + ) -> Self { + self.max_fragment_density_map_layers = max_fragment_density_map_layers; + self + } +} ///Provided by [`valve::fragment_density_map_layered`](crate::valve::fragment_density_map_layered) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_FEATURES_VALVE: Self = Self( diff --git a/ash-rewrite/src/generated/valve/shader_mixed_float_dot_product.rs b/ash-rewrite/src/generated/valve/shader_mixed_float_dot_product.rs index 878ba70bf..964e6a8e5 100644 --- a/ash-rewrite/src/generated/valve/shader_mixed_float_dot_product.rs +++ b/ash-rewrite/src/generated/valve/shader_mixed_float_dot_product.rs @@ -12,6 +12,61 @@ pub struct PhysicalDeviceShaderMixedFloatDotProductFeaturesVALVE<'a> { pub shader_mixed_float_dot_product_float8_acc_float32: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceShaderMixedFloatDotProductFeaturesVALVE<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_SHADER_MIXED_FLOAT_DOT_PRODUCT_FEATURES_VALVE; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceShaderMixedFloatDotProductFeaturesVALVE<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceShaderMixedFloatDotProductFeaturesVALVE<'a> {} +impl<'a> Default for PhysicalDeviceShaderMixedFloatDotProductFeaturesVALVE<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + shader_mixed_float_dot_product_float16_acc_float32: Default::default(), + shader_mixed_float_dot_product_float16_acc_float16: Default::default(), + shader_mixed_float_dot_product_b_float16_acc: Default::default(), + shader_mixed_float_dot_product_float8_acc_float32: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceShaderMixedFloatDotProductFeaturesVALVE<'a> { + pub fn shader_mixed_float_dot_product_float16_acc_float32( + mut self, + shader_mixed_float_dot_product_float16_acc_float32: bool, + ) -> Self { + self.shader_mixed_float_dot_product_float16_acc_float32 = shader_mixed_float_dot_product_float16_acc_float32 + .into(); + self + } + pub fn shader_mixed_float_dot_product_float16_acc_float16( + mut self, + shader_mixed_float_dot_product_float16_acc_float16: bool, + ) -> Self { + self.shader_mixed_float_dot_product_float16_acc_float16 = shader_mixed_float_dot_product_float16_acc_float16 + .into(); + self + } + pub fn shader_mixed_float_dot_product_b_float16_acc( + mut self, + shader_mixed_float_dot_product_b_float16_acc: bool, + ) -> Self { + self.shader_mixed_float_dot_product_b_float16_acc = shader_mixed_float_dot_product_b_float16_acc + .into(); + self + } + pub fn shader_mixed_float_dot_product_float8_acc_float32( + mut self, + shader_mixed_float_dot_product_float8_acc_float32: bool, + ) -> Self { + self.shader_mixed_float_dot_product_float8_acc_float32 = shader_mixed_float_dot_product_float8_acc_float32 + .into(); + self + } +} ///Provided by [`valve::shader_mixed_float_dot_product`](crate::valve::shader_mixed_float_dot_product) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_SHADER_MIXED_FLOAT_DOT_PRODUCT_FEATURES_VALVE: Self = Self( diff --git a/ash-rewrite/src/generated/valve/video_encode_rgb_conversion.rs b/ash-rewrite/src/generated/valve/video_encode_rgb_conversion.rs index 64979ed61..62622bf92 100644 --- a/ash-rewrite/src/generated/valve/video_encode_rgb_conversion.rs +++ b/ash-rewrite/src/generated/valve/video_encode_rgb_conversion.rs @@ -9,6 +9,33 @@ pub struct PhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE<'a> { pub video_encode_rgb_conversion: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for PhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_VIDEO_ENCODE_RGB_CONVERSION_FEATURES_VALVE; +} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE<'a> {} +unsafe impl<'a> crate::Extends> +for PhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE<'a> {} +impl<'a> Default for PhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + video_encode_rgb_conversion: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> PhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE<'a> { + pub fn video_encode_rgb_conversion( + mut self, + video_encode_rgb_conversion: bool, + ) -> Self { + self.video_encode_rgb_conversion = video_encode_rgb_conversion.into(); + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct VideoEncodeRgbConversionCapabilitiesVALVE<'a> { @@ -20,6 +47,55 @@ pub struct VideoEncodeRgbConversionCapabilitiesVALVE<'a> { pub y_chroma_offsets: crate::vk::VideoEncodeRgbChromaOffsetFlagsVALVE, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for VideoEncodeRgbConversionCapabilitiesVALVE<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::VIDEO_ENCODE_RGB_CONVERSION_CAPABILITIES_VALVE; +} +unsafe impl<'a> crate::Extends> +for VideoEncodeRgbConversionCapabilitiesVALVE<'a> {} +impl<'a> Default for VideoEncodeRgbConversionCapabilitiesVALVE<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + rgb_models: Default::default(), + rgb_ranges: Default::default(), + x_chroma_offsets: Default::default(), + y_chroma_offsets: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> VideoEncodeRgbConversionCapabilitiesVALVE<'a> { + pub fn rgb_models( + mut self, + rgb_models: crate::vk::VideoEncodeRgbModelConversionFlagsVALVE, + ) -> Self { + self.rgb_models = rgb_models; + self + } + pub fn rgb_ranges( + mut self, + rgb_ranges: crate::vk::VideoEncodeRgbRangeCompressionFlagsVALVE, + ) -> Self { + self.rgb_ranges = rgb_ranges; + self + } + pub fn x_chroma_offsets( + mut self, + x_chroma_offsets: crate::vk::VideoEncodeRgbChromaOffsetFlagsVALVE, + ) -> Self { + self.x_chroma_offsets = x_chroma_offsets; + self + } + pub fn y_chroma_offsets( + mut self, + y_chroma_offsets: crate::vk::VideoEncodeRgbChromaOffsetFlagsVALVE, + ) -> Self { + self.y_chroma_offsets = y_chroma_offsets; + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct VideoEncodeProfileRgbConversionInfoVALVE<'a> { @@ -28,6 +104,31 @@ pub struct VideoEncodeProfileRgbConversionInfoVALVE<'a> { pub perform_encode_rgb_conversion: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for VideoEncodeProfileRgbConversionInfoVALVE<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::VIDEO_ENCODE_PROFILE_RGB_CONVERSION_INFO_VALVE; +} +unsafe impl<'a> crate::Extends> +for VideoEncodeProfileRgbConversionInfoVALVE<'a> {} +impl<'a> Default for VideoEncodeProfileRgbConversionInfoVALVE<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + perform_encode_rgb_conversion: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> VideoEncodeProfileRgbConversionInfoVALVE<'a> { + pub fn perform_encode_rgb_conversion( + mut self, + perform_encode_rgb_conversion: bool, + ) -> Self { + self.perform_encode_rgb_conversion = perform_encode_rgb_conversion.into(); + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct VideoEncodeSessionRgbConversionCreateInfoVALVE<'a> { @@ -39,6 +140,55 @@ pub struct VideoEncodeSessionRgbConversionCreateInfoVALVE<'a> { pub y_chroma_offset: crate::vk::VideoEncodeRgbChromaOffsetFlagBitsVALVE, pub _marker: ::core::marker::PhantomData<&'a ()>, } +unsafe impl<'a> crate::TaggedStructure<'a> +for VideoEncodeSessionRgbConversionCreateInfoVALVE<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::VIDEO_ENCODE_SESSION_RGB_CONVERSION_CREATE_INFO_VALVE; +} +unsafe impl<'a> crate::Extends> +for VideoEncodeSessionRgbConversionCreateInfoVALVE<'a> {} +impl<'a> Default for VideoEncodeSessionRgbConversionCreateInfoVALVE<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + rgb_model: Default::default(), + rgb_range: Default::default(), + x_chroma_offset: Default::default(), + y_chroma_offset: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> VideoEncodeSessionRgbConversionCreateInfoVALVE<'a> { + pub fn rgb_model( + mut self, + rgb_model: crate::vk::VideoEncodeRgbModelConversionFlagBitsVALVE, + ) -> Self { + self.rgb_model = rgb_model; + self + } + pub fn rgb_range( + mut self, + rgb_range: crate::vk::VideoEncodeRgbRangeCompressionFlagBitsVALVE, + ) -> Self { + self.rgb_range = rgb_range; + self + } + pub fn x_chroma_offset( + mut self, + x_chroma_offset: crate::vk::VideoEncodeRgbChromaOffsetFlagBitsVALVE, + ) -> Self { + self.x_chroma_offset = x_chroma_offset; + self + } + pub fn y_chroma_offset( + mut self, + y_chroma_offset: crate::vk::VideoEncodeRgbChromaOffsetFlagBitsVALVE, + ) -> Self { + self.y_chroma_offset = y_chroma_offset; + self + } +} ///Provided by [`valve::video_encode_rgb_conversion`](crate::valve::video_encode_rgb_conversion) impl crate::vk::StructureType { pub const PHYSICAL_DEVICE_VIDEO_ENCODE_RGB_CONVERSION_FEATURES_VALVE: Self = Self( @@ -133,7 +283,7 @@ impl core::ops::Not for VideoEncodeRgbModelConversionFlagsVALVE { } } #[repr(transparent)] -#[derive(Clone, Copy)] +#[derive(Clone, Copy, Default)] pub struct VideoEncodeRgbModelConversionFlagBitsVALVE(pub(crate) u32); ///Provided by [`valve::video_encode_rgb_conversion`](crate::valve::video_encode_rgb_conversion) impl VideoEncodeRgbModelConversionFlagBitsVALVE { @@ -217,7 +367,7 @@ impl core::ops::Not for VideoEncodeRgbRangeCompressionFlagsVALVE { } } #[repr(transparent)] -#[derive(Clone, Copy)] +#[derive(Clone, Copy, Default)] pub struct VideoEncodeRgbRangeCompressionFlagBitsVALVE(pub(crate) u32); ///Provided by [`valve::video_encode_rgb_conversion`](crate::valve::video_encode_rgb_conversion) impl VideoEncodeRgbRangeCompressionFlagBitsVALVE { @@ -298,7 +448,7 @@ impl core::ops::Not for VideoEncodeRgbChromaOffsetFlagsVALVE { } } #[repr(transparent)] -#[derive(Clone, Copy)] +#[derive(Clone, Copy, Default)] pub struct VideoEncodeRgbChromaOffsetFlagBitsVALVE(pub(crate) u32); ///Provided by [`valve::video_encode_rgb_conversion`](crate::valve::video_encode_rgb_conversion) impl VideoEncodeRgbChromaOffsetFlagBitsVALVE { diff --git a/ash-rewrite/src/generated/video/codec_av1std.rs b/ash-rewrite/src/generated/video/codec_av1std.rs index edf3dadfd..5bc6c417f 100644 --- a/ash-rewrite/src/generated/video/codec_av1std.rs +++ b/ash-rewrite/src/generated/video/codec_av1std.rs @@ -2,7 +2,7 @@ #![cfg_attr(rustfmt, rustfmt_skip)] //!Items provided by `vulkan_video_codec_av1std` #[repr(C)] -#[derive(Clone, Copy)] +#[derive(Clone, Copy, Default)] pub struct AV1ColorConfigFlags { /**- `mono_chrome` @ `0..1` - `color_range` @ `1..2` @@ -10,8 +10,33 @@ pub struct AV1ColorConfigFlags { - `color_description_present_flag` @ `3..4`*/ pub bitfield0: u32, } +impl AV1ColorConfigFlags { + pub fn mono_chrome(mut self, mono_chrome: u32) -> Self { + let rest = self.bitfield0 & 0xFFFFFFFE; + self.bitfield0 = (mono_chrome & 0x00000001) | rest; + self + } + pub fn color_range(mut self, color_range: u32) -> Self { + let rest = self.bitfield0 & 0xFFFFFFFD; + self.bitfield0 = ((color_range << 1u32) & 0x00000002) | rest; + self + } + pub fn separate_uv_delta_q(mut self, separate_uv_delta_q: u32) -> Self { + let rest = self.bitfield0 & 0xFFFFFFFB; + self.bitfield0 = ((separate_uv_delta_q << 2u32) & 0x00000004) | rest; + self + } + pub fn color_description_present_flag( + mut self, + color_description_present_flag: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFFFFFFF7; + self.bitfield0 = ((color_description_present_flag << 3u32) & 0x00000008) | rest; + self + } +} #[repr(C)] -#[derive(Clone, Copy)] +#[derive(Clone, Copy, Default)] pub struct AV1ColorConfig { pub flags: crate::vk::AV1ColorConfigFlags, pub bit_depth: u8, @@ -23,22 +48,100 @@ pub struct AV1ColorConfig { pub matrix_coefficients: crate::vk::AV1MatrixCoefficients, pub chroma_sample_position: crate::vk::AV1ChromaSamplePosition, } +impl AV1ColorConfig { + pub fn flags(mut self, flags: crate::vk::AV1ColorConfigFlags) -> Self { + self.flags = flags; + self + } + pub fn bit_depth(mut self, bit_depth: u8) -> Self { + self.bit_depth = bit_depth; + self + } + pub fn subsampling_x(mut self, subsampling_x: u8) -> Self { + self.subsampling_x = subsampling_x; + self + } + pub fn subsampling_y(mut self, subsampling_y: u8) -> Self { + self.subsampling_y = subsampling_y; + self + } + pub fn reserved1(mut self, reserved1: u8) -> Self { + self.reserved1 = reserved1; + self + } + pub fn color_primaries( + mut self, + color_primaries: crate::vk::AV1ColorPrimaries, + ) -> Self { + self.color_primaries = color_primaries; + self + } + pub fn transfer_characteristics( + mut self, + transfer_characteristics: crate::vk::AV1TransferCharacteristics, + ) -> Self { + self.transfer_characteristics = transfer_characteristics; + self + } + pub fn matrix_coefficients( + mut self, + matrix_coefficients: crate::vk::AV1MatrixCoefficients, + ) -> Self { + self.matrix_coefficients = matrix_coefficients; + self + } + pub fn chroma_sample_position( + mut self, + chroma_sample_position: crate::vk::AV1ChromaSamplePosition, + ) -> Self { + self.chroma_sample_position = chroma_sample_position; + self + } +} #[repr(C)] -#[derive(Clone, Copy)] +#[derive(Clone, Copy, Default)] pub struct AV1TimingInfoFlags { ///- `equal_picture_interval` @ `0..1` pub bitfield0: u32, } +impl AV1TimingInfoFlags { + pub fn equal_picture_interval(mut self, equal_picture_interval: u32) -> Self { + let rest = self.bitfield0 & 0xFFFFFFFE; + self.bitfield0 = (equal_picture_interval & 0x00000001) | rest; + self + } +} #[repr(C)] -#[derive(Clone, Copy)] +#[derive(Clone, Copy, Default)] pub struct AV1TimingInfo { pub flags: crate::vk::AV1TimingInfoFlags, pub num_units_in_display_tick: u32, pub time_scale: u32, pub num_ticks_per_picture_minus_1: u32, } +impl AV1TimingInfo { + pub fn flags(mut self, flags: crate::vk::AV1TimingInfoFlags) -> Self { + self.flags = flags; + self + } + pub fn num_units_in_display_tick(mut self, num_units_in_display_tick: u32) -> Self { + self.num_units_in_display_tick = num_units_in_display_tick; + self + } + pub fn time_scale(mut self, time_scale: u32) -> Self { + self.time_scale = time_scale; + self + } + pub fn num_ticks_per_picture_minus_1( + mut self, + num_ticks_per_picture_minus_1: u32, + ) -> Self { + self.num_ticks_per_picture_minus_1 = num_ticks_per_picture_minus_1; + self + } +} #[repr(C)] -#[derive(Clone, Copy)] +#[derive(Clone, Copy, Default)] pub struct AV1SequenceHeaderFlags { /**- `still_picture` @ `0..1` - `reduced_still_picture_header` @ `1..2` @@ -61,6 +164,116 @@ pub struct AV1SequenceHeaderFlags { - `initial_display_delay_present_flag` @ `18..19`*/ pub bitfield0: u32, } +impl AV1SequenceHeaderFlags { + pub fn still_picture(mut self, still_picture: u32) -> Self { + let rest = self.bitfield0 & 0xFFFFFFFE; + self.bitfield0 = (still_picture & 0x00000001) | rest; + self + } + pub fn reduced_still_picture_header( + mut self, + reduced_still_picture_header: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFFFFFFFD; + self.bitfield0 = ((reduced_still_picture_header << 1u32) & 0x00000002) | rest; + self + } + pub fn use_128x128_superblock(mut self, use_128x128_superblock: u32) -> Self { + let rest = self.bitfield0 & 0xFFFFFFFB; + self.bitfield0 = ((use_128x128_superblock << 2u32) & 0x00000004) | rest; + self + } + pub fn enable_filter_intra(mut self, enable_filter_intra: u32) -> Self { + let rest = self.bitfield0 & 0xFFFFFFF7; + self.bitfield0 = ((enable_filter_intra << 3u32) & 0x00000008) | rest; + self + } + pub fn enable_intra_edge_filter(mut self, enable_intra_edge_filter: u32) -> Self { + let rest = self.bitfield0 & 0xFFFFFFEF; + self.bitfield0 = ((enable_intra_edge_filter << 4u32) & 0x00000010) | rest; + self + } + pub fn enable_interintra_compound( + mut self, + enable_interintra_compound: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFFFFFFDF; + self.bitfield0 = ((enable_interintra_compound << 5u32) & 0x00000020) | rest; + self + } + pub fn enable_masked_compound(mut self, enable_masked_compound: u32) -> Self { + let rest = self.bitfield0 & 0xFFFFFFBF; + self.bitfield0 = ((enable_masked_compound << 6u32) & 0x00000040) | rest; + self + } + pub fn enable_warped_motion(mut self, enable_warped_motion: u32) -> Self { + let rest = self.bitfield0 & 0xFFFFFF7F; + self.bitfield0 = ((enable_warped_motion << 7u32) & 0x00000080) | rest; + self + } + pub fn enable_dual_filter(mut self, enable_dual_filter: u32) -> Self { + let rest = self.bitfield0 & 0xFFFFFEFF; + self.bitfield0 = ((enable_dual_filter << 8u32) & 0x00000100) | rest; + self + } + pub fn enable_order_hint(mut self, enable_order_hint: u32) -> Self { + let rest = self.bitfield0 & 0xFFFFFDFF; + self.bitfield0 = ((enable_order_hint << 9u32) & 0x00000200) | rest; + self + } + pub fn enable_jnt_comp(mut self, enable_jnt_comp: u32) -> Self { + let rest = self.bitfield0 & 0xFFFFFBFF; + self.bitfield0 = ((enable_jnt_comp << 10u32) & 0x00000400) | rest; + self + } + pub fn enable_ref_frame_mvs(mut self, enable_ref_frame_mvs: u32) -> Self { + let rest = self.bitfield0 & 0xFFFFF7FF; + self.bitfield0 = ((enable_ref_frame_mvs << 11u32) & 0x00000800) | rest; + self + } + pub fn frame_id_numbers_present_flag( + mut self, + frame_id_numbers_present_flag: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFFFFEFFF; + self.bitfield0 = ((frame_id_numbers_present_flag << 12u32) & 0x00001000) | rest; + self + } + pub fn enable_superres(mut self, enable_superres: u32) -> Self { + let rest = self.bitfield0 & 0xFFFFDFFF; + self.bitfield0 = ((enable_superres << 13u32) & 0x00002000) | rest; + self + } + pub fn enable_cdef(mut self, enable_cdef: u32) -> Self { + let rest = self.bitfield0 & 0xFFFFBFFF; + self.bitfield0 = ((enable_cdef << 14u32) & 0x00004000) | rest; + self + } + pub fn enable_restoration(mut self, enable_restoration: u32) -> Self { + let rest = self.bitfield0 & 0xFFFF7FFF; + self.bitfield0 = ((enable_restoration << 15u32) & 0x00008000) | rest; + self + } + pub fn film_grain_params_present(mut self, film_grain_params_present: u32) -> Self { + let rest = self.bitfield0 & 0xFFFEFFFF; + self.bitfield0 = ((film_grain_params_present << 16u32) & 0x00010000) | rest; + self + } + pub fn timing_info_present_flag(mut self, timing_info_present_flag: u32) -> Self { + let rest = self.bitfield0 & 0xFFFDFFFF; + self.bitfield0 = ((timing_info_present_flag << 17u32) & 0x00020000) | rest; + self + } + pub fn initial_display_delay_present_flag( + mut self, + initial_display_delay_present_flag: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFFFBFFFF; + self.bitfield0 = ((initial_display_delay_present_flag << 18u32) & 0x00040000) + | rest; + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct AV1SequenceHeader<'a> { @@ -80,13 +293,116 @@ pub struct AV1SequenceHeader<'a> { pub p_timing_info: *const crate::vk::AV1TimingInfo, pub _marker: ::core::marker::PhantomData<&'a ()>, } +impl<'a> Default for AV1SequenceHeader<'a> { + fn default() -> Self { + Self { + flags: Default::default(), + seq_profile: Default::default(), + frame_width_bits_minus_1: Default::default(), + frame_height_bits_minus_1: Default::default(), + max_frame_width_minus_1: Default::default(), + max_frame_height_minus_1: Default::default(), + delta_frame_id_length_minus_2: Default::default(), + additional_frame_id_length_minus_1: Default::default(), + order_hint_bits_minus_1: Default::default(), + seq_force_integer_mv: Default::default(), + seq_force_screen_content_tools: Default::default(), + reserved1: unsafe { core::mem::zeroed() }, + p_color_config: Default::default(), + p_timing_info: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> AV1SequenceHeader<'a> { + pub fn flags(mut self, flags: crate::vk::AV1SequenceHeaderFlags) -> Self { + self.flags = flags; + self + } + pub fn seq_profile(mut self, seq_profile: crate::vk::AV1Profile) -> Self { + self.seq_profile = seq_profile; + self + } + pub fn frame_width_bits_minus_1(mut self, frame_width_bits_minus_1: u8) -> Self { + self.frame_width_bits_minus_1 = frame_width_bits_minus_1; + self + } + pub fn frame_height_bits_minus_1(mut self, frame_height_bits_minus_1: u8) -> Self { + self.frame_height_bits_minus_1 = frame_height_bits_minus_1; + self + } + pub fn max_frame_width_minus_1(mut self, max_frame_width_minus_1: u16) -> Self { + self.max_frame_width_minus_1 = max_frame_width_minus_1; + self + } + pub fn max_frame_height_minus_1(mut self, max_frame_height_minus_1: u16) -> Self { + self.max_frame_height_minus_1 = max_frame_height_minus_1; + self + } + pub fn delta_frame_id_length_minus_2( + mut self, + delta_frame_id_length_minus_2: u8, + ) -> Self { + self.delta_frame_id_length_minus_2 = delta_frame_id_length_minus_2; + self + } + pub fn additional_frame_id_length_minus_1( + mut self, + additional_frame_id_length_minus_1: u8, + ) -> Self { + self.additional_frame_id_length_minus_1 = additional_frame_id_length_minus_1; + self + } + pub fn order_hint_bits_minus_1(mut self, order_hint_bits_minus_1: u8) -> Self { + self.order_hint_bits_minus_1 = order_hint_bits_minus_1; + self + } + pub fn seq_force_integer_mv(mut self, seq_force_integer_mv: u8) -> Self { + self.seq_force_integer_mv = seq_force_integer_mv; + self + } + pub fn seq_force_screen_content_tools( + mut self, + seq_force_screen_content_tools: u8, + ) -> Self { + self.seq_force_screen_content_tools = seq_force_screen_content_tools; + self + } + pub fn reserved1(mut self, reserved1: [u8; 5 as _]) -> Self { + self.reserved1 = reserved1; + self + } + pub fn p_color_config( + mut self, + p_color_config: &'a crate::vk::AV1ColorConfig, + ) -> Self { + self.p_color_config = p_color_config; + self + } + pub fn p_timing_info(mut self, p_timing_info: &'a crate::vk::AV1TimingInfo) -> Self { + self.p_timing_info = p_timing_info; + self + } +} #[repr(C)] -#[derive(Clone, Copy)] +#[derive(Clone, Copy, Default)] pub struct AV1LoopFilterFlags { /**- `loop_filter_delta_enabled` @ `0..1` - `loop_filter_delta_update` @ `1..2`*/ pub bitfield0: u32, } +impl AV1LoopFilterFlags { + pub fn loop_filter_delta_enabled(mut self, loop_filter_delta_enabled: u32) -> Self { + let rest = self.bitfield0 & 0xFFFFFFFE; + self.bitfield0 = (loop_filter_delta_enabled & 0x00000001) | rest; + self + } + pub fn loop_filter_delta_update(mut self, loop_filter_delta_update: u32) -> Self { + let rest = self.bitfield0 & 0xFFFFFFFD; + self.bitfield0 = ((loop_filter_delta_update << 1u32) & 0x00000002) | rest; + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct AV1LoopFilter { @@ -99,15 +415,80 @@ pub struct AV1LoopFilter { pub loop_filter_mode_deltas: [i8; crate::vk::STD_VIDEO_AV1_LOOP_FILTER_ADJUSTMENTS as _], } +impl Default for AV1LoopFilter { + fn default() -> Self { + Self { + flags: Default::default(), + loop_filter_level: unsafe { core::mem::zeroed() }, + loop_filter_sharpness: Default::default(), + update_ref_delta: Default::default(), + loop_filter_ref_deltas: unsafe { core::mem::zeroed() }, + update_mode_delta: Default::default(), + loop_filter_mode_deltas: unsafe { core::mem::zeroed() }, + } + } +} +impl AV1LoopFilter { + pub fn flags(mut self, flags: crate::vk::AV1LoopFilterFlags) -> Self { + self.flags = flags; + self + } + pub fn loop_filter_level( + mut self, + loop_filter_level: [u8; crate::vk::STD_VIDEO_AV1_MAX_LOOP_FILTER_STRENGTHS as _], + ) -> Self { + self.loop_filter_level = loop_filter_level; + self + } + pub fn loop_filter_sharpness(mut self, loop_filter_sharpness: u8) -> Self { + self.loop_filter_sharpness = loop_filter_sharpness; + self + } + pub fn update_ref_delta(mut self, update_ref_delta: u8) -> Self { + self.update_ref_delta = update_ref_delta; + self + } + pub fn loop_filter_ref_deltas( + mut self, + loop_filter_ref_deltas: [i8; crate::vk::STD_VIDEO_AV1_TOTAL_REFS_PER_FRAME as _], + ) -> Self { + self.loop_filter_ref_deltas = loop_filter_ref_deltas; + self + } + pub fn update_mode_delta(mut self, update_mode_delta: u8) -> Self { + self.update_mode_delta = update_mode_delta; + self + } + pub fn loop_filter_mode_deltas( + mut self, + loop_filter_mode_deltas: [i8; crate::vk::STD_VIDEO_AV1_LOOP_FILTER_ADJUSTMENTS + as _], + ) -> Self { + self.loop_filter_mode_deltas = loop_filter_mode_deltas; + self + } +} #[repr(C)] -#[derive(Clone, Copy)] +#[derive(Clone, Copy, Default)] pub struct AV1QuantizationFlags { /**- `using_qmatrix` @ `0..1` - `diff_uv_delta` @ `1..2`*/ pub bitfield0: u32, } +impl AV1QuantizationFlags { + pub fn using_qmatrix(mut self, using_qmatrix: u32) -> Self { + let rest = self.bitfield0 & 0xFFFFFFFE; + self.bitfield0 = (using_qmatrix & 0x00000001) | rest; + self + } + pub fn diff_uv_delta(mut self, diff_uv_delta: u32) -> Self { + let rest = self.bitfield0 & 0xFFFFFFFD; + self.bitfield0 = ((diff_uv_delta << 1u32) & 0x00000002) | rest; + self + } +} #[repr(C)] -#[derive(Clone, Copy)] +#[derive(Clone, Copy, Default)] pub struct AV1Quantization { pub flags: crate::vk::AV1QuantizationFlags, pub base_q_idx: u8, @@ -120,6 +501,48 @@ pub struct AV1Quantization { pub qm_u: u8, pub qm_v: u8, } +impl AV1Quantization { + pub fn flags(mut self, flags: crate::vk::AV1QuantizationFlags) -> Self { + self.flags = flags; + self + } + pub fn base_q_idx(mut self, base_q_idx: u8) -> Self { + self.base_q_idx = base_q_idx; + self + } + pub fn delta_qy_dc(mut self, delta_qy_dc: i8) -> Self { + self.delta_qy_dc = delta_qy_dc; + self + } + pub fn delta_qu_dc(mut self, delta_qu_dc: i8) -> Self { + self.delta_qu_dc = delta_qu_dc; + self + } + pub fn delta_qu_ac(mut self, delta_qu_ac: i8) -> Self { + self.delta_qu_ac = delta_qu_ac; + self + } + pub fn delta_qv_dc(mut self, delta_qv_dc: i8) -> Self { + self.delta_qv_dc = delta_qv_dc; + self + } + pub fn delta_qv_ac(mut self, delta_qv_ac: i8) -> Self { + self.delta_qv_ac = delta_qv_ac; + self + } + pub fn qm_y(mut self, qm_y: u8) -> Self { + self.qm_y = qm_y; + self + } + pub fn qm_u(mut self, qm_u: u8) -> Self { + self.qm_u = qm_u; + self + } + pub fn qm_v(mut self, qm_v: u8) -> Self { + self.qm_v = qm_v; + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct AV1Segmentation { @@ -127,12 +550,44 @@ pub struct AV1Segmentation { pub feature_data: [[i16; crate::vk::STD_VIDEO_AV1_SEG_LVL_MAX as _]; crate::vk::STD_VIDEO_AV1_MAX_SEGMENTS as _], } +impl Default for AV1Segmentation { + fn default() -> Self { + Self { + feature_enabled: unsafe { core::mem::zeroed() }, + feature_data: unsafe { core::mem::zeroed() }, + } + } +} +impl AV1Segmentation { + pub fn feature_enabled( + mut self, + feature_enabled: [u8; crate::vk::STD_VIDEO_AV1_MAX_SEGMENTS as _], + ) -> Self { + self.feature_enabled = feature_enabled; + self + } + pub fn feature_data( + mut self, + feature_data: [[i16; crate::vk::STD_VIDEO_AV1_SEG_LVL_MAX + as _]; crate::vk::STD_VIDEO_AV1_MAX_SEGMENTS as _], + ) -> Self { + self.feature_data = feature_data; + self + } +} #[repr(C)] -#[derive(Clone, Copy)] +#[derive(Clone, Copy, Default)] pub struct AV1TileInfoFlags { ///- `uniform_tile_spacing_flag` @ `0..1` pub bitfield0: u32, } +impl AV1TileInfoFlags { + pub fn uniform_tile_spacing_flag(mut self, uniform_tile_spacing_flag: u32) -> Self { + let rest = self.bitfield0 & 0xFFFFFFFE; + self.bitfield0 = (uniform_tile_spacing_flag & 0x00000001) | rest; + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct AV1TileInfo<'a> { @@ -148,6 +603,69 @@ pub struct AV1TileInfo<'a> { pub p_height_in_sbs_minus1: *const u16, pub _marker: ::core::marker::PhantomData<&'a ()>, } +impl<'a> Default for AV1TileInfo<'a> { + fn default() -> Self { + Self { + flags: Default::default(), + tile_cols: Default::default(), + tile_rows: Default::default(), + context_update_tile_id: Default::default(), + tile_size_bytes_minus_1: Default::default(), + reserved1: unsafe { core::mem::zeroed() }, + p_mi_col_starts: Default::default(), + p_mi_row_starts: Default::default(), + p_width_in_sbs_minus1: Default::default(), + p_height_in_sbs_minus1: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> AV1TileInfo<'a> { + pub fn flags(mut self, flags: crate::vk::AV1TileInfoFlags) -> Self { + self.flags = flags; + self + } + pub fn tile_cols(mut self, tile_cols: u8) -> Self { + self.tile_cols = tile_cols; + self + } + pub fn tile_rows(mut self, tile_rows: u8) -> Self { + self.tile_rows = tile_rows; + self + } + pub fn context_update_tile_id(mut self, context_update_tile_id: u16) -> Self { + self.context_update_tile_id = context_update_tile_id; + self + } + pub fn tile_size_bytes_minus_1(mut self, tile_size_bytes_minus_1: u8) -> Self { + self.tile_size_bytes_minus_1 = tile_size_bytes_minus_1; + self + } + pub fn reserved1(mut self, reserved1: [u8; 7 as _]) -> Self { + self.reserved1 = reserved1; + self + } + pub fn p_mi_col_starts(mut self, p_mi_col_starts: &'a [u16]) -> Self { + self.tile_cols = p_mi_col_starts.len() as _; + self.p_mi_col_starts = p_mi_col_starts.as_ptr(); + self + } + pub fn p_mi_row_starts(mut self, p_mi_row_starts: &'a [u16]) -> Self { + self.tile_rows = p_mi_row_starts.len() as _; + self.p_mi_row_starts = p_mi_row_starts.as_ptr(); + self + } + pub fn p_width_in_sbs_minus1(mut self, p_width_in_sbs_minus1: &'a [u16]) -> Self { + self.tile_cols = p_width_in_sbs_minus1.len() as _; + self.p_width_in_sbs_minus1 = p_width_in_sbs_minus1.as_ptr(); + self + } + pub fn p_height_in_sbs_minus1(mut self, p_height_in_sbs_minus1: &'a [u16]) -> Self { + self.tile_rows = p_height_in_sbs_minus1.len() as _; + self.p_height_in_sbs_minus1 = p_height_in_sbs_minus1.as_ptr(); + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct AV1CDEF { @@ -162,6 +680,60 @@ pub struct AV1CDEF { pub cdef_uv_sec_strength: [u8; crate::vk::STD_VIDEO_AV1_MAX_CDEF_FILTER_STRENGTHS as _], } +impl Default for AV1CDEF { + fn default() -> Self { + Self { + cdef_damping_minus_3: Default::default(), + cdef_bits: Default::default(), + cdef_y_pri_strength: unsafe { core::mem::zeroed() }, + cdef_y_sec_strength: unsafe { core::mem::zeroed() }, + cdef_uv_pri_strength: unsafe { core::mem::zeroed() }, + cdef_uv_sec_strength: unsafe { core::mem::zeroed() }, + } + } +} +impl AV1CDEF { + pub fn cdef_damping_minus_3(mut self, cdef_damping_minus_3: u8) -> Self { + self.cdef_damping_minus_3 = cdef_damping_minus_3; + self + } + pub fn cdef_bits(mut self, cdef_bits: u8) -> Self { + self.cdef_bits = cdef_bits; + self + } + pub fn cdef_y_pri_strength( + mut self, + cdef_y_pri_strength: [u8; crate::vk::STD_VIDEO_AV1_MAX_CDEF_FILTER_STRENGTHS + as _], + ) -> Self { + self.cdef_y_pri_strength = cdef_y_pri_strength; + self + } + pub fn cdef_y_sec_strength( + mut self, + cdef_y_sec_strength: [u8; crate::vk::STD_VIDEO_AV1_MAX_CDEF_FILTER_STRENGTHS + as _], + ) -> Self { + self.cdef_y_sec_strength = cdef_y_sec_strength; + self + } + pub fn cdef_uv_pri_strength( + mut self, + cdef_uv_pri_strength: [u8; crate::vk::STD_VIDEO_AV1_MAX_CDEF_FILTER_STRENGTHS + as _], + ) -> Self { + self.cdef_uv_pri_strength = cdef_uv_pri_strength; + self + } + pub fn cdef_uv_sec_strength( + mut self, + cdef_uv_sec_strength: [u8; crate::vk::STD_VIDEO_AV1_MAX_CDEF_FILTER_STRENGTHS + as _], + ) -> Self { + self.cdef_uv_sec_strength = cdef_uv_sec_strength; + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct AV1LoopRestoration { @@ -169,6 +741,31 @@ pub struct AV1LoopRestoration { as _], pub loop_restoration_size: [u16; crate::vk::STD_VIDEO_AV1_MAX_NUM_PLANES as _], } +impl Default for AV1LoopRestoration { + fn default() -> Self { + Self { + frame_restoration_type: unsafe { core::mem::zeroed() }, + loop_restoration_size: unsafe { core::mem::zeroed() }, + } + } +} +impl AV1LoopRestoration { + pub fn frame_restoration_type( + mut self, + frame_restoration_type: [crate::vk::AV1FrameRestorationType; crate::vk::STD_VIDEO_AV1_MAX_NUM_PLANES + as _], + ) -> Self { + self.frame_restoration_type = frame_restoration_type; + self + } + pub fn loop_restoration_size( + mut self, + loop_restoration_size: [u16; crate::vk::STD_VIDEO_AV1_MAX_NUM_PLANES as _], + ) -> Self { + self.loop_restoration_size = loop_restoration_size; + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct AV1GlobalMotion { @@ -176,8 +773,33 @@ pub struct AV1GlobalMotion { pub gm_params: [[i32; crate::vk::STD_VIDEO_AV1_GLOBAL_MOTION_PARAMS as _]; crate::vk::STD_VIDEO_AV1_NUM_REF_FRAMES as _], } +impl Default for AV1GlobalMotion { + fn default() -> Self { + Self { + gm_type: unsafe { core::mem::zeroed() }, + gm_params: unsafe { core::mem::zeroed() }, + } + } +} +impl AV1GlobalMotion { + pub fn gm_type( + mut self, + gm_type: [u8; crate::vk::STD_VIDEO_AV1_NUM_REF_FRAMES as _], + ) -> Self { + self.gm_type = gm_type; + self + } + pub fn gm_params( + mut self, + gm_params: [[i32; crate::vk::STD_VIDEO_AV1_GLOBAL_MOTION_PARAMS + as _]; crate::vk::STD_VIDEO_AV1_NUM_REF_FRAMES as _], + ) -> Self { + self.gm_params = gm_params; + self + } +} #[repr(C)] -#[derive(Clone, Copy)] +#[derive(Clone, Copy, Default)] pub struct AV1FilmGrainFlags { /**- `chroma_scaling_from_luma` @ `0..1` - `overlap_flag` @ `1..2` @@ -185,6 +807,28 @@ pub struct AV1FilmGrainFlags { - `update_grain` @ `3..4`*/ pub bitfield0: u32, } +impl AV1FilmGrainFlags { + pub fn chroma_scaling_from_luma(mut self, chroma_scaling_from_luma: u32) -> Self { + let rest = self.bitfield0 & 0xFFFFFFFE; + self.bitfield0 = (chroma_scaling_from_luma & 0x00000001) | rest; + self + } + pub fn overlap_flag(mut self, overlap_flag: u32) -> Self { + let rest = self.bitfield0 & 0xFFFFFFFD; + self.bitfield0 = ((overlap_flag << 1u32) & 0x00000002) | rest; + self + } + pub fn clip_to_restricted_range(mut self, clip_to_restricted_range: u32) -> Self { + let rest = self.bitfield0 & 0xFFFFFFFB; + self.bitfield0 = ((clip_to_restricted_range << 2u32) & 0x00000004) | rest; + self + } + pub fn update_grain(mut self, update_grain: u32) -> Self { + let rest = self.bitfield0 & 0xFFFFFFF7; + self.bitfield0 = ((update_grain << 3u32) & 0x00000008) | rest; + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct AV1FilmGrain { @@ -214,6 +858,166 @@ pub struct AV1FilmGrain { pub cr_luma_mult: u8, pub cr_offset: u16, } +impl Default for AV1FilmGrain { + fn default() -> Self { + Self { + flags: Default::default(), + grain_scaling_minus_8: Default::default(), + ar_coeff_lag: Default::default(), + ar_coeff_shift_minus_6: Default::default(), + grain_scale_shift: Default::default(), + grain_seed: Default::default(), + film_grain_params_ref_idx: Default::default(), + num_y_points: Default::default(), + point_y_value: unsafe { core::mem::zeroed() }, + point_y_scaling: unsafe { core::mem::zeroed() }, + num_cb_points: Default::default(), + point_cb_value: unsafe { core::mem::zeroed() }, + point_cb_scaling: unsafe { core::mem::zeroed() }, + num_cr_points: Default::default(), + point_cr_value: unsafe { core::mem::zeroed() }, + point_cr_scaling: unsafe { core::mem::zeroed() }, + ar_coeffs_y_plus_128: unsafe { core::mem::zeroed() }, + ar_coeffs_cb_plus_128: unsafe { core::mem::zeroed() }, + ar_coeffs_cr_plus_128: unsafe { core::mem::zeroed() }, + cb_mult: Default::default(), + cb_luma_mult: Default::default(), + cb_offset: Default::default(), + cr_mult: Default::default(), + cr_luma_mult: Default::default(), + cr_offset: Default::default(), + } + } +} +impl AV1FilmGrain { + pub fn flags(mut self, flags: crate::vk::AV1FilmGrainFlags) -> Self { + self.flags = flags; + self + } + pub fn grain_scaling_minus_8(mut self, grain_scaling_minus_8: u8) -> Self { + self.grain_scaling_minus_8 = grain_scaling_minus_8; + self + } + pub fn ar_coeff_lag(mut self, ar_coeff_lag: u8) -> Self { + self.ar_coeff_lag = ar_coeff_lag; + self + } + pub fn ar_coeff_shift_minus_6(mut self, ar_coeff_shift_minus_6: u8) -> Self { + self.ar_coeff_shift_minus_6 = ar_coeff_shift_minus_6; + self + } + pub fn grain_scale_shift(mut self, grain_scale_shift: u8) -> Self { + self.grain_scale_shift = grain_scale_shift; + self + } + pub fn grain_seed(mut self, grain_seed: u16) -> Self { + self.grain_seed = grain_seed; + self + } + pub fn film_grain_params_ref_idx(mut self, film_grain_params_ref_idx: u8) -> Self { + self.film_grain_params_ref_idx = film_grain_params_ref_idx; + self + } + pub fn num_y_points(mut self, num_y_points: u8) -> Self { + self.num_y_points = num_y_points; + self + } + pub fn point_y_value( + mut self, + point_y_value: [u8; crate::vk::STD_VIDEO_AV1_MAX_NUM_Y_POINTS as _], + ) -> Self { + self.point_y_value = point_y_value; + self + } + pub fn point_y_scaling( + mut self, + point_y_scaling: [u8; crate::vk::STD_VIDEO_AV1_MAX_NUM_Y_POINTS as _], + ) -> Self { + self.point_y_scaling = point_y_scaling; + self + } + pub fn num_cb_points(mut self, num_cb_points: u8) -> Self { + self.num_cb_points = num_cb_points; + self + } + pub fn point_cb_value( + mut self, + point_cb_value: [u8; crate::vk::STD_VIDEO_AV1_MAX_NUM_CB_POINTS as _], + ) -> Self { + self.point_cb_value = point_cb_value; + self + } + pub fn point_cb_scaling( + mut self, + point_cb_scaling: [u8; crate::vk::STD_VIDEO_AV1_MAX_NUM_CB_POINTS as _], + ) -> Self { + self.point_cb_scaling = point_cb_scaling; + self + } + pub fn num_cr_points(mut self, num_cr_points: u8) -> Self { + self.num_cr_points = num_cr_points; + self + } + pub fn point_cr_value( + mut self, + point_cr_value: [u8; crate::vk::STD_VIDEO_AV1_MAX_NUM_CR_POINTS as _], + ) -> Self { + self.point_cr_value = point_cr_value; + self + } + pub fn point_cr_scaling( + mut self, + point_cr_scaling: [u8; crate::vk::STD_VIDEO_AV1_MAX_NUM_CR_POINTS as _], + ) -> Self { + self.point_cr_scaling = point_cr_scaling; + self + } + pub fn ar_coeffs_y_plus_128( + mut self, + ar_coeffs_y_plus_128: [i8; crate::vk::STD_VIDEO_AV1_MAX_NUM_POS_LUMA as _], + ) -> Self { + self.ar_coeffs_y_plus_128 = ar_coeffs_y_plus_128; + self + } + pub fn ar_coeffs_cb_plus_128( + mut self, + ar_coeffs_cb_plus_128: [i8; crate::vk::STD_VIDEO_AV1_MAX_NUM_POS_CHROMA as _], + ) -> Self { + self.ar_coeffs_cb_plus_128 = ar_coeffs_cb_plus_128; + self + } + pub fn ar_coeffs_cr_plus_128( + mut self, + ar_coeffs_cr_plus_128: [i8; crate::vk::STD_VIDEO_AV1_MAX_NUM_POS_CHROMA as _], + ) -> Self { + self.ar_coeffs_cr_plus_128 = ar_coeffs_cr_plus_128; + self + } + pub fn cb_mult(mut self, cb_mult: u8) -> Self { + self.cb_mult = cb_mult; + self + } + pub fn cb_luma_mult(mut self, cb_luma_mult: u8) -> Self { + self.cb_luma_mult = cb_luma_mult; + self + } + pub fn cb_offset(mut self, cb_offset: u16) -> Self { + self.cb_offset = cb_offset; + self + } + pub fn cr_mult(mut self, cr_mult: u8) -> Self { + self.cr_mult = cr_mult; + self + } + pub fn cr_luma_mult(mut self, cr_luma_mult: u8) -> Self { + self.cr_luma_mult = cr_luma_mult; + self + } + pub fn cr_offset(mut self, cr_offset: u16) -> Self { + self.cr_offset = cr_offset; + self + } +} #[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[derive(Debug)] diff --git a/ash-rewrite/src/generated/video/codec_av1std_decode.rs b/ash-rewrite/src/generated/video/codec_av1std_decode.rs index f8434c3dc..03b8dbf54 100644 --- a/ash-rewrite/src/generated/video/codec_av1std_decode.rs +++ b/ash-rewrite/src/generated/video/codec_av1std_decode.rs @@ -2,7 +2,7 @@ #![cfg_attr(rustfmt, rustfmt_skip)] //!Items provided by `vulkan_video_codec_av1std_decode` #[repr(C)] -#[derive(Clone, Copy)] +#[derive(Clone, Copy, Default)] pub struct DecodeAV1PictureInfoFlags { /**- `error_resilient_mode` @ `0..1` - `disable_cdf_update` @ `1..2` @@ -35,6 +35,172 @@ pub struct DecodeAV1PictureInfoFlags { - `apply_grain` @ `28..29`*/ pub bitfield0: u32, } +impl DecodeAV1PictureInfoFlags { + pub fn error_resilient_mode(mut self, error_resilient_mode: u32) -> Self { + let rest = self.bitfield0 & 0xFFFFFFFE; + self.bitfield0 = (error_resilient_mode & 0x00000001) | rest; + self + } + pub fn disable_cdf_update(mut self, disable_cdf_update: u32) -> Self { + let rest = self.bitfield0 & 0xFFFFFFFD; + self.bitfield0 = ((disable_cdf_update << 1u32) & 0x00000002) | rest; + self + } + pub fn use_superres(mut self, use_superres: u32) -> Self { + let rest = self.bitfield0 & 0xFFFFFFFB; + self.bitfield0 = ((use_superres << 2u32) & 0x00000004) | rest; + self + } + pub fn render_and_frame_size_different( + mut self, + render_and_frame_size_different: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFFFFFFF7; + self.bitfield0 = ((render_and_frame_size_different << 3u32) & 0x00000008) | rest; + self + } + pub fn allow_screen_content_tools( + mut self, + allow_screen_content_tools: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFFFFFFEF; + self.bitfield0 = ((allow_screen_content_tools << 4u32) & 0x00000010) | rest; + self + } + pub fn is_filter_switchable(mut self, is_filter_switchable: u32) -> Self { + let rest = self.bitfield0 & 0xFFFFFFDF; + self.bitfield0 = ((is_filter_switchable << 5u32) & 0x00000020) | rest; + self + } + pub fn force_integer_mv(mut self, force_integer_mv: u32) -> Self { + let rest = self.bitfield0 & 0xFFFFFFBF; + self.bitfield0 = ((force_integer_mv << 6u32) & 0x00000040) | rest; + self + } + pub fn frame_size_override_flag(mut self, frame_size_override_flag: u32) -> Self { + let rest = self.bitfield0 & 0xFFFFFF7F; + self.bitfield0 = ((frame_size_override_flag << 7u32) & 0x00000080) | rest; + self + } + pub fn buffer_removal_time_present_flag( + mut self, + buffer_removal_time_present_flag: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFFFFFEFF; + self.bitfield0 = ((buffer_removal_time_present_flag << 8u32) & 0x00000100) + | rest; + self + } + pub fn allow_intrabc(mut self, allow_intrabc: u32) -> Self { + let rest = self.bitfield0 & 0xFFFFFDFF; + self.bitfield0 = ((allow_intrabc << 9u32) & 0x00000200) | rest; + self + } + pub fn frame_refs_short_signaling( + mut self, + frame_refs_short_signaling: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFFFFFBFF; + self.bitfield0 = ((frame_refs_short_signaling << 10u32) & 0x00000400) | rest; + self + } + pub fn allow_high_precision_mv(mut self, allow_high_precision_mv: u32) -> Self { + let rest = self.bitfield0 & 0xFFFFF7FF; + self.bitfield0 = ((allow_high_precision_mv << 11u32) & 0x00000800) | rest; + self + } + pub fn is_motion_mode_switchable(mut self, is_motion_mode_switchable: u32) -> Self { + let rest = self.bitfield0 & 0xFFFFEFFF; + self.bitfield0 = ((is_motion_mode_switchable << 12u32) & 0x00001000) | rest; + self + } + pub fn use_ref_frame_mvs(mut self, use_ref_frame_mvs: u32) -> Self { + let rest = self.bitfield0 & 0xFFFFDFFF; + self.bitfield0 = ((use_ref_frame_mvs << 13u32) & 0x00002000) | rest; + self + } + pub fn disable_frame_end_update_cdf( + mut self, + disable_frame_end_update_cdf: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFFFFBFFF; + self.bitfield0 = ((disable_frame_end_update_cdf << 14u32) & 0x00004000) | rest; + self + } + pub fn allow_warped_motion(mut self, allow_warped_motion: u32) -> Self { + let rest = self.bitfield0 & 0xFFFF7FFF; + self.bitfield0 = ((allow_warped_motion << 15u32) & 0x00008000) | rest; + self + } + pub fn reduced_tx_set(mut self, reduced_tx_set: u32) -> Self { + let rest = self.bitfield0 & 0xFFFEFFFF; + self.bitfield0 = ((reduced_tx_set << 16u32) & 0x00010000) | rest; + self + } + pub fn reference_select(mut self, reference_select: u32) -> Self { + let rest = self.bitfield0 & 0xFFFDFFFF; + self.bitfield0 = ((reference_select << 17u32) & 0x00020000) | rest; + self + } + pub fn skip_mode_present(mut self, skip_mode_present: u32) -> Self { + let rest = self.bitfield0 & 0xFFFBFFFF; + self.bitfield0 = ((skip_mode_present << 18u32) & 0x00040000) | rest; + self + } + pub fn delta_q_present(mut self, delta_q_present: u32) -> Self { + let rest = self.bitfield0 & 0xFFF7FFFF; + self.bitfield0 = ((delta_q_present << 19u32) & 0x00080000) | rest; + self + } + pub fn delta_lf_present(mut self, delta_lf_present: u32) -> Self { + let rest = self.bitfield0 & 0xFFEFFFFF; + self.bitfield0 = ((delta_lf_present << 20u32) & 0x00100000) | rest; + self + } + pub fn delta_lf_multi(mut self, delta_lf_multi: u32) -> Self { + let rest = self.bitfield0 & 0xFFDFFFFF; + self.bitfield0 = ((delta_lf_multi << 21u32) & 0x00200000) | rest; + self + } + pub fn segmentation_enabled(mut self, segmentation_enabled: u32) -> Self { + let rest = self.bitfield0 & 0xFFBFFFFF; + self.bitfield0 = ((segmentation_enabled << 22u32) & 0x00400000) | rest; + self + } + pub fn segmentation_update_map(mut self, segmentation_update_map: u32) -> Self { + let rest = self.bitfield0 & 0xFF7FFFFF; + self.bitfield0 = ((segmentation_update_map << 23u32) & 0x00800000) | rest; + self + } + pub fn segmentation_temporal_update( + mut self, + segmentation_temporal_update: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFEFFFFFF; + self.bitfield0 = ((segmentation_temporal_update << 24u32) & 0x01000000) | rest; + self + } + pub fn segmentation_update_data(mut self, segmentation_update_data: u32) -> Self { + let rest = self.bitfield0 & 0xFDFFFFFF; + self.bitfield0 = ((segmentation_update_data << 25u32) & 0x02000000) | rest; + self + } + pub fn uses_lr(mut self, uses_lr: u32) -> Self { + let rest = self.bitfield0 & 0xFBFFFFFF; + self.bitfield0 = ((uses_lr << 26u32) & 0x04000000) | rest; + self + } + pub fn uses_chroma_lr(mut self, uses_chroma_lr: u32) -> Self { + let rest = self.bitfield0 & 0xF7FFFFFF; + self.bitfield0 = ((uses_chroma_lr << 27u32) & 0x08000000) | rest; + self + } + pub fn apply_grain(mut self, apply_grain: u32) -> Self { + let rest = self.bitfield0 & 0xEFFFFFFF; + self.bitfield0 = ((apply_grain << 28u32) & 0x10000000) | rest; + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct DecodeAV1PictureInfo<'a> { @@ -64,13 +230,181 @@ pub struct DecodeAV1PictureInfo<'a> { pub p_film_grain: *const crate::vk::AV1FilmGrain, pub _marker: ::core::marker::PhantomData<&'a ()>, } +impl<'a> Default for DecodeAV1PictureInfo<'a> { + fn default() -> Self { + Self { + flags: Default::default(), + frame_type: Default::default(), + current_frame_id: Default::default(), + order_hint: Default::default(), + primary_ref_frame: Default::default(), + refresh_frame_flags: Default::default(), + reserved1: Default::default(), + interpolation_filter: Default::default(), + tx_mode: Default::default(), + delta_q_res: Default::default(), + delta_lf_res: Default::default(), + skip_mode_frame: unsafe { core::mem::zeroed() }, + coded_denom: Default::default(), + reserved2: unsafe { core::mem::zeroed() }, + order_hints: unsafe { core::mem::zeroed() }, + expected_frame_id: unsafe { core::mem::zeroed() }, + p_tile_info: Default::default(), + p_quantization: Default::default(), + p_segmentation: Default::default(), + p_loop_filter: Default::default(), + p_cdef: Default::default(), + p_loop_restoration: Default::default(), + p_global_motion: Default::default(), + p_film_grain: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> DecodeAV1PictureInfo<'a> { + pub fn flags(mut self, flags: crate::vk::DecodeAV1PictureInfoFlags) -> Self { + self.flags = flags; + self + } + pub fn frame_type(mut self, frame_type: crate::vk::AV1FrameType) -> Self { + self.frame_type = frame_type; + self + } + pub fn current_frame_id(mut self, current_frame_id: u32) -> Self { + self.current_frame_id = current_frame_id; + self + } + pub fn order_hint(mut self, order_hint: u8) -> Self { + self.order_hint = order_hint; + self + } + pub fn primary_ref_frame(mut self, primary_ref_frame: u8) -> Self { + self.primary_ref_frame = primary_ref_frame; + self + } + pub fn refresh_frame_flags(mut self, refresh_frame_flags: u8) -> Self { + self.refresh_frame_flags = refresh_frame_flags; + self + } + pub fn reserved1(mut self, reserved1: u8) -> Self { + self.reserved1 = reserved1; + self + } + pub fn interpolation_filter( + mut self, + interpolation_filter: crate::vk::AV1InterpolationFilter, + ) -> Self { + self.interpolation_filter = interpolation_filter; + self + } + pub fn tx_mode(mut self, tx_mode: crate::vk::AV1TxMode) -> Self { + self.tx_mode = tx_mode; + self + } + pub fn delta_q_res(mut self, delta_q_res: u8) -> Self { + self.delta_q_res = delta_q_res; + self + } + pub fn delta_lf_res(mut self, delta_lf_res: u8) -> Self { + self.delta_lf_res = delta_lf_res; + self + } + pub fn skip_mode_frame( + mut self, + skip_mode_frame: [u8; crate::vk::STD_VIDEO_AV1_SKIP_MODE_FRAMES as _], + ) -> Self { + self.skip_mode_frame = skip_mode_frame; + self + } + pub fn coded_denom(mut self, coded_denom: u8) -> Self { + self.coded_denom = coded_denom; + self + } + pub fn reserved2(mut self, reserved2: [u8; 3 as _]) -> Self { + self.reserved2 = reserved2; + self + } + pub fn order_hints( + mut self, + order_hints: [u8; crate::vk::STD_VIDEO_AV1_NUM_REF_FRAMES as _], + ) -> Self { + self.order_hints = order_hints; + self + } + pub fn expected_frame_id( + mut self, + expected_frame_id: [u32; crate::vk::STD_VIDEO_AV1_NUM_REF_FRAMES as _], + ) -> Self { + self.expected_frame_id = expected_frame_id; + self + } + pub fn p_tile_info(mut self, p_tile_info: &'a crate::vk::AV1TileInfo<'a>) -> Self { + self.p_tile_info = p_tile_info; + self + } + pub fn p_quantization( + mut self, + p_quantization: &'a crate::vk::AV1Quantization, + ) -> Self { + self.p_quantization = p_quantization; + self + } + pub fn p_segmentation( + mut self, + p_segmentation: &'a crate::vk::AV1Segmentation, + ) -> Self { + self.p_segmentation = p_segmentation; + self + } + pub fn p_loop_filter(mut self, p_loop_filter: &'a crate::vk::AV1LoopFilter) -> Self { + self.p_loop_filter = p_loop_filter; + self + } + pub fn p_cdef(mut self, p_cdef: &'a crate::vk::AV1CDEF) -> Self { + self.p_cdef = p_cdef; + self + } + pub fn p_loop_restoration( + mut self, + p_loop_restoration: &'a crate::vk::AV1LoopRestoration, + ) -> Self { + self.p_loop_restoration = p_loop_restoration; + self + } + pub fn p_global_motion( + mut self, + p_global_motion: &'a crate::vk::AV1GlobalMotion, + ) -> Self { + self.p_global_motion = p_global_motion; + self + } + pub fn p_film_grain(mut self, p_film_grain: &'a crate::vk::AV1FilmGrain) -> Self { + self.p_film_grain = p_film_grain; + self + } +} #[repr(C)] -#[derive(Clone, Copy)] +#[derive(Clone, Copy, Default)] pub struct DecodeAV1ReferenceInfoFlags { /**- `disable_frame_end_update_cdf` @ `0..1` - `segmentation_enabled` @ `1..2`*/ pub bitfield0: u32, } +impl DecodeAV1ReferenceInfoFlags { + pub fn disable_frame_end_update_cdf( + mut self, + disable_frame_end_update_cdf: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFFFFFFFE; + self.bitfield0 = (disable_frame_end_update_cdf & 0x00000001) | rest; + self + } + pub fn segmentation_enabled(mut self, segmentation_enabled: u32) -> Self { + let rest = self.bitfield0 & 0xFFFFFFFD; + self.bitfield0 = ((segmentation_enabled << 1u32) & 0x00000002) | rest; + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct DecodeAV1ReferenceInfo { @@ -80,6 +414,42 @@ pub struct DecodeAV1ReferenceInfo { pub order_hint: u8, pub saved_order_hints: [u8; crate::vk::STD_VIDEO_AV1_NUM_REF_FRAMES as _], } +impl Default for DecodeAV1ReferenceInfo { + fn default() -> Self { + Self { + flags: Default::default(), + frame_type: Default::default(), + ref_frame_sign_bias: Default::default(), + order_hint: Default::default(), + saved_order_hints: unsafe { core::mem::zeroed() }, + } + } +} +impl DecodeAV1ReferenceInfo { + pub fn flags(mut self, flags: crate::vk::DecodeAV1ReferenceInfoFlags) -> Self { + self.flags = flags; + self + } + pub fn frame_type(mut self, frame_type: u8) -> Self { + self.frame_type = frame_type; + self + } + pub fn ref_frame_sign_bias(mut self, ref_frame_sign_bias: u8) -> Self { + self.ref_frame_sign_bias = ref_frame_sign_bias; + self + } + pub fn order_hint(mut self, order_hint: u8) -> Self { + self.order_hint = order_hint; + self + } + pub fn saved_order_hints( + mut self, + saved_order_hints: [u8; crate::vk::STD_VIDEO_AV1_NUM_REF_FRAMES as _], + ) -> Self { + self.saved_order_hints = saved_order_hints; + self + } +} pub const STD_VULKAN_VIDEO_CODEC_AV1_DECODE_SPEC_VERSION: u32 = crate::vk::STD_VULKAN_VIDEO_CODEC_AV1_DECODE_API_VERSION_1_0_0; pub const STD_VULKAN_VIDEO_CODEC_AV1_DECODE_EXTENSION_NAME: &core::ffi::CStr = c"VK_STD_vulkan_video_codec_av1_decode"; pub const STD_VULKAN_VIDEO_CODEC_AV1_DECODE_API_VERSION_1_0_0: u32 = crate::vk::make_video_std_version( diff --git a/ash-rewrite/src/generated/video/codec_av1std_encode.rs b/ash-rewrite/src/generated/video/codec_av1std_encode.rs index 8e513a212..4d373df1b 100644 --- a/ash-rewrite/src/generated/video/codec_av1std_encode.rs +++ b/ash-rewrite/src/generated/video/codec_av1std_encode.rs @@ -2,13 +2,23 @@ #![cfg_attr(rustfmt, rustfmt_skip)] //!Items provided by `vulkan_video_codec_av1std_encode` #[repr(C)] -#[derive(Clone, Copy)] +#[derive(Clone, Copy, Default)] pub struct EncodeAV1ExtensionHeader { pub temporal_id: u8, pub spatial_id: u8, } +impl EncodeAV1ExtensionHeader { + pub fn temporal_id(mut self, temporal_id: u8) -> Self { + self.temporal_id = temporal_id; + self + } + pub fn spatial_id(mut self, spatial_id: u8) -> Self { + self.spatial_id = spatial_id; + self + } +} #[repr(C)] -#[derive(Clone, Copy)] +#[derive(Clone, Copy, Default)] pub struct EncodeAV1DecoderModelInfo { pub buffer_delay_length_minus_1: u8, pub buffer_removal_time_length_minus_1: u8, @@ -16,16 +26,74 @@ pub struct EncodeAV1DecoderModelInfo { pub reserved1: u8, pub num_units_in_decoding_tick: u32, } +impl EncodeAV1DecoderModelInfo { + pub fn buffer_delay_length_minus_1( + mut self, + buffer_delay_length_minus_1: u8, + ) -> Self { + self.buffer_delay_length_minus_1 = buffer_delay_length_minus_1; + self + } + pub fn buffer_removal_time_length_minus_1( + mut self, + buffer_removal_time_length_minus_1: u8, + ) -> Self { + self.buffer_removal_time_length_minus_1 = buffer_removal_time_length_minus_1; + self + } + pub fn frame_presentation_time_length_minus_1( + mut self, + frame_presentation_time_length_minus_1: u8, + ) -> Self { + self.frame_presentation_time_length_minus_1 = frame_presentation_time_length_minus_1; + self + } + pub fn reserved1(mut self, reserved1: u8) -> Self { + self.reserved1 = reserved1; + self + } + pub fn num_units_in_decoding_tick( + mut self, + num_units_in_decoding_tick: u32, + ) -> Self { + self.num_units_in_decoding_tick = num_units_in_decoding_tick; + self + } +} #[repr(C)] -#[derive(Clone, Copy)] +#[derive(Clone, Copy, Default)] pub struct EncodeAV1OperatingPointInfoFlags { /**- `decoder_model_present_for_this_op` @ `0..1` - `low_delay_mode_flag` @ `1..2` - `initial_display_delay_present_for_this_op` @ `2..3`*/ pub bitfield0: u32, } +impl EncodeAV1OperatingPointInfoFlags { + pub fn decoder_model_present_for_this_op( + mut self, + decoder_model_present_for_this_op: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFFFFFFFE; + self.bitfield0 = (decoder_model_present_for_this_op & 0x00000001) | rest; + self + } + pub fn low_delay_mode_flag(mut self, low_delay_mode_flag: u32) -> Self { + let rest = self.bitfield0 & 0xFFFFFFFD; + self.bitfield0 = ((low_delay_mode_flag << 1u32) & 0x00000002) | rest; + self + } + pub fn initial_display_delay_present_for_this_op( + mut self, + initial_display_delay_present_for_this_op: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFFFFFFFB; + self.bitfield0 = ((initial_display_delay_present_for_this_op << 2u32) + & 0x00000004) | rest; + self + } +} #[repr(C)] -#[derive(Clone, Copy)] +#[derive(Clone, Copy, Default)] pub struct EncodeAV1OperatingPointInfo { pub flags: crate::vk::EncodeAV1OperatingPointInfoFlags, pub operating_point_idc: u16, @@ -35,8 +103,41 @@ pub struct EncodeAV1OperatingPointInfo { pub encoder_buffer_delay: u32, pub initial_display_delay_minus_1: u8, } +impl EncodeAV1OperatingPointInfo { + pub fn flags(mut self, flags: crate::vk::EncodeAV1OperatingPointInfoFlags) -> Self { + self.flags = flags; + self + } + pub fn operating_point_idc(mut self, operating_point_idc: u16) -> Self { + self.operating_point_idc = operating_point_idc; + self + } + pub fn seq_level_idx(mut self, seq_level_idx: u8) -> Self { + self.seq_level_idx = seq_level_idx; + self + } + pub fn seq_tier(mut self, seq_tier: u8) -> Self { + self.seq_tier = seq_tier; + self + } + pub fn decoder_buffer_delay(mut self, decoder_buffer_delay: u32) -> Self { + self.decoder_buffer_delay = decoder_buffer_delay; + self + } + pub fn encoder_buffer_delay(mut self, encoder_buffer_delay: u32) -> Self { + self.encoder_buffer_delay = encoder_buffer_delay; + self + } + pub fn initial_display_delay_minus_1( + mut self, + initial_display_delay_minus_1: u8, + ) -> Self { + self.initial_display_delay_minus_1 = initial_display_delay_minus_1; + self + } +} #[repr(C)] -#[derive(Clone, Copy)] +#[derive(Clone, Copy, Default)] pub struct EncodeAV1PictureInfoFlags { /**- `error_resilient_mode` @ `0..1` - `disable_cdf_update` @ `1..2` @@ -69,6 +170,172 @@ pub struct EncodeAV1PictureInfoFlags { - `showable_frame` @ `28..29`*/ pub bitfield0: u32, } +impl EncodeAV1PictureInfoFlags { + pub fn error_resilient_mode(mut self, error_resilient_mode: u32) -> Self { + let rest = self.bitfield0 & 0xFFFFFFFE; + self.bitfield0 = (error_resilient_mode & 0x00000001) | rest; + self + } + pub fn disable_cdf_update(mut self, disable_cdf_update: u32) -> Self { + let rest = self.bitfield0 & 0xFFFFFFFD; + self.bitfield0 = ((disable_cdf_update << 1u32) & 0x00000002) | rest; + self + } + pub fn use_superres(mut self, use_superres: u32) -> Self { + let rest = self.bitfield0 & 0xFFFFFFFB; + self.bitfield0 = ((use_superres << 2u32) & 0x00000004) | rest; + self + } + pub fn render_and_frame_size_different( + mut self, + render_and_frame_size_different: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFFFFFFF7; + self.bitfield0 = ((render_and_frame_size_different << 3u32) & 0x00000008) | rest; + self + } + pub fn allow_screen_content_tools( + mut self, + allow_screen_content_tools: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFFFFFFEF; + self.bitfield0 = ((allow_screen_content_tools << 4u32) & 0x00000010) | rest; + self + } + pub fn is_filter_switchable(mut self, is_filter_switchable: u32) -> Self { + let rest = self.bitfield0 & 0xFFFFFFDF; + self.bitfield0 = ((is_filter_switchable << 5u32) & 0x00000020) | rest; + self + } + pub fn force_integer_mv(mut self, force_integer_mv: u32) -> Self { + let rest = self.bitfield0 & 0xFFFFFFBF; + self.bitfield0 = ((force_integer_mv << 6u32) & 0x00000040) | rest; + self + } + pub fn frame_size_override_flag(mut self, frame_size_override_flag: u32) -> Self { + let rest = self.bitfield0 & 0xFFFFFF7F; + self.bitfield0 = ((frame_size_override_flag << 7u32) & 0x00000080) | rest; + self + } + pub fn buffer_removal_time_present_flag( + mut self, + buffer_removal_time_present_flag: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFFFFFEFF; + self.bitfield0 = ((buffer_removal_time_present_flag << 8u32) & 0x00000100) + | rest; + self + } + pub fn allow_intrabc(mut self, allow_intrabc: u32) -> Self { + let rest = self.bitfield0 & 0xFFFFFDFF; + self.bitfield0 = ((allow_intrabc << 9u32) & 0x00000200) | rest; + self + } + pub fn frame_refs_short_signaling( + mut self, + frame_refs_short_signaling: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFFFFFBFF; + self.bitfield0 = ((frame_refs_short_signaling << 10u32) & 0x00000400) | rest; + self + } + pub fn allow_high_precision_mv(mut self, allow_high_precision_mv: u32) -> Self { + let rest = self.bitfield0 & 0xFFFFF7FF; + self.bitfield0 = ((allow_high_precision_mv << 11u32) & 0x00000800) | rest; + self + } + pub fn is_motion_mode_switchable(mut self, is_motion_mode_switchable: u32) -> Self { + let rest = self.bitfield0 & 0xFFFFEFFF; + self.bitfield0 = ((is_motion_mode_switchable << 12u32) & 0x00001000) | rest; + self + } + pub fn use_ref_frame_mvs(mut self, use_ref_frame_mvs: u32) -> Self { + let rest = self.bitfield0 & 0xFFFFDFFF; + self.bitfield0 = ((use_ref_frame_mvs << 13u32) & 0x00002000) | rest; + self + } + pub fn disable_frame_end_update_cdf( + mut self, + disable_frame_end_update_cdf: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFFFFBFFF; + self.bitfield0 = ((disable_frame_end_update_cdf << 14u32) & 0x00004000) | rest; + self + } + pub fn allow_warped_motion(mut self, allow_warped_motion: u32) -> Self { + let rest = self.bitfield0 & 0xFFFF7FFF; + self.bitfield0 = ((allow_warped_motion << 15u32) & 0x00008000) | rest; + self + } + pub fn reduced_tx_set(mut self, reduced_tx_set: u32) -> Self { + let rest = self.bitfield0 & 0xFFFEFFFF; + self.bitfield0 = ((reduced_tx_set << 16u32) & 0x00010000) | rest; + self + } + pub fn skip_mode_present(mut self, skip_mode_present: u32) -> Self { + let rest = self.bitfield0 & 0xFFFDFFFF; + self.bitfield0 = ((skip_mode_present << 17u32) & 0x00020000) | rest; + self + } + pub fn delta_q_present(mut self, delta_q_present: u32) -> Self { + let rest = self.bitfield0 & 0xFFFBFFFF; + self.bitfield0 = ((delta_q_present << 18u32) & 0x00040000) | rest; + self + } + pub fn delta_lf_present(mut self, delta_lf_present: u32) -> Self { + let rest = self.bitfield0 & 0xFFF7FFFF; + self.bitfield0 = ((delta_lf_present << 19u32) & 0x00080000) | rest; + self + } + pub fn delta_lf_multi(mut self, delta_lf_multi: u32) -> Self { + let rest = self.bitfield0 & 0xFFEFFFFF; + self.bitfield0 = ((delta_lf_multi << 20u32) & 0x00100000) | rest; + self + } + pub fn segmentation_enabled(mut self, segmentation_enabled: u32) -> Self { + let rest = self.bitfield0 & 0xFFDFFFFF; + self.bitfield0 = ((segmentation_enabled << 21u32) & 0x00200000) | rest; + self + } + pub fn segmentation_update_map(mut self, segmentation_update_map: u32) -> Self { + let rest = self.bitfield0 & 0xFFBFFFFF; + self.bitfield0 = ((segmentation_update_map << 22u32) & 0x00400000) | rest; + self + } + pub fn segmentation_temporal_update( + mut self, + segmentation_temporal_update: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFF7FFFFF; + self.bitfield0 = ((segmentation_temporal_update << 23u32) & 0x00800000) | rest; + self + } + pub fn segmentation_update_data(mut self, segmentation_update_data: u32) -> Self { + let rest = self.bitfield0 & 0xFEFFFFFF; + self.bitfield0 = ((segmentation_update_data << 24u32) & 0x01000000) | rest; + self + } + pub fn uses_lr(mut self, uses_lr: u32) -> Self { + let rest = self.bitfield0 & 0xFDFFFFFF; + self.bitfield0 = ((uses_lr << 25u32) & 0x02000000) | rest; + self + } + pub fn uses_chroma_lr(mut self, uses_chroma_lr: u32) -> Self { + let rest = self.bitfield0 & 0xFBFFFFFF; + self.bitfield0 = ((uses_chroma_lr << 26u32) & 0x04000000) | rest; + self + } + pub fn show_frame(mut self, show_frame: u32) -> Self { + let rest = self.bitfield0 & 0xF7FFFFFF; + self.bitfield0 = ((show_frame << 27u32) & 0x08000000) | rest; + self + } + pub fn showable_frame(mut self, showable_frame: u32) -> Self { + let rest = self.bitfield0 & 0xEFFFFFFF; + self.bitfield0 = ((showable_frame << 28u32) & 0x10000000) | rest; + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct EncodeAV1PictureInfo<'a> { @@ -101,13 +368,199 @@ pub struct EncodeAV1PictureInfo<'a> { pub p_buffer_removal_times: *const u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } +impl<'a> Default for EncodeAV1PictureInfo<'a> { + fn default() -> Self { + Self { + flags: Default::default(), + frame_type: Default::default(), + frame_presentation_time: Default::default(), + current_frame_id: Default::default(), + order_hint: Default::default(), + primary_ref_frame: Default::default(), + refresh_frame_flags: Default::default(), + coded_denom: Default::default(), + render_width_minus_1: Default::default(), + render_height_minus_1: Default::default(), + interpolation_filter: Default::default(), + tx_mode: Default::default(), + delta_q_res: Default::default(), + delta_lf_res: Default::default(), + ref_order_hint: unsafe { core::mem::zeroed() }, + ref_frame_idx: unsafe { core::mem::zeroed() }, + reserved1: unsafe { core::mem::zeroed() }, + delta_frame_id_minus_1: unsafe { core::mem::zeroed() }, + p_tile_info: Default::default(), + p_quantization: Default::default(), + p_segmentation: Default::default(), + p_loop_filter: Default::default(), + p_cdef: Default::default(), + p_loop_restoration: Default::default(), + p_global_motion: Default::default(), + p_extension_header: Default::default(), + p_buffer_removal_times: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> EncodeAV1PictureInfo<'a> { + pub fn flags(mut self, flags: crate::vk::EncodeAV1PictureInfoFlags) -> Self { + self.flags = flags; + self + } + pub fn frame_type(mut self, frame_type: crate::vk::AV1FrameType) -> Self { + self.frame_type = frame_type; + self + } + pub fn frame_presentation_time(mut self, frame_presentation_time: u32) -> Self { + self.frame_presentation_time = frame_presentation_time; + self + } + pub fn current_frame_id(mut self, current_frame_id: u32) -> Self { + self.current_frame_id = current_frame_id; + self + } + pub fn order_hint(mut self, order_hint: u8) -> Self { + self.order_hint = order_hint; + self + } + pub fn primary_ref_frame(mut self, primary_ref_frame: u8) -> Self { + self.primary_ref_frame = primary_ref_frame; + self + } + pub fn refresh_frame_flags(mut self, refresh_frame_flags: u8) -> Self { + self.refresh_frame_flags = refresh_frame_flags; + self + } + pub fn coded_denom(mut self, coded_denom: u8) -> Self { + self.coded_denom = coded_denom; + self + } + pub fn render_width_minus_1(mut self, render_width_minus_1: u16) -> Self { + self.render_width_minus_1 = render_width_minus_1; + self + } + pub fn render_height_minus_1(mut self, render_height_minus_1: u16) -> Self { + self.render_height_minus_1 = render_height_minus_1; + self + } + pub fn interpolation_filter( + mut self, + interpolation_filter: crate::vk::AV1InterpolationFilter, + ) -> Self { + self.interpolation_filter = interpolation_filter; + self + } + pub fn tx_mode(mut self, tx_mode: crate::vk::AV1TxMode) -> Self { + self.tx_mode = tx_mode; + self + } + pub fn delta_q_res(mut self, delta_q_res: u8) -> Self { + self.delta_q_res = delta_q_res; + self + } + pub fn delta_lf_res(mut self, delta_lf_res: u8) -> Self { + self.delta_lf_res = delta_lf_res; + self + } + pub fn ref_order_hint( + mut self, + ref_order_hint: [u8; crate::vk::STD_VIDEO_AV1_NUM_REF_FRAMES as _], + ) -> Self { + self.ref_order_hint = ref_order_hint; + self + } + pub fn ref_frame_idx( + mut self, + ref_frame_idx: [i8; crate::vk::STD_VIDEO_AV1_REFS_PER_FRAME as _], + ) -> Self { + self.ref_frame_idx = ref_frame_idx; + self + } + pub fn reserved1(mut self, reserved1: [u8; 3 as _]) -> Self { + self.reserved1 = reserved1; + self + } + pub fn delta_frame_id_minus_1( + mut self, + delta_frame_id_minus_1: [u32; crate::vk::STD_VIDEO_AV1_REFS_PER_FRAME as _], + ) -> Self { + self.delta_frame_id_minus_1 = delta_frame_id_minus_1; + self + } + pub fn p_tile_info(mut self, p_tile_info: &'a crate::vk::AV1TileInfo<'a>) -> Self { + self.p_tile_info = p_tile_info; + self + } + pub fn p_quantization( + mut self, + p_quantization: &'a crate::vk::AV1Quantization, + ) -> Self { + self.p_quantization = p_quantization; + self + } + pub fn p_segmentation( + mut self, + p_segmentation: &'a crate::vk::AV1Segmentation, + ) -> Self { + self.p_segmentation = p_segmentation; + self + } + pub fn p_loop_filter(mut self, p_loop_filter: &'a crate::vk::AV1LoopFilter) -> Self { + self.p_loop_filter = p_loop_filter; + self + } + pub fn p_cdef(mut self, p_cdef: &'a crate::vk::AV1CDEF) -> Self { + self.p_cdef = p_cdef; + self + } + pub fn p_loop_restoration( + mut self, + p_loop_restoration: &'a crate::vk::AV1LoopRestoration, + ) -> Self { + self.p_loop_restoration = p_loop_restoration; + self + } + pub fn p_global_motion( + mut self, + p_global_motion: &'a crate::vk::AV1GlobalMotion, + ) -> Self { + self.p_global_motion = p_global_motion; + self + } + pub fn p_extension_header( + mut self, + p_extension_header: &'a crate::vk::EncodeAV1ExtensionHeader, + ) -> Self { + self.p_extension_header = p_extension_header; + self + } + pub fn p_buffer_removal_times(mut self, p_buffer_removal_times: &'a u32) -> Self { + self.p_buffer_removal_times = p_buffer_removal_times; + self + } +} #[repr(C)] -#[derive(Clone, Copy)] +#[derive(Clone, Copy, Default)] pub struct EncodeAV1ReferenceInfoFlags { /**- `disable_frame_end_update_cdf` @ `0..1` - `segmentation_enabled` @ `1..2`*/ pub bitfield0: u32, } +impl EncodeAV1ReferenceInfoFlags { + pub fn disable_frame_end_update_cdf( + mut self, + disable_frame_end_update_cdf: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFFFFFFFE; + self.bitfield0 = (disable_frame_end_update_cdf & 0x00000001) | rest; + self + } + pub fn segmentation_enabled(mut self, segmentation_enabled: u32) -> Self { + let rest = self.bitfield0 & 0xFFFFFFFD; + self.bitfield0 = ((segmentation_enabled << 1u32) & 0x00000002) | rest; + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct EncodeAV1ReferenceInfo<'a> { @@ -119,6 +572,48 @@ pub struct EncodeAV1ReferenceInfo<'a> { pub p_extension_header: *const crate::vk::EncodeAV1ExtensionHeader, pub _marker: ::core::marker::PhantomData<&'a ()>, } +impl<'a> Default for EncodeAV1ReferenceInfo<'a> { + fn default() -> Self { + Self { + flags: Default::default(), + ref_frame_id: Default::default(), + frame_type: Default::default(), + order_hint: Default::default(), + reserved1: unsafe { core::mem::zeroed() }, + p_extension_header: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> EncodeAV1ReferenceInfo<'a> { + pub fn flags(mut self, flags: crate::vk::EncodeAV1ReferenceInfoFlags) -> Self { + self.flags = flags; + self + } + pub fn ref_frame_id(mut self, ref_frame_id: u32) -> Self { + self.ref_frame_id = ref_frame_id; + self + } + pub fn frame_type(mut self, frame_type: crate::vk::AV1FrameType) -> Self { + self.frame_type = frame_type; + self + } + pub fn order_hint(mut self, order_hint: u8) -> Self { + self.order_hint = order_hint; + self + } + pub fn reserved1(mut self, reserved1: [u8; 3 as _]) -> Self { + self.reserved1 = reserved1; + self + } + pub fn p_extension_header( + mut self, + p_extension_header: &'a crate::vk::EncodeAV1ExtensionHeader, + ) -> Self { + self.p_extension_header = p_extension_header; + self + } +} pub const STD_VULKAN_VIDEO_CODEC_AV1_ENCODE_SPEC_VERSION: u32 = crate::vk::STD_VULKAN_VIDEO_CODEC_AV1_ENCODE_API_VERSION_1_0_0; pub const STD_VULKAN_VIDEO_CODEC_AV1_ENCODE_EXTENSION_NAME: &core::ffi::CStr = c"VK_STD_vulkan_video_codec_av1_encode"; pub const STD_VULKAN_VIDEO_CODEC_AV1_ENCODE_API_VERSION_1_0_0: u32 = crate::vk::make_video_std_version( diff --git a/ash-rewrite/src/generated/video/codec_h264std.rs b/ash-rewrite/src/generated/video/codec_h264std.rs index d786bb84a..f0bc74ac4 100644 --- a/ash-rewrite/src/generated/video/codec_h264std.rs +++ b/ash-rewrite/src/generated/video/codec_h264std.rs @@ -2,7 +2,7 @@ #![cfg_attr(rustfmt, rustfmt_skip)] //!Items provided by `vulkan_video_codec_h264std` #[repr(C)] -#[derive(Clone, Copy)] +#[derive(Clone, Copy, Default)] pub struct H264SpsVuiFlags { /**- `aspect_ratio_info_present_flag` @ `0..1` - `overscan_info_present_flag` @ `1..2` @@ -18,6 +18,94 @@ pub struct H264SpsVuiFlags { - `vcl_hrd_parameters_present_flag` @ `11..12`*/ pub bitfield0: u32, } +impl H264SpsVuiFlags { + pub fn aspect_ratio_info_present_flag( + mut self, + aspect_ratio_info_present_flag: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFFFFFFFE; + self.bitfield0 = (aspect_ratio_info_present_flag & 0x00000001) | rest; + self + } + pub fn overscan_info_present_flag( + mut self, + overscan_info_present_flag: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFFFFFFFD; + self.bitfield0 = ((overscan_info_present_flag << 1u32) & 0x00000002) | rest; + self + } + pub fn overscan_appropriate_flag(mut self, overscan_appropriate_flag: u32) -> Self { + let rest = self.bitfield0 & 0xFFFFFFFB; + self.bitfield0 = ((overscan_appropriate_flag << 2u32) & 0x00000004) | rest; + self + } + pub fn video_signal_type_present_flag( + mut self, + video_signal_type_present_flag: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFFFFFFF7; + self.bitfield0 = ((video_signal_type_present_flag << 3u32) & 0x00000008) | rest; + self + } + pub fn video_full_range_flag(mut self, video_full_range_flag: u32) -> Self { + let rest = self.bitfield0 & 0xFFFFFFEF; + self.bitfield0 = ((video_full_range_flag << 4u32) & 0x00000010) | rest; + self + } + pub fn color_description_present_flag( + mut self, + color_description_present_flag: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFFFFFFDF; + self.bitfield0 = ((color_description_present_flag << 5u32) & 0x00000020) | rest; + self + } + pub fn chroma_loc_info_present_flag( + mut self, + chroma_loc_info_present_flag: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFFFFFFBF; + self.bitfield0 = ((chroma_loc_info_present_flag << 6u32) & 0x00000040) | rest; + self + } + pub fn timing_info_present_flag(mut self, timing_info_present_flag: u32) -> Self { + let rest = self.bitfield0 & 0xFFFFFF7F; + self.bitfield0 = ((timing_info_present_flag << 7u32) & 0x00000080) | rest; + self + } + pub fn fixed_frame_rate_flag(mut self, fixed_frame_rate_flag: u32) -> Self { + let rest = self.bitfield0 & 0xFFFFFEFF; + self.bitfield0 = ((fixed_frame_rate_flag << 8u32) & 0x00000100) | rest; + self + } + pub fn bitstream_restriction_flag( + mut self, + bitstream_restriction_flag: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFFFFFDFF; + self.bitfield0 = ((bitstream_restriction_flag << 9u32) & 0x00000200) | rest; + self + } + pub fn nal_hrd_parameters_present_flag( + mut self, + nal_hrd_parameters_present_flag: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFFFFFBFF; + self.bitfield0 = ((nal_hrd_parameters_present_flag << 10u32) & 0x00000400) + | rest; + self + } + pub fn vcl_hrd_parameters_present_flag( + mut self, + vcl_hrd_parameters_present_flag: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFFFFF7FF; + self.bitfield0 = ((vcl_hrd_parameters_present_flag << 11u32) & 0x00000800) + | rest; + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct H264HrdParameters { @@ -33,8 +121,89 @@ pub struct H264HrdParameters { pub dpb_output_delay_length_minus1: u32, pub time_offset_length: u32, } +impl Default for H264HrdParameters { + fn default() -> Self { + Self { + cpb_cnt_minus1: Default::default(), + bit_rate_scale: Default::default(), + cpb_size_scale: Default::default(), + reserved1: Default::default(), + bit_rate_value_minus1: unsafe { core::mem::zeroed() }, + cpb_size_value_minus1: unsafe { core::mem::zeroed() }, + cbr_flag: unsafe { core::mem::zeroed() }, + initial_cpb_removal_delay_length_minus1: Default::default(), + cpb_removal_delay_length_minus1: Default::default(), + dpb_output_delay_length_minus1: Default::default(), + time_offset_length: Default::default(), + } + } +} +impl H264HrdParameters { + pub fn cpb_cnt_minus1(mut self, cpb_cnt_minus1: u8) -> Self { + self.cpb_cnt_minus1 = cpb_cnt_minus1; + self + } + pub fn bit_rate_scale(mut self, bit_rate_scale: u8) -> Self { + self.bit_rate_scale = bit_rate_scale; + self + } + pub fn cpb_size_scale(mut self, cpb_size_scale: u8) -> Self { + self.cpb_size_scale = cpb_size_scale; + self + } + pub fn reserved1(mut self, reserved1: u8) -> Self { + self.reserved1 = reserved1; + self + } + pub fn bit_rate_value_minus1( + mut self, + bit_rate_value_minus1: [u32; crate::vk::STD_VIDEO_H264_CPB_CNT_LIST_SIZE as _], + ) -> Self { + self.bit_rate_value_minus1 = bit_rate_value_minus1; + self + } + pub fn cpb_size_value_minus1( + mut self, + cpb_size_value_minus1: [u32; crate::vk::STD_VIDEO_H264_CPB_CNT_LIST_SIZE as _], + ) -> Self { + self.cpb_size_value_minus1 = cpb_size_value_minus1; + self + } + pub fn cbr_flag( + mut self, + cbr_flag: [u8; crate::vk::STD_VIDEO_H264_CPB_CNT_LIST_SIZE as _], + ) -> Self { + self.cbr_flag = cbr_flag; + self + } + pub fn initial_cpb_removal_delay_length_minus1( + mut self, + initial_cpb_removal_delay_length_minus1: u32, + ) -> Self { + self.initial_cpb_removal_delay_length_minus1 = initial_cpb_removal_delay_length_minus1; + self + } + pub fn cpb_removal_delay_length_minus1( + mut self, + cpb_removal_delay_length_minus1: u32, + ) -> Self { + self.cpb_removal_delay_length_minus1 = cpb_removal_delay_length_minus1; + self + } + pub fn dpb_output_delay_length_minus1( + mut self, + dpb_output_delay_length_minus1: u32, + ) -> Self { + self.dpb_output_delay_length_minus1 = dpb_output_delay_length_minus1; + self + } + pub fn time_offset_length(mut self, time_offset_length: u32) -> Self { + self.time_offset_length = time_offset_length; + self + } +} #[repr(C)] -#[derive(Clone, Copy)] +#[derive(Clone, Copy, Default)] pub struct H264SequenceParameterSetVui<'a> { pub flags: crate::vk::H264SpsVuiFlags, pub aspect_ratio_idc: crate::vk::H264AspectRatioIdc, @@ -54,8 +223,86 @@ pub struct H264SequenceParameterSetVui<'a> { pub p_hrd_parameters: *const crate::vk::H264HrdParameters, pub _marker: ::core::marker::PhantomData<&'a ()>, } +impl<'a> H264SequenceParameterSetVui<'a> { + pub fn flags(mut self, flags: crate::vk::H264SpsVuiFlags) -> Self { + self.flags = flags; + self + } + pub fn aspect_ratio_idc( + mut self, + aspect_ratio_idc: crate::vk::H264AspectRatioIdc, + ) -> Self { + self.aspect_ratio_idc = aspect_ratio_idc; + self + } + pub fn sar_width(mut self, sar_width: u16) -> Self { + self.sar_width = sar_width; + self + } + pub fn sar_height(mut self, sar_height: u16) -> Self { + self.sar_height = sar_height; + self + } + pub fn video_format(mut self, video_format: u8) -> Self { + self.video_format = video_format; + self + } + pub fn colour_primaries(mut self, colour_primaries: u8) -> Self { + self.colour_primaries = colour_primaries; + self + } + pub fn transfer_characteristics(mut self, transfer_characteristics: u8) -> Self { + self.transfer_characteristics = transfer_characteristics; + self + } + pub fn matrix_coefficients(mut self, matrix_coefficients: u8) -> Self { + self.matrix_coefficients = matrix_coefficients; + self + } + pub fn num_units_in_tick(mut self, num_units_in_tick: u32) -> Self { + self.num_units_in_tick = num_units_in_tick; + self + } + pub fn time_scale(mut self, time_scale: u32) -> Self { + self.time_scale = time_scale; + self + } + pub fn max_num_reorder_frames(mut self, max_num_reorder_frames: u8) -> Self { + self.max_num_reorder_frames = max_num_reorder_frames; + self + } + pub fn max_dec_frame_buffering(mut self, max_dec_frame_buffering: u8) -> Self { + self.max_dec_frame_buffering = max_dec_frame_buffering; + self + } + pub fn chroma_sample_loc_type_top_field( + mut self, + chroma_sample_loc_type_top_field: u8, + ) -> Self { + self.chroma_sample_loc_type_top_field = chroma_sample_loc_type_top_field; + self + } + pub fn chroma_sample_loc_type_bottom_field( + mut self, + chroma_sample_loc_type_bottom_field: u8, + ) -> Self { + self.chroma_sample_loc_type_bottom_field = chroma_sample_loc_type_bottom_field; + self + } + pub fn reserved1(mut self, reserved1: u32) -> Self { + self.reserved1 = reserved1; + self + } + pub fn p_hrd_parameters( + mut self, + p_hrd_parameters: &'a crate::vk::H264HrdParameters, + ) -> Self { + self.p_hrd_parameters = p_hrd_parameters; + self + } +} #[repr(C)] -#[derive(Clone, Copy)] +#[derive(Clone, Copy, Default)] pub struct H264SpsFlags { /**- `constraint_set0_flag` @ `0..1` - `constraint_set1_flag` @ `1..2` @@ -75,6 +322,113 @@ pub struct H264SpsFlags { - `vui_parameters_present_flag` @ `15..16`*/ pub bitfield0: u32, } +impl H264SpsFlags { + pub fn constraint_set0_flag(mut self, constraint_set0_flag: u32) -> Self { + let rest = self.bitfield0 & 0xFFFFFFFE; + self.bitfield0 = (constraint_set0_flag & 0x00000001) | rest; + self + } + pub fn constraint_set1_flag(mut self, constraint_set1_flag: u32) -> Self { + let rest = self.bitfield0 & 0xFFFFFFFD; + self.bitfield0 = ((constraint_set1_flag << 1u32) & 0x00000002) | rest; + self + } + pub fn constraint_set2_flag(mut self, constraint_set2_flag: u32) -> Self { + let rest = self.bitfield0 & 0xFFFFFFFB; + self.bitfield0 = ((constraint_set2_flag << 2u32) & 0x00000004) | rest; + self + } + pub fn constraint_set3_flag(mut self, constraint_set3_flag: u32) -> Self { + let rest = self.bitfield0 & 0xFFFFFFF7; + self.bitfield0 = ((constraint_set3_flag << 3u32) & 0x00000008) | rest; + self + } + pub fn constraint_set4_flag(mut self, constraint_set4_flag: u32) -> Self { + let rest = self.bitfield0 & 0xFFFFFFEF; + self.bitfield0 = ((constraint_set4_flag << 4u32) & 0x00000010) | rest; + self + } + pub fn constraint_set5_flag(mut self, constraint_set5_flag: u32) -> Self { + let rest = self.bitfield0 & 0xFFFFFFDF; + self.bitfield0 = ((constraint_set5_flag << 5u32) & 0x00000020) | rest; + self + } + pub fn direct_8x8_inference_flag(mut self, direct_8x8_inference_flag: u32) -> Self { + let rest = self.bitfield0 & 0xFFFFFFBF; + self.bitfield0 = ((direct_8x8_inference_flag << 6u32) & 0x00000040) | rest; + self + } + pub fn mb_adaptive_frame_field_flag( + mut self, + mb_adaptive_frame_field_flag: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFFFFFF7F; + self.bitfield0 = ((mb_adaptive_frame_field_flag << 7u32) & 0x00000080) | rest; + self + } + pub fn frame_mbs_only_flag(mut self, frame_mbs_only_flag: u32) -> Self { + let rest = self.bitfield0 & 0xFFFFFEFF; + self.bitfield0 = ((frame_mbs_only_flag << 8u32) & 0x00000100) | rest; + self + } + pub fn delta_pic_order_always_zero_flag( + mut self, + delta_pic_order_always_zero_flag: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFFFFFDFF; + self.bitfield0 = ((delta_pic_order_always_zero_flag << 9u32) & 0x00000200) + | rest; + self + } + pub fn separate_colour_plane_flag( + mut self, + separate_colour_plane_flag: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFFFFFBFF; + self.bitfield0 = ((separate_colour_plane_flag << 10u32) & 0x00000400) | rest; + self + } + pub fn gaps_in_frame_num_value_allowed_flag( + mut self, + gaps_in_frame_num_value_allowed_flag: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFFFFF7FF; + self.bitfield0 = ((gaps_in_frame_num_value_allowed_flag << 11u32) & 0x00000800) + | rest; + self + } + pub fn qpprime_y_zero_transform_bypass_flag( + mut self, + qpprime_y_zero_transform_bypass_flag: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFFFFEFFF; + self.bitfield0 = ((qpprime_y_zero_transform_bypass_flag << 12u32) & 0x00001000) + | rest; + self + } + pub fn frame_cropping_flag(mut self, frame_cropping_flag: u32) -> Self { + let rest = self.bitfield0 & 0xFFFFDFFF; + self.bitfield0 = ((frame_cropping_flag << 13u32) & 0x00002000) | rest; + self + } + pub fn seq_scaling_matrix_present_flag( + mut self, + seq_scaling_matrix_present_flag: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFFFFBFFF; + self.bitfield0 = ((seq_scaling_matrix_present_flag << 14u32) & 0x00004000) + | rest; + self + } + pub fn vui_parameters_present_flag( + mut self, + vui_parameters_present_flag: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFFFF7FFF; + self.bitfield0 = ((vui_parameters_present_flag << 15u32) & 0x00008000) | rest; + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct H264ScalingLists { @@ -85,8 +439,47 @@ pub struct H264ScalingLists { pub scaling_list8x8: [[u8; crate::vk::STD_VIDEO_H264_SCALING_LIST_8X8_NUM_ELEMENTS as _]; crate::vk::STD_VIDEO_H264_SCALING_LIST_8X8_NUM_LISTS as _], } +impl Default for H264ScalingLists { + fn default() -> Self { + Self { + scaling_list_present_mask: Default::default(), + use_default_scaling_matrix_mask: Default::default(), + scaling_list4x4: unsafe { core::mem::zeroed() }, + scaling_list8x8: unsafe { core::mem::zeroed() }, + } + } +} +impl H264ScalingLists { + pub fn scaling_list_present_mask(mut self, scaling_list_present_mask: u16) -> Self { + self.scaling_list_present_mask = scaling_list_present_mask; + self + } + pub fn use_default_scaling_matrix_mask( + mut self, + use_default_scaling_matrix_mask: u16, + ) -> Self { + self.use_default_scaling_matrix_mask = use_default_scaling_matrix_mask; + self + } + pub fn scaling_list4x4( + mut self, + scaling_list4x4: [[u8; crate::vk::STD_VIDEO_H264_SCALING_LIST_4X4_NUM_ELEMENTS + as _]; crate::vk::STD_VIDEO_H264_SCALING_LIST_4X4_NUM_LISTS as _], + ) -> Self { + self.scaling_list4x4 = scaling_list4x4; + self + } + pub fn scaling_list8x8( + mut self, + scaling_list8x8: [[u8; crate::vk::STD_VIDEO_H264_SCALING_LIST_8X8_NUM_ELEMENTS + as _]; crate::vk::STD_VIDEO_H264_SCALING_LIST_8X8_NUM_LISTS as _], + ) -> Self { + self.scaling_list8x8 = scaling_list8x8; + self + } +} #[repr(C)] -#[derive(Clone, Copy)] +#[derive(Clone, Copy, Default)] pub struct H264SequenceParameterSet<'a> { pub flags: crate::vk::H264SpsFlags, pub profile_idc: crate::vk::H264ProfileIdc, @@ -115,8 +508,135 @@ pub struct H264SequenceParameterSet<'a> { pub p_sequence_parameter_set_vui: *const crate::vk::H264SequenceParameterSetVui<'a>, pub _marker: ::core::marker::PhantomData<&'a ()>, } +impl<'a> H264SequenceParameterSet<'a> { + pub fn flags(mut self, flags: crate::vk::H264SpsFlags) -> Self { + self.flags = flags; + self + } + pub fn profile_idc(mut self, profile_idc: crate::vk::H264ProfileIdc) -> Self { + self.profile_idc = profile_idc; + self + } + pub fn level_idc(mut self, level_idc: crate::vk::H264LevelIdc) -> Self { + self.level_idc = level_idc; + self + } + pub fn chroma_format_idc( + mut self, + chroma_format_idc: crate::vk::H264ChromaFormatIdc, + ) -> Self { + self.chroma_format_idc = chroma_format_idc; + self + } + pub fn seq_parameter_set_id(mut self, seq_parameter_set_id: u8) -> Self { + self.seq_parameter_set_id = seq_parameter_set_id; + self + } + pub fn bit_depth_luma_minus8(mut self, bit_depth_luma_minus8: u8) -> Self { + self.bit_depth_luma_minus8 = bit_depth_luma_minus8; + self + } + pub fn bit_depth_chroma_minus8(mut self, bit_depth_chroma_minus8: u8) -> Self { + self.bit_depth_chroma_minus8 = bit_depth_chroma_minus8; + self + } + pub fn log2_max_frame_num_minus4(mut self, log2_max_frame_num_minus4: u8) -> Self { + self.log2_max_frame_num_minus4 = log2_max_frame_num_minus4; + self + } + pub fn pic_order_cnt_type( + mut self, + pic_order_cnt_type: crate::vk::H264PocType, + ) -> Self { + self.pic_order_cnt_type = pic_order_cnt_type; + self + } + pub fn offset_for_non_ref_pic(mut self, offset_for_non_ref_pic: i32) -> Self { + self.offset_for_non_ref_pic = offset_for_non_ref_pic; + self + } + pub fn offset_for_top_to_bottom_field( + mut self, + offset_for_top_to_bottom_field: i32, + ) -> Self { + self.offset_for_top_to_bottom_field = offset_for_top_to_bottom_field; + self + } + pub fn log2_max_pic_order_cnt_lsb_minus4( + mut self, + log2_max_pic_order_cnt_lsb_minus4: u8, + ) -> Self { + self.log2_max_pic_order_cnt_lsb_minus4 = log2_max_pic_order_cnt_lsb_minus4; + self + } + pub fn num_ref_frames_in_pic_order_cnt_cycle( + mut self, + num_ref_frames_in_pic_order_cnt_cycle: u8, + ) -> Self { + self.num_ref_frames_in_pic_order_cnt_cycle = num_ref_frames_in_pic_order_cnt_cycle; + self + } + pub fn max_num_ref_frames(mut self, max_num_ref_frames: u8) -> Self { + self.max_num_ref_frames = max_num_ref_frames; + self + } + pub fn reserved1(mut self, reserved1: u8) -> Self { + self.reserved1 = reserved1; + self + } + pub fn pic_width_in_mbs_minus1(mut self, pic_width_in_mbs_minus1: u32) -> Self { + self.pic_width_in_mbs_minus1 = pic_width_in_mbs_minus1; + self + } + pub fn pic_height_in_map_units_minus1( + mut self, + pic_height_in_map_units_minus1: u32, + ) -> Self { + self.pic_height_in_map_units_minus1 = pic_height_in_map_units_minus1; + self + } + pub fn frame_crop_left_offset(mut self, frame_crop_left_offset: u32) -> Self { + self.frame_crop_left_offset = frame_crop_left_offset; + self + } + pub fn frame_crop_right_offset(mut self, frame_crop_right_offset: u32) -> Self { + self.frame_crop_right_offset = frame_crop_right_offset; + self + } + pub fn frame_crop_top_offset(mut self, frame_crop_top_offset: u32) -> Self { + self.frame_crop_top_offset = frame_crop_top_offset; + self + } + pub fn frame_crop_bottom_offset(mut self, frame_crop_bottom_offset: u32) -> Self { + self.frame_crop_bottom_offset = frame_crop_bottom_offset; + self + } + pub fn reserved2(mut self, reserved2: u32) -> Self { + self.reserved2 = reserved2; + self + } + pub fn p_offset_for_ref_frame(mut self, p_offset_for_ref_frame: &'a [i32]) -> Self { + self.num_ref_frames_in_pic_order_cnt_cycle = p_offset_for_ref_frame.len() as _; + self.p_offset_for_ref_frame = p_offset_for_ref_frame.as_ptr(); + self + } + pub fn p_scaling_lists( + mut self, + p_scaling_lists: &'a crate::vk::H264ScalingLists, + ) -> Self { + self.p_scaling_lists = p_scaling_lists; + self + } + pub fn p_sequence_parameter_set_vui( + mut self, + p_sequence_parameter_set_vui: &'a crate::vk::H264SequenceParameterSetVui<'a>, + ) -> Self { + self.p_sequence_parameter_set_vui = p_sequence_parameter_set_vui; + self + } +} #[repr(C)] -#[derive(Clone, Copy)] +#[derive(Clone, Copy, Default)] pub struct H264PpsFlags { /**- `transform_8x8_mode_flag` @ `0..1` - `redundant_pic_cnt_present_flag` @ `1..2` @@ -128,8 +648,67 @@ pub struct H264PpsFlags { - `pic_scaling_matrix_present_flag` @ `7..8`*/ pub bitfield0: u32, } +impl H264PpsFlags { + pub fn transform_8x8_mode_flag(mut self, transform_8x8_mode_flag: u32) -> Self { + let rest = self.bitfield0 & 0xFFFFFFFE; + self.bitfield0 = (transform_8x8_mode_flag & 0x00000001) | rest; + self + } + pub fn redundant_pic_cnt_present_flag( + mut self, + redundant_pic_cnt_present_flag: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFFFFFFFD; + self.bitfield0 = ((redundant_pic_cnt_present_flag << 1u32) & 0x00000002) | rest; + self + } + pub fn constrained_intra_pred_flag( + mut self, + constrained_intra_pred_flag: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFFFFFFFB; + self.bitfield0 = ((constrained_intra_pred_flag << 2u32) & 0x00000004) | rest; + self + } + pub fn deblocking_filter_control_present_flag( + mut self, + deblocking_filter_control_present_flag: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFFFFFFF7; + self.bitfield0 = ((deblocking_filter_control_present_flag << 3u32) & 0x00000008) + | rest; + self + } + pub fn weighted_pred_flag(mut self, weighted_pred_flag: u32) -> Self { + let rest = self.bitfield0 & 0xFFFFFFEF; + self.bitfield0 = ((weighted_pred_flag << 4u32) & 0x00000010) | rest; + self + } + pub fn bottom_field_pic_order_in_frame_present_flag( + mut self, + bottom_field_pic_order_in_frame_present_flag: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFFFFFFDF; + self.bitfield0 = ((bottom_field_pic_order_in_frame_present_flag << 5u32) + & 0x00000020) | rest; + self + } + pub fn entropy_coding_mode_flag(mut self, entropy_coding_mode_flag: u32) -> Self { + let rest = self.bitfield0 & 0xFFFFFFBF; + self.bitfield0 = ((entropy_coding_mode_flag << 6u32) & 0x00000040) | rest; + self + } + pub fn pic_scaling_matrix_present_flag( + mut self, + pic_scaling_matrix_present_flag: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFFFFFF7F; + self.bitfield0 = ((pic_scaling_matrix_present_flag << 7u32) & 0x00000080) | rest; + self + } +} #[repr(C)] -#[derive(Clone, Copy)] +#[derive(Clone, Copy, Default)] pub struct H264PictureParameterSet<'a> { pub flags: crate::vk::H264PpsFlags, pub seq_parameter_set_id: u8, @@ -144,6 +723,67 @@ pub struct H264PictureParameterSet<'a> { pub p_scaling_lists: *const crate::vk::H264ScalingLists, pub _marker: ::core::marker::PhantomData<&'a ()>, } +impl<'a> H264PictureParameterSet<'a> { + pub fn flags(mut self, flags: crate::vk::H264PpsFlags) -> Self { + self.flags = flags; + self + } + pub fn seq_parameter_set_id(mut self, seq_parameter_set_id: u8) -> Self { + self.seq_parameter_set_id = seq_parameter_set_id; + self + } + pub fn pic_parameter_set_id(mut self, pic_parameter_set_id: u8) -> Self { + self.pic_parameter_set_id = pic_parameter_set_id; + self + } + pub fn num_ref_idx_l0_default_active_minus1( + mut self, + num_ref_idx_l0_default_active_minus1: u8, + ) -> Self { + self.num_ref_idx_l0_default_active_minus1 = num_ref_idx_l0_default_active_minus1; + self + } + pub fn num_ref_idx_l1_default_active_minus1( + mut self, + num_ref_idx_l1_default_active_minus1: u8, + ) -> Self { + self.num_ref_idx_l1_default_active_minus1 = num_ref_idx_l1_default_active_minus1; + self + } + pub fn weighted_bipred_idc( + mut self, + weighted_bipred_idc: crate::vk::H264WeightedBipredIdc, + ) -> Self { + self.weighted_bipred_idc = weighted_bipred_idc; + self + } + pub fn pic_init_qp_minus26(mut self, pic_init_qp_minus26: i8) -> Self { + self.pic_init_qp_minus26 = pic_init_qp_minus26; + self + } + pub fn pic_init_qs_minus26(mut self, pic_init_qs_minus26: i8) -> Self { + self.pic_init_qs_minus26 = pic_init_qs_minus26; + self + } + pub fn chroma_qp_index_offset(mut self, chroma_qp_index_offset: i8) -> Self { + self.chroma_qp_index_offset = chroma_qp_index_offset; + self + } + pub fn second_chroma_qp_index_offset( + mut self, + second_chroma_qp_index_offset: i8, + ) -> Self { + self.second_chroma_qp_index_offset = second_chroma_qp_index_offset; + self + } + pub fn p_scaling_lists( + mut self, + p_scaling_lists: &'a crate::vk::H264ScalingLists, + ) -> Self { + self.p_scaling_lists = p_scaling_lists; + self + } +} #[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[derive(Debug)] diff --git a/ash-rewrite/src/generated/video/codec_h264std_decode.rs b/ash-rewrite/src/generated/video/codec_h264std_decode.rs index 517f965fc..b2a1ded9d 100644 --- a/ash-rewrite/src/generated/video/codec_h264std_decode.rs +++ b/ash-rewrite/src/generated/video/codec_h264std_decode.rs @@ -2,7 +2,7 @@ #![cfg_attr(rustfmt, rustfmt_skip)] //!Items provided by `vulkan_video_codec_h264std_decode` #[repr(C)] -#[derive(Clone, Copy)] +#[derive(Clone, Copy, Default)] pub struct DecodeH264PictureInfoFlags { /**- `field_pic_flag` @ `0..1` - `is_intra` @ `1..2` @@ -12,6 +12,38 @@ pub struct DecodeH264PictureInfoFlags { - `complementary_field_pair` @ `5..6`*/ pub bitfield0: u32, } +impl DecodeH264PictureInfoFlags { + pub fn field_pic_flag(mut self, field_pic_flag: u32) -> Self { + let rest = self.bitfield0 & 0xFFFFFFFE; + self.bitfield0 = (field_pic_flag & 0x00000001) | rest; + self + } + pub fn is_intra(mut self, is_intra: u32) -> Self { + let rest = self.bitfield0 & 0xFFFFFFFD; + self.bitfield0 = ((is_intra << 1u32) & 0x00000002) | rest; + self + } + pub fn idr_pic_flag(mut self, idr_pic_flag: u32) -> Self { + let rest = self.bitfield0 & 0xFFFFFFFB; + self.bitfield0 = ((idr_pic_flag << 2u32) & 0x00000004) | rest; + self + } + pub fn bottom_field_flag(mut self, bottom_field_flag: u32) -> Self { + let rest = self.bitfield0 & 0xFFFFFFF7; + self.bitfield0 = ((bottom_field_flag << 3u32) & 0x00000008) | rest; + self + } + pub fn is_reference(mut self, is_reference: u32) -> Self { + let rest = self.bitfield0 & 0xFFFFFFEF; + self.bitfield0 = ((is_reference << 4u32) & 0x00000010) | rest; + self + } + pub fn complementary_field_pair(mut self, complementary_field_pair: u32) -> Self { + let rest = self.bitfield0 & 0xFFFFFFDF; + self.bitfield0 = ((complementary_field_pair << 5u32) & 0x00000020) | rest; + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct DecodeH264PictureInfo { @@ -25,8 +57,60 @@ pub struct DecodeH264PictureInfo { pub pic_order_cnt: [i32; crate::vk::STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_LIST_SIZE as _], } +impl Default for DecodeH264PictureInfo { + fn default() -> Self { + Self { + flags: Default::default(), + seq_parameter_set_id: Default::default(), + pic_parameter_set_id: Default::default(), + reserved1: Default::default(), + reserved2: Default::default(), + frame_num: Default::default(), + idr_pic_id: Default::default(), + pic_order_cnt: unsafe { core::mem::zeroed() }, + } + } +} +impl DecodeH264PictureInfo { + pub fn flags(mut self, flags: crate::vk::DecodeH264PictureInfoFlags) -> Self { + self.flags = flags; + self + } + pub fn seq_parameter_set_id(mut self, seq_parameter_set_id: u8) -> Self { + self.seq_parameter_set_id = seq_parameter_set_id; + self + } + pub fn pic_parameter_set_id(mut self, pic_parameter_set_id: u8) -> Self { + self.pic_parameter_set_id = pic_parameter_set_id; + self + } + pub fn reserved1(mut self, reserved1: u8) -> Self { + self.reserved1 = reserved1; + self + } + pub fn reserved2(mut self, reserved2: u8) -> Self { + self.reserved2 = reserved2; + self + } + pub fn frame_num(mut self, frame_num: u16) -> Self { + self.frame_num = frame_num; + self + } + pub fn idr_pic_id(mut self, idr_pic_id: u16) -> Self { + self.idr_pic_id = idr_pic_id; + self + } + pub fn pic_order_cnt( + mut self, + pic_order_cnt: [i32; crate::vk::STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_LIST_SIZE + as _], + ) -> Self { + self.pic_order_cnt = pic_order_cnt; + self + } +} #[repr(C)] -#[derive(Clone, Copy)] +#[derive(Clone, Copy, Default)] pub struct DecodeH264ReferenceInfoFlags { /**- `top_field_flag` @ `0..1` - `bottom_field_flag` @ `1..2` @@ -34,6 +118,31 @@ pub struct DecodeH264ReferenceInfoFlags { - `is_non_existing` @ `3..4`*/ pub bitfield0: u32, } +impl DecodeH264ReferenceInfoFlags { + pub fn top_field_flag(mut self, top_field_flag: u32) -> Self { + let rest = self.bitfield0 & 0xFFFFFFFE; + self.bitfield0 = (top_field_flag & 0x00000001) | rest; + self + } + pub fn bottom_field_flag(mut self, bottom_field_flag: u32) -> Self { + let rest = self.bitfield0 & 0xFFFFFFFD; + self.bitfield0 = ((bottom_field_flag << 1u32) & 0x00000002) | rest; + self + } + pub fn used_for_long_term_reference( + mut self, + used_for_long_term_reference: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFFFFFFFB; + self.bitfield0 = ((used_for_long_term_reference << 2u32) & 0x00000004) | rest; + self + } + pub fn is_non_existing(mut self, is_non_existing: u32) -> Self { + let rest = self.bitfield0 & 0xFFFFFFF7; + self.bitfield0 = ((is_non_existing << 3u32) & 0x00000008) | rest; + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct DecodeH264ReferenceInfo { @@ -43,6 +152,38 @@ pub struct DecodeH264ReferenceInfo { pub pic_order_cnt: [i32; crate::vk::STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_LIST_SIZE as _], } +impl Default for DecodeH264ReferenceInfo { + fn default() -> Self { + Self { + flags: Default::default(), + frame_num: Default::default(), + reserved: Default::default(), + pic_order_cnt: unsafe { core::mem::zeroed() }, + } + } +} +impl DecodeH264ReferenceInfo { + pub fn flags(mut self, flags: crate::vk::DecodeH264ReferenceInfoFlags) -> Self { + self.flags = flags; + self + } + pub fn frame_num(mut self, frame_num: u16) -> Self { + self.frame_num = frame_num; + self + } + pub fn reserved(mut self, reserved: u16) -> Self { + self.reserved = reserved; + self + } + pub fn pic_order_cnt( + mut self, + pic_order_cnt: [i32; crate::vk::STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_LIST_SIZE + as _], + ) -> Self { + self.pic_order_cnt = pic_order_cnt; + self + } +} #[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[derive(Debug)] diff --git a/ash-rewrite/src/generated/video/codec_h264std_encode.rs b/ash-rewrite/src/generated/video/codec_h264std_encode.rs index 89664bc54..bd9c2a2a3 100644 --- a/ash-rewrite/src/generated/video/codec_h264std_encode.rs +++ b/ash-rewrite/src/generated/video/codec_h264std_encode.rs @@ -2,13 +2,31 @@ #![cfg_attr(rustfmt, rustfmt_skip)] //!Items provided by `vulkan_video_codec_h264std_encode` #[repr(C)] -#[derive(Clone, Copy)] +#[derive(Clone, Copy, Default)] pub struct EncodeH264WeightTableFlags { pub luma_weight_l0_flag: u32, pub chroma_weight_l0_flag: u32, pub luma_weight_l1_flag: u32, pub chroma_weight_l1_flag: u32, } +impl EncodeH264WeightTableFlags { + pub fn luma_weight_l0_flag(mut self, luma_weight_l0_flag: u32) -> Self { + self.luma_weight_l0_flag = luma_weight_l0_flag; + self + } + pub fn chroma_weight_l0_flag(mut self, chroma_weight_l0_flag: u32) -> Self { + self.chroma_weight_l0_flag = chroma_weight_l0_flag; + self + } + pub fn luma_weight_l1_flag(mut self, luma_weight_l1_flag: u32) -> Self { + self.luma_weight_l1_flag = luma_weight_l1_flag; + self + } + pub fn chroma_weight_l1_flag(mut self, chroma_weight_l1_flag: u32) -> Self { + self.chroma_weight_l1_flag = chroma_weight_l1_flag; + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct EncodeH264WeightTable { @@ -28,15 +46,125 @@ pub struct EncodeH264WeightTable { pub chroma_offset_l1: [[i8; crate::vk::STD_VIDEO_H264_MAX_CHROMA_PLANES as _]; crate::vk::STD_VIDEO_H264_MAX_NUM_LIST_REF as _], } +impl Default for EncodeH264WeightTable { + fn default() -> Self { + Self { + flags: Default::default(), + luma_log2_weight_denom: Default::default(), + chroma_log2_weight_denom: Default::default(), + luma_weight_l0: unsafe { core::mem::zeroed() }, + luma_offset_l0: unsafe { core::mem::zeroed() }, + chroma_weight_l0: unsafe { core::mem::zeroed() }, + chroma_offset_l0: unsafe { core::mem::zeroed() }, + luma_weight_l1: unsafe { core::mem::zeroed() }, + luma_offset_l1: unsafe { core::mem::zeroed() }, + chroma_weight_l1: unsafe { core::mem::zeroed() }, + chroma_offset_l1: unsafe { core::mem::zeroed() }, + } + } +} +impl EncodeH264WeightTable { + pub fn flags(mut self, flags: crate::vk::EncodeH264WeightTableFlags) -> Self { + self.flags = flags; + self + } + pub fn luma_log2_weight_denom(mut self, luma_log2_weight_denom: u8) -> Self { + self.luma_log2_weight_denom = luma_log2_weight_denom; + self + } + pub fn chroma_log2_weight_denom(mut self, chroma_log2_weight_denom: u8) -> Self { + self.chroma_log2_weight_denom = chroma_log2_weight_denom; + self + } + pub fn luma_weight_l0( + mut self, + luma_weight_l0: [i8; crate::vk::STD_VIDEO_H264_MAX_NUM_LIST_REF as _], + ) -> Self { + self.luma_weight_l0 = luma_weight_l0; + self + } + pub fn luma_offset_l0( + mut self, + luma_offset_l0: [i8; crate::vk::STD_VIDEO_H264_MAX_NUM_LIST_REF as _], + ) -> Self { + self.luma_offset_l0 = luma_offset_l0; + self + } + pub fn chroma_weight_l0( + mut self, + chroma_weight_l0: [[i8; crate::vk::STD_VIDEO_H264_MAX_CHROMA_PLANES + as _]; crate::vk::STD_VIDEO_H264_MAX_NUM_LIST_REF as _], + ) -> Self { + self.chroma_weight_l0 = chroma_weight_l0; + self + } + pub fn chroma_offset_l0( + mut self, + chroma_offset_l0: [[i8; crate::vk::STD_VIDEO_H264_MAX_CHROMA_PLANES + as _]; crate::vk::STD_VIDEO_H264_MAX_NUM_LIST_REF as _], + ) -> Self { + self.chroma_offset_l0 = chroma_offset_l0; + self + } + pub fn luma_weight_l1( + mut self, + luma_weight_l1: [i8; crate::vk::STD_VIDEO_H264_MAX_NUM_LIST_REF as _], + ) -> Self { + self.luma_weight_l1 = luma_weight_l1; + self + } + pub fn luma_offset_l1( + mut self, + luma_offset_l1: [i8; crate::vk::STD_VIDEO_H264_MAX_NUM_LIST_REF as _], + ) -> Self { + self.luma_offset_l1 = luma_offset_l1; + self + } + pub fn chroma_weight_l1( + mut self, + chroma_weight_l1: [[i8; crate::vk::STD_VIDEO_H264_MAX_CHROMA_PLANES + as _]; crate::vk::STD_VIDEO_H264_MAX_NUM_LIST_REF as _], + ) -> Self { + self.chroma_weight_l1 = chroma_weight_l1; + self + } + pub fn chroma_offset_l1( + mut self, + chroma_offset_l1: [[i8; crate::vk::STD_VIDEO_H264_MAX_CHROMA_PLANES + as _]; crate::vk::STD_VIDEO_H264_MAX_NUM_LIST_REF as _], + ) -> Self { + self.chroma_offset_l1 = chroma_offset_l1; + self + } +} #[repr(C)] -#[derive(Clone, Copy)] +#[derive(Clone, Copy, Default)] pub struct EncodeH264SliceHeaderFlags { /**- `direct_spatial_mv_pred_flag` @ `0..1` - `num_ref_idx_active_override_flag` @ `1..2`*/ pub bitfield0: u32, } +impl EncodeH264SliceHeaderFlags { + pub fn direct_spatial_mv_pred_flag( + mut self, + direct_spatial_mv_pred_flag: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFFFFFFFE; + self.bitfield0 = (direct_spatial_mv_pred_flag & 0x00000001) | rest; + self + } + pub fn num_ref_idx_active_override_flag( + mut self, + num_ref_idx_active_override_flag: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFFFFFFFD; + self.bitfield0 = ((num_ref_idx_active_override_flag << 1u32) & 0x00000002) + | rest; + self + } +} #[repr(C)] -#[derive(Clone, Copy)] +#[derive(Clone, Copy, Default)] pub struct EncodeH264PictureInfoFlags { /**- `IdrPicFlag` @ `0..1` - `is_reference` @ `1..2` @@ -45,28 +173,108 @@ pub struct EncodeH264PictureInfoFlags { - `adaptive_ref_pic_marking_mode_flag` @ `4..5`*/ pub bitfield0: u32, } +impl EncodeH264PictureInfoFlags { + pub fn idr_pic_flag(mut self, idr_pic_flag: u32) -> Self { + let rest = self.bitfield0 & 0xFFFFFFFE; + self.bitfield0 = (idr_pic_flag & 0x00000001) | rest; + self + } + pub fn is_reference(mut self, is_reference: u32) -> Self { + let rest = self.bitfield0 & 0xFFFFFFFD; + self.bitfield0 = ((is_reference << 1u32) & 0x00000002) | rest; + self + } + pub fn no_output_of_prior_pics_flag( + mut self, + no_output_of_prior_pics_flag: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFFFFFFFB; + self.bitfield0 = ((no_output_of_prior_pics_flag << 2u32) & 0x00000004) | rest; + self + } + pub fn long_term_reference_flag(mut self, long_term_reference_flag: u32) -> Self { + let rest = self.bitfield0 & 0xFFFFFFF7; + self.bitfield0 = ((long_term_reference_flag << 3u32) & 0x00000008) | rest; + self + } + pub fn adaptive_ref_pic_marking_mode_flag( + mut self, + adaptive_ref_pic_marking_mode_flag: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFFFFFFEF; + self.bitfield0 = ((adaptive_ref_pic_marking_mode_flag << 4u32) & 0x00000010) + | rest; + self + } +} #[repr(C)] -#[derive(Clone, Copy)] +#[derive(Clone, Copy, Default)] pub struct EncodeH264ReferenceInfoFlags { ///- `used_for_long_term_reference` @ `0..1` pub bitfield0: u32, } +impl EncodeH264ReferenceInfoFlags { + pub fn used_for_long_term_reference( + mut self, + used_for_long_term_reference: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFFFFFFFE; + self.bitfield0 = (used_for_long_term_reference & 0x00000001) | rest; + self + } +} #[repr(C)] -#[derive(Clone, Copy)] +#[derive(Clone, Copy, Default)] pub struct EncodeH264ReferenceListsInfoFlags { /**- `ref_pic_list_modification_flag_l0` @ `0..1` - `ref_pic_list_modification_flag_l1` @ `1..2`*/ pub bitfield0: u32, } +impl EncodeH264ReferenceListsInfoFlags { + pub fn ref_pic_list_modification_flag_l0( + mut self, + ref_pic_list_modification_flag_l0: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFFFFFFFE; + self.bitfield0 = (ref_pic_list_modification_flag_l0 & 0x00000001) | rest; + self + } + pub fn ref_pic_list_modification_flag_l1( + mut self, + ref_pic_list_modification_flag_l1: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFFFFFFFD; + self.bitfield0 = ((ref_pic_list_modification_flag_l1 << 1u32) & 0x00000002) + | rest; + self + } +} #[repr(C)] -#[derive(Clone, Copy)] +#[derive(Clone, Copy, Default)] pub struct EncodeH264RefListModEntry { pub modification_of_pic_nums_idc: crate::vk::H264ModificationOfPicNumsIdc, pub abs_diff_pic_num_minus1: u16, pub long_term_pic_num: u16, } +impl EncodeH264RefListModEntry { + pub fn modification_of_pic_nums_idc( + mut self, + modification_of_pic_nums_idc: crate::vk::H264ModificationOfPicNumsIdc, + ) -> Self { + self.modification_of_pic_nums_idc = modification_of_pic_nums_idc; + self + } + pub fn abs_diff_pic_num_minus1(mut self, abs_diff_pic_num_minus1: u16) -> Self { + self.abs_diff_pic_num_minus1 = abs_diff_pic_num_minus1; + self + } + pub fn long_term_pic_num(mut self, long_term_pic_num: u16) -> Self { + self.long_term_pic_num = long_term_pic_num; + self + } +} #[repr(C)] -#[derive(Clone, Copy)] +#[derive(Clone, Copy, Default)] pub struct EncodeH264RefPicMarkingEntry { pub memory_management_control_operation: crate::vk::H264MemMgmtControlOp, pub difference_of_pic_nums_minus1: u16, @@ -74,6 +282,37 @@ pub struct EncodeH264RefPicMarkingEntry { pub long_term_frame_idx: u16, pub max_long_term_frame_idx_plus1: u16, } +impl EncodeH264RefPicMarkingEntry { + pub fn memory_management_control_operation( + mut self, + memory_management_control_operation: crate::vk::H264MemMgmtControlOp, + ) -> Self { + self.memory_management_control_operation = memory_management_control_operation; + self + } + pub fn difference_of_pic_nums_minus1( + mut self, + difference_of_pic_nums_minus1: u16, + ) -> Self { + self.difference_of_pic_nums_minus1 = difference_of_pic_nums_minus1; + self + } + pub fn long_term_pic_num(mut self, long_term_pic_num: u16) -> Self { + self.long_term_pic_num = long_term_pic_num; + self + } + pub fn long_term_frame_idx(mut self, long_term_frame_idx: u16) -> Self { + self.long_term_frame_idx = long_term_frame_idx; + self + } + pub fn max_long_term_frame_idx_plus1( + mut self, + max_long_term_frame_idx_plus1: u16, + ) -> Self { + self.max_long_term_frame_idx_plus1 = max_long_term_frame_idx_plus1; + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct EncodeH264ReferenceListsInfo<'a> { @@ -91,6 +330,99 @@ pub struct EncodeH264ReferenceListsInfo<'a> { pub p_ref_pic_marking_operations: *const crate::vk::EncodeH264RefPicMarkingEntry, pub _marker: ::core::marker::PhantomData<&'a ()>, } +impl<'a> Default for EncodeH264ReferenceListsInfo<'a> { + fn default() -> Self { + Self { + flags: Default::default(), + num_ref_idx_l0_active_minus1: Default::default(), + num_ref_idx_l1_active_minus1: Default::default(), + ref_pic_list0: unsafe { core::mem::zeroed() }, + ref_pic_list1: unsafe { core::mem::zeroed() }, + ref_list0_mod_op_count: Default::default(), + ref_list1_mod_op_count: Default::default(), + ref_pic_marking_op_count: Default::default(), + reserved1: unsafe { core::mem::zeroed() }, + p_ref_list0_mod_operations: Default::default(), + p_ref_list1_mod_operations: Default::default(), + p_ref_pic_marking_operations: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> EncodeH264ReferenceListsInfo<'a> { + pub fn flags(mut self, flags: crate::vk::EncodeH264ReferenceListsInfoFlags) -> Self { + self.flags = flags; + self + } + pub fn num_ref_idx_l0_active_minus1( + mut self, + num_ref_idx_l0_active_minus1: u8, + ) -> Self { + self.num_ref_idx_l0_active_minus1 = num_ref_idx_l0_active_minus1; + self + } + pub fn num_ref_idx_l1_active_minus1( + mut self, + num_ref_idx_l1_active_minus1: u8, + ) -> Self { + self.num_ref_idx_l1_active_minus1 = num_ref_idx_l1_active_minus1; + self + } + pub fn ref_pic_list0( + mut self, + ref_pic_list0: [u8; crate::vk::STD_VIDEO_H264_MAX_NUM_LIST_REF as _], + ) -> Self { + self.ref_pic_list0 = ref_pic_list0; + self + } + pub fn ref_pic_list1( + mut self, + ref_pic_list1: [u8; crate::vk::STD_VIDEO_H264_MAX_NUM_LIST_REF as _], + ) -> Self { + self.ref_pic_list1 = ref_pic_list1; + self + } + pub fn ref_list0_mod_op_count(mut self, ref_list0_mod_op_count: u8) -> Self { + self.ref_list0_mod_op_count = ref_list0_mod_op_count; + self + } + pub fn ref_list1_mod_op_count(mut self, ref_list1_mod_op_count: u8) -> Self { + self.ref_list1_mod_op_count = ref_list1_mod_op_count; + self + } + pub fn ref_pic_marking_op_count(mut self, ref_pic_marking_op_count: u8) -> Self { + self.ref_pic_marking_op_count = ref_pic_marking_op_count; + self + } + pub fn reserved1(mut self, reserved1: [u8; 7 as _]) -> Self { + self.reserved1 = reserved1; + self + } + pub fn p_ref_list0_mod_operations( + mut self, + p_ref_list0_mod_operations: &'a [crate::vk::EncodeH264RefListModEntry], + ) -> Self { + self.ref_list0_mod_op_count = p_ref_list0_mod_operations.len() as _; + self.p_ref_list0_mod_operations = p_ref_list0_mod_operations.as_ptr(); + self + } + pub fn p_ref_list1_mod_operations( + mut self, + p_ref_list1_mod_operations: &'a [crate::vk::EncodeH264RefListModEntry], + ) -> Self { + self.ref_list1_mod_op_count = p_ref_list1_mod_operations.len() as _; + self.p_ref_list1_mod_operations = p_ref_list1_mod_operations.as_ptr(); + self + } + pub fn p_ref_pic_marking_operations( + mut self, + p_ref_pic_marking_operations: &'a [crate::vk::EncodeH264RefPicMarkingEntry], + ) -> Self { + self.ref_pic_marking_op_count = p_ref_pic_marking_operations.len() as _; + self.p_ref_pic_marking_operations = p_ref_pic_marking_operations.as_ptr(); + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct EncodeH264PictureInfo<'a> { @@ -106,8 +438,73 @@ pub struct EncodeH264PictureInfo<'a> { pub p_ref_lists: *const crate::vk::EncodeH264ReferenceListsInfo<'a>, pub _marker: ::core::marker::PhantomData<&'a ()>, } +impl<'a> Default for EncodeH264PictureInfo<'a> { + fn default() -> Self { + Self { + flags: Default::default(), + seq_parameter_set_id: Default::default(), + pic_parameter_set_id: Default::default(), + idr_pic_id: Default::default(), + primary_pic_type: Default::default(), + frame_num: Default::default(), + pic_order_cnt: Default::default(), + temporal_id: Default::default(), + reserved1: unsafe { core::mem::zeroed() }, + p_ref_lists: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> EncodeH264PictureInfo<'a> { + pub fn flags(mut self, flags: crate::vk::EncodeH264PictureInfoFlags) -> Self { + self.flags = flags; + self + } + pub fn seq_parameter_set_id(mut self, seq_parameter_set_id: u8) -> Self { + self.seq_parameter_set_id = seq_parameter_set_id; + self + } + pub fn pic_parameter_set_id(mut self, pic_parameter_set_id: u8) -> Self { + self.pic_parameter_set_id = pic_parameter_set_id; + self + } + pub fn idr_pic_id(mut self, idr_pic_id: u16) -> Self { + self.idr_pic_id = idr_pic_id; + self + } + pub fn primary_pic_type( + mut self, + primary_pic_type: crate::vk::H264PictureType, + ) -> Self { + self.primary_pic_type = primary_pic_type; + self + } + pub fn frame_num(mut self, frame_num: u32) -> Self { + self.frame_num = frame_num; + self + } + pub fn pic_order_cnt(mut self, pic_order_cnt: i32) -> Self { + self.pic_order_cnt = pic_order_cnt; + self + } + pub fn temporal_id(mut self, temporal_id: u8) -> Self { + self.temporal_id = temporal_id; + self + } + pub fn reserved1(mut self, reserved1: [u8; 3 as _]) -> Self { + self.reserved1 = reserved1; + self + } + pub fn p_ref_lists( + mut self, + p_ref_lists: &'a crate::vk::EncodeH264ReferenceListsInfo<'a>, + ) -> Self { + self.p_ref_lists = p_ref_lists; + self + } +} #[repr(C)] -#[derive(Clone, Copy)] +#[derive(Clone, Copy, Default)] pub struct EncodeH264ReferenceInfo { pub flags: crate::vk::EncodeH264ReferenceInfoFlags, pub primary_pic_type: crate::vk::H264PictureType, @@ -117,8 +514,41 @@ pub struct EncodeH264ReferenceInfo { pub long_term_frame_idx: u16, pub temporal_id: u8, } +impl EncodeH264ReferenceInfo { + pub fn flags(mut self, flags: crate::vk::EncodeH264ReferenceInfoFlags) -> Self { + self.flags = flags; + self + } + pub fn primary_pic_type( + mut self, + primary_pic_type: crate::vk::H264PictureType, + ) -> Self { + self.primary_pic_type = primary_pic_type; + self + } + pub fn frame_num(mut self, frame_num: u32) -> Self { + self.frame_num = frame_num; + self + } + pub fn pic_order_cnt(mut self, pic_order_cnt: i32) -> Self { + self.pic_order_cnt = pic_order_cnt; + self + } + pub fn long_term_pic_num(mut self, long_term_pic_num: u16) -> Self { + self.long_term_pic_num = long_term_pic_num; + self + } + pub fn long_term_frame_idx(mut self, long_term_frame_idx: u16) -> Self { + self.long_term_frame_idx = long_term_frame_idx; + self + } + pub fn temporal_id(mut self, temporal_id: u8) -> Self { + self.temporal_id = temporal_id; + self + } +} #[repr(C)] -#[derive(Clone, Copy)] +#[derive(Clone, Copy, Default)] pub struct EncodeH264SliceHeader<'a> { pub flags: crate::vk::EncodeH264SliceHeaderFlags, pub first_mb_in_slice: u32, @@ -132,6 +562,57 @@ pub struct EncodeH264SliceHeader<'a> { pub p_weight_table: *const crate::vk::EncodeH264WeightTable, pub _marker: ::core::marker::PhantomData<&'a ()>, } +impl<'a> EncodeH264SliceHeader<'a> { + pub fn flags(mut self, flags: crate::vk::EncodeH264SliceHeaderFlags) -> Self { + self.flags = flags; + self + } + pub fn first_mb_in_slice(mut self, first_mb_in_slice: u32) -> Self { + self.first_mb_in_slice = first_mb_in_slice; + self + } + pub fn slice_type(mut self, slice_type: crate::vk::H264SliceType) -> Self { + self.slice_type = slice_type; + self + } + pub fn slice_alpha_c0_offset_div2(mut self, slice_alpha_c0_offset_div2: i8) -> Self { + self.slice_alpha_c0_offset_div2 = slice_alpha_c0_offset_div2; + self + } + pub fn slice_beta_offset_div2(mut self, slice_beta_offset_div2: i8) -> Self { + self.slice_beta_offset_div2 = slice_beta_offset_div2; + self + } + pub fn slice_qp_delta(mut self, slice_qp_delta: i8) -> Self { + self.slice_qp_delta = slice_qp_delta; + self + } + pub fn reserved1(mut self, reserved1: u8) -> Self { + self.reserved1 = reserved1; + self + } + pub fn cabac_init_idc( + mut self, + cabac_init_idc: crate::vk::H264CabacInitIdc, + ) -> Self { + self.cabac_init_idc = cabac_init_idc; + self + } + pub fn disable_deblocking_filter_idc( + mut self, + disable_deblocking_filter_idc: crate::vk::H264DisableDeblockingFilterIdc, + ) -> Self { + self.disable_deblocking_filter_idc = disable_deblocking_filter_idc; + self + } + pub fn p_weight_table( + mut self, + p_weight_table: &'a crate::vk::EncodeH264WeightTable, + ) -> Self { + self.p_weight_table = p_weight_table; + self + } +} pub const STD_VULKAN_VIDEO_CODEC_H264_ENCODE_SPEC_VERSION: u32 = crate::vk::STD_VULKAN_VIDEO_CODEC_H264_ENCODE_API_VERSION_1_0_0; pub const STD_VULKAN_VIDEO_CODEC_H264_ENCODE_EXTENSION_NAME: &core::ffi::CStr = c"VK_STD_vulkan_video_codec_h264_encode"; pub const STD_VULKAN_VIDEO_CODEC_H264_ENCODE_API_VERSION_1_0_0: u32 = crate::vk::make_video_std_version( diff --git a/ash-rewrite/src/generated/video/codec_h265std.rs b/ash-rewrite/src/generated/video/codec_h265std.rs index 6dd43dfe9..d9c6a3171 100644 --- a/ash-rewrite/src/generated/video/codec_h265std.rs +++ b/ash-rewrite/src/generated/video/codec_h265std.rs @@ -2,7 +2,7 @@ #![cfg_attr(rustfmt, rustfmt_skip)] //!Items provided by `vulkan_video_codec_h265std` #[repr(C)] -#[derive(Clone, Copy)] +#[derive(Clone, Copy, Default)] pub struct H265ProfileTierLevelFlags { /**- `general_tier_flag` @ `0..1` - `general_progressive_source_flag` @ `1..2` @@ -11,13 +11,74 @@ pub struct H265ProfileTierLevelFlags { - `general_frame_only_constraint_flag` @ `4..5`*/ pub bitfield0: u32, } +impl H265ProfileTierLevelFlags { + pub fn general_tier_flag(mut self, general_tier_flag: u32) -> Self { + let rest = self.bitfield0 & 0xFFFFFFFE; + self.bitfield0 = (general_tier_flag & 0x00000001) | rest; + self + } + pub fn general_progressive_source_flag( + mut self, + general_progressive_source_flag: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFFFFFFFD; + self.bitfield0 = ((general_progressive_source_flag << 1u32) & 0x00000002) | rest; + self + } + pub fn general_interlaced_source_flag( + mut self, + general_interlaced_source_flag: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFFFFFFFB; + self.bitfield0 = ((general_interlaced_source_flag << 2u32) & 0x00000004) | rest; + self + } + pub fn general_non_packed_constraint_flag( + mut self, + general_non_packed_constraint_flag: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFFFFFFF7; + self.bitfield0 = ((general_non_packed_constraint_flag << 3u32) & 0x00000008) + | rest; + self + } + pub fn general_frame_only_constraint_flag( + mut self, + general_frame_only_constraint_flag: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFFFFFFEF; + self.bitfield0 = ((general_frame_only_constraint_flag << 4u32) & 0x00000010) + | rest; + self + } +} #[repr(C)] -#[derive(Clone, Copy)] +#[derive(Clone, Copy, Default)] pub struct H265ProfileTierLevel { pub flags: crate::vk::H265ProfileTierLevelFlags, pub general_profile_idc: crate::vk::H265ProfileIdc, pub general_level_idc: crate::vk::H265LevelIdc, } +impl H265ProfileTierLevel { + pub fn flags(mut self, flags: crate::vk::H265ProfileTierLevelFlags) -> Self { + self.flags = flags; + self + } + pub fn general_profile_idc( + mut self, + general_profile_idc: crate::vk::H265ProfileIdc, + ) -> Self { + self.general_profile_idc = general_profile_idc; + self + } + pub fn general_level_idc( + mut self, + general_level_idc: crate::vk::H265LevelIdc, + ) -> Self { + self.general_level_idc = general_level_idc; + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct H265DecPicBufMgr { @@ -27,6 +88,40 @@ pub struct H265DecPicBufMgr { as _], pub max_num_reorder_pics: [u8; crate::vk::STD_VIDEO_H265_SUBLAYERS_LIST_SIZE as _], } +impl Default for H265DecPicBufMgr { + fn default() -> Self { + Self { + max_latency_increase_plus1: unsafe { core::mem::zeroed() }, + max_dec_pic_buffering_minus1: unsafe { core::mem::zeroed() }, + max_num_reorder_pics: unsafe { core::mem::zeroed() }, + } + } +} +impl H265DecPicBufMgr { + pub fn max_latency_increase_plus1( + mut self, + max_latency_increase_plus1: [u32; crate::vk::STD_VIDEO_H265_SUBLAYERS_LIST_SIZE + as _], + ) -> Self { + self.max_latency_increase_plus1 = max_latency_increase_plus1; + self + } + pub fn max_dec_pic_buffering_minus1( + mut self, + max_dec_pic_buffering_minus1: [u8; crate::vk::STD_VIDEO_H265_SUBLAYERS_LIST_SIZE + as _], + ) -> Self { + self.max_dec_pic_buffering_minus1 = max_dec_pic_buffering_minus1; + self + } + pub fn max_num_reorder_pics( + mut self, + max_num_reorder_pics: [u8; crate::vk::STD_VIDEO_H265_SUBLAYERS_LIST_SIZE as _], + ) -> Self { + self.max_num_reorder_pics = max_num_reorder_pics; + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct H265SubLayerHrdParameters { @@ -38,8 +133,53 @@ pub struct H265SubLayerHrdParameters { as _], pub cbr_flag: u32, } +impl Default for H265SubLayerHrdParameters { + fn default() -> Self { + Self { + bit_rate_value_minus1: unsafe { core::mem::zeroed() }, + cpb_size_value_minus1: unsafe { core::mem::zeroed() }, + cpb_size_du_value_minus1: unsafe { core::mem::zeroed() }, + bit_rate_du_value_minus1: unsafe { core::mem::zeroed() }, + cbr_flag: Default::default(), + } + } +} +impl H265SubLayerHrdParameters { + pub fn bit_rate_value_minus1( + mut self, + bit_rate_value_minus1: [u32; crate::vk::STD_VIDEO_H265_CPB_CNT_LIST_SIZE as _], + ) -> Self { + self.bit_rate_value_minus1 = bit_rate_value_minus1; + self + } + pub fn cpb_size_value_minus1( + mut self, + cpb_size_value_minus1: [u32; crate::vk::STD_VIDEO_H265_CPB_CNT_LIST_SIZE as _], + ) -> Self { + self.cpb_size_value_minus1 = cpb_size_value_minus1; + self + } + pub fn cpb_size_du_value_minus1( + mut self, + cpb_size_du_value_minus1: [u32; crate::vk::STD_VIDEO_H265_CPB_CNT_LIST_SIZE as _], + ) -> Self { + self.cpb_size_du_value_minus1 = cpb_size_du_value_minus1; + self + } + pub fn bit_rate_du_value_minus1( + mut self, + bit_rate_du_value_minus1: [u32; crate::vk::STD_VIDEO_H265_CPB_CNT_LIST_SIZE as _], + ) -> Self { + self.bit_rate_du_value_minus1 = bit_rate_du_value_minus1; + self + } + pub fn cbr_flag(mut self, cbr_flag: u32) -> Self { + self.cbr_flag = cbr_flag; + self + } +} #[repr(C)] -#[derive(Clone, Copy)] +#[derive(Clone, Copy, Default)] pub struct H265HrdFlags { /**- `nal_hrd_parameters_present_flag` @ `0..1` - `vcl_hrd_parameters_present_flag` @ `1..2` @@ -50,6 +190,62 @@ pub struct H265HrdFlags { - `low_delay_hrd_flag` @ `20..28`*/ pub bitfield0: u32, } +impl H265HrdFlags { + pub fn nal_hrd_parameters_present_flag( + mut self, + nal_hrd_parameters_present_flag: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFFFFFFFE; + self.bitfield0 = (nal_hrd_parameters_present_flag & 0x00000001) | rest; + self + } + pub fn vcl_hrd_parameters_present_flag( + mut self, + vcl_hrd_parameters_present_flag: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFFFFFFFD; + self.bitfield0 = ((vcl_hrd_parameters_present_flag << 1u32) & 0x00000002) | rest; + self + } + pub fn sub_pic_hrd_params_present_flag( + mut self, + sub_pic_hrd_params_present_flag: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFFFFFFFB; + self.bitfield0 = ((sub_pic_hrd_params_present_flag << 2u32) & 0x00000004) | rest; + self + } + pub fn sub_pic_cpb_params_in_pic_timing_sei_flag( + mut self, + sub_pic_cpb_params_in_pic_timing_sei_flag: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFFFFFFF7; + self.bitfield0 = ((sub_pic_cpb_params_in_pic_timing_sei_flag << 3u32) + & 0x00000008) | rest; + self + } + pub fn fixed_pic_rate_general_flag( + mut self, + fixed_pic_rate_general_flag: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFFFFF00F; + self.bitfield0 = ((fixed_pic_rate_general_flag << 4u32) & 0x00000FF0) | rest; + self + } + pub fn fixed_pic_rate_within_cvs_flag( + mut self, + fixed_pic_rate_within_cvs_flag: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFFF00FFF; + self.bitfield0 = ((fixed_pic_rate_within_cvs_flag << 12u32) & 0x000FF000) | rest; + self + } + pub fn low_delay_hrd_flag(mut self, low_delay_hrd_flag: u32) -> Self { + let rest = self.bitfield0 & 0xF00FFFFF; + self.bitfield0 = ((low_delay_hrd_flag << 20u32) & 0x0FF00000) | rest; + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct H265HrdParameters<'a> { @@ -71,8 +267,120 @@ pub struct H265HrdParameters<'a> { pub p_sub_layer_hrd_parameters_vcl: *const crate::vk::H265SubLayerHrdParameters, pub _marker: ::core::marker::PhantomData<&'a ()>, } +impl<'a> Default for H265HrdParameters<'a> { + fn default() -> Self { + Self { + flags: Default::default(), + tick_divisor_minus2: Default::default(), + du_cpb_removal_delay_increment_length_minus1: Default::default(), + dpb_output_delay_du_length_minus1: Default::default(), + bit_rate_scale: Default::default(), + cpb_size_scale: Default::default(), + cpb_size_du_scale: Default::default(), + initial_cpb_removal_delay_length_minus1: Default::default(), + au_cpb_removal_delay_length_minus1: Default::default(), + dpb_output_delay_length_minus1: Default::default(), + cpb_cnt_minus1: unsafe { core::mem::zeroed() }, + elemental_duration_in_tc_minus1: unsafe { core::mem::zeroed() }, + reserved: unsafe { core::mem::zeroed() }, + p_sub_layer_hrd_parameters_nal: Default::default(), + p_sub_layer_hrd_parameters_vcl: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> H265HrdParameters<'a> { + pub fn flags(mut self, flags: crate::vk::H265HrdFlags) -> Self { + self.flags = flags; + self + } + pub fn tick_divisor_minus2(mut self, tick_divisor_minus2: u8) -> Self { + self.tick_divisor_minus2 = tick_divisor_minus2; + self + } + pub fn du_cpb_removal_delay_increment_length_minus1( + mut self, + du_cpb_removal_delay_increment_length_minus1: u8, + ) -> Self { + self.du_cpb_removal_delay_increment_length_minus1 = du_cpb_removal_delay_increment_length_minus1; + self + } + pub fn dpb_output_delay_du_length_minus1( + mut self, + dpb_output_delay_du_length_minus1: u8, + ) -> Self { + self.dpb_output_delay_du_length_minus1 = dpb_output_delay_du_length_minus1; + self + } + pub fn bit_rate_scale(mut self, bit_rate_scale: u8) -> Self { + self.bit_rate_scale = bit_rate_scale; + self + } + pub fn cpb_size_scale(mut self, cpb_size_scale: u8) -> Self { + self.cpb_size_scale = cpb_size_scale; + self + } + pub fn cpb_size_du_scale(mut self, cpb_size_du_scale: u8) -> Self { + self.cpb_size_du_scale = cpb_size_du_scale; + self + } + pub fn initial_cpb_removal_delay_length_minus1( + mut self, + initial_cpb_removal_delay_length_minus1: u8, + ) -> Self { + self.initial_cpb_removal_delay_length_minus1 = initial_cpb_removal_delay_length_minus1; + self + } + pub fn au_cpb_removal_delay_length_minus1( + mut self, + au_cpb_removal_delay_length_minus1: u8, + ) -> Self { + self.au_cpb_removal_delay_length_minus1 = au_cpb_removal_delay_length_minus1; + self + } + pub fn dpb_output_delay_length_minus1( + mut self, + dpb_output_delay_length_minus1: u8, + ) -> Self { + self.dpb_output_delay_length_minus1 = dpb_output_delay_length_minus1; + self + } + pub fn cpb_cnt_minus1( + mut self, + cpb_cnt_minus1: [u8; crate::vk::STD_VIDEO_H265_SUBLAYERS_LIST_SIZE as _], + ) -> Self { + self.cpb_cnt_minus1 = cpb_cnt_minus1; + self + } + pub fn elemental_duration_in_tc_minus1( + mut self, + elemental_duration_in_tc_minus1: [u16; crate::vk::STD_VIDEO_H265_SUBLAYERS_LIST_SIZE + as _], + ) -> Self { + self.elemental_duration_in_tc_minus1 = elemental_duration_in_tc_minus1; + self + } + pub fn reserved(mut self, reserved: [u16; 3 as _]) -> Self { + self.reserved = reserved; + self + } + pub fn p_sub_layer_hrd_parameters_nal( + mut self, + p_sub_layer_hrd_parameters_nal: *const crate::vk::H265SubLayerHrdParameters, + ) -> Self { + self.p_sub_layer_hrd_parameters_nal = p_sub_layer_hrd_parameters_nal; + self + } + pub fn p_sub_layer_hrd_parameters_vcl( + mut self, + p_sub_layer_hrd_parameters_vcl: *const crate::vk::H265SubLayerHrdParameters, + ) -> Self { + self.p_sub_layer_hrd_parameters_vcl = p_sub_layer_hrd_parameters_vcl; + self + } +} #[repr(C)] -#[derive(Clone, Copy)] +#[derive(Clone, Copy, Default)] pub struct H265VpsFlags { /**- `vps_temporal_id_nesting_flag` @ `0..1` - `vps_sub_layer_ordering_info_present_flag` @ `1..2` @@ -80,8 +388,44 @@ pub struct H265VpsFlags { - `vps_poc_proportional_to_timing_flag` @ `3..4`*/ pub bitfield0: u32, } +impl H265VpsFlags { + pub fn vps_temporal_id_nesting_flag( + mut self, + vps_temporal_id_nesting_flag: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFFFFFFFE; + self.bitfield0 = (vps_temporal_id_nesting_flag & 0x00000001) | rest; + self + } + pub fn vps_sub_layer_ordering_info_present_flag( + mut self, + vps_sub_layer_ordering_info_present_flag: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFFFFFFFD; + self.bitfield0 = ((vps_sub_layer_ordering_info_present_flag << 1u32) + & 0x00000002) | rest; + self + } + pub fn vps_timing_info_present_flag( + mut self, + vps_timing_info_present_flag: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFFFFFFFB; + self.bitfield0 = ((vps_timing_info_present_flag << 2u32) & 0x00000004) | rest; + self + } + pub fn vps_poc_proportional_to_timing_flag( + mut self, + vps_poc_proportional_to_timing_flag: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFFFFFFF7; + self.bitfield0 = ((vps_poc_proportional_to_timing_flag << 3u32) & 0x00000008) + | rest; + self + } +} #[repr(C)] -#[derive(Clone, Copy)] +#[derive(Clone, Copy, Default)] pub struct H265VideoParameterSet<'a> { pub flags: crate::vk::H265VpsFlags, pub vps_video_parameter_set_id: u8, @@ -97,6 +441,68 @@ pub struct H265VideoParameterSet<'a> { pub p_profile_tier_level: *const crate::vk::H265ProfileTierLevel, pub _marker: ::core::marker::PhantomData<&'a ()>, } +impl<'a> H265VideoParameterSet<'a> { + pub fn flags(mut self, flags: crate::vk::H265VpsFlags) -> Self { + self.flags = flags; + self + } + pub fn vps_video_parameter_set_id(mut self, vps_video_parameter_set_id: u8) -> Self { + self.vps_video_parameter_set_id = vps_video_parameter_set_id; + self + } + pub fn vps_max_sub_layers_minus1(mut self, vps_max_sub_layers_minus1: u8) -> Self { + self.vps_max_sub_layers_minus1 = vps_max_sub_layers_minus1; + self + } + pub fn reserved1(mut self, reserved1: u8) -> Self { + self.reserved1 = reserved1; + self + } + pub fn reserved2(mut self, reserved2: u8) -> Self { + self.reserved2 = reserved2; + self + } + pub fn vps_num_units_in_tick(mut self, vps_num_units_in_tick: u32) -> Self { + self.vps_num_units_in_tick = vps_num_units_in_tick; + self + } + pub fn vps_time_scale(mut self, vps_time_scale: u32) -> Self { + self.vps_time_scale = vps_time_scale; + self + } + pub fn vps_num_ticks_poc_diff_one_minus1( + mut self, + vps_num_ticks_poc_diff_one_minus1: u32, + ) -> Self { + self.vps_num_ticks_poc_diff_one_minus1 = vps_num_ticks_poc_diff_one_minus1; + self + } + pub fn reserved3(mut self, reserved3: u32) -> Self { + self.reserved3 = reserved3; + self + } + pub fn p_dec_pic_buf_mgr( + mut self, + p_dec_pic_buf_mgr: &'a crate::vk::H265DecPicBufMgr, + ) -> Self { + self.p_dec_pic_buf_mgr = p_dec_pic_buf_mgr; + self + } + pub fn p_hrd_parameters( + mut self, + p_hrd_parameters: &'a crate::vk::H265HrdParameters<'a>, + ) -> Self { + self.p_hrd_parameters = p_hrd_parameters; + self + } + pub fn p_profile_tier_level( + mut self, + p_profile_tier_level: &'a crate::vk::H265ProfileTierLevel, + ) -> Self { + self.p_profile_tier_level = p_profile_tier_level; + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct H265ScalingLists { @@ -113,13 +519,90 @@ pub struct H265ScalingLists { pub scaling_list_dc_coef32x32: [u8; crate::vk::STD_VIDEO_H265_SCALING_LIST_32X32_NUM_LISTS as _], } +impl Default for H265ScalingLists { + fn default() -> Self { + Self { + scaling_list4x4: unsafe { core::mem::zeroed() }, + scaling_list8x8: unsafe { core::mem::zeroed() }, + scaling_list16x16: unsafe { core::mem::zeroed() }, + scaling_list32x32: unsafe { core::mem::zeroed() }, + scaling_list_dc_coef16x16: unsafe { core::mem::zeroed() }, + scaling_list_dc_coef32x32: unsafe { core::mem::zeroed() }, + } + } +} +impl H265ScalingLists { + pub fn scaling_list4x4( + mut self, + scaling_list4x4: [[u8; crate::vk::STD_VIDEO_H265_SCALING_LIST_4X4_NUM_ELEMENTS + as _]; crate::vk::STD_VIDEO_H265_SCALING_LIST_4X4_NUM_LISTS as _], + ) -> Self { + self.scaling_list4x4 = scaling_list4x4; + self + } + pub fn scaling_list8x8( + mut self, + scaling_list8x8: [[u8; crate::vk::STD_VIDEO_H265_SCALING_LIST_8X8_NUM_ELEMENTS + as _]; crate::vk::STD_VIDEO_H265_SCALING_LIST_8X8_NUM_LISTS as _], + ) -> Self { + self.scaling_list8x8 = scaling_list8x8; + self + } + pub fn scaling_list16x16( + mut self, + scaling_list16x16: [[u8; crate::vk::STD_VIDEO_H265_SCALING_LIST_16X16_NUM_ELEMENTS + as _]; crate::vk::STD_VIDEO_H265_SCALING_LIST_16X16_NUM_LISTS as _], + ) -> Self { + self.scaling_list16x16 = scaling_list16x16; + self + } + pub fn scaling_list32x32( + mut self, + scaling_list32x32: [[u8; crate::vk::STD_VIDEO_H265_SCALING_LIST_32X32_NUM_ELEMENTS + as _]; crate::vk::STD_VIDEO_H265_SCALING_LIST_32X32_NUM_LISTS as _], + ) -> Self { + self.scaling_list32x32 = scaling_list32x32; + self + } + pub fn scaling_list_dc_coef16x16( + mut self, + scaling_list_dc_coef16x16: [u8; crate::vk::STD_VIDEO_H265_SCALING_LIST_16X16_NUM_LISTS + as _], + ) -> Self { + self.scaling_list_dc_coef16x16 = scaling_list_dc_coef16x16; + self + } + pub fn scaling_list_dc_coef32x32( + mut self, + scaling_list_dc_coef32x32: [u8; crate::vk::STD_VIDEO_H265_SCALING_LIST_32X32_NUM_LISTS + as _], + ) -> Self { + self.scaling_list_dc_coef32x32 = scaling_list_dc_coef32x32; + self + } +} #[repr(C)] -#[derive(Clone, Copy)] +#[derive(Clone, Copy, Default)] pub struct H265ShortTermRefPicSetFlags { /**- `inter_ref_pic_set_prediction_flag` @ `0..1` - `delta_rps_sign` @ `1..2`*/ pub bitfield0: u32, } +impl H265ShortTermRefPicSetFlags { + pub fn inter_ref_pic_set_prediction_flag( + mut self, + inter_ref_pic_set_prediction_flag: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFFFFFFFE; + self.bitfield0 = (inter_ref_pic_set_prediction_flag & 0x00000001) | rest; + self + } + pub fn delta_rps_sign(mut self, delta_rps_sign: u32) -> Self { + let rest = self.bitfield0 & 0xFFFFFFFD; + self.bitfield0 = ((delta_rps_sign << 1u32) & 0x00000002) | rest; + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct H265ShortTermRefPicSet { @@ -138,6 +621,90 @@ pub struct H265ShortTermRefPicSet { pub delta_poc_s0_minus1: [u16; crate::vk::STD_VIDEO_H265_MAX_DPB_SIZE as _], pub delta_poc_s1_minus1: [u16; crate::vk::STD_VIDEO_H265_MAX_DPB_SIZE as _], } +impl Default for H265ShortTermRefPicSet { + fn default() -> Self { + Self { + flags: Default::default(), + delta_idx_minus1: Default::default(), + use_delta_flag: Default::default(), + abs_delta_rps_minus1: Default::default(), + used_by_curr_pic_flag: Default::default(), + used_by_curr_pic_s0_flag: Default::default(), + used_by_curr_pic_s1_flag: Default::default(), + reserved1: Default::default(), + reserved2: Default::default(), + reserved3: Default::default(), + num_negative_pics: Default::default(), + num_positive_pics: Default::default(), + delta_poc_s0_minus1: unsafe { core::mem::zeroed() }, + delta_poc_s1_minus1: unsafe { core::mem::zeroed() }, + } + } +} +impl H265ShortTermRefPicSet { + pub fn flags(mut self, flags: crate::vk::H265ShortTermRefPicSetFlags) -> Self { + self.flags = flags; + self + } + pub fn delta_idx_minus1(mut self, delta_idx_minus1: u32) -> Self { + self.delta_idx_minus1 = delta_idx_minus1; + self + } + pub fn use_delta_flag(mut self, use_delta_flag: u16) -> Self { + self.use_delta_flag = use_delta_flag; + self + } + pub fn abs_delta_rps_minus1(mut self, abs_delta_rps_minus1: u16) -> Self { + self.abs_delta_rps_minus1 = abs_delta_rps_minus1; + self + } + pub fn used_by_curr_pic_flag(mut self, used_by_curr_pic_flag: u16) -> Self { + self.used_by_curr_pic_flag = used_by_curr_pic_flag; + self + } + pub fn used_by_curr_pic_s0_flag(mut self, used_by_curr_pic_s0_flag: u16) -> Self { + self.used_by_curr_pic_s0_flag = used_by_curr_pic_s0_flag; + self + } + pub fn used_by_curr_pic_s1_flag(mut self, used_by_curr_pic_s1_flag: u16) -> Self { + self.used_by_curr_pic_s1_flag = used_by_curr_pic_s1_flag; + self + } + pub fn reserved1(mut self, reserved1: u16) -> Self { + self.reserved1 = reserved1; + self + } + pub fn reserved2(mut self, reserved2: u8) -> Self { + self.reserved2 = reserved2; + self + } + pub fn reserved3(mut self, reserved3: u8) -> Self { + self.reserved3 = reserved3; + self + } + pub fn num_negative_pics(mut self, num_negative_pics: u8) -> Self { + self.num_negative_pics = num_negative_pics; + self + } + pub fn num_positive_pics(mut self, num_positive_pics: u8) -> Self { + self.num_positive_pics = num_positive_pics; + self + } + pub fn delta_poc_s0_minus1( + mut self, + delta_poc_s0_minus1: [u16; crate::vk::STD_VIDEO_H265_MAX_DPB_SIZE as _], + ) -> Self { + self.delta_poc_s0_minus1 = delta_poc_s0_minus1; + self + } + pub fn delta_poc_s1_minus1( + mut self, + delta_poc_s1_minus1: [u16; crate::vk::STD_VIDEO_H265_MAX_DPB_SIZE as _], + ) -> Self { + self.delta_poc_s1_minus1 = delta_poc_s1_minus1; + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct H265LongTermRefPicsSps { @@ -145,8 +712,33 @@ pub struct H265LongTermRefPicsSps { pub lt_ref_pic_poc_lsb_sps: [u32; crate::vk::STD_VIDEO_H265_MAX_LONG_TERM_REF_PICS_SPS as _], } +impl Default for H265LongTermRefPicsSps { + fn default() -> Self { + Self { + used_by_curr_pic_lt_sps_flag: Default::default(), + lt_ref_pic_poc_lsb_sps: unsafe { core::mem::zeroed() }, + } + } +} +impl H265LongTermRefPicsSps { + pub fn used_by_curr_pic_lt_sps_flag( + mut self, + used_by_curr_pic_lt_sps_flag: u32, + ) -> Self { + self.used_by_curr_pic_lt_sps_flag = used_by_curr_pic_lt_sps_flag; + self + } + pub fn lt_ref_pic_poc_lsb_sps( + mut self, + lt_ref_pic_poc_lsb_sps: [u32; crate::vk::STD_VIDEO_H265_MAX_LONG_TERM_REF_PICS_SPS + as _], + ) -> Self { + self.lt_ref_pic_poc_lsb_sps = lt_ref_pic_poc_lsb_sps; + self + } +} #[repr(C)] -#[derive(Clone, Copy)] +#[derive(Clone, Copy, Default)] pub struct H265SpsVuiFlags { /**- `aspect_ratio_info_present_flag` @ `0..1` - `overscan_info_present_flag` @ `1..2` @@ -168,8 +760,148 @@ pub struct H265SpsVuiFlags { - `restricted_ref_pic_lists_flag` @ `17..18`*/ pub bitfield0: u32, } +impl H265SpsVuiFlags { + pub fn aspect_ratio_info_present_flag( + mut self, + aspect_ratio_info_present_flag: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFFFFFFFE; + self.bitfield0 = (aspect_ratio_info_present_flag & 0x00000001) | rest; + self + } + pub fn overscan_info_present_flag( + mut self, + overscan_info_present_flag: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFFFFFFFD; + self.bitfield0 = ((overscan_info_present_flag << 1u32) & 0x00000002) | rest; + self + } + pub fn overscan_appropriate_flag(mut self, overscan_appropriate_flag: u32) -> Self { + let rest = self.bitfield0 & 0xFFFFFFFB; + self.bitfield0 = ((overscan_appropriate_flag << 2u32) & 0x00000004) | rest; + self + } + pub fn video_signal_type_present_flag( + mut self, + video_signal_type_present_flag: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFFFFFFF7; + self.bitfield0 = ((video_signal_type_present_flag << 3u32) & 0x00000008) | rest; + self + } + pub fn video_full_range_flag(mut self, video_full_range_flag: u32) -> Self { + let rest = self.bitfield0 & 0xFFFFFFEF; + self.bitfield0 = ((video_full_range_flag << 4u32) & 0x00000010) | rest; + self + } + pub fn colour_description_present_flag( + mut self, + colour_description_present_flag: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFFFFFFDF; + self.bitfield0 = ((colour_description_present_flag << 5u32) & 0x00000020) | rest; + self + } + pub fn chroma_loc_info_present_flag( + mut self, + chroma_loc_info_present_flag: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFFFFFFBF; + self.bitfield0 = ((chroma_loc_info_present_flag << 6u32) & 0x00000040) | rest; + self + } + pub fn neutral_chroma_indication_flag( + mut self, + neutral_chroma_indication_flag: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFFFFFF7F; + self.bitfield0 = ((neutral_chroma_indication_flag << 7u32) & 0x00000080) | rest; + self + } + pub fn field_seq_flag(mut self, field_seq_flag: u32) -> Self { + let rest = self.bitfield0 & 0xFFFFFEFF; + self.bitfield0 = ((field_seq_flag << 8u32) & 0x00000100) | rest; + self + } + pub fn frame_field_info_present_flag( + mut self, + frame_field_info_present_flag: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFFFFFDFF; + self.bitfield0 = ((frame_field_info_present_flag << 9u32) & 0x00000200) | rest; + self + } + pub fn default_display_window_flag( + mut self, + default_display_window_flag: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFFFFFBFF; + self.bitfield0 = ((default_display_window_flag << 10u32) & 0x00000400) | rest; + self + } + pub fn vui_timing_info_present_flag( + mut self, + vui_timing_info_present_flag: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFFFFF7FF; + self.bitfield0 = ((vui_timing_info_present_flag << 11u32) & 0x00000800) | rest; + self + } + pub fn vui_poc_proportional_to_timing_flag( + mut self, + vui_poc_proportional_to_timing_flag: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFFFFEFFF; + self.bitfield0 = ((vui_poc_proportional_to_timing_flag << 12u32) & 0x00001000) + | rest; + self + } + pub fn vui_hrd_parameters_present_flag( + mut self, + vui_hrd_parameters_present_flag: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFFFFDFFF; + self.bitfield0 = ((vui_hrd_parameters_present_flag << 13u32) & 0x00002000) + | rest; + self + } + pub fn bitstream_restriction_flag( + mut self, + bitstream_restriction_flag: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFFFFBFFF; + self.bitfield0 = ((bitstream_restriction_flag << 14u32) & 0x00004000) | rest; + self + } + pub fn tiles_fixed_structure_flag( + mut self, + tiles_fixed_structure_flag: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFFFF7FFF; + self.bitfield0 = ((tiles_fixed_structure_flag << 15u32) & 0x00008000) | rest; + self + } + pub fn motion_vectors_over_pic_boundaries_flag( + mut self, + motion_vectors_over_pic_boundaries_flag: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFFFEFFFF; + self.bitfield0 = ((motion_vectors_over_pic_boundaries_flag << 16u32) + & 0x00010000) | rest; + self + } + pub fn restricted_ref_pic_lists_flag( + mut self, + restricted_ref_pic_lists_flag: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFFFDFFFF; + self.bitfield0 = ((restricted_ref_pic_lists_flag << 17u32) & 0x00020000) | rest; + self + } +} #[repr(C)] -#[derive(Clone, Copy)] +#[derive(Clone, Copy, Default)] pub struct H265SequenceParameterSetVui<'a> { pub flags: crate::vk::H265SpsVuiFlags, pub aspect_ratio_idc: crate::vk::H265AspectRatioIdc, @@ -199,14 +931,164 @@ pub struct H265SequenceParameterSetVui<'a> { pub p_hrd_parameters: *const crate::vk::H265HrdParameters<'a>, pub _marker: ::core::marker::PhantomData<&'a ()>, } +impl<'a> H265SequenceParameterSetVui<'a> { + pub fn flags(mut self, flags: crate::vk::H265SpsVuiFlags) -> Self { + self.flags = flags; + self + } + pub fn aspect_ratio_idc( + mut self, + aspect_ratio_idc: crate::vk::H265AspectRatioIdc, + ) -> Self { + self.aspect_ratio_idc = aspect_ratio_idc; + self + } + pub fn sar_width(mut self, sar_width: u16) -> Self { + self.sar_width = sar_width; + self + } + pub fn sar_height(mut self, sar_height: u16) -> Self { + self.sar_height = sar_height; + self + } + pub fn video_format(mut self, video_format: u8) -> Self { + self.video_format = video_format; + self + } + pub fn colour_primaries(mut self, colour_primaries: u8) -> Self { + self.colour_primaries = colour_primaries; + self + } + pub fn transfer_characteristics(mut self, transfer_characteristics: u8) -> Self { + self.transfer_characteristics = transfer_characteristics; + self + } + pub fn matrix_coeffs(mut self, matrix_coeffs: u8) -> Self { + self.matrix_coeffs = matrix_coeffs; + self + } + pub fn chroma_sample_loc_type_top_field( + mut self, + chroma_sample_loc_type_top_field: u8, + ) -> Self { + self.chroma_sample_loc_type_top_field = chroma_sample_loc_type_top_field; + self + } + pub fn chroma_sample_loc_type_bottom_field( + mut self, + chroma_sample_loc_type_bottom_field: u8, + ) -> Self { + self.chroma_sample_loc_type_bottom_field = chroma_sample_loc_type_bottom_field; + self + } + pub fn reserved1(mut self, reserved1: u8) -> Self { + self.reserved1 = reserved1; + self + } + pub fn reserved2(mut self, reserved2: u8) -> Self { + self.reserved2 = reserved2; + self + } + pub fn def_disp_win_left_offset(mut self, def_disp_win_left_offset: u16) -> Self { + self.def_disp_win_left_offset = def_disp_win_left_offset; + self + } + pub fn def_disp_win_right_offset(mut self, def_disp_win_right_offset: u16) -> Self { + self.def_disp_win_right_offset = def_disp_win_right_offset; + self + } + pub fn def_disp_win_top_offset(mut self, def_disp_win_top_offset: u16) -> Self { + self.def_disp_win_top_offset = def_disp_win_top_offset; + self + } + pub fn def_disp_win_bottom_offset( + mut self, + def_disp_win_bottom_offset: u16, + ) -> Self { + self.def_disp_win_bottom_offset = def_disp_win_bottom_offset; + self + } + pub fn vui_num_units_in_tick(mut self, vui_num_units_in_tick: u32) -> Self { + self.vui_num_units_in_tick = vui_num_units_in_tick; + self + } + pub fn vui_time_scale(mut self, vui_time_scale: u32) -> Self { + self.vui_time_scale = vui_time_scale; + self + } + pub fn vui_num_ticks_poc_diff_one_minus1( + mut self, + vui_num_ticks_poc_diff_one_minus1: u32, + ) -> Self { + self.vui_num_ticks_poc_diff_one_minus1 = vui_num_ticks_poc_diff_one_minus1; + self + } + pub fn min_spatial_segmentation_idc( + mut self, + min_spatial_segmentation_idc: u16, + ) -> Self { + self.min_spatial_segmentation_idc = min_spatial_segmentation_idc; + self + } + pub fn reserved3(mut self, reserved3: u16) -> Self { + self.reserved3 = reserved3; + self + } + pub fn max_bytes_per_pic_denom(mut self, max_bytes_per_pic_denom: u8) -> Self { + self.max_bytes_per_pic_denom = max_bytes_per_pic_denom; + self + } + pub fn max_bits_per_min_cu_denom(mut self, max_bits_per_min_cu_denom: u8) -> Self { + self.max_bits_per_min_cu_denom = max_bits_per_min_cu_denom; + self + } + pub fn log2_max_mv_length_horizontal( + mut self, + log2_max_mv_length_horizontal: u8, + ) -> Self { + self.log2_max_mv_length_horizontal = log2_max_mv_length_horizontal; + self + } + pub fn log2_max_mv_length_vertical( + mut self, + log2_max_mv_length_vertical: u8, + ) -> Self { + self.log2_max_mv_length_vertical = log2_max_mv_length_vertical; + self + } + pub fn p_hrd_parameters( + mut self, + p_hrd_parameters: &'a crate::vk::H265HrdParameters<'a>, + ) -> Self { + self.p_hrd_parameters = p_hrd_parameters; + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct H265PredictorPaletteEntries { pub predictor_palette_entries: [[u16; crate::vk::STD_VIDEO_H265_PREDICTOR_PALETTE_COMP_ENTRIES_LIST_SIZE as _]; crate::vk::STD_VIDEO_H265_PREDICTOR_PALETTE_COMPONENTS_LIST_SIZE as _], } +impl Default for H265PredictorPaletteEntries { + fn default() -> Self { + Self { + predictor_palette_entries: unsafe { core::mem::zeroed() }, + } + } +} +impl H265PredictorPaletteEntries { + pub fn predictor_palette_entries( + mut self, + predictor_palette_entries: [[u16; crate::vk::STD_VIDEO_H265_PREDICTOR_PALETTE_COMP_ENTRIES_LIST_SIZE + as _]; crate::vk::STD_VIDEO_H265_PREDICTOR_PALETTE_COMPONENTS_LIST_SIZE as _], + ) -> Self { + self.predictor_palette_entries = predictor_palette_entries; + self + } +} #[repr(C)] -#[derive(Clone, Copy)] +#[derive(Clone, Copy, Default)] pub struct H265SpsFlags { /**- `sps_temporal_id_nesting_flag` @ `0..1` - `separate_colour_plane_flag` @ `1..2` @@ -240,8 +1122,242 @@ pub struct H265SpsFlags { - `intra_boundary_filtering_disabled_flag` @ `29..30`*/ pub bitfield0: u32, } +impl H265SpsFlags { + pub fn sps_temporal_id_nesting_flag( + mut self, + sps_temporal_id_nesting_flag: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFFFFFFFE; + self.bitfield0 = (sps_temporal_id_nesting_flag & 0x00000001) | rest; + self + } + pub fn separate_colour_plane_flag( + mut self, + separate_colour_plane_flag: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFFFFFFFD; + self.bitfield0 = ((separate_colour_plane_flag << 1u32) & 0x00000002) | rest; + self + } + pub fn conformance_window_flag(mut self, conformance_window_flag: u32) -> Self { + let rest = self.bitfield0 & 0xFFFFFFFB; + self.bitfield0 = ((conformance_window_flag << 2u32) & 0x00000004) | rest; + self + } + pub fn sps_sub_layer_ordering_info_present_flag( + mut self, + sps_sub_layer_ordering_info_present_flag: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFFFFFFF7; + self.bitfield0 = ((sps_sub_layer_ordering_info_present_flag << 3u32) + & 0x00000008) | rest; + self + } + pub fn scaling_list_enabled_flag(mut self, scaling_list_enabled_flag: u32) -> Self { + let rest = self.bitfield0 & 0xFFFFFFEF; + self.bitfield0 = ((scaling_list_enabled_flag << 4u32) & 0x00000010) | rest; + self + } + pub fn sps_scaling_list_data_present_flag( + mut self, + sps_scaling_list_data_present_flag: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFFFFFFDF; + self.bitfield0 = ((sps_scaling_list_data_present_flag << 5u32) & 0x00000020) + | rest; + self + } + pub fn amp_enabled_flag(mut self, amp_enabled_flag: u32) -> Self { + let rest = self.bitfield0 & 0xFFFFFFBF; + self.bitfield0 = ((amp_enabled_flag << 6u32) & 0x00000040) | rest; + self + } + pub fn sample_adaptive_offset_enabled_flag( + mut self, + sample_adaptive_offset_enabled_flag: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFFFFFF7F; + self.bitfield0 = ((sample_adaptive_offset_enabled_flag << 7u32) & 0x00000080) + | rest; + self + } + pub fn pcm_enabled_flag(mut self, pcm_enabled_flag: u32) -> Self { + let rest = self.bitfield0 & 0xFFFFFEFF; + self.bitfield0 = ((pcm_enabled_flag << 8u32) & 0x00000100) | rest; + self + } + pub fn pcm_loop_filter_disabled_flag( + mut self, + pcm_loop_filter_disabled_flag: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFFFFFDFF; + self.bitfield0 = ((pcm_loop_filter_disabled_flag << 9u32) & 0x00000200) | rest; + self + } + pub fn long_term_ref_pics_present_flag( + mut self, + long_term_ref_pics_present_flag: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFFFFFBFF; + self.bitfield0 = ((long_term_ref_pics_present_flag << 10u32) & 0x00000400) + | rest; + self + } + pub fn sps_temporal_mvp_enabled_flag( + mut self, + sps_temporal_mvp_enabled_flag: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFFFFF7FF; + self.bitfield0 = ((sps_temporal_mvp_enabled_flag << 11u32) & 0x00000800) | rest; + self + } + pub fn strong_intra_smoothing_enabled_flag( + mut self, + strong_intra_smoothing_enabled_flag: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFFFFEFFF; + self.bitfield0 = ((strong_intra_smoothing_enabled_flag << 12u32) & 0x00001000) + | rest; + self + } + pub fn vui_parameters_present_flag( + mut self, + vui_parameters_present_flag: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFFFFDFFF; + self.bitfield0 = ((vui_parameters_present_flag << 13u32) & 0x00002000) | rest; + self + } + pub fn sps_extension_present_flag( + mut self, + sps_extension_present_flag: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFFFFBFFF; + self.bitfield0 = ((sps_extension_present_flag << 14u32) & 0x00004000) | rest; + self + } + pub fn sps_range_extension_flag(mut self, sps_range_extension_flag: u32) -> Self { + let rest = self.bitfield0 & 0xFFFF7FFF; + self.bitfield0 = ((sps_range_extension_flag << 15u32) & 0x00008000) | rest; + self + } + pub fn transform_skip_rotation_enabled_flag( + mut self, + transform_skip_rotation_enabled_flag: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFFFEFFFF; + self.bitfield0 = ((transform_skip_rotation_enabled_flag << 16u32) & 0x00010000) + | rest; + self + } + pub fn transform_skip_context_enabled_flag( + mut self, + transform_skip_context_enabled_flag: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFFFDFFFF; + self.bitfield0 = ((transform_skip_context_enabled_flag << 17u32) & 0x00020000) + | rest; + self + } + pub fn implicit_rdpcm_enabled_flag( + mut self, + implicit_rdpcm_enabled_flag: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFFFBFFFF; + self.bitfield0 = ((implicit_rdpcm_enabled_flag << 18u32) & 0x00040000) | rest; + self + } + pub fn explicit_rdpcm_enabled_flag( + mut self, + explicit_rdpcm_enabled_flag: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFFF7FFFF; + self.bitfield0 = ((explicit_rdpcm_enabled_flag << 19u32) & 0x00080000) | rest; + self + } + pub fn extended_precision_processing_flag( + mut self, + extended_precision_processing_flag: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFFEFFFFF; + self.bitfield0 = ((extended_precision_processing_flag << 20u32) & 0x00100000) + | rest; + self + } + pub fn intra_smoothing_disabled_flag( + mut self, + intra_smoothing_disabled_flag: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFFDFFFFF; + self.bitfield0 = ((intra_smoothing_disabled_flag << 21u32) & 0x00200000) | rest; + self + } + pub fn high_precision_offsets_enabled_flag( + mut self, + high_precision_offsets_enabled_flag: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFFBFFFFF; + self.bitfield0 = ((high_precision_offsets_enabled_flag << 22u32) & 0x00400000) + | rest; + self + } + pub fn persistent_rice_adaptation_enabled_flag( + mut self, + persistent_rice_adaptation_enabled_flag: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFF7FFFFF; + self.bitfield0 = ((persistent_rice_adaptation_enabled_flag << 23u32) + & 0x00800000) | rest; + self + } + pub fn cabac_bypass_alignment_enabled_flag( + mut self, + cabac_bypass_alignment_enabled_flag: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFEFFFFFF; + self.bitfield0 = ((cabac_bypass_alignment_enabled_flag << 24u32) & 0x01000000) + | rest; + self + } + pub fn sps_scc_extension_flag(mut self, sps_scc_extension_flag: u32) -> Self { + let rest = self.bitfield0 & 0xFDFFFFFF; + self.bitfield0 = ((sps_scc_extension_flag << 25u32) & 0x02000000) | rest; + self + } + pub fn sps_curr_pic_ref_enabled_flag( + mut self, + sps_curr_pic_ref_enabled_flag: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFBFFFFFF; + self.bitfield0 = ((sps_curr_pic_ref_enabled_flag << 26u32) & 0x04000000) | rest; + self + } + pub fn palette_mode_enabled_flag(mut self, palette_mode_enabled_flag: u32) -> Self { + let rest = self.bitfield0 & 0xF7FFFFFF; + self.bitfield0 = ((palette_mode_enabled_flag << 27u32) & 0x08000000) | rest; + self + } + pub fn sps_palette_predictor_initializers_present_flag( + mut self, + sps_palette_predictor_initializers_present_flag: u32, + ) -> Self { + let rest = self.bitfield0 & 0xEFFFFFFF; + self.bitfield0 = ((sps_palette_predictor_initializers_present_flag << 28u32) + & 0x10000000) | rest; + self + } + pub fn intra_boundary_filtering_disabled_flag( + mut self, + intra_boundary_filtering_disabled_flag: u32, + ) -> Self { + let rest = self.bitfield0 & 0xDFFFFFFF; + self.bitfield0 = ((intra_boundary_filtering_disabled_flag << 29u32) & 0x20000000) + | rest; + self + } +} #[repr(C)] -#[derive(Clone, Copy)] +#[derive(Clone, Copy, Default)] pub struct H265SequenceParameterSet<'a> { pub flags: crate::vk::H265SpsFlags, pub chroma_format_idc: crate::vk::H265ChromaFormatIdc, @@ -284,8 +1400,239 @@ pub struct H265SequenceParameterSet<'a> { pub p_predictor_palette_entries: *const crate::vk::H265PredictorPaletteEntries, pub _marker: ::core::marker::PhantomData<&'a ()>, } +impl<'a> H265SequenceParameterSet<'a> { + pub fn flags(mut self, flags: crate::vk::H265SpsFlags) -> Self { + self.flags = flags; + self + } + pub fn chroma_format_idc( + mut self, + chroma_format_idc: crate::vk::H265ChromaFormatIdc, + ) -> Self { + self.chroma_format_idc = chroma_format_idc; + self + } + pub fn pic_width_in_luma_samples(mut self, pic_width_in_luma_samples: u32) -> Self { + self.pic_width_in_luma_samples = pic_width_in_luma_samples; + self + } + pub fn pic_height_in_luma_samples( + mut self, + pic_height_in_luma_samples: u32, + ) -> Self { + self.pic_height_in_luma_samples = pic_height_in_luma_samples; + self + } + pub fn sps_video_parameter_set_id(mut self, sps_video_parameter_set_id: u8) -> Self { + self.sps_video_parameter_set_id = sps_video_parameter_set_id; + self + } + pub fn sps_max_sub_layers_minus1(mut self, sps_max_sub_layers_minus1: u8) -> Self { + self.sps_max_sub_layers_minus1 = sps_max_sub_layers_minus1; + self + } + pub fn sps_seq_parameter_set_id(mut self, sps_seq_parameter_set_id: u8) -> Self { + self.sps_seq_parameter_set_id = sps_seq_parameter_set_id; + self + } + pub fn bit_depth_luma_minus8(mut self, bit_depth_luma_minus8: u8) -> Self { + self.bit_depth_luma_minus8 = bit_depth_luma_minus8; + self + } + pub fn bit_depth_chroma_minus8(mut self, bit_depth_chroma_minus8: u8) -> Self { + self.bit_depth_chroma_minus8 = bit_depth_chroma_minus8; + self + } + pub fn log2_max_pic_order_cnt_lsb_minus4( + mut self, + log2_max_pic_order_cnt_lsb_minus4: u8, + ) -> Self { + self.log2_max_pic_order_cnt_lsb_minus4 = log2_max_pic_order_cnt_lsb_minus4; + self + } + pub fn log2_min_luma_coding_block_size_minus3( + mut self, + log2_min_luma_coding_block_size_minus3: u8, + ) -> Self { + self.log2_min_luma_coding_block_size_minus3 = log2_min_luma_coding_block_size_minus3; + self + } + pub fn log2_diff_max_min_luma_coding_block_size( + mut self, + log2_diff_max_min_luma_coding_block_size: u8, + ) -> Self { + self.log2_diff_max_min_luma_coding_block_size = log2_diff_max_min_luma_coding_block_size; + self + } + pub fn log2_min_luma_transform_block_size_minus2( + mut self, + log2_min_luma_transform_block_size_minus2: u8, + ) -> Self { + self.log2_min_luma_transform_block_size_minus2 = log2_min_luma_transform_block_size_minus2; + self + } + pub fn log2_diff_max_min_luma_transform_block_size( + mut self, + log2_diff_max_min_luma_transform_block_size: u8, + ) -> Self { + self.log2_diff_max_min_luma_transform_block_size = log2_diff_max_min_luma_transform_block_size; + self + } + pub fn max_transform_hierarchy_depth_inter( + mut self, + max_transform_hierarchy_depth_inter: u8, + ) -> Self { + self.max_transform_hierarchy_depth_inter = max_transform_hierarchy_depth_inter; + self + } + pub fn max_transform_hierarchy_depth_intra( + mut self, + max_transform_hierarchy_depth_intra: u8, + ) -> Self { + self.max_transform_hierarchy_depth_intra = max_transform_hierarchy_depth_intra; + self + } + pub fn num_short_term_ref_pic_sets( + mut self, + num_short_term_ref_pic_sets: u8, + ) -> Self { + self.num_short_term_ref_pic_sets = num_short_term_ref_pic_sets; + self + } + pub fn num_long_term_ref_pics_sps(mut self, num_long_term_ref_pics_sps: u8) -> Self { + self.num_long_term_ref_pics_sps = num_long_term_ref_pics_sps; + self + } + pub fn pcm_sample_bit_depth_luma_minus1( + mut self, + pcm_sample_bit_depth_luma_minus1: u8, + ) -> Self { + self.pcm_sample_bit_depth_luma_minus1 = pcm_sample_bit_depth_luma_minus1; + self + } + pub fn pcm_sample_bit_depth_chroma_minus1( + mut self, + pcm_sample_bit_depth_chroma_minus1: u8, + ) -> Self { + self.pcm_sample_bit_depth_chroma_minus1 = pcm_sample_bit_depth_chroma_minus1; + self + } + pub fn log2_min_pcm_luma_coding_block_size_minus3( + mut self, + log2_min_pcm_luma_coding_block_size_minus3: u8, + ) -> Self { + self.log2_min_pcm_luma_coding_block_size_minus3 = log2_min_pcm_luma_coding_block_size_minus3; + self + } + pub fn log2_diff_max_min_pcm_luma_coding_block_size( + mut self, + log2_diff_max_min_pcm_luma_coding_block_size: u8, + ) -> Self { + self.log2_diff_max_min_pcm_luma_coding_block_size = log2_diff_max_min_pcm_luma_coding_block_size; + self + } + pub fn reserved1(mut self, reserved1: u8) -> Self { + self.reserved1 = reserved1; + self + } + pub fn reserved2(mut self, reserved2: u8) -> Self { + self.reserved2 = reserved2; + self + } + pub fn palette_max_size(mut self, palette_max_size: u8) -> Self { + self.palette_max_size = palette_max_size; + self + } + pub fn delta_palette_max_predictor_size( + mut self, + delta_palette_max_predictor_size: u8, + ) -> Self { + self.delta_palette_max_predictor_size = delta_palette_max_predictor_size; + self + } + pub fn motion_vector_resolution_control_idc( + mut self, + motion_vector_resolution_control_idc: u8, + ) -> Self { + self.motion_vector_resolution_control_idc = motion_vector_resolution_control_idc; + self + } + pub fn sps_num_palette_predictor_initializers_minus1( + mut self, + sps_num_palette_predictor_initializers_minus1: u8, + ) -> Self { + self.sps_num_palette_predictor_initializers_minus1 = sps_num_palette_predictor_initializers_minus1; + self + } + pub fn conf_win_left_offset(mut self, conf_win_left_offset: u32) -> Self { + self.conf_win_left_offset = conf_win_left_offset; + self + } + pub fn conf_win_right_offset(mut self, conf_win_right_offset: u32) -> Self { + self.conf_win_right_offset = conf_win_right_offset; + self + } + pub fn conf_win_top_offset(mut self, conf_win_top_offset: u32) -> Self { + self.conf_win_top_offset = conf_win_top_offset; + self + } + pub fn conf_win_bottom_offset(mut self, conf_win_bottom_offset: u32) -> Self { + self.conf_win_bottom_offset = conf_win_bottom_offset; + self + } + pub fn p_profile_tier_level( + mut self, + p_profile_tier_level: &'a crate::vk::H265ProfileTierLevel, + ) -> Self { + self.p_profile_tier_level = p_profile_tier_level; + self + } + pub fn p_dec_pic_buf_mgr( + mut self, + p_dec_pic_buf_mgr: &'a crate::vk::H265DecPicBufMgr, + ) -> Self { + self.p_dec_pic_buf_mgr = p_dec_pic_buf_mgr; + self + } + pub fn p_scaling_lists( + mut self, + p_scaling_lists: &'a crate::vk::H265ScalingLists, + ) -> Self { + self.p_scaling_lists = p_scaling_lists; + self + } + pub fn p_short_term_ref_pic_set( + mut self, + p_short_term_ref_pic_set: &'a [crate::vk::H265ShortTermRefPicSet], + ) -> Self { + self.num_short_term_ref_pic_sets = p_short_term_ref_pic_set.len() as _; + self.p_short_term_ref_pic_set = p_short_term_ref_pic_set.as_ptr(); + self + } + pub fn p_long_term_ref_pics_sps( + mut self, + p_long_term_ref_pics_sps: &'a crate::vk::H265LongTermRefPicsSps, + ) -> Self { + self.p_long_term_ref_pics_sps = p_long_term_ref_pics_sps; + self + } + pub fn p_sequence_parameter_set_vui( + mut self, + p_sequence_parameter_set_vui: &'a crate::vk::H265SequenceParameterSetVui<'a>, + ) -> Self { + self.p_sequence_parameter_set_vui = p_sequence_parameter_set_vui; + self + } + pub fn p_predictor_palette_entries( + mut self, + p_predictor_palette_entries: &'a crate::vk::H265PredictorPaletteEntries, + ) -> Self { + self.p_predictor_palette_entries = p_predictor_palette_entries; + self + } +} #[repr(C)] -#[derive(Clone, Copy)] +#[derive(Clone, Copy, Default)] pub struct H265PpsFlags { /**- `dependent_slice_segments_enabled_flag` @ `0..1` - `output_flag_present_flag` @ `1..2` @@ -320,6 +1667,244 @@ pub struct H265PpsFlags { - `pps_range_extension_flag` @ `30..31`*/ pub bitfield0: u32, } +impl H265PpsFlags { + pub fn dependent_slice_segments_enabled_flag( + mut self, + dependent_slice_segments_enabled_flag: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFFFFFFFE; + self.bitfield0 = (dependent_slice_segments_enabled_flag & 0x00000001) | rest; + self + } + pub fn output_flag_present_flag(mut self, output_flag_present_flag: u32) -> Self { + let rest = self.bitfield0 & 0xFFFFFFFD; + self.bitfield0 = ((output_flag_present_flag << 1u32) & 0x00000002) | rest; + self + } + pub fn sign_data_hiding_enabled_flag( + mut self, + sign_data_hiding_enabled_flag: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFFFFFFFB; + self.bitfield0 = ((sign_data_hiding_enabled_flag << 2u32) & 0x00000004) | rest; + self + } + pub fn cabac_init_present_flag(mut self, cabac_init_present_flag: u32) -> Self { + let rest = self.bitfield0 & 0xFFFFFFF7; + self.bitfield0 = ((cabac_init_present_flag << 3u32) & 0x00000008) | rest; + self + } + pub fn constrained_intra_pred_flag( + mut self, + constrained_intra_pred_flag: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFFFFFFEF; + self.bitfield0 = ((constrained_intra_pred_flag << 4u32) & 0x00000010) | rest; + self + } + pub fn transform_skip_enabled_flag( + mut self, + transform_skip_enabled_flag: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFFFFFFDF; + self.bitfield0 = ((transform_skip_enabled_flag << 5u32) & 0x00000020) | rest; + self + } + pub fn cu_qp_delta_enabled_flag(mut self, cu_qp_delta_enabled_flag: u32) -> Self { + let rest = self.bitfield0 & 0xFFFFFFBF; + self.bitfield0 = ((cu_qp_delta_enabled_flag << 6u32) & 0x00000040) | rest; + self + } + pub fn pps_slice_chroma_qp_offsets_present_flag( + mut self, + pps_slice_chroma_qp_offsets_present_flag: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFFFFFF7F; + self.bitfield0 = ((pps_slice_chroma_qp_offsets_present_flag << 7u32) + & 0x00000080) | rest; + self + } + pub fn weighted_pred_flag(mut self, weighted_pred_flag: u32) -> Self { + let rest = self.bitfield0 & 0xFFFFFEFF; + self.bitfield0 = ((weighted_pred_flag << 8u32) & 0x00000100) | rest; + self + } + pub fn weighted_bipred_flag(mut self, weighted_bipred_flag: u32) -> Self { + let rest = self.bitfield0 & 0xFFFFFDFF; + self.bitfield0 = ((weighted_bipred_flag << 9u32) & 0x00000200) | rest; + self + } + pub fn transquant_bypass_enabled_flag( + mut self, + transquant_bypass_enabled_flag: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFFFFFBFF; + self.bitfield0 = ((transquant_bypass_enabled_flag << 10u32) & 0x00000400) | rest; + self + } + pub fn tiles_enabled_flag(mut self, tiles_enabled_flag: u32) -> Self { + let rest = self.bitfield0 & 0xFFFFF7FF; + self.bitfield0 = ((tiles_enabled_flag << 11u32) & 0x00000800) | rest; + self + } + pub fn entropy_coding_sync_enabled_flag( + mut self, + entropy_coding_sync_enabled_flag: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFFFFEFFF; + self.bitfield0 = ((entropy_coding_sync_enabled_flag << 12u32) & 0x00001000) + | rest; + self + } + pub fn uniform_spacing_flag(mut self, uniform_spacing_flag: u32) -> Self { + let rest = self.bitfield0 & 0xFFFFDFFF; + self.bitfield0 = ((uniform_spacing_flag << 13u32) & 0x00002000) | rest; + self + } + pub fn loop_filter_across_tiles_enabled_flag( + mut self, + loop_filter_across_tiles_enabled_flag: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFFFFBFFF; + self.bitfield0 = ((loop_filter_across_tiles_enabled_flag << 14u32) & 0x00004000) + | rest; + self + } + pub fn pps_loop_filter_across_slices_enabled_flag( + mut self, + pps_loop_filter_across_slices_enabled_flag: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFFFF7FFF; + self.bitfield0 = ((pps_loop_filter_across_slices_enabled_flag << 15u32) + & 0x00008000) | rest; + self + } + pub fn deblocking_filter_control_present_flag( + mut self, + deblocking_filter_control_present_flag: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFFFEFFFF; + self.bitfield0 = ((deblocking_filter_control_present_flag << 16u32) & 0x00010000) + | rest; + self + } + pub fn deblocking_filter_override_enabled_flag( + mut self, + deblocking_filter_override_enabled_flag: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFFFDFFFF; + self.bitfield0 = ((deblocking_filter_override_enabled_flag << 17u32) + & 0x00020000) | rest; + self + } + pub fn pps_deblocking_filter_disabled_flag( + mut self, + pps_deblocking_filter_disabled_flag: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFFFBFFFF; + self.bitfield0 = ((pps_deblocking_filter_disabled_flag << 18u32) & 0x00040000) + | rest; + self + } + pub fn pps_scaling_list_data_present_flag( + mut self, + pps_scaling_list_data_present_flag: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFFF7FFFF; + self.bitfield0 = ((pps_scaling_list_data_present_flag << 19u32) & 0x00080000) + | rest; + self + } + pub fn lists_modification_present_flag( + mut self, + lists_modification_present_flag: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFFEFFFFF; + self.bitfield0 = ((lists_modification_present_flag << 20u32) & 0x00100000) + | rest; + self + } + pub fn slice_segment_header_extension_present_flag( + mut self, + slice_segment_header_extension_present_flag: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFFDFFFFF; + self.bitfield0 = ((slice_segment_header_extension_present_flag << 21u32) + & 0x00200000) | rest; + self + } + pub fn pps_extension_present_flag( + mut self, + pps_extension_present_flag: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFFBFFFFF; + self.bitfield0 = ((pps_extension_present_flag << 22u32) & 0x00400000) | rest; + self + } + pub fn cross_component_prediction_enabled_flag( + mut self, + cross_component_prediction_enabled_flag: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFF7FFFFF; + self.bitfield0 = ((cross_component_prediction_enabled_flag << 23u32) + & 0x00800000) | rest; + self + } + pub fn chroma_qp_offset_list_enabled_flag( + mut self, + chroma_qp_offset_list_enabled_flag: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFEFFFFFF; + self.bitfield0 = ((chroma_qp_offset_list_enabled_flag << 24u32) & 0x01000000) + | rest; + self + } + pub fn pps_curr_pic_ref_enabled_flag( + mut self, + pps_curr_pic_ref_enabled_flag: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFDFFFFFF; + self.bitfield0 = ((pps_curr_pic_ref_enabled_flag << 25u32) & 0x02000000) | rest; + self + } + pub fn residual_adaptive_colour_transform_enabled_flag( + mut self, + residual_adaptive_colour_transform_enabled_flag: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFBFFFFFF; + self.bitfield0 = ((residual_adaptive_colour_transform_enabled_flag << 26u32) + & 0x04000000) | rest; + self + } + pub fn pps_slice_act_qp_offsets_present_flag( + mut self, + pps_slice_act_qp_offsets_present_flag: u32, + ) -> Self { + let rest = self.bitfield0 & 0xF7FFFFFF; + self.bitfield0 = ((pps_slice_act_qp_offsets_present_flag << 27u32) & 0x08000000) + | rest; + self + } + pub fn pps_palette_predictor_initializers_present_flag( + mut self, + pps_palette_predictor_initializers_present_flag: u32, + ) -> Self { + let rest = self.bitfield0 & 0xEFFFFFFF; + self.bitfield0 = ((pps_palette_predictor_initializers_present_flag << 28u32) + & 0x10000000) | rest; + self + } + pub fn monochrome_palette_flag(mut self, monochrome_palette_flag: u32) -> Self { + let rest = self.bitfield0 & 0xDFFFFFFF; + self.bitfield0 = ((monochrome_palette_flag << 29u32) & 0x20000000) | rest; + self + } + pub fn pps_range_extension_flag(mut self, pps_range_extension_flag: u32) -> Self { + let rest = self.bitfield0 & 0xBFFFFFFF; + self.bitfield0 = ((pps_range_extension_flag << 30u32) & 0x40000000) | rest; + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct H265PictureParameterSet<'a> { @@ -365,6 +1950,250 @@ pub struct H265PictureParameterSet<'a> { pub p_predictor_palette_entries: *const crate::vk::H265PredictorPaletteEntries, pub _marker: ::core::marker::PhantomData<&'a ()>, } +impl<'a> Default for H265PictureParameterSet<'a> { + fn default() -> Self { + Self { + flags: Default::default(), + pps_pic_parameter_set_id: Default::default(), + pps_seq_parameter_set_id: Default::default(), + sps_video_parameter_set_id: Default::default(), + num_extra_slice_header_bits: Default::default(), + num_ref_idx_l0_default_active_minus1: Default::default(), + num_ref_idx_l1_default_active_minus1: Default::default(), + init_qp_minus26: Default::default(), + diff_cu_qp_delta_depth: Default::default(), + pps_cb_qp_offset: Default::default(), + pps_cr_qp_offset: Default::default(), + pps_beta_offset_div2: Default::default(), + pps_tc_offset_div2: Default::default(), + log2_parallel_merge_level_minus2: Default::default(), + log2_max_transform_skip_block_size_minus2: Default::default(), + diff_cu_chroma_qp_offset_depth: Default::default(), + chroma_qp_offset_list_len_minus1: Default::default(), + cb_qp_offset_list: unsafe { core::mem::zeroed() }, + cr_qp_offset_list: unsafe { core::mem::zeroed() }, + log2_sao_offset_scale_luma: Default::default(), + log2_sao_offset_scale_chroma: Default::default(), + pps_act_y_qp_offset_plus5: Default::default(), + pps_act_cb_qp_offset_plus5: Default::default(), + pps_act_cr_qp_offset_plus3: Default::default(), + pps_num_palette_predictor_initializers: Default::default(), + luma_bit_depth_entry_minus8: Default::default(), + chroma_bit_depth_entry_minus8: Default::default(), + num_tile_columns_minus1: Default::default(), + num_tile_rows_minus1: Default::default(), + reserved1: Default::default(), + reserved2: Default::default(), + column_width_minus1: unsafe { core::mem::zeroed() }, + row_height_minus1: unsafe { core::mem::zeroed() }, + reserved3: Default::default(), + p_scaling_lists: Default::default(), + p_predictor_palette_entries: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> H265PictureParameterSet<'a> { + pub fn flags(mut self, flags: crate::vk::H265PpsFlags) -> Self { + self.flags = flags; + self + } + pub fn pps_pic_parameter_set_id(mut self, pps_pic_parameter_set_id: u8) -> Self { + self.pps_pic_parameter_set_id = pps_pic_parameter_set_id; + self + } + pub fn pps_seq_parameter_set_id(mut self, pps_seq_parameter_set_id: u8) -> Self { + self.pps_seq_parameter_set_id = pps_seq_parameter_set_id; + self + } + pub fn sps_video_parameter_set_id(mut self, sps_video_parameter_set_id: u8) -> Self { + self.sps_video_parameter_set_id = sps_video_parameter_set_id; + self + } + pub fn num_extra_slice_header_bits( + mut self, + num_extra_slice_header_bits: u8, + ) -> Self { + self.num_extra_slice_header_bits = num_extra_slice_header_bits; + self + } + pub fn num_ref_idx_l0_default_active_minus1( + mut self, + num_ref_idx_l0_default_active_minus1: u8, + ) -> Self { + self.num_ref_idx_l0_default_active_minus1 = num_ref_idx_l0_default_active_minus1; + self + } + pub fn num_ref_idx_l1_default_active_minus1( + mut self, + num_ref_idx_l1_default_active_minus1: u8, + ) -> Self { + self.num_ref_idx_l1_default_active_minus1 = num_ref_idx_l1_default_active_minus1; + self + } + pub fn init_qp_minus26(mut self, init_qp_minus26: i8) -> Self { + self.init_qp_minus26 = init_qp_minus26; + self + } + pub fn diff_cu_qp_delta_depth(mut self, diff_cu_qp_delta_depth: u8) -> Self { + self.diff_cu_qp_delta_depth = diff_cu_qp_delta_depth; + self + } + pub fn pps_cb_qp_offset(mut self, pps_cb_qp_offset: i8) -> Self { + self.pps_cb_qp_offset = pps_cb_qp_offset; + self + } + pub fn pps_cr_qp_offset(mut self, pps_cr_qp_offset: i8) -> Self { + self.pps_cr_qp_offset = pps_cr_qp_offset; + self + } + pub fn pps_beta_offset_div2(mut self, pps_beta_offset_div2: i8) -> Self { + self.pps_beta_offset_div2 = pps_beta_offset_div2; + self + } + pub fn pps_tc_offset_div2(mut self, pps_tc_offset_div2: i8) -> Self { + self.pps_tc_offset_div2 = pps_tc_offset_div2; + self + } + pub fn log2_parallel_merge_level_minus2( + mut self, + log2_parallel_merge_level_minus2: u8, + ) -> Self { + self.log2_parallel_merge_level_minus2 = log2_parallel_merge_level_minus2; + self + } + pub fn log2_max_transform_skip_block_size_minus2( + mut self, + log2_max_transform_skip_block_size_minus2: u8, + ) -> Self { + self.log2_max_transform_skip_block_size_minus2 = log2_max_transform_skip_block_size_minus2; + self + } + pub fn diff_cu_chroma_qp_offset_depth( + mut self, + diff_cu_chroma_qp_offset_depth: u8, + ) -> Self { + self.diff_cu_chroma_qp_offset_depth = diff_cu_chroma_qp_offset_depth; + self + } + pub fn chroma_qp_offset_list_len_minus1( + mut self, + chroma_qp_offset_list_len_minus1: u8, + ) -> Self { + self.chroma_qp_offset_list_len_minus1 = chroma_qp_offset_list_len_minus1; + self + } + pub fn cb_qp_offset_list( + mut self, + cb_qp_offset_list: [i8; crate::vk::STD_VIDEO_H265_CHROMA_QP_OFFSET_LIST_SIZE + as _], + ) -> Self { + self.cb_qp_offset_list = cb_qp_offset_list; + self + } + pub fn cr_qp_offset_list( + mut self, + cr_qp_offset_list: [i8; crate::vk::STD_VIDEO_H265_CHROMA_QP_OFFSET_LIST_SIZE + as _], + ) -> Self { + self.cr_qp_offset_list = cr_qp_offset_list; + self + } + pub fn log2_sao_offset_scale_luma(mut self, log2_sao_offset_scale_luma: u8) -> Self { + self.log2_sao_offset_scale_luma = log2_sao_offset_scale_luma; + self + } + pub fn log2_sao_offset_scale_chroma( + mut self, + log2_sao_offset_scale_chroma: u8, + ) -> Self { + self.log2_sao_offset_scale_chroma = log2_sao_offset_scale_chroma; + self + } + pub fn pps_act_y_qp_offset_plus5(mut self, pps_act_y_qp_offset_plus5: i8) -> Self { + self.pps_act_y_qp_offset_plus5 = pps_act_y_qp_offset_plus5; + self + } + pub fn pps_act_cb_qp_offset_plus5(mut self, pps_act_cb_qp_offset_plus5: i8) -> Self { + self.pps_act_cb_qp_offset_plus5 = pps_act_cb_qp_offset_plus5; + self + } + pub fn pps_act_cr_qp_offset_plus3(mut self, pps_act_cr_qp_offset_plus3: i8) -> Self { + self.pps_act_cr_qp_offset_plus3 = pps_act_cr_qp_offset_plus3; + self + } + pub fn pps_num_palette_predictor_initializers( + mut self, + pps_num_palette_predictor_initializers: u8, + ) -> Self { + self.pps_num_palette_predictor_initializers = pps_num_palette_predictor_initializers; + self + } + pub fn luma_bit_depth_entry_minus8( + mut self, + luma_bit_depth_entry_minus8: u8, + ) -> Self { + self.luma_bit_depth_entry_minus8 = luma_bit_depth_entry_minus8; + self + } + pub fn chroma_bit_depth_entry_minus8( + mut self, + chroma_bit_depth_entry_minus8: u8, + ) -> Self { + self.chroma_bit_depth_entry_minus8 = chroma_bit_depth_entry_minus8; + self + } + pub fn num_tile_columns_minus1(mut self, num_tile_columns_minus1: u8) -> Self { + self.num_tile_columns_minus1 = num_tile_columns_minus1; + self + } + pub fn num_tile_rows_minus1(mut self, num_tile_rows_minus1: u8) -> Self { + self.num_tile_rows_minus1 = num_tile_rows_minus1; + self + } + pub fn reserved1(mut self, reserved1: u8) -> Self { + self.reserved1 = reserved1; + self + } + pub fn reserved2(mut self, reserved2: u8) -> Self { + self.reserved2 = reserved2; + self + } + pub fn column_width_minus1( + mut self, + column_width_minus1: [u16; crate::vk::STD_VIDEO_H265_CHROMA_QP_OFFSET_TILE_COLS_LIST_SIZE + as _], + ) -> Self { + self.column_width_minus1 = column_width_minus1; + self + } + pub fn row_height_minus1( + mut self, + row_height_minus1: [u16; crate::vk::STD_VIDEO_H265_CHROMA_QP_OFFSET_TILE_ROWS_LIST_SIZE + as _], + ) -> Self { + self.row_height_minus1 = row_height_minus1; + self + } + pub fn reserved3(mut self, reserved3: u32) -> Self { + self.reserved3 = reserved3; + self + } + pub fn p_scaling_lists( + mut self, + p_scaling_lists: &'a crate::vk::H265ScalingLists, + ) -> Self { + self.p_scaling_lists = p_scaling_lists; + self + } + pub fn p_predictor_palette_entries( + mut self, + p_predictor_palette_entries: &'a crate::vk::H265PredictorPaletteEntries, + ) -> Self { + self.p_predictor_palette_entries = p_predictor_palette_entries; + self + } +} #[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[derive(Debug)] diff --git a/ash-rewrite/src/generated/video/codec_h265std_decode.rs b/ash-rewrite/src/generated/video/codec_h265std_decode.rs index af1e758ac..f21bee9f6 100644 --- a/ash-rewrite/src/generated/video/codec_h265std_decode.rs +++ b/ash-rewrite/src/generated/video/codec_h265std_decode.rs @@ -2,7 +2,7 @@ #![cfg_attr(rustfmt, rustfmt_skip)] //!Items provided by `vulkan_video_codec_h265std_decode` #[repr(C)] -#[derive(Clone, Copy)] +#[derive(Clone, Copy, Default)] pub struct DecodeH265PictureInfoFlags { /**- `IrapPicFlag` @ `0..1` - `IdrPicFlag` @ `1..2` @@ -10,6 +10,31 @@ pub struct DecodeH265PictureInfoFlags { - `short_term_ref_pic_set_sps_flag` @ `3..4`*/ pub bitfield0: u32, } +impl DecodeH265PictureInfoFlags { + pub fn irap_pic_flag(mut self, irap_pic_flag: u32) -> Self { + let rest = self.bitfield0 & 0xFFFFFFFE; + self.bitfield0 = (irap_pic_flag & 0x00000001) | rest; + self + } + pub fn idr_pic_flag(mut self, idr_pic_flag: u32) -> Self { + let rest = self.bitfield0 & 0xFFFFFFFD; + self.bitfield0 = ((idr_pic_flag << 1u32) & 0x00000002) | rest; + self + } + pub fn is_reference(mut self, is_reference: u32) -> Self { + let rest = self.bitfield0 & 0xFFFFFFFB; + self.bitfield0 = ((is_reference << 2u32) & 0x00000004) | rest; + self + } + pub fn short_term_ref_pic_set_sps_flag( + mut self, + short_term_ref_pic_set_sps_flag: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFFFFFFF7; + self.bitfield0 = ((short_term_ref_pic_set_sps_flag << 3u32) & 0x00000008) | rest; + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct DecodeH265PictureInfo { @@ -28,19 +53,125 @@ pub struct DecodeH265PictureInfo { pub ref_pic_set_lt_curr: [u8; crate::vk::STD_VIDEO_DECODE_H265_REF_PIC_SET_LIST_SIZE as _], } +impl Default for DecodeH265PictureInfo { + fn default() -> Self { + Self { + flags: Default::default(), + sps_video_parameter_set_id: Default::default(), + pps_seq_parameter_set_id: Default::default(), + pps_pic_parameter_set_id: Default::default(), + num_delta_pocs_of_ref_rps_idx: Default::default(), + pic_order_cnt_val: Default::default(), + num_bits_for_st_ref_pic_set_in_slice: Default::default(), + reserved: Default::default(), + ref_pic_set_st_curr_before: unsafe { core::mem::zeroed() }, + ref_pic_set_st_curr_after: unsafe { core::mem::zeroed() }, + ref_pic_set_lt_curr: unsafe { core::mem::zeroed() }, + } + } +} +impl DecodeH265PictureInfo { + pub fn flags(mut self, flags: crate::vk::DecodeH265PictureInfoFlags) -> Self { + self.flags = flags; + self + } + pub fn sps_video_parameter_set_id(mut self, sps_video_parameter_set_id: u8) -> Self { + self.sps_video_parameter_set_id = sps_video_parameter_set_id; + self + } + pub fn pps_seq_parameter_set_id(mut self, pps_seq_parameter_set_id: u8) -> Self { + self.pps_seq_parameter_set_id = pps_seq_parameter_set_id; + self + } + pub fn pps_pic_parameter_set_id(mut self, pps_pic_parameter_set_id: u8) -> Self { + self.pps_pic_parameter_set_id = pps_pic_parameter_set_id; + self + } + pub fn num_delta_pocs_of_ref_rps_idx( + mut self, + num_delta_pocs_of_ref_rps_idx: u8, + ) -> Self { + self.num_delta_pocs_of_ref_rps_idx = num_delta_pocs_of_ref_rps_idx; + self + } + pub fn pic_order_cnt_val(mut self, pic_order_cnt_val: i32) -> Self { + self.pic_order_cnt_val = pic_order_cnt_val; + self + } + pub fn num_bits_for_st_ref_pic_set_in_slice( + mut self, + num_bits_for_st_ref_pic_set_in_slice: u16, + ) -> Self { + self.num_bits_for_st_ref_pic_set_in_slice = num_bits_for_st_ref_pic_set_in_slice; + self + } + pub fn reserved(mut self, reserved: u16) -> Self { + self.reserved = reserved; + self + } + pub fn ref_pic_set_st_curr_before( + mut self, + ref_pic_set_st_curr_before: [u8; crate::vk::STD_VIDEO_DECODE_H265_REF_PIC_SET_LIST_SIZE + as _], + ) -> Self { + self.ref_pic_set_st_curr_before = ref_pic_set_st_curr_before; + self + } + pub fn ref_pic_set_st_curr_after( + mut self, + ref_pic_set_st_curr_after: [u8; crate::vk::STD_VIDEO_DECODE_H265_REF_PIC_SET_LIST_SIZE + as _], + ) -> Self { + self.ref_pic_set_st_curr_after = ref_pic_set_st_curr_after; + self + } + pub fn ref_pic_set_lt_curr( + mut self, + ref_pic_set_lt_curr: [u8; crate::vk::STD_VIDEO_DECODE_H265_REF_PIC_SET_LIST_SIZE + as _], + ) -> Self { + self.ref_pic_set_lt_curr = ref_pic_set_lt_curr; + self + } +} #[repr(C)] -#[derive(Clone, Copy)] +#[derive(Clone, Copy, Default)] pub struct DecodeH265ReferenceInfoFlags { /**- `used_for_long_term_reference` @ `0..1` - `unused_for_reference` @ `1..2`*/ pub bitfield0: u32, } +impl DecodeH265ReferenceInfoFlags { + pub fn used_for_long_term_reference( + mut self, + used_for_long_term_reference: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFFFFFFFE; + self.bitfield0 = (used_for_long_term_reference & 0x00000001) | rest; + self + } + pub fn unused_for_reference(mut self, unused_for_reference: u32) -> Self { + let rest = self.bitfield0 & 0xFFFFFFFD; + self.bitfield0 = ((unused_for_reference << 1u32) & 0x00000002) | rest; + self + } +} #[repr(C)] -#[derive(Clone, Copy)] +#[derive(Clone, Copy, Default)] pub struct DecodeH265ReferenceInfo { pub flags: crate::vk::DecodeH265ReferenceInfoFlags, pub pic_order_cnt_val: i32, } +impl DecodeH265ReferenceInfo { + pub fn flags(mut self, flags: crate::vk::DecodeH265ReferenceInfoFlags) -> Self { + self.flags = flags; + self + } + pub fn pic_order_cnt_val(mut self, pic_order_cnt_val: i32) -> Self { + self.pic_order_cnt_val = pic_order_cnt_val; + self + } +} pub const STD_VULKAN_VIDEO_CODEC_H265_DECODE_SPEC_VERSION: u32 = crate::vk::STD_VULKAN_VIDEO_CODEC_H265_DECODE_API_VERSION_1_0_0; pub const STD_VULKAN_VIDEO_CODEC_H265_DECODE_EXTENSION_NAME: &core::ffi::CStr = c"VK_STD_vulkan_video_codec_h265_decode"; pub const STD_VIDEO_DECODE_H265_REF_PIC_SET_LIST_SIZE: u32 = 8; diff --git a/ash-rewrite/src/generated/video/codec_h265std_encode.rs b/ash-rewrite/src/generated/video/codec_h265std_encode.rs index 089c0854d..89ddb6570 100644 --- a/ash-rewrite/src/generated/video/codec_h265std_encode.rs +++ b/ash-rewrite/src/generated/video/codec_h265std_encode.rs @@ -2,13 +2,31 @@ #![cfg_attr(rustfmt, rustfmt_skip)] //!Items provided by `vulkan_video_codec_h265std_encode` #[repr(C)] -#[derive(Clone, Copy)] +#[derive(Clone, Copy, Default)] pub struct EncodeH265WeightTableFlags { pub luma_weight_l0_flag: u16, pub chroma_weight_l0_flag: u16, pub luma_weight_l1_flag: u16, pub chroma_weight_l1_flag: u16, } +impl EncodeH265WeightTableFlags { + pub fn luma_weight_l0_flag(mut self, luma_weight_l0_flag: u16) -> Self { + self.luma_weight_l0_flag = luma_weight_l0_flag; + self + } + pub fn chroma_weight_l0_flag(mut self, chroma_weight_l0_flag: u16) -> Self { + self.chroma_weight_l0_flag = chroma_weight_l0_flag; + self + } + pub fn luma_weight_l1_flag(mut self, luma_weight_l1_flag: u16) -> Self { + self.luma_weight_l1_flag = luma_weight_l1_flag; + self + } + pub fn chroma_weight_l1_flag(mut self, chroma_weight_l1_flag: u16) -> Self { + self.chroma_weight_l1_flag = chroma_weight_l1_flag; + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct EncodeH265WeightTable { @@ -28,6 +46,100 @@ pub struct EncodeH265WeightTable { pub delta_chroma_offset_l1: [[i8; crate::vk::STD_VIDEO_H265_MAX_CHROMA_PLANES as _]; crate::vk::STD_VIDEO_H265_MAX_NUM_LIST_REF as _], } +impl Default for EncodeH265WeightTable { + fn default() -> Self { + Self { + flags: Default::default(), + luma_log2_weight_denom: Default::default(), + delta_chroma_log2_weight_denom: Default::default(), + delta_luma_weight_l0: unsafe { core::mem::zeroed() }, + luma_offset_l0: unsafe { core::mem::zeroed() }, + delta_chroma_weight_l0: unsafe { core::mem::zeroed() }, + delta_chroma_offset_l0: unsafe { core::mem::zeroed() }, + delta_luma_weight_l1: unsafe { core::mem::zeroed() }, + luma_offset_l1: unsafe { core::mem::zeroed() }, + delta_chroma_weight_l1: unsafe { core::mem::zeroed() }, + delta_chroma_offset_l1: unsafe { core::mem::zeroed() }, + } + } +} +impl EncodeH265WeightTable { + pub fn flags(mut self, flags: crate::vk::EncodeH265WeightTableFlags) -> Self { + self.flags = flags; + self + } + pub fn luma_log2_weight_denom(mut self, luma_log2_weight_denom: u8) -> Self { + self.luma_log2_weight_denom = luma_log2_weight_denom; + self + } + pub fn delta_chroma_log2_weight_denom( + mut self, + delta_chroma_log2_weight_denom: i8, + ) -> Self { + self.delta_chroma_log2_weight_denom = delta_chroma_log2_weight_denom; + self + } + pub fn delta_luma_weight_l0( + mut self, + delta_luma_weight_l0: [i8; crate::vk::STD_VIDEO_H265_MAX_NUM_LIST_REF as _], + ) -> Self { + self.delta_luma_weight_l0 = delta_luma_weight_l0; + self + } + pub fn luma_offset_l0( + mut self, + luma_offset_l0: [i8; crate::vk::STD_VIDEO_H265_MAX_NUM_LIST_REF as _], + ) -> Self { + self.luma_offset_l0 = luma_offset_l0; + self + } + pub fn delta_chroma_weight_l0( + mut self, + delta_chroma_weight_l0: [[i8; crate::vk::STD_VIDEO_H265_MAX_CHROMA_PLANES + as _]; crate::vk::STD_VIDEO_H265_MAX_NUM_LIST_REF as _], + ) -> Self { + self.delta_chroma_weight_l0 = delta_chroma_weight_l0; + self + } + pub fn delta_chroma_offset_l0( + mut self, + delta_chroma_offset_l0: [[i8; crate::vk::STD_VIDEO_H265_MAX_CHROMA_PLANES + as _]; crate::vk::STD_VIDEO_H265_MAX_NUM_LIST_REF as _], + ) -> Self { + self.delta_chroma_offset_l0 = delta_chroma_offset_l0; + self + } + pub fn delta_luma_weight_l1( + mut self, + delta_luma_weight_l1: [i8; crate::vk::STD_VIDEO_H265_MAX_NUM_LIST_REF as _], + ) -> Self { + self.delta_luma_weight_l1 = delta_luma_weight_l1; + self + } + pub fn luma_offset_l1( + mut self, + luma_offset_l1: [i8; crate::vk::STD_VIDEO_H265_MAX_NUM_LIST_REF as _], + ) -> Self { + self.luma_offset_l1 = luma_offset_l1; + self + } + pub fn delta_chroma_weight_l1( + mut self, + delta_chroma_weight_l1: [[i8; crate::vk::STD_VIDEO_H265_MAX_CHROMA_PLANES + as _]; crate::vk::STD_VIDEO_H265_MAX_NUM_LIST_REF as _], + ) -> Self { + self.delta_chroma_weight_l1 = delta_chroma_weight_l1; + self + } + pub fn delta_chroma_offset_l1( + mut self, + delta_chroma_offset_l1: [[i8; crate::vk::STD_VIDEO_H265_MAX_CHROMA_PLANES + as _]; crate::vk::STD_VIDEO_H265_MAX_NUM_LIST_REF as _], + ) -> Self { + self.delta_chroma_offset_l1 = delta_chroma_offset_l1; + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct EncodeH265LongTermRefPics { @@ -39,8 +151,63 @@ pub struct EncodeH265LongTermRefPics { pub delta_poc_msb_present_flag: [u8; crate::vk::STD_VIDEO_H265_MAX_DELTA_POC as _], pub delta_poc_msb_cycle_lt: [u8; crate::vk::STD_VIDEO_H265_MAX_DELTA_POC as _], } +impl Default for EncodeH265LongTermRefPics { + fn default() -> Self { + Self { + num_long_term_sps: Default::default(), + num_long_term_pics: Default::default(), + lt_idx_sps: unsafe { core::mem::zeroed() }, + poc_lsb_lt: unsafe { core::mem::zeroed() }, + used_by_curr_pic_lt_flag: Default::default(), + delta_poc_msb_present_flag: unsafe { core::mem::zeroed() }, + delta_poc_msb_cycle_lt: unsafe { core::mem::zeroed() }, + } + } +} +impl EncodeH265LongTermRefPics { + pub fn num_long_term_sps(mut self, num_long_term_sps: u8) -> Self { + self.num_long_term_sps = num_long_term_sps; + self + } + pub fn num_long_term_pics(mut self, num_long_term_pics: u8) -> Self { + self.num_long_term_pics = num_long_term_pics; + self + } + pub fn lt_idx_sps( + mut self, + lt_idx_sps: [u8; crate::vk::STD_VIDEO_H265_MAX_LONG_TERM_REF_PICS_SPS as _], + ) -> Self { + self.lt_idx_sps = lt_idx_sps; + self + } + pub fn poc_lsb_lt( + mut self, + poc_lsb_lt: [u8; crate::vk::STD_VIDEO_H265_MAX_LONG_TERM_PICS as _], + ) -> Self { + self.poc_lsb_lt = poc_lsb_lt; + self + } + pub fn used_by_curr_pic_lt_flag(mut self, used_by_curr_pic_lt_flag: u16) -> Self { + self.used_by_curr_pic_lt_flag = used_by_curr_pic_lt_flag; + self + } + pub fn delta_poc_msb_present_flag( + mut self, + delta_poc_msb_present_flag: [u8; crate::vk::STD_VIDEO_H265_MAX_DELTA_POC as _], + ) -> Self { + self.delta_poc_msb_present_flag = delta_poc_msb_present_flag; + self + } + pub fn delta_poc_msb_cycle_lt( + mut self, + delta_poc_msb_cycle_lt: [u8; crate::vk::STD_VIDEO_H265_MAX_DELTA_POC as _], + ) -> Self { + self.delta_poc_msb_cycle_lt = delta_poc_msb_cycle_lt; + self + } +} #[repr(C)] -#[derive(Clone, Copy)] +#[derive(Clone, Copy, Default)] pub struct EncodeH265SliceSegmentHeaderFlags { /**- `first_slice_segment_in_pic_flag` @ `0..1` - `dependent_slice_segment_flag` @ `1..2` @@ -56,8 +223,95 @@ pub struct EncodeH265SliceSegmentHeaderFlags { - `slice_loop_filter_across_slices_enabled_flag` @ `11..12`*/ pub bitfield0: u32, } +impl EncodeH265SliceSegmentHeaderFlags { + pub fn first_slice_segment_in_pic_flag( + mut self, + first_slice_segment_in_pic_flag: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFFFFFFFE; + self.bitfield0 = (first_slice_segment_in_pic_flag & 0x00000001) | rest; + self + } + pub fn dependent_slice_segment_flag( + mut self, + dependent_slice_segment_flag: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFFFFFFFD; + self.bitfield0 = ((dependent_slice_segment_flag << 1u32) & 0x00000002) | rest; + self + } + pub fn slice_sao_luma_flag(mut self, slice_sao_luma_flag: u32) -> Self { + let rest = self.bitfield0 & 0xFFFFFFFB; + self.bitfield0 = ((slice_sao_luma_flag << 2u32) & 0x00000004) | rest; + self + } + pub fn slice_sao_chroma_flag(mut self, slice_sao_chroma_flag: u32) -> Self { + let rest = self.bitfield0 & 0xFFFFFFF7; + self.bitfield0 = ((slice_sao_chroma_flag << 3u32) & 0x00000008) | rest; + self + } + pub fn num_ref_idx_active_override_flag( + mut self, + num_ref_idx_active_override_flag: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFFFFFFEF; + self.bitfield0 = ((num_ref_idx_active_override_flag << 4u32) & 0x00000010) + | rest; + self + } + pub fn mvd_l1_zero_flag(mut self, mvd_l1_zero_flag: u32) -> Self { + let rest = self.bitfield0 & 0xFFFFFFDF; + self.bitfield0 = ((mvd_l1_zero_flag << 5u32) & 0x00000020) | rest; + self + } + pub fn cabac_init_flag(mut self, cabac_init_flag: u32) -> Self { + let rest = self.bitfield0 & 0xFFFFFFBF; + self.bitfield0 = ((cabac_init_flag << 6u32) & 0x00000040) | rest; + self + } + pub fn cu_chroma_qp_offset_enabled_flag( + mut self, + cu_chroma_qp_offset_enabled_flag: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFFFFFF7F; + self.bitfield0 = ((cu_chroma_qp_offset_enabled_flag << 7u32) & 0x00000080) + | rest; + self + } + pub fn deblocking_filter_override_flag( + mut self, + deblocking_filter_override_flag: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFFFFFEFF; + self.bitfield0 = ((deblocking_filter_override_flag << 8u32) & 0x00000100) | rest; + self + } + pub fn slice_deblocking_filter_disabled_flag( + mut self, + slice_deblocking_filter_disabled_flag: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFFFFFDFF; + self.bitfield0 = ((slice_deblocking_filter_disabled_flag << 9u32) & 0x00000200) + | rest; + self + } + pub fn collocated_from_l0_flag(mut self, collocated_from_l0_flag: u32) -> Self { + let rest = self.bitfield0 & 0xFFFFFBFF; + self.bitfield0 = ((collocated_from_l0_flag << 10u32) & 0x00000400) | rest; + self + } + pub fn slice_loop_filter_across_slices_enabled_flag( + mut self, + slice_loop_filter_across_slices_enabled_flag: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFFFFF7FF; + self.bitfield0 = ((slice_loop_filter_across_slices_enabled_flag << 11u32) + & 0x00000800) | rest; + self + } +} #[repr(C)] -#[derive(Clone, Copy)] +#[derive(Clone, Copy, Default)] pub struct EncodeH265SliceSegmentHeader<'a> { pub flags: crate::vk::EncodeH265SliceSegmentHeaderFlags, pub slice_type: crate::vk::H265SliceType, @@ -76,13 +330,97 @@ pub struct EncodeH265SliceSegmentHeader<'a> { pub p_weight_table: *const crate::vk::EncodeH265WeightTable, pub _marker: ::core::marker::PhantomData<&'a ()>, } +impl<'a> EncodeH265SliceSegmentHeader<'a> { + pub fn flags(mut self, flags: crate::vk::EncodeH265SliceSegmentHeaderFlags) -> Self { + self.flags = flags; + self + } + pub fn slice_type(mut self, slice_type: crate::vk::H265SliceType) -> Self { + self.slice_type = slice_type; + self + } + pub fn slice_segment_address(mut self, slice_segment_address: u32) -> Self { + self.slice_segment_address = slice_segment_address; + self + } + pub fn collocated_ref_idx(mut self, collocated_ref_idx: u8) -> Self { + self.collocated_ref_idx = collocated_ref_idx; + self + } + pub fn max_num_merge_cand(mut self, max_num_merge_cand: u8) -> Self { + self.max_num_merge_cand = max_num_merge_cand; + self + } + pub fn slice_cb_qp_offset(mut self, slice_cb_qp_offset: i8) -> Self { + self.slice_cb_qp_offset = slice_cb_qp_offset; + self + } + pub fn slice_cr_qp_offset(mut self, slice_cr_qp_offset: i8) -> Self { + self.slice_cr_qp_offset = slice_cr_qp_offset; + self + } + pub fn slice_beta_offset_div2(mut self, slice_beta_offset_div2: i8) -> Self { + self.slice_beta_offset_div2 = slice_beta_offset_div2; + self + } + pub fn slice_tc_offset_div2(mut self, slice_tc_offset_div2: i8) -> Self { + self.slice_tc_offset_div2 = slice_tc_offset_div2; + self + } + pub fn slice_act_y_qp_offset(mut self, slice_act_y_qp_offset: i8) -> Self { + self.slice_act_y_qp_offset = slice_act_y_qp_offset; + self + } + pub fn slice_act_cb_qp_offset(mut self, slice_act_cb_qp_offset: i8) -> Self { + self.slice_act_cb_qp_offset = slice_act_cb_qp_offset; + self + } + pub fn slice_act_cr_qp_offset(mut self, slice_act_cr_qp_offset: i8) -> Self { + self.slice_act_cr_qp_offset = slice_act_cr_qp_offset; + self + } + pub fn slice_qp_delta(mut self, slice_qp_delta: i8) -> Self { + self.slice_qp_delta = slice_qp_delta; + self + } + pub fn reserved1(mut self, reserved1: u16) -> Self { + self.reserved1 = reserved1; + self + } + pub fn p_weight_table( + mut self, + p_weight_table: &'a crate::vk::EncodeH265WeightTable, + ) -> Self { + self.p_weight_table = p_weight_table; + self + } +} #[repr(C)] -#[derive(Clone, Copy)] +#[derive(Clone, Copy, Default)] pub struct EncodeH265ReferenceListsInfoFlags { /**- `ref_pic_list_modification_flag_l0` @ `0..1` - `ref_pic_list_modification_flag_l1` @ `1..2`*/ pub bitfield0: u32, } +impl EncodeH265ReferenceListsInfoFlags { + pub fn ref_pic_list_modification_flag_l0( + mut self, + ref_pic_list_modification_flag_l0: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFFFFFFFE; + self.bitfield0 = (ref_pic_list_modification_flag_l0 & 0x00000001) | rest; + self + } + pub fn ref_pic_list_modification_flag_l1( + mut self, + ref_pic_list_modification_flag_l1: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFFFFFFFD; + self.bitfield0 = ((ref_pic_list_modification_flag_l1 << 1u32) & 0x00000002) + | rest; + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct EncodeH265ReferenceListsInfo { @@ -94,8 +432,69 @@ pub struct EncodeH265ReferenceListsInfo { pub list_entry_l0: [u8; crate::vk::STD_VIDEO_H265_MAX_NUM_LIST_REF as _], pub list_entry_l1: [u8; crate::vk::STD_VIDEO_H265_MAX_NUM_LIST_REF as _], } +impl Default for EncodeH265ReferenceListsInfo { + fn default() -> Self { + Self { + flags: Default::default(), + num_ref_idx_l0_active_minus1: Default::default(), + num_ref_idx_l1_active_minus1: Default::default(), + ref_pic_list0: unsafe { core::mem::zeroed() }, + ref_pic_list1: unsafe { core::mem::zeroed() }, + list_entry_l0: unsafe { core::mem::zeroed() }, + list_entry_l1: unsafe { core::mem::zeroed() }, + } + } +} +impl EncodeH265ReferenceListsInfo { + pub fn flags(mut self, flags: crate::vk::EncodeH265ReferenceListsInfoFlags) -> Self { + self.flags = flags; + self + } + pub fn num_ref_idx_l0_active_minus1( + mut self, + num_ref_idx_l0_active_minus1: u8, + ) -> Self { + self.num_ref_idx_l0_active_minus1 = num_ref_idx_l0_active_minus1; + self + } + pub fn num_ref_idx_l1_active_minus1( + mut self, + num_ref_idx_l1_active_minus1: u8, + ) -> Self { + self.num_ref_idx_l1_active_minus1 = num_ref_idx_l1_active_minus1; + self + } + pub fn ref_pic_list0( + mut self, + ref_pic_list0: [u8; crate::vk::STD_VIDEO_H265_MAX_NUM_LIST_REF as _], + ) -> Self { + self.ref_pic_list0 = ref_pic_list0; + self + } + pub fn ref_pic_list1( + mut self, + ref_pic_list1: [u8; crate::vk::STD_VIDEO_H265_MAX_NUM_LIST_REF as _], + ) -> Self { + self.ref_pic_list1 = ref_pic_list1; + self + } + pub fn list_entry_l0( + mut self, + list_entry_l0: [u8; crate::vk::STD_VIDEO_H265_MAX_NUM_LIST_REF as _], + ) -> Self { + self.list_entry_l0 = list_entry_l0; + self + } + pub fn list_entry_l1( + mut self, + list_entry_l1: [u8; crate::vk::STD_VIDEO_H265_MAX_NUM_LIST_REF as _], + ) -> Self { + self.list_entry_l1 = list_entry_l1; + self + } +} #[repr(C)] -#[derive(Clone, Copy)] +#[derive(Clone, Copy, Default)] pub struct EncodeH265PictureInfoFlags { /**- `is_reference` @ `0..1` - `IrapPicFlag` @ `1..2` @@ -108,6 +507,65 @@ pub struct EncodeH265PictureInfoFlags { - `slice_temporal_mvp_enabled_flag` @ `8..9`*/ pub bitfield0: u32, } +impl EncodeH265PictureInfoFlags { + pub fn is_reference(mut self, is_reference: u32) -> Self { + let rest = self.bitfield0 & 0xFFFFFFFE; + self.bitfield0 = (is_reference & 0x00000001) | rest; + self + } + pub fn irap_pic_flag(mut self, irap_pic_flag: u32) -> Self { + let rest = self.bitfield0 & 0xFFFFFFFD; + self.bitfield0 = ((irap_pic_flag << 1u32) & 0x00000002) | rest; + self + } + pub fn used_for_long_term_reference( + mut self, + used_for_long_term_reference: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFFFFFFFB; + self.bitfield0 = ((used_for_long_term_reference << 2u32) & 0x00000004) | rest; + self + } + pub fn discardable_flag(mut self, discardable_flag: u32) -> Self { + let rest = self.bitfield0 & 0xFFFFFFF7; + self.bitfield0 = ((discardable_flag << 3u32) & 0x00000008) | rest; + self + } + pub fn cross_layer_bla_flag(mut self, cross_layer_bla_flag: u32) -> Self { + let rest = self.bitfield0 & 0xFFFFFFEF; + self.bitfield0 = ((cross_layer_bla_flag << 4u32) & 0x00000010) | rest; + self + } + pub fn pic_output_flag(mut self, pic_output_flag: u32) -> Self { + let rest = self.bitfield0 & 0xFFFFFFDF; + self.bitfield0 = ((pic_output_flag << 5u32) & 0x00000020) | rest; + self + } + pub fn no_output_of_prior_pics_flag( + mut self, + no_output_of_prior_pics_flag: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFFFFFFBF; + self.bitfield0 = ((no_output_of_prior_pics_flag << 6u32) & 0x00000040) | rest; + self + } + pub fn short_term_ref_pic_set_sps_flag( + mut self, + short_term_ref_pic_set_sps_flag: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFFFFFF7F; + self.bitfield0 = ((short_term_ref_pic_set_sps_flag << 7u32) & 0x00000080) | rest; + self + } + pub fn slice_temporal_mvp_enabled_flag( + mut self, + slice_temporal_mvp_enabled_flag: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFFFFFEFF; + self.bitfield0 = ((slice_temporal_mvp_enabled_flag << 8u32) & 0x00000100) | rest; + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct EncodeH265PictureInfo<'a> { @@ -125,21 +583,132 @@ pub struct EncodeH265PictureInfo<'a> { pub p_long_term_ref_pics: *const crate::vk::EncodeH265LongTermRefPics, pub _marker: ::core::marker::PhantomData<&'a ()>, } +impl<'a> Default for EncodeH265PictureInfo<'a> { + fn default() -> Self { + Self { + flags: Default::default(), + pic_type: Default::default(), + sps_video_parameter_set_id: Default::default(), + pps_seq_parameter_set_id: Default::default(), + pps_pic_parameter_set_id: Default::default(), + short_term_ref_pic_set_idx: Default::default(), + pic_order_cnt_val: Default::default(), + temporal_id: Default::default(), + reserved1: unsafe { core::mem::zeroed() }, + p_ref_lists: Default::default(), + p_short_term_ref_pic_set: Default::default(), + p_long_term_ref_pics: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> EncodeH265PictureInfo<'a> { + pub fn flags(mut self, flags: crate::vk::EncodeH265PictureInfoFlags) -> Self { + self.flags = flags; + self + } + pub fn pic_type(mut self, pic_type: crate::vk::H265PictureType) -> Self { + self.pic_type = pic_type; + self + } + pub fn sps_video_parameter_set_id(mut self, sps_video_parameter_set_id: u8) -> Self { + self.sps_video_parameter_set_id = sps_video_parameter_set_id; + self + } + pub fn pps_seq_parameter_set_id(mut self, pps_seq_parameter_set_id: u8) -> Self { + self.pps_seq_parameter_set_id = pps_seq_parameter_set_id; + self + } + pub fn pps_pic_parameter_set_id(mut self, pps_pic_parameter_set_id: u8) -> Self { + self.pps_pic_parameter_set_id = pps_pic_parameter_set_id; + self + } + pub fn short_term_ref_pic_set_idx(mut self, short_term_ref_pic_set_idx: u8) -> Self { + self.short_term_ref_pic_set_idx = short_term_ref_pic_set_idx; + self + } + pub fn pic_order_cnt_val(mut self, pic_order_cnt_val: i32) -> Self { + self.pic_order_cnt_val = pic_order_cnt_val; + self + } + pub fn temporal_id(mut self, temporal_id: u8) -> Self { + self.temporal_id = temporal_id; + self + } + pub fn reserved1(mut self, reserved1: [u8; 7 as _]) -> Self { + self.reserved1 = reserved1; + self + } + pub fn p_ref_lists( + mut self, + p_ref_lists: &'a crate::vk::EncodeH265ReferenceListsInfo, + ) -> Self { + self.p_ref_lists = p_ref_lists; + self + } + pub fn p_short_term_ref_pic_set( + mut self, + p_short_term_ref_pic_set: &'a crate::vk::H265ShortTermRefPicSet, + ) -> Self { + self.p_short_term_ref_pic_set = p_short_term_ref_pic_set; + self + } + pub fn p_long_term_ref_pics( + mut self, + p_long_term_ref_pics: &'a crate::vk::EncodeH265LongTermRefPics, + ) -> Self { + self.p_long_term_ref_pics = p_long_term_ref_pics; + self + } +} #[repr(C)] -#[derive(Clone, Copy)] +#[derive(Clone, Copy, Default)] pub struct EncodeH265ReferenceInfoFlags { /**- `used_for_long_term_reference` @ `0..1` - `unused_for_reference` @ `1..2`*/ pub bitfield0: u32, } +impl EncodeH265ReferenceInfoFlags { + pub fn used_for_long_term_reference( + mut self, + used_for_long_term_reference: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFFFFFFFE; + self.bitfield0 = (used_for_long_term_reference & 0x00000001) | rest; + self + } + pub fn unused_for_reference(mut self, unused_for_reference: u32) -> Self { + let rest = self.bitfield0 & 0xFFFFFFFD; + self.bitfield0 = ((unused_for_reference << 1u32) & 0x00000002) | rest; + self + } +} #[repr(C)] -#[derive(Clone, Copy)] +#[derive(Clone, Copy, Default)] pub struct EncodeH265ReferenceInfo { pub flags: crate::vk::EncodeH265ReferenceInfoFlags, pub pic_type: crate::vk::H265PictureType, pub pic_order_cnt_val: i32, pub temporal_id: u8, } +impl EncodeH265ReferenceInfo { + pub fn flags(mut self, flags: crate::vk::EncodeH265ReferenceInfoFlags) -> Self { + self.flags = flags; + self + } + pub fn pic_type(mut self, pic_type: crate::vk::H265PictureType) -> Self { + self.pic_type = pic_type; + self + } + pub fn pic_order_cnt_val(mut self, pic_order_cnt_val: i32) -> Self { + self.pic_order_cnt_val = pic_order_cnt_val; + self + } + pub fn temporal_id(mut self, temporal_id: u8) -> Self { + self.temporal_id = temporal_id; + self + } +} pub const STD_VULKAN_VIDEO_CODEC_H265_ENCODE_SPEC_VERSION: u32 = crate::vk::STD_VULKAN_VIDEO_CODEC_H265_ENCODE_API_VERSION_1_0_0; pub const STD_VULKAN_VIDEO_CODEC_H265_ENCODE_EXTENSION_NAME: &core::ffi::CStr = c"VK_STD_vulkan_video_codec_h265_encode"; pub const STD_VULKAN_VIDEO_CODEC_H265_ENCODE_API_VERSION_1_0_0: u32 = crate::vk::make_video_std_version( diff --git a/ash-rewrite/src/generated/video/codec_vp9std.rs b/ash-rewrite/src/generated/video/codec_vp9std.rs index 6584dd204..6f88ad29e 100644 --- a/ash-rewrite/src/generated/video/codec_vp9std.rs +++ b/ash-rewrite/src/generated/video/codec_vp9std.rs @@ -2,13 +2,20 @@ #![cfg_attr(rustfmt, rustfmt_skip)] //!Items provided by `vulkan_video_codec_vp9std` #[repr(C)] -#[derive(Clone, Copy)] +#[derive(Clone, Copy, Default)] pub struct VP9ColorConfigFlags { ///- `color_range` @ `0..1` pub bitfield0: u32, } +impl VP9ColorConfigFlags { + pub fn color_range(mut self, color_range: u32) -> Self { + let rest = self.bitfield0 & 0xFFFFFFFE; + self.bitfield0 = (color_range & 0x00000001) | rest; + self + } +} #[repr(C)] -#[derive(Clone, Copy)] +#[derive(Clone, Copy, Default)] pub struct VP9ColorConfig { pub flags: crate::vk::VP9ColorConfigFlags, pub bit_depth: u8, @@ -17,13 +24,51 @@ pub struct VP9ColorConfig { pub reserved1: u8, pub color_space: crate::vk::VP9ColorSpace, } +impl VP9ColorConfig { + pub fn flags(mut self, flags: crate::vk::VP9ColorConfigFlags) -> Self { + self.flags = flags; + self + } + pub fn bit_depth(mut self, bit_depth: u8) -> Self { + self.bit_depth = bit_depth; + self + } + pub fn subsampling_x(mut self, subsampling_x: u8) -> Self { + self.subsampling_x = subsampling_x; + self + } + pub fn subsampling_y(mut self, subsampling_y: u8) -> Self { + self.subsampling_y = subsampling_y; + self + } + pub fn reserved1(mut self, reserved1: u8) -> Self { + self.reserved1 = reserved1; + self + } + pub fn color_space(mut self, color_space: crate::vk::VP9ColorSpace) -> Self { + self.color_space = color_space; + self + } +} #[repr(C)] -#[derive(Clone, Copy)] +#[derive(Clone, Copy, Default)] pub struct VP9LoopFilterFlags { /**- `loop_filter_delta_enabled` @ `0..1` - `loop_filter_delta_update` @ `1..2`*/ pub bitfield0: u32, } +impl VP9LoopFilterFlags { + pub fn loop_filter_delta_enabled(mut self, loop_filter_delta_enabled: u32) -> Self { + let rest = self.bitfield0 & 0xFFFFFFFE; + self.bitfield0 = (loop_filter_delta_enabled & 0x00000001) | rest; + self + } + pub fn loop_filter_delta_update(mut self, loop_filter_delta_update: u32) -> Self { + let rest = self.bitfield0 & 0xFFFFFFFD; + self.bitfield0 = ((loop_filter_delta_update << 1u32) & 0x00000002) | rest; + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct VP9LoopFilter { @@ -36,8 +81,58 @@ pub struct VP9LoopFilter { pub loop_filter_mode_deltas: [i8; crate::vk::STD_VIDEO_VP9_LOOP_FILTER_ADJUSTMENTS as _], } +impl Default for VP9LoopFilter { + fn default() -> Self { + Self { + flags: Default::default(), + loop_filter_level: Default::default(), + loop_filter_sharpness: Default::default(), + update_ref_delta: Default::default(), + loop_filter_ref_deltas: unsafe { core::mem::zeroed() }, + update_mode_delta: Default::default(), + loop_filter_mode_deltas: unsafe { core::mem::zeroed() }, + } + } +} +impl VP9LoopFilter { + pub fn flags(mut self, flags: crate::vk::VP9LoopFilterFlags) -> Self { + self.flags = flags; + self + } + pub fn loop_filter_level(mut self, loop_filter_level: u8) -> Self { + self.loop_filter_level = loop_filter_level; + self + } + pub fn loop_filter_sharpness(mut self, loop_filter_sharpness: u8) -> Self { + self.loop_filter_sharpness = loop_filter_sharpness; + self + } + pub fn update_ref_delta(mut self, update_ref_delta: u8) -> Self { + self.update_ref_delta = update_ref_delta; + self + } + pub fn loop_filter_ref_deltas( + mut self, + loop_filter_ref_deltas: [i8; crate::vk::STD_VIDEO_VP9_MAX_REF_FRAMES as _], + ) -> Self { + self.loop_filter_ref_deltas = loop_filter_ref_deltas; + self + } + pub fn update_mode_delta(mut self, update_mode_delta: u8) -> Self { + self.update_mode_delta = update_mode_delta; + self + } + pub fn loop_filter_mode_deltas( + mut self, + loop_filter_mode_deltas: [i8; crate::vk::STD_VIDEO_VP9_LOOP_FILTER_ADJUSTMENTS + as _], + ) -> Self { + self.loop_filter_mode_deltas = loop_filter_mode_deltas; + self + } +} #[repr(C)] -#[derive(Clone, Copy)] +#[derive(Clone, Copy, Default)] pub struct VP9SegmentationFlags { /**- `segmentation_update_map` @ `0..1` - `segmentation_temporal_update` @ `1..2` @@ -45,6 +140,35 @@ pub struct VP9SegmentationFlags { - `segmentation_abs_or_delta_update` @ `3..4`*/ pub bitfield0: u32, } +impl VP9SegmentationFlags { + pub fn segmentation_update_map(mut self, segmentation_update_map: u32) -> Self { + let rest = self.bitfield0 & 0xFFFFFFFE; + self.bitfield0 = (segmentation_update_map & 0x00000001) | rest; + self + } + pub fn segmentation_temporal_update( + mut self, + segmentation_temporal_update: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFFFFFFFD; + self.bitfield0 = ((segmentation_temporal_update << 1u32) & 0x00000002) | rest; + self + } + pub fn segmentation_update_data(mut self, segmentation_update_data: u32) -> Self { + let rest = self.bitfield0 & 0xFFFFFFFB; + self.bitfield0 = ((segmentation_update_data << 2u32) & 0x00000004) | rest; + self + } + pub fn segmentation_abs_or_delta_update( + mut self, + segmentation_abs_or_delta_update: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFFFFFFF7; + self.bitfield0 = ((segmentation_abs_or_delta_update << 3u32) & 0x00000008) + | rest; + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct VP9Segmentation { @@ -57,6 +181,54 @@ pub struct VP9Segmentation { pub feature_data: [[i16; crate::vk::STD_VIDEO_VP9_SEG_LVL_MAX as _]; crate::vk::STD_VIDEO_VP9_MAX_SEGMENTS as _], } +impl Default for VP9Segmentation { + fn default() -> Self { + Self { + flags: Default::default(), + segmentation_tree_probs: unsafe { core::mem::zeroed() }, + segmentation_pred_prob: unsafe { core::mem::zeroed() }, + feature_enabled: unsafe { core::mem::zeroed() }, + feature_data: unsafe { core::mem::zeroed() }, + } + } +} +impl VP9Segmentation { + pub fn flags(mut self, flags: crate::vk::VP9SegmentationFlags) -> Self { + self.flags = flags; + self + } + pub fn segmentation_tree_probs( + mut self, + segmentation_tree_probs: [u8; crate::vk::STD_VIDEO_VP9_MAX_SEGMENTATION_TREE_PROBS + as _], + ) -> Self { + self.segmentation_tree_probs = segmentation_tree_probs; + self + } + pub fn segmentation_pred_prob( + mut self, + segmentation_pred_prob: [u8; crate::vk::STD_VIDEO_VP9_MAX_SEGMENTATION_PRED_PROB + as _], + ) -> Self { + self.segmentation_pred_prob = segmentation_pred_prob; + self + } + pub fn feature_enabled( + mut self, + feature_enabled: [u8; crate::vk::STD_VIDEO_VP9_MAX_SEGMENTS as _], + ) -> Self { + self.feature_enabled = feature_enabled; + self + } + pub fn feature_data( + mut self, + feature_data: [[i16; crate::vk::STD_VIDEO_VP9_SEG_LVL_MAX + as _]; crate::vk::STD_VIDEO_VP9_MAX_SEGMENTS as _], + ) -> Self { + self.feature_data = feature_data; + self + } +} #[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[derive(Debug)] diff --git a/ash-rewrite/src/generated/video/codec_vp9std_decode.rs b/ash-rewrite/src/generated/video/codec_vp9std_decode.rs index 81a321842..b5c2d93b7 100644 --- a/ash-rewrite/src/generated/video/codec_vp9std_decode.rs +++ b/ash-rewrite/src/generated/video/codec_vp9std_decode.rs @@ -2,7 +2,7 @@ #![cfg_attr(rustfmt, rustfmt_skip)] //!Items provided by `vulkan_video_codec_vp9std_decode` #[repr(C)] -#[derive(Clone, Copy)] +#[derive(Clone, Copy, Default)] pub struct DecodeVP9PictureInfoFlags { /**- `error_resilient_mode` @ `0..1` - `intra_only` @ `1..2` @@ -14,6 +14,51 @@ pub struct DecodeVP9PictureInfoFlags { - `UsePrevFrameMvs` @ `7..8`*/ pub bitfield0: u32, } +impl DecodeVP9PictureInfoFlags { + pub fn error_resilient_mode(mut self, error_resilient_mode: u32) -> Self { + let rest = self.bitfield0 & 0xFFFFFFFE; + self.bitfield0 = (error_resilient_mode & 0x00000001) | rest; + self + } + pub fn intra_only(mut self, intra_only: u32) -> Self { + let rest = self.bitfield0 & 0xFFFFFFFD; + self.bitfield0 = ((intra_only << 1u32) & 0x00000002) | rest; + self + } + pub fn allow_high_precision_mv(mut self, allow_high_precision_mv: u32) -> Self { + let rest = self.bitfield0 & 0xFFFFFFFB; + self.bitfield0 = ((allow_high_precision_mv << 2u32) & 0x00000004) | rest; + self + } + pub fn refresh_frame_context(mut self, refresh_frame_context: u32) -> Self { + let rest = self.bitfield0 & 0xFFFFFFF7; + self.bitfield0 = ((refresh_frame_context << 3u32) & 0x00000008) | rest; + self + } + pub fn frame_parallel_decoding_mode( + mut self, + frame_parallel_decoding_mode: u32, + ) -> Self { + let rest = self.bitfield0 & 0xFFFFFFEF; + self.bitfield0 = ((frame_parallel_decoding_mode << 4u32) & 0x00000010) | rest; + self + } + pub fn segmentation_enabled(mut self, segmentation_enabled: u32) -> Self { + let rest = self.bitfield0 & 0xFFFFFFDF; + self.bitfield0 = ((segmentation_enabled << 5u32) & 0x00000020) | rest; + self + } + pub fn show_frame(mut self, show_frame: u32) -> Self { + let rest = self.bitfield0 & 0xFFFFFFBF; + self.bitfield0 = ((show_frame << 6u32) & 0x00000040) | rest; + self + } + pub fn use_prev_frame_mvs(mut self, use_prev_frame_mvs: u32) -> Self { + let rest = self.bitfield0 & 0xFFFFFF7F; + self.bitfield0 = ((use_prev_frame_mvs << 7u32) & 0x00000080) | rest; + self + } +} #[repr(C)] #[derive(Clone, Copy)] pub struct DecodeVP9PictureInfo<'a> { @@ -37,6 +82,114 @@ pub struct DecodeVP9PictureInfo<'a> { pub p_segmentation: *const crate::vk::VP9Segmentation, pub _marker: ::core::marker::PhantomData<&'a ()>, } +impl<'a> Default for DecodeVP9PictureInfo<'a> { + fn default() -> Self { + Self { + flags: Default::default(), + profile: Default::default(), + frame_type: Default::default(), + frame_context_idx: Default::default(), + reset_frame_context: Default::default(), + refresh_frame_flags: Default::default(), + ref_frame_sign_bias_mask: Default::default(), + interpolation_filter: Default::default(), + base_q_idx: Default::default(), + delta_q_y_dc: Default::default(), + delta_q_uv_dc: Default::default(), + delta_q_uv_ac: Default::default(), + tile_cols_log2: Default::default(), + tile_rows_log2: Default::default(), + reserved1: unsafe { core::mem::zeroed() }, + p_color_config: Default::default(), + p_loop_filter: Default::default(), + p_segmentation: Default::default(), + _marker: ::core::marker::PhantomData, + } + } +} +impl<'a> DecodeVP9PictureInfo<'a> { + pub fn flags(mut self, flags: crate::vk::DecodeVP9PictureInfoFlags) -> Self { + self.flags = flags; + self + } + pub fn profile(mut self, profile: crate::vk::VP9Profile) -> Self { + self.profile = profile; + self + } + pub fn frame_type(mut self, frame_type: crate::vk::VP9FrameType) -> Self { + self.frame_type = frame_type; + self + } + pub fn frame_context_idx(mut self, frame_context_idx: u8) -> Self { + self.frame_context_idx = frame_context_idx; + self + } + pub fn reset_frame_context(mut self, reset_frame_context: u8) -> Self { + self.reset_frame_context = reset_frame_context; + self + } + pub fn refresh_frame_flags(mut self, refresh_frame_flags: u8) -> Self { + self.refresh_frame_flags = refresh_frame_flags; + self + } + pub fn ref_frame_sign_bias_mask(mut self, ref_frame_sign_bias_mask: u8) -> Self { + self.ref_frame_sign_bias_mask = ref_frame_sign_bias_mask; + self + } + pub fn interpolation_filter( + mut self, + interpolation_filter: crate::vk::VP9InterpolationFilter, + ) -> Self { + self.interpolation_filter = interpolation_filter; + self + } + pub fn base_q_idx(mut self, base_q_idx: u8) -> Self { + self.base_q_idx = base_q_idx; + self + } + pub fn delta_q_y_dc(mut self, delta_q_y_dc: i8) -> Self { + self.delta_q_y_dc = delta_q_y_dc; + self + } + pub fn delta_q_uv_dc(mut self, delta_q_uv_dc: i8) -> Self { + self.delta_q_uv_dc = delta_q_uv_dc; + self + } + pub fn delta_q_uv_ac(mut self, delta_q_uv_ac: i8) -> Self { + self.delta_q_uv_ac = delta_q_uv_ac; + self + } + pub fn tile_cols_log2(mut self, tile_cols_log2: u8) -> Self { + self.tile_cols_log2 = tile_cols_log2; + self + } + pub fn tile_rows_log2(mut self, tile_rows_log2: u8) -> Self { + self.tile_rows_log2 = tile_rows_log2; + self + } + pub fn reserved1(mut self, reserved1: [u16; 3 as _]) -> Self { + self.reserved1 = reserved1; + self + } + pub fn p_color_config( + mut self, + p_color_config: &'a crate::vk::VP9ColorConfig, + ) -> Self { + self.p_color_config = p_color_config; + self + } + pub fn p_loop_filter(mut self, p_loop_filter: &'a crate::vk::VP9LoopFilter) -> Self { + self.p_loop_filter = p_loop_filter; + self + } + pub fn p_segmentation( + mut self, + p_segmentation: &'a crate::vk::VP9Segmentation, + ) -> Self { + self.p_segmentation = p_segmentation; + self + } +} pub const STD_VULKAN_VIDEO_CODEC_VP9_DECODE_SPEC_VERSION: u32 = crate::vk::STD_VULKAN_VIDEO_CODEC_VP9_DECODE_API_VERSION_1_0_0; pub const STD_VULKAN_VIDEO_CODEC_VP9_DECODE_EXTENSION_NAME: &core::ffi::CStr = c"VK_STD_vulkan_video_codec_vp9_decode"; pub const STD_VULKAN_VIDEO_CODEC_VP9_DECODE_API_VERSION_1_0_0: u32 = crate::vk::make_video_std_version( diff --git a/ash-rewrite/src/generated/vk.rs b/ash-rewrite/src/generated/vk.rs index ed02282ef..54f23b0c8 100644 --- a/ash-rewrite/src/generated/vk.rs +++ b/ash-rewrite/src/generated/vk.rs @@ -476,3 +476,5 @@ pub use super::khr::shader_non_semantic_info::*; pub use super::google::surfaceless_query::*; pub use super::video::codecs_common::*; pub use crate::Handle; +pub use crate::TaggedStructure; +pub use crate::Extends; diff --git a/ash-rewrite/src/generated/vk1_0.rs b/ash-rewrite/src/generated/vk1_0.rs index b50519f00..a3a1d087b 100644 --- a/ash-rewrite/src/generated/vk1_0.rs +++ b/ash-rewrite/src/generated/vk1_0.rs @@ -2241,47 +2241,97 @@ impl DeviceFnV1_0 { } pub(crate) mod reexport { #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct BaseOutStructure<'a> { pub s_type: crate::vk::StructureType, pub p_next: *mut crate::vk::BaseOutStructure<'a>, pub _marker: ::core::marker::PhantomData<&'a ()>, } + impl<'a> BaseOutStructure<'a> {} #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct BaseInStructure<'a> { pub s_type: crate::vk::StructureType, pub p_next: *const crate::vk::BaseInStructure<'a>, pub _marker: ::core::marker::PhantomData<&'a ()>, } + impl<'a> BaseInStructure<'a> {} #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct Offset2D { pub x: i32, pub y: i32, } + impl Offset2D { + pub fn x(mut self, x: i32) -> Self { + self.x = x; + self + } + pub fn y(mut self, y: i32) -> Self { + self.y = y; + self + } + } #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct Offset3D { pub x: i32, pub y: i32, pub z: i32, } + impl Offset3D { + pub fn x(mut self, x: i32) -> Self { + self.x = x; + self + } + pub fn y(mut self, y: i32) -> Self { + self.y = y; + self + } + pub fn z(mut self, z: i32) -> Self { + self.z = z; + self + } + } #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct Extent2D { pub width: u32, pub height: u32, } + impl Extent2D { + pub fn width(mut self, width: u32) -> Self { + self.width = width; + self + } + pub fn height(mut self, height: u32) -> Self { + self.height = height; + self + } + } #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct Extent3D { pub width: u32, pub height: u32, pub depth: u32, } + impl Extent3D { + pub fn width(mut self, width: u32) -> Self { + self.width = width; + self + } + pub fn height(mut self, height: u32) -> Self { + self.height = height; + self + } + pub fn depth(mut self, depth: u32) -> Self { + self.depth = depth; + self + } + } #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct Viewport { pub x: core::ffi::c_float, pub y: core::ffi::c_float, @@ -2290,27 +2340,95 @@ pub(crate) mod reexport { pub min_depth: core::ffi::c_float, pub max_depth: core::ffi::c_float, } + impl Viewport { + pub fn x(mut self, x: core::ffi::c_float) -> Self { + self.x = x; + self + } + pub fn y(mut self, y: core::ffi::c_float) -> Self { + self.y = y; + self + } + pub fn width(mut self, width: core::ffi::c_float) -> Self { + self.width = width; + self + } + pub fn height(mut self, height: core::ffi::c_float) -> Self { + self.height = height; + self + } + pub fn min_depth(mut self, min_depth: core::ffi::c_float) -> Self { + self.min_depth = min_depth; + self + } + pub fn max_depth(mut self, max_depth: core::ffi::c_float) -> Self { + self.max_depth = max_depth; + self + } + } #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct Rect2D { pub offset: crate::vk::Offset2D, pub extent: crate::vk::Extent2D, } + impl Rect2D { + pub fn offset(mut self, offset: crate::vk::Offset2D) -> Self { + self.offset = offset; + self + } + pub fn extent(mut self, extent: crate::vk::Extent2D) -> Self { + self.extent = extent; + self + } + } #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct ClearRect { pub rect: crate::vk::Rect2D, pub base_array_layer: u32, pub layer_count: u32, } + impl ClearRect { + pub fn rect(mut self, rect: crate::vk::Rect2D) -> Self { + self.rect = rect; + self + } + pub fn base_array_layer(mut self, base_array_layer: u32) -> Self { + self.base_array_layer = base_array_layer; + self + } + pub fn layer_count(mut self, layer_count: u32) -> Self { + self.layer_count = layer_count; + self + } + } #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct ComponentMapping { pub r: crate::vk::ComponentSwizzle, pub g: crate::vk::ComponentSwizzle, pub b: crate::vk::ComponentSwizzle, pub a: crate::vk::ComponentSwizzle, } + impl ComponentMapping { + pub fn r(mut self, r: crate::vk::ComponentSwizzle) -> Self { + self.r = r; + self + } + pub fn g(mut self, g: crate::vk::ComponentSwizzle) -> Self { + self.g = g; + self + } + pub fn b(mut self, b: crate::vk::ComponentSwizzle) -> Self { + self.b = b; + self + } + pub fn a(mut self, a: crate::vk::ComponentSwizzle) -> Self { + self.a = a; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceProperties { @@ -2325,12 +2443,108 @@ pub(crate) mod reexport { pub limits: crate::vk::PhysicalDeviceLimits, pub sparse_properties: crate::vk::PhysicalDeviceSparseProperties, } + impl Default for PhysicalDeviceProperties { + fn default() -> Self { + Self { + api_version: Default::default(), + driver_version: Default::default(), + vendor_id: Default::default(), + device_id: Default::default(), + device_type: Default::default(), + device_name: unsafe { core::mem::zeroed() }, + pipeline_cache_uuid: unsafe { core::mem::zeroed() }, + limits: Default::default(), + sparse_properties: Default::default(), + } + } + } + impl PhysicalDeviceProperties { + pub fn api_version(mut self, api_version: u32) -> Self { + self.api_version = api_version; + self + } + pub fn driver_version(mut self, driver_version: u32) -> Self { + self.driver_version = driver_version; + self + } + pub fn vendor_id(mut self, vendor_id: u32) -> Self { + self.vendor_id = vendor_id; + self + } + pub fn device_id(mut self, device_id: u32) -> Self { + self.device_id = device_id; + self + } + pub fn device_type( + mut self, + device_type: crate::vk::PhysicalDeviceType, + ) -> Self { + self.device_type = device_type; + self + } + pub fn device_name( + mut self, + device_name: &core::ffi::CStr, + ) -> core::result::Result { + crate::write_c_str_slice_with_nul(&mut self.device_name, device_name) + .map(|_| self) + } + pub fn device_name_as_c_str( + &self, + ) -> core::result::Result<&core::ffi::CStr, core::ffi::FromBytesUntilNulError> { + crate::wrap_c_str_slice_until_nul(&self.device_name) + } + pub fn pipeline_cache_uuid( + mut self, + pipeline_cache_uuid: [u8; crate::vk::UUID_SIZE as _], + ) -> Self { + self.pipeline_cache_uuid = pipeline_cache_uuid; + self + } + pub fn limits(mut self, limits: crate::vk::PhysicalDeviceLimits) -> Self { + self.limits = limits; + self + } + pub fn sparse_properties( + mut self, + sparse_properties: crate::vk::PhysicalDeviceSparseProperties, + ) -> Self { + self.sparse_properties = sparse_properties; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct ExtensionProperties { pub extension_name: [core::ffi::c_char; crate::vk::MAX_EXTENSION_NAME_SIZE as _], pub spec_version: u32, } + impl Default for ExtensionProperties { + fn default() -> Self { + Self { + extension_name: unsafe { core::mem::zeroed() }, + spec_version: Default::default(), + } + } + } + impl ExtensionProperties { + pub fn extension_name( + mut self, + extension_name: &core::ffi::CStr, + ) -> core::result::Result { + crate::write_c_str_slice_with_nul(&mut self.extension_name, extension_name) + .map(|_| self) + } + pub fn extension_name_as_c_str( + &self, + ) -> core::result::Result<&core::ffi::CStr, core::ffi::FromBytesUntilNulError> { + crate::wrap_c_str_slice_until_nul(&self.extension_name) + } + pub fn spec_version(mut self, spec_version: u32) -> Self { + self.spec_version = spec_version; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct LayerProperties { @@ -2339,6 +2553,50 @@ pub(crate) mod reexport { pub implementation_version: u32, pub description: [core::ffi::c_char; crate::vk::MAX_DESCRIPTION_SIZE as _], } + impl Default for LayerProperties { + fn default() -> Self { + Self { + layer_name: unsafe { core::mem::zeroed() }, + spec_version: Default::default(), + implementation_version: Default::default(), + description: unsafe { core::mem::zeroed() }, + } + } + } + impl LayerProperties { + pub fn layer_name( + mut self, + layer_name: &core::ffi::CStr, + ) -> core::result::Result { + crate::write_c_str_slice_with_nul(&mut self.layer_name, layer_name) + .map(|_| self) + } + pub fn layer_name_as_c_str( + &self, + ) -> core::result::Result<&core::ffi::CStr, core::ffi::FromBytesUntilNulError> { + crate::wrap_c_str_slice_until_nul(&self.layer_name) + } + pub fn spec_version(mut self, spec_version: u32) -> Self { + self.spec_version = spec_version; + self + } + pub fn implementation_version(mut self, implementation_version: u32) -> Self { + self.implementation_version = implementation_version; + self + } + pub fn description( + mut self, + description: &core::ffi::CStr, + ) -> core::result::Result { + crate::write_c_str_slice_with_nul(&mut self.description, description) + .map(|_| self) + } + pub fn description_as_c_str( + &self, + ) -> core::result::Result<&core::ffi::CStr, core::ffi::FromBytesUntilNulError> { + crate::wrap_c_str_slice_until_nul(&self.description) + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct ApplicationInfo<'a> { @@ -2351,8 +2609,64 @@ pub(crate) mod reexport { pub api_version: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for ApplicationInfo<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::APPLICATION_INFO; + } + impl<'a> Default for ApplicationInfo<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + p_application_name: Default::default(), + application_version: Default::default(), + p_engine_name: Default::default(), + engine_version: Default::default(), + api_version: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> ApplicationInfo<'a> { + pub fn p_application_name( + mut self, + p_application_name: &'a core::ffi::CStr, + ) -> Self { + self.p_application_name = p_application_name.as_ptr(); + self + } + pub unsafe fn p_application_name_as_c_str(&self) -> Option<&core::ffi::CStr> { + if self.p_application_name.is_null() { + None + } else { + Some(unsafe { core::ffi::CStr::from_ptr(self.p_application_name) }) + } + } + pub fn application_version(mut self, application_version: u32) -> Self { + self.application_version = application_version; + self + } + pub fn p_engine_name(mut self, p_engine_name: &'a core::ffi::CStr) -> Self { + self.p_engine_name = p_engine_name.as_ptr(); + self + } + pub unsafe fn p_engine_name_as_c_str(&self) -> Option<&core::ffi::CStr> { + if self.p_engine_name.is_null() { + None + } else { + Some(unsafe { core::ffi::CStr::from_ptr(self.p_engine_name) }) + } + } + pub fn engine_version(mut self, engine_version: u32) -> Self { + self.engine_version = engine_version; + self + } + pub fn api_version(mut self, api_version: u32) -> Self { + self.api_version = api_version; + self + } + } #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct AllocationCallbacks<'a> { pub p_user_data: *mut core::ffi::c_void, pub pfn_allocation: crate::vk::PFN_vkAllocationFunction, @@ -2362,6 +2676,44 @@ pub(crate) mod reexport { pub pfn_internal_free: crate::vk::PFN_vkInternalFreeNotification, pub _marker: ::core::marker::PhantomData<&'a ()>, } + impl<'a> AllocationCallbacks<'a> { + pub fn p_user_data(mut self, p_user_data: &'a mut core::ffi::c_void) -> Self { + self.p_user_data = p_user_data; + self + } + pub fn pfn_allocation( + mut self, + pfn_allocation: crate::vk::PFN_vkAllocationFunction, + ) -> Self { + self.pfn_allocation = pfn_allocation; + self + } + pub fn pfn_reallocation( + mut self, + pfn_reallocation: crate::vk::PFN_vkReallocationFunction, + ) -> Self { + self.pfn_reallocation = pfn_reallocation; + self + } + pub fn pfn_free(mut self, pfn_free: crate::vk::PFN_vkFreeFunction) -> Self { + self.pfn_free = pfn_free; + self + } + pub fn pfn_internal_allocation( + mut self, + pfn_internal_allocation: crate::vk::PFN_vkInternalAllocationNotification, + ) -> Self { + self.pfn_internal_allocation = pfn_internal_allocation; + self + } + pub fn pfn_internal_free( + mut self, + pfn_internal_free: crate::vk::PFN_vkInternalFreeNotification, + ) -> Self { + self.pfn_internal_free = pfn_internal_free; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct DeviceQueueCreateInfo<'a> { @@ -2373,6 +2725,44 @@ pub(crate) mod reexport { pub p_queue_priorities: *const core::ffi::c_float, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for DeviceQueueCreateInfo<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::DEVICE_QUEUE_CREATE_INFO; + } + impl<'a> Default for DeviceQueueCreateInfo<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + flags: Default::default(), + queue_family_index: Default::default(), + queue_count: Default::default(), + p_queue_priorities: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> DeviceQueueCreateInfo<'a> { + pub fn flags(mut self, flags: crate::vk::DeviceQueueCreateFlags) -> Self { + self.flags = flags; + self + } + pub fn queue_family_index(mut self, queue_family_index: u32) -> Self { + self.queue_family_index = queue_family_index; + self + } + pub fn queue_count(mut self, queue_count: u32) -> Self { + self.queue_count = queue_count; + self + } + pub fn p_queue_priorities( + mut self, + p_queue_priorities: &'a [core::ffi::c_float], + ) -> Self { + self.queue_count = p_queue_priorities.len() as _; + self.p_queue_priorities = p_queue_priorities.as_ptr(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct DeviceCreateInfo<'a> { @@ -2388,6 +2778,75 @@ pub(crate) mod reexport { pub p_enabled_features: *const crate::vk::PhysicalDeviceFeatures, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for DeviceCreateInfo<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::DEVICE_CREATE_INFO; + } + impl<'a> Default for DeviceCreateInfo<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + flags: Default::default(), + queue_create_info_count: Default::default(), + p_queue_create_infos: Default::default(), + enabled_layer_count: Default::default(), + pp_enabled_layer_names: Default::default(), + enabled_extension_count: Default::default(), + pp_enabled_extension_names: Default::default(), + p_enabled_features: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> DeviceCreateInfo<'a> { + pub fn flags(mut self, flags: crate::vk::DeviceCreateFlags) -> Self { + self.flags = flags; + self + } + pub fn queue_create_info_count(mut self, queue_create_info_count: u32) -> Self { + self.queue_create_info_count = queue_create_info_count; + self + } + pub fn p_queue_create_infos( + mut self, + p_queue_create_infos: &'a [crate::vk::DeviceQueueCreateInfo<'a>], + ) -> Self { + self.queue_create_info_count = p_queue_create_infos.len() as _; + self.p_queue_create_infos = p_queue_create_infos.as_ptr(); + self + } + pub fn enabled_layer_count(mut self, enabled_layer_count: u32) -> Self { + self.enabled_layer_count = enabled_layer_count; + self + } + pub fn pp_enabled_layer_names( + mut self, + pp_enabled_layer_names: &'a [*const core::ffi::c_char], + ) -> Self { + self.enabled_layer_count = pp_enabled_layer_names.len() as _; + self.pp_enabled_layer_names = pp_enabled_layer_names.as_ptr(); + self + } + pub fn enabled_extension_count(mut self, enabled_extension_count: u32) -> Self { + self.enabled_extension_count = enabled_extension_count; + self + } + pub fn pp_enabled_extension_names( + mut self, + pp_enabled_extension_names: &'a [*const core::ffi::c_char], + ) -> Self { + self.enabled_extension_count = pp_enabled_extension_names.len() as _; + self.pp_enabled_extension_names = pp_enabled_extension_names.as_ptr(); + self + } + pub fn p_enabled_features( + mut self, + p_enabled_features: &'a crate::vk::PhysicalDeviceFeatures, + ) -> Self { + self.p_enabled_features = p_enabled_features; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct InstanceCreateInfo<'a> { @@ -2401,14 +2860,90 @@ pub(crate) mod reexport { pub pp_enabled_extension_names: *const *const core::ffi::c_char, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for InstanceCreateInfo<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::INSTANCE_CREATE_INFO; + } + impl<'a> Default for InstanceCreateInfo<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + flags: Default::default(), + p_application_info: Default::default(), + enabled_layer_count: Default::default(), + pp_enabled_layer_names: Default::default(), + enabled_extension_count: Default::default(), + pp_enabled_extension_names: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> InstanceCreateInfo<'a> { + pub fn flags(mut self, flags: crate::vk::InstanceCreateFlags) -> Self { + self.flags = flags; + self + } + pub fn p_application_info( + mut self, + p_application_info: &'a crate::vk::ApplicationInfo<'a>, + ) -> Self { + self.p_application_info = p_application_info; + self + } + pub fn enabled_layer_count(mut self, enabled_layer_count: u32) -> Self { + self.enabled_layer_count = enabled_layer_count; + self + } + pub fn pp_enabled_layer_names( + mut self, + pp_enabled_layer_names: &'a [*const core::ffi::c_char], + ) -> Self { + self.enabled_layer_count = pp_enabled_layer_names.len() as _; + self.pp_enabled_layer_names = pp_enabled_layer_names.as_ptr(); + self + } + pub fn enabled_extension_count(mut self, enabled_extension_count: u32) -> Self { + self.enabled_extension_count = enabled_extension_count; + self + } + pub fn pp_enabled_extension_names( + mut self, + pp_enabled_extension_names: &'a [*const core::ffi::c_char], + ) -> Self { + self.enabled_extension_count = pp_enabled_extension_names.len() as _; + self.pp_enabled_extension_names = pp_enabled_extension_names.as_ptr(); + self + } + } #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct QueueFamilyProperties { pub queue_flags: crate::vk::QueueFlags, pub queue_count: u32, pub timestamp_valid_bits: u32, pub min_image_transfer_granularity: crate::vk::Extent3D, } + impl QueueFamilyProperties { + pub fn queue_flags(mut self, queue_flags: crate::vk::QueueFlags) -> Self { + self.queue_flags = queue_flags; + self + } + pub fn queue_count(mut self, queue_count: u32) -> Self { + self.queue_count = queue_count; + self + } + pub fn timestamp_valid_bits(mut self, timestamp_valid_bits: u32) -> Self { + self.timestamp_valid_bits = timestamp_valid_bits; + self + } + pub fn min_image_transfer_granularity( + mut self, + min_image_transfer_granularity: crate::vk::Extent3D, + ) -> Self { + self.min_image_transfer_granularity = min_image_transfer_granularity; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceMemoryProperties { @@ -2417,6 +2952,42 @@ pub(crate) mod reexport { pub memory_heap_count: u32, pub memory_heaps: [crate::vk::MemoryHeap; crate::vk::MAX_MEMORY_HEAPS as _], } + impl Default for PhysicalDeviceMemoryProperties { + fn default() -> Self { + Self { + memory_type_count: Default::default(), + memory_types: unsafe { core::mem::zeroed() }, + memory_heap_count: Default::default(), + memory_heaps: unsafe { core::mem::zeroed() }, + } + } + } + impl PhysicalDeviceMemoryProperties { + pub fn memory_type_count(mut self, memory_type_count: u32) -> Self { + self.memory_type_count = memory_type_count; + self + } + pub fn memory_types(mut self, memory_types: &[crate::vk::MemoryType]) -> Self { + self.memory_type_count = memory_types.len() as _; + self.memory_types[..memory_types.len()].copy_from_slice(memory_types); + self + } + pub fn memory_types_as_slice(&self) -> &[crate::vk::MemoryType] { + &self.memory_types[..self.memory_type_count as _] + } + pub fn memory_heap_count(mut self, memory_heap_count: u32) -> Self { + self.memory_heap_count = memory_heap_count; + self + } + pub fn memory_heaps(mut self, memory_heaps: &[crate::vk::MemoryHeap]) -> Self { + self.memory_heap_count = memory_heaps.len() as _; + self.memory_heaps[..memory_heaps.len()].copy_from_slice(memory_heaps); + self + } + pub fn memory_heaps_as_slice(&self) -> &[crate::vk::MemoryHeap] { + &self.memory_heaps[..self.memory_heap_count as _] + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct MemoryAllocateInfo<'a> { @@ -2426,22 +2997,80 @@ pub(crate) mod reexport { pub memory_type_index: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for MemoryAllocateInfo<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::MEMORY_ALLOCATE_INFO; + } + impl<'a> Default for MemoryAllocateInfo<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + allocation_size: Default::default(), + memory_type_index: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> MemoryAllocateInfo<'a> { + pub fn allocation_size( + mut self, + allocation_size: crate::vk::DeviceSize, + ) -> Self { + self.allocation_size = allocation_size; + self + } + pub fn memory_type_index(mut self, memory_type_index: u32) -> Self { + self.memory_type_index = memory_type_index; + self + } + } #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct MemoryRequirements { pub size: crate::vk::DeviceSize, pub alignment: crate::vk::DeviceSize, pub memory_type_bits: u32, } + impl MemoryRequirements { + pub fn size(mut self, size: crate::vk::DeviceSize) -> Self { + self.size = size; + self + } + pub fn alignment(mut self, alignment: crate::vk::DeviceSize) -> Self { + self.alignment = alignment; + self + } + pub fn memory_type_bits(mut self, memory_type_bits: u32) -> Self { + self.memory_type_bits = memory_type_bits; + self + } + } #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct SparseImageFormatProperties { pub aspect_mask: crate::vk::ImageAspectFlags, pub image_granularity: crate::vk::Extent3D, pub flags: crate::vk::SparseImageFormatFlags, } + impl SparseImageFormatProperties { + pub fn aspect_mask(mut self, aspect_mask: crate::vk::ImageAspectFlags) -> Self { + self.aspect_mask = aspect_mask; + self + } + pub fn image_granularity( + mut self, + image_granularity: crate::vk::Extent3D, + ) -> Self { + self.image_granularity = image_granularity; + self + } + pub fn flags(mut self, flags: crate::vk::SparseImageFormatFlags) -> Self { + self.flags = flags; + self + } + } #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct SparseImageMemoryRequirements { pub format_properties: crate::vk::SparseImageFormatProperties, pub image_mip_tail_first_lod: u32, @@ -2449,18 +3078,78 @@ pub(crate) mod reexport { pub image_mip_tail_offset: crate::vk::DeviceSize, pub image_mip_tail_stride: crate::vk::DeviceSize, } + impl SparseImageMemoryRequirements { + pub fn format_properties( + mut self, + format_properties: crate::vk::SparseImageFormatProperties, + ) -> Self { + self.format_properties = format_properties; + self + } + pub fn image_mip_tail_first_lod( + mut self, + image_mip_tail_first_lod: u32, + ) -> Self { + self.image_mip_tail_first_lod = image_mip_tail_first_lod; + self + } + pub fn image_mip_tail_size( + mut self, + image_mip_tail_size: crate::vk::DeviceSize, + ) -> Self { + self.image_mip_tail_size = image_mip_tail_size; + self + } + pub fn image_mip_tail_offset( + mut self, + image_mip_tail_offset: crate::vk::DeviceSize, + ) -> Self { + self.image_mip_tail_offset = image_mip_tail_offset; + self + } + pub fn image_mip_tail_stride( + mut self, + image_mip_tail_stride: crate::vk::DeviceSize, + ) -> Self { + self.image_mip_tail_stride = image_mip_tail_stride; + self + } + } #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct MemoryType { pub property_flags: crate::vk::MemoryPropertyFlags, pub heap_index: u32, } + impl MemoryType { + pub fn property_flags( + mut self, + property_flags: crate::vk::MemoryPropertyFlags, + ) -> Self { + self.property_flags = property_flags; + self + } + pub fn heap_index(mut self, heap_index: u32) -> Self { + self.heap_index = heap_index; + self + } + } #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct MemoryHeap { pub size: crate::vk::DeviceSize, pub flags: crate::vk::MemoryHeapFlags, } + impl MemoryHeap { + pub fn size(mut self, size: crate::vk::DeviceSize) -> Self { + self.size = size; + self + } + pub fn flags(mut self, flags: crate::vk::MemoryHeapFlags) -> Self { + self.flags = flags; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct MappedMemoryRange<'a> { @@ -2471,15 +3160,67 @@ pub(crate) mod reexport { pub size: crate::vk::DeviceSize, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for MappedMemoryRange<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::MAPPED_MEMORY_RANGE; + } + impl<'a> Default for MappedMemoryRange<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + memory: Default::default(), + offset: Default::default(), + size: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> MappedMemoryRange<'a> { + pub fn memory(mut self, memory: crate::vk::DeviceMemory) -> Self { + self.memory = memory; + self + } + pub fn offset(mut self, offset: crate::vk::DeviceSize) -> Self { + self.offset = offset; + self + } + pub fn size(mut self, size: crate::vk::DeviceSize) -> Self { + self.size = size; + self + } + } #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct FormatProperties { pub linear_tiling_features: crate::vk::FormatFeatureFlags, pub optimal_tiling_features: crate::vk::FormatFeatureFlags, pub buffer_features: crate::vk::FormatFeatureFlags, } + impl FormatProperties { + pub fn linear_tiling_features( + mut self, + linear_tiling_features: crate::vk::FormatFeatureFlags, + ) -> Self { + self.linear_tiling_features = linear_tiling_features; + self + } + pub fn optimal_tiling_features( + mut self, + optimal_tiling_features: crate::vk::FormatFeatureFlags, + ) -> Self { + self.optimal_tiling_features = optimal_tiling_features; + self + } + pub fn buffer_features( + mut self, + buffer_features: crate::vk::FormatFeatureFlags, + ) -> Self { + self.buffer_features = buffer_features; + self + } + } #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct ImageFormatProperties { pub max_extent: crate::vk::Extent3D, pub max_mip_levels: u32, @@ -2487,20 +3228,76 @@ pub(crate) mod reexport { pub sample_counts: crate::vk::SampleCountFlags, pub max_resource_size: crate::vk::DeviceSize, } + impl ImageFormatProperties { + pub fn max_extent(mut self, max_extent: crate::vk::Extent3D) -> Self { + self.max_extent = max_extent; + self + } + pub fn max_mip_levels(mut self, max_mip_levels: u32) -> Self { + self.max_mip_levels = max_mip_levels; + self + } + pub fn max_array_layers(mut self, max_array_layers: u32) -> Self { + self.max_array_layers = max_array_layers; + self + } + pub fn sample_counts( + mut self, + sample_counts: crate::vk::SampleCountFlags, + ) -> Self { + self.sample_counts = sample_counts; + self + } + pub fn max_resource_size( + mut self, + max_resource_size: crate::vk::DeviceSize, + ) -> Self { + self.max_resource_size = max_resource_size; + self + } + } #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct DescriptorBufferInfo { pub buffer: crate::vk::Buffer, pub offset: crate::vk::DeviceSize, pub range: crate::vk::DeviceSize, } + impl DescriptorBufferInfo { + pub fn buffer(mut self, buffer: crate::vk::Buffer) -> Self { + self.buffer = buffer; + self + } + pub fn offset(mut self, offset: crate::vk::DeviceSize) -> Self { + self.offset = offset; + self + } + pub fn range(mut self, range: crate::vk::DeviceSize) -> Self { + self.range = range; + self + } + } #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct DescriptorImageInfo { pub sampler: crate::vk::Sampler, pub image_view: crate::vk::ImageView, pub image_layout: crate::vk::ImageLayout, } + impl DescriptorImageInfo { + pub fn sampler(mut self, sampler: crate::vk::Sampler) -> Self { + self.sampler = sampler; + self + } + pub fn image_view(mut self, image_view: crate::vk::ImageView) -> Self { + self.image_view = image_view; + self + } + pub fn image_layout(mut self, image_layout: crate::vk::ImageLayout) -> Self { + self.image_layout = image_layout; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct WriteDescriptorSet<'a> { @@ -2516,6 +3313,75 @@ pub(crate) mod reexport { pub p_texel_buffer_view: *const crate::vk::BufferView, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for WriteDescriptorSet<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::WRITE_DESCRIPTOR_SET; + } + impl<'a> Default for WriteDescriptorSet<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + dst_set: Default::default(), + dst_binding: Default::default(), + dst_array_element: Default::default(), + descriptor_count: Default::default(), + descriptor_type: Default::default(), + p_image_info: Default::default(), + p_buffer_info: Default::default(), + p_texel_buffer_view: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> WriteDescriptorSet<'a> { + pub fn dst_set(mut self, dst_set: crate::vk::DescriptorSet) -> Self { + self.dst_set = dst_set; + self + } + pub fn dst_binding(mut self, dst_binding: u32) -> Self { + self.dst_binding = dst_binding; + self + } + pub fn dst_array_element(mut self, dst_array_element: u32) -> Self { + self.dst_array_element = dst_array_element; + self + } + pub fn descriptor_count(mut self, descriptor_count: u32) -> Self { + self.descriptor_count = descriptor_count; + self + } + pub fn descriptor_type( + mut self, + descriptor_type: crate::vk::DescriptorType, + ) -> Self { + self.descriptor_type = descriptor_type; + self + } + pub fn p_image_info( + mut self, + p_image_info: &'a [crate::vk::DescriptorImageInfo], + ) -> Self { + self.descriptor_count = p_image_info.len() as _; + self.p_image_info = p_image_info.as_ptr(); + self + } + pub fn p_buffer_info( + mut self, + p_buffer_info: &'a [crate::vk::DescriptorBufferInfo], + ) -> Self { + self.descriptor_count = p_buffer_info.len() as _; + self.p_buffer_info = p_buffer_info.as_ptr(); + self + } + pub fn p_texel_buffer_view( + mut self, + p_texel_buffer_view: &'a [crate::vk::BufferView], + ) -> Self { + self.descriptor_count = p_texel_buffer_view.len() as _; + self.p_texel_buffer_view = p_texel_buffer_view.as_ptr(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct CopyDescriptorSet<'a> { @@ -2530,6 +3396,55 @@ pub(crate) mod reexport { pub descriptor_count: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for CopyDescriptorSet<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::COPY_DESCRIPTOR_SET; + } + impl<'a> Default for CopyDescriptorSet<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + src_set: Default::default(), + src_binding: Default::default(), + src_array_element: Default::default(), + dst_set: Default::default(), + dst_binding: Default::default(), + dst_array_element: Default::default(), + descriptor_count: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> CopyDescriptorSet<'a> { + pub fn src_set(mut self, src_set: crate::vk::DescriptorSet) -> Self { + self.src_set = src_set; + self + } + pub fn src_binding(mut self, src_binding: u32) -> Self { + self.src_binding = src_binding; + self + } + pub fn src_array_element(mut self, src_array_element: u32) -> Self { + self.src_array_element = src_array_element; + self + } + pub fn dst_set(mut self, dst_set: crate::vk::DescriptorSet) -> Self { + self.dst_set = dst_set; + self + } + pub fn dst_binding(mut self, dst_binding: u32) -> Self { + self.dst_binding = dst_binding; + self + } + pub fn dst_array_element(mut self, dst_array_element: u32) -> Self { + self.dst_array_element = dst_array_element; + self + } + pub fn descriptor_count(mut self, descriptor_count: u32) -> Self { + self.descriptor_count = descriptor_count; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct BufferCreateInfo<'a> { @@ -2543,6 +3458,57 @@ pub(crate) mod reexport { pub p_queue_family_indices: *const u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for BufferCreateInfo<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::BUFFER_CREATE_INFO; + } + impl<'a> Default for BufferCreateInfo<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + flags: Default::default(), + size: Default::default(), + usage: Default::default(), + sharing_mode: Default::default(), + queue_family_index_count: Default::default(), + p_queue_family_indices: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> BufferCreateInfo<'a> { + pub fn flags(mut self, flags: crate::vk::BufferCreateFlags) -> Self { + self.flags = flags; + self + } + pub fn size(mut self, size: crate::vk::DeviceSize) -> Self { + self.size = size; + self + } + pub fn usage(mut self, usage: crate::vk::BufferUsageFlags) -> Self { + self.usage = usage; + self + } + pub fn sharing_mode(mut self, sharing_mode: crate::vk::SharingMode) -> Self { + self.sharing_mode = sharing_mode; + self + } + pub fn queue_family_index_count( + mut self, + queue_family_index_count: u32, + ) -> Self { + self.queue_family_index_count = queue_family_index_count; + self + } + pub fn p_queue_family_indices( + mut self, + p_queue_family_indices: &'a [u32], + ) -> Self { + self.queue_family_index_count = p_queue_family_indices.len() as _; + self.p_queue_family_indices = p_queue_family_indices.as_ptr(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct BufferViewCreateInfo<'a> { @@ -2555,23 +3521,94 @@ pub(crate) mod reexport { pub range: crate::vk::DeviceSize, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for BufferViewCreateInfo<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::BUFFER_VIEW_CREATE_INFO; + } + impl<'a> Default for BufferViewCreateInfo<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + flags: Default::default(), + buffer: Default::default(), + format: Default::default(), + offset: Default::default(), + range: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> BufferViewCreateInfo<'a> { + pub fn flags(mut self, flags: crate::vk::BufferViewCreateFlags) -> Self { + self.flags = flags; + self + } + pub fn buffer(mut self, buffer: crate::vk::Buffer) -> Self { + self.buffer = buffer; + self + } + pub fn format(mut self, format: crate::vk::Format) -> Self { + self.format = format; + self + } + pub fn offset(mut self, offset: crate::vk::DeviceSize) -> Self { + self.offset = offset; + self + } + pub fn range(mut self, range: crate::vk::DeviceSize) -> Self { + self.range = range; + self + } + } #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct ImageSubresource { pub aspect_mask: crate::vk::ImageAspectFlags, pub mip_level: u32, pub array_layer: u32, } + impl ImageSubresource { + pub fn aspect_mask(mut self, aspect_mask: crate::vk::ImageAspectFlags) -> Self { + self.aspect_mask = aspect_mask; + self + } + pub fn mip_level(mut self, mip_level: u32) -> Self { + self.mip_level = mip_level; + self + } + pub fn array_layer(mut self, array_layer: u32) -> Self { + self.array_layer = array_layer; + self + } + } #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct ImageSubresourceLayers { pub aspect_mask: crate::vk::ImageAspectFlags, pub mip_level: u32, pub base_array_layer: u32, pub layer_count: u32, } + impl ImageSubresourceLayers { + pub fn aspect_mask(mut self, aspect_mask: crate::vk::ImageAspectFlags) -> Self { + self.aspect_mask = aspect_mask; + self + } + pub fn mip_level(mut self, mip_level: u32) -> Self { + self.mip_level = mip_level; + self + } + pub fn base_array_layer(mut self, base_array_layer: u32) -> Self { + self.base_array_layer = base_array_layer; + self + } + pub fn layer_count(mut self, layer_count: u32) -> Self { + self.layer_count = layer_count; + self + } + } #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct ImageSubresourceRange { pub aspect_mask: crate::vk::ImageAspectFlags, pub base_mip_level: u32, @@ -2579,6 +3616,28 @@ pub(crate) mod reexport { pub base_array_layer: u32, pub layer_count: u32, } + impl ImageSubresourceRange { + pub fn aspect_mask(mut self, aspect_mask: crate::vk::ImageAspectFlags) -> Self { + self.aspect_mask = aspect_mask; + self + } + pub fn base_mip_level(mut self, base_mip_level: u32) -> Self { + self.base_mip_level = base_mip_level; + self + } + pub fn level_count(mut self, level_count: u32) -> Self { + self.level_count = level_count; + self + } + pub fn base_array_layer(mut self, base_array_layer: u32) -> Self { + self.base_array_layer = base_array_layer; + self + } + pub fn layer_count(mut self, layer_count: u32) -> Self { + self.layer_count = layer_count; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct MemoryBarrier<'a> { @@ -2588,6 +3647,36 @@ pub(crate) mod reexport { pub dst_access_mask: crate::vk::AccessFlags, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for MemoryBarrier<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::MEMORY_BARRIER; + } + impl<'a> Default for MemoryBarrier<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + src_access_mask: Default::default(), + dst_access_mask: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> MemoryBarrier<'a> { + pub fn src_access_mask( + mut self, + src_access_mask: crate::vk::AccessFlags, + ) -> Self { + self.src_access_mask = src_access_mask; + self + } + pub fn dst_access_mask( + mut self, + dst_access_mask: crate::vk::AccessFlags, + ) -> Self { + self.dst_access_mask = dst_access_mask; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct BufferMemoryBarrier<'a> { @@ -2602,6 +3691,61 @@ pub(crate) mod reexport { pub size: crate::vk::DeviceSize, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for BufferMemoryBarrier<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::BUFFER_MEMORY_BARRIER; + } + impl<'a> Default for BufferMemoryBarrier<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + src_access_mask: Default::default(), + dst_access_mask: Default::default(), + src_queue_family_index: Default::default(), + dst_queue_family_index: Default::default(), + buffer: Default::default(), + offset: Default::default(), + size: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> BufferMemoryBarrier<'a> { + pub fn src_access_mask( + mut self, + src_access_mask: crate::vk::AccessFlags, + ) -> Self { + self.src_access_mask = src_access_mask; + self + } + pub fn dst_access_mask( + mut self, + dst_access_mask: crate::vk::AccessFlags, + ) -> Self { + self.dst_access_mask = dst_access_mask; + self + } + pub fn src_queue_family_index(mut self, src_queue_family_index: u32) -> Self { + self.src_queue_family_index = src_queue_family_index; + self + } + pub fn dst_queue_family_index(mut self, dst_queue_family_index: u32) -> Self { + self.dst_queue_family_index = dst_queue_family_index; + self + } + pub fn buffer(mut self, buffer: crate::vk::Buffer) -> Self { + self.buffer = buffer; + self + } + pub fn offset(mut self, offset: crate::vk::DeviceSize) -> Self { + self.offset = offset; + self + } + pub fn size(mut self, size: crate::vk::DeviceSize) -> Self { + self.size = size; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct ImageMemoryBarrier<'a> { @@ -2617,6 +3761,69 @@ pub(crate) mod reexport { pub subresource_range: crate::vk::ImageSubresourceRange, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for ImageMemoryBarrier<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::IMAGE_MEMORY_BARRIER; + } + impl<'a> Default for ImageMemoryBarrier<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + src_access_mask: Default::default(), + dst_access_mask: Default::default(), + old_layout: Default::default(), + new_layout: Default::default(), + src_queue_family_index: Default::default(), + dst_queue_family_index: Default::default(), + image: Default::default(), + subresource_range: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> ImageMemoryBarrier<'a> { + pub fn src_access_mask( + mut self, + src_access_mask: crate::vk::AccessFlags, + ) -> Self { + self.src_access_mask = src_access_mask; + self + } + pub fn dst_access_mask( + mut self, + dst_access_mask: crate::vk::AccessFlags, + ) -> Self { + self.dst_access_mask = dst_access_mask; + self + } + pub fn old_layout(mut self, old_layout: crate::vk::ImageLayout) -> Self { + self.old_layout = old_layout; + self + } + pub fn new_layout(mut self, new_layout: crate::vk::ImageLayout) -> Self { + self.new_layout = new_layout; + self + } + pub fn src_queue_family_index(mut self, src_queue_family_index: u32) -> Self { + self.src_queue_family_index = src_queue_family_index; + self + } + pub fn dst_queue_family_index(mut self, dst_queue_family_index: u32) -> Self { + self.dst_queue_family_index = dst_queue_family_index; + self + } + pub fn image(mut self, image: crate::vk::Image) -> Self { + self.image = image; + self + } + pub fn subresource_range( + mut self, + subresource_range: crate::vk::ImageSubresourceRange, + ) -> Self { + self.subresource_range = subresource_range; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct ImageCreateInfo<'a> { @@ -2637,8 +3844,94 @@ pub(crate) mod reexport { pub initial_layout: crate::vk::ImageLayout, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for ImageCreateInfo<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::IMAGE_CREATE_INFO; + } + impl<'a> Default for ImageCreateInfo<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + flags: Default::default(), + image_type: Default::default(), + format: Default::default(), + extent: Default::default(), + mip_levels: Default::default(), + array_layers: Default::default(), + samples: Default::default(), + tiling: Default::default(), + usage: Default::default(), + sharing_mode: Default::default(), + queue_family_index_count: Default::default(), + p_queue_family_indices: Default::default(), + initial_layout: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> ImageCreateInfo<'a> { + pub fn flags(mut self, flags: crate::vk::ImageCreateFlags) -> Self { + self.flags = flags; + self + } + pub fn image_type(mut self, image_type: crate::vk::ImageType) -> Self { + self.image_type = image_type; + self + } + pub fn format(mut self, format: crate::vk::Format) -> Self { + self.format = format; + self + } + pub fn extent(mut self, extent: crate::vk::Extent3D) -> Self { + self.extent = extent; + self + } + pub fn mip_levels(mut self, mip_levels: u32) -> Self { + self.mip_levels = mip_levels; + self + } + pub fn array_layers(mut self, array_layers: u32) -> Self { + self.array_layers = array_layers; + self + } + pub fn samples(mut self, samples: crate::vk::SampleCountFlagBits) -> Self { + self.samples = samples; + self + } + pub fn tiling(mut self, tiling: crate::vk::ImageTiling) -> Self { + self.tiling = tiling; + self + } + pub fn usage(mut self, usage: crate::vk::ImageUsageFlags) -> Self { + self.usage = usage; + self + } + pub fn sharing_mode(mut self, sharing_mode: crate::vk::SharingMode) -> Self { + self.sharing_mode = sharing_mode; + self + } + pub fn queue_family_index_count( + mut self, + queue_family_index_count: u32, + ) -> Self { + self.queue_family_index_count = queue_family_index_count; + self + } + pub fn p_queue_family_indices( + mut self, + p_queue_family_indices: &'a [u32], + ) -> Self { + self.queue_family_index_count = p_queue_family_indices.len() as _; + self.p_queue_family_indices = p_queue_family_indices.as_ptr(); + self + } + pub fn initial_layout(mut self, initial_layout: crate::vk::ImageLayout) -> Self { + self.initial_layout = initial_layout; + self + } + } #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct SubresourceLayout { pub offset: crate::vk::DeviceSize, pub size: crate::vk::DeviceSize, @@ -2646,6 +3939,28 @@ pub(crate) mod reexport { pub array_pitch: crate::vk::DeviceSize, pub depth_pitch: crate::vk::DeviceSize, } + impl SubresourceLayout { + pub fn offset(mut self, offset: crate::vk::DeviceSize) -> Self { + self.offset = offset; + self + } + pub fn size(mut self, size: crate::vk::DeviceSize) -> Self { + self.size = size; + self + } + pub fn row_pitch(mut self, row_pitch: crate::vk::DeviceSize) -> Self { + self.row_pitch = row_pitch; + self + } + pub fn array_pitch(mut self, array_pitch: crate::vk::DeviceSize) -> Self { + self.array_pitch = array_pitch; + self + } + pub fn depth_pitch(mut self, depth_pitch: crate::vk::DeviceSize) -> Self { + self.depth_pitch = depth_pitch; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct ImageViewCreateInfo<'a> { @@ -2659,15 +3974,76 @@ pub(crate) mod reexport { pub subresource_range: crate::vk::ImageSubresourceRange, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for ImageViewCreateInfo<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::IMAGE_VIEW_CREATE_INFO; + } + impl<'a> Default for ImageViewCreateInfo<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + flags: Default::default(), + image: Default::default(), + view_type: Default::default(), + format: Default::default(), + components: Default::default(), + subresource_range: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> ImageViewCreateInfo<'a> { + pub fn flags(mut self, flags: crate::vk::ImageViewCreateFlags) -> Self { + self.flags = flags; + self + } + pub fn image(mut self, image: crate::vk::Image) -> Self { + self.image = image; + self + } + pub fn view_type(mut self, view_type: crate::vk::ImageViewType) -> Self { + self.view_type = view_type; + self + } + pub fn format(mut self, format: crate::vk::Format) -> Self { + self.format = format; + self + } + pub fn components(mut self, components: crate::vk::ComponentMapping) -> Self { + self.components = components; + self + } + pub fn subresource_range( + mut self, + subresource_range: crate::vk::ImageSubresourceRange, + ) -> Self { + self.subresource_range = subresource_range; + self + } + } #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct BufferCopy { pub src_offset: crate::vk::DeviceSize, pub dst_offset: crate::vk::DeviceSize, pub size: crate::vk::DeviceSize, } + impl BufferCopy { + pub fn src_offset(mut self, src_offset: crate::vk::DeviceSize) -> Self { + self.src_offset = src_offset; + self + } + pub fn dst_offset(mut self, dst_offset: crate::vk::DeviceSize) -> Self { + self.dst_offset = dst_offset; + self + } + pub fn size(mut self, size: crate::vk::DeviceSize) -> Self { + self.size = size; + self + } + } #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct SparseMemoryBind { pub resource_offset: crate::vk::DeviceSize, pub size: crate::vk::DeviceSize, @@ -2675,8 +4051,33 @@ pub(crate) mod reexport { pub memory_offset: crate::vk::DeviceSize, pub flags: crate::vk::SparseMemoryBindFlags, } + impl SparseMemoryBind { + pub fn resource_offset( + mut self, + resource_offset: crate::vk::DeviceSize, + ) -> Self { + self.resource_offset = resource_offset; + self + } + pub fn size(mut self, size: crate::vk::DeviceSize) -> Self { + self.size = size; + self + } + pub fn memory(mut self, memory: crate::vk::DeviceMemory) -> Self { + self.memory = memory; + self + } + pub fn memory_offset(mut self, memory_offset: crate::vk::DeviceSize) -> Self { + self.memory_offset = memory_offset; + self + } + pub fn flags(mut self, flags: crate::vk::SparseMemoryBindFlags) -> Self { + self.flags = flags; + self + } + } #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct SparseImageMemoryBind { pub subresource: crate::vk::ImageSubresource, pub offset: crate::vk::Offset3D, @@ -2685,30 +4086,104 @@ pub(crate) mod reexport { pub memory_offset: crate::vk::DeviceSize, pub flags: crate::vk::SparseMemoryBindFlags, } + impl SparseImageMemoryBind { + pub fn subresource(mut self, subresource: crate::vk::ImageSubresource) -> Self { + self.subresource = subresource; + self + } + pub fn offset(mut self, offset: crate::vk::Offset3D) -> Self { + self.offset = offset; + self + } + pub fn extent(mut self, extent: crate::vk::Extent3D) -> Self { + self.extent = extent; + self + } + pub fn memory(mut self, memory: crate::vk::DeviceMemory) -> Self { + self.memory = memory; + self + } + pub fn memory_offset(mut self, memory_offset: crate::vk::DeviceSize) -> Self { + self.memory_offset = memory_offset; + self + } + pub fn flags(mut self, flags: crate::vk::SparseMemoryBindFlags) -> Self { + self.flags = flags; + self + } + } #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct SparseBufferMemoryBindInfo<'a> { pub buffer: crate::vk::Buffer, pub bind_count: u32, pub p_binds: *const crate::vk::SparseMemoryBind, pub _marker: ::core::marker::PhantomData<&'a ()>, } + impl<'a> SparseBufferMemoryBindInfo<'a> { + pub fn buffer(mut self, buffer: crate::vk::Buffer) -> Self { + self.buffer = buffer; + self + } + pub fn bind_count(mut self, bind_count: u32) -> Self { + self.bind_count = bind_count; + self + } + pub fn p_binds(mut self, p_binds: &'a [crate::vk::SparseMemoryBind]) -> Self { + self.bind_count = p_binds.len() as _; + self.p_binds = p_binds.as_ptr(); + self + } + } #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct SparseImageOpaqueMemoryBindInfo<'a> { pub image: crate::vk::Image, pub bind_count: u32, pub p_binds: *const crate::vk::SparseMemoryBind, pub _marker: ::core::marker::PhantomData<&'a ()>, } + impl<'a> SparseImageOpaqueMemoryBindInfo<'a> { + pub fn image(mut self, image: crate::vk::Image) -> Self { + self.image = image; + self + } + pub fn bind_count(mut self, bind_count: u32) -> Self { + self.bind_count = bind_count; + self + } + pub fn p_binds(mut self, p_binds: &'a [crate::vk::SparseMemoryBind]) -> Self { + self.bind_count = p_binds.len() as _; + self.p_binds = p_binds.as_ptr(); + self + } + } #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct SparseImageMemoryBindInfo<'a> { pub image: crate::vk::Image, pub bind_count: u32, pub p_binds: *const crate::vk::SparseImageMemoryBind, pub _marker: ::core::marker::PhantomData<&'a ()>, } + impl<'a> SparseImageMemoryBindInfo<'a> { + pub fn image(mut self, image: crate::vk::Image) -> Self { + self.image = image; + self + } + pub fn bind_count(mut self, bind_count: u32) -> Self { + self.bind_count = bind_count; + self + } + pub fn p_binds( + mut self, + p_binds: &'a [crate::vk::SparseImageMemoryBind], + ) -> Self { + self.bind_count = p_binds.len() as _; + self.p_binds = p_binds.as_ptr(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct BindSparseInfo<'a> { @@ -2726,8 +4201,92 @@ pub(crate) mod reexport { pub p_signal_semaphores: *const crate::vk::Semaphore, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for BindSparseInfo<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::BIND_SPARSE_INFO; + } + impl<'a> Default for BindSparseInfo<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + wait_semaphore_count: Default::default(), + p_wait_semaphores: Default::default(), + buffer_bind_count: Default::default(), + p_buffer_binds: Default::default(), + image_opaque_bind_count: Default::default(), + p_image_opaque_binds: Default::default(), + image_bind_count: Default::default(), + p_image_binds: Default::default(), + signal_semaphore_count: Default::default(), + p_signal_semaphores: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> BindSparseInfo<'a> { + pub fn wait_semaphore_count(mut self, wait_semaphore_count: u32) -> Self { + self.wait_semaphore_count = wait_semaphore_count; + self + } + pub fn p_wait_semaphores( + mut self, + p_wait_semaphores: &'a [crate::vk::Semaphore], + ) -> Self { + self.wait_semaphore_count = p_wait_semaphores.len() as _; + self.p_wait_semaphores = p_wait_semaphores.as_ptr(); + self + } + pub fn buffer_bind_count(mut self, buffer_bind_count: u32) -> Self { + self.buffer_bind_count = buffer_bind_count; + self + } + pub fn p_buffer_binds( + mut self, + p_buffer_binds: &'a [crate::vk::SparseBufferMemoryBindInfo<'a>], + ) -> Self { + self.buffer_bind_count = p_buffer_binds.len() as _; + self.p_buffer_binds = p_buffer_binds.as_ptr(); + self + } + pub fn image_opaque_bind_count(mut self, image_opaque_bind_count: u32) -> Self { + self.image_opaque_bind_count = image_opaque_bind_count; + self + } + pub fn p_image_opaque_binds( + mut self, + p_image_opaque_binds: &'a [crate::vk::SparseImageOpaqueMemoryBindInfo<'a>], + ) -> Self { + self.image_opaque_bind_count = p_image_opaque_binds.len() as _; + self.p_image_opaque_binds = p_image_opaque_binds.as_ptr(); + self + } + pub fn image_bind_count(mut self, image_bind_count: u32) -> Self { + self.image_bind_count = image_bind_count; + self + } + pub fn p_image_binds( + mut self, + p_image_binds: &'a [crate::vk::SparseImageMemoryBindInfo<'a>], + ) -> Self { + self.image_bind_count = p_image_binds.len() as _; + self.p_image_binds = p_image_binds.as_ptr(); + self + } + pub fn signal_semaphore_count(mut self, signal_semaphore_count: u32) -> Self { + self.signal_semaphore_count = signal_semaphore_count; + self + } + pub fn p_signal_semaphores( + mut self, + p_signal_semaphores: &'a [crate::vk::Semaphore], + ) -> Self { + self.signal_semaphore_count = p_signal_semaphores.len() as _; + self.p_signal_semaphores = p_signal_semaphores.as_ptr(); + self + } + } #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct ImageCopy { pub src_subresource: crate::vk::ImageSubresourceLayers, pub src_offset: crate::vk::Offset3D, @@ -2735,6 +4294,34 @@ pub(crate) mod reexport { pub dst_offset: crate::vk::Offset3D, pub extent: crate::vk::Extent3D, } + impl ImageCopy { + pub fn src_subresource( + mut self, + src_subresource: crate::vk::ImageSubresourceLayers, + ) -> Self { + self.src_subresource = src_subresource; + self + } + pub fn src_offset(mut self, src_offset: crate::vk::Offset3D) -> Self { + self.src_offset = src_offset; + self + } + pub fn dst_subresource( + mut self, + dst_subresource: crate::vk::ImageSubresourceLayers, + ) -> Self { + self.dst_subresource = dst_subresource; + self + } + pub fn dst_offset(mut self, dst_offset: crate::vk::Offset3D) -> Self { + self.dst_offset = dst_offset; + self + } + pub fn extent(mut self, extent: crate::vk::Extent3D) -> Self { + self.extent = extent; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct ImageBlit { @@ -2743,8 +4330,48 @@ pub(crate) mod reexport { pub dst_subresource: crate::vk::ImageSubresourceLayers, pub dst_offsets: [crate::vk::Offset3D; 2 as _], } + impl Default for ImageBlit { + fn default() -> Self { + Self { + src_subresource: Default::default(), + src_offsets: unsafe { core::mem::zeroed() }, + dst_subresource: Default::default(), + dst_offsets: unsafe { core::mem::zeroed() }, + } + } + } + impl ImageBlit { + pub fn src_subresource( + mut self, + src_subresource: crate::vk::ImageSubresourceLayers, + ) -> Self { + self.src_subresource = src_subresource; + self + } + pub fn src_offsets( + mut self, + src_offsets: [crate::vk::Offset3D; 2 as _], + ) -> Self { + self.src_offsets = src_offsets; + self + } + pub fn dst_subresource( + mut self, + dst_subresource: crate::vk::ImageSubresourceLayers, + ) -> Self { + self.dst_subresource = dst_subresource; + self + } + pub fn dst_offsets( + mut self, + dst_offsets: [crate::vk::Offset3D; 2 as _], + ) -> Self { + self.dst_offsets = dst_offsets; + self + } + } #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct BufferImageCopy { pub buffer_offset: crate::vk::DeviceSize, pub buffer_row_length: u32, @@ -2753,8 +4380,37 @@ pub(crate) mod reexport { pub image_offset: crate::vk::Offset3D, pub image_extent: crate::vk::Extent3D, } + impl BufferImageCopy { + pub fn buffer_offset(mut self, buffer_offset: crate::vk::DeviceSize) -> Self { + self.buffer_offset = buffer_offset; + self + } + pub fn buffer_row_length(mut self, buffer_row_length: u32) -> Self { + self.buffer_row_length = buffer_row_length; + self + } + pub fn buffer_image_height(mut self, buffer_image_height: u32) -> Self { + self.buffer_image_height = buffer_image_height; + self + } + pub fn image_subresource( + mut self, + image_subresource: crate::vk::ImageSubresourceLayers, + ) -> Self { + self.image_subresource = image_subresource; + self + } + pub fn image_offset(mut self, image_offset: crate::vk::Offset3D) -> Self { + self.image_offset = image_offset; + self + } + pub fn image_extent(mut self, image_extent: crate::vk::Extent3D) -> Self { + self.image_extent = image_extent; + self + } + } #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct ImageResolve { pub src_subresource: crate::vk::ImageSubresourceLayers, pub src_offset: crate::vk::Offset3D, @@ -2762,6 +4418,34 @@ pub(crate) mod reexport { pub dst_offset: crate::vk::Offset3D, pub extent: crate::vk::Extent3D, } + impl ImageResolve { + pub fn src_subresource( + mut self, + src_subresource: crate::vk::ImageSubresourceLayers, + ) -> Self { + self.src_subresource = src_subresource; + self + } + pub fn src_offset(mut self, src_offset: crate::vk::Offset3D) -> Self { + self.src_offset = src_offset; + self + } + pub fn dst_subresource( + mut self, + dst_subresource: crate::vk::ImageSubresourceLayers, + ) -> Self { + self.dst_subresource = dst_subresource; + self + } + pub fn dst_offset(mut self, dst_offset: crate::vk::Offset3D) -> Self { + self.dst_offset = dst_offset; + self + } + pub fn extent(mut self, extent: crate::vk::Extent3D) -> Self { + self.extent = extent; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct ShaderModuleCreateInfo<'a> { @@ -2772,8 +4456,41 @@ pub(crate) mod reexport { pub p_code: *const u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for ShaderModuleCreateInfo<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::SHADER_MODULE_CREATE_INFO; + } + unsafe impl<'a> crate::Extends> + for ShaderModuleCreateInfo<'a> {} + unsafe impl<'a> crate::Extends> + for ShaderModuleCreateInfo<'a> {} + impl<'a> Default for ShaderModuleCreateInfo<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + flags: Default::default(), + code_size: Default::default(), + p_code: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> ShaderModuleCreateInfo<'a> { + pub fn flags(mut self, flags: crate::vk::ShaderModuleCreateFlags) -> Self { + self.flags = flags; + self + } + pub fn code_size(mut self, code_size: usize) -> Self { + self.code_size = code_size; + self + } + pub fn p_code(mut self, p_code: *const u32) -> Self { + self.p_code = p_code; + self + } + } #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct DescriptorSetLayoutBinding<'a> { pub binding: u32, pub descriptor_type: crate::vk::DescriptorType, @@ -2782,6 +4499,35 @@ pub(crate) mod reexport { pub p_immutable_samplers: *const crate::vk::Sampler, pub _marker: ::core::marker::PhantomData<&'a ()>, } + impl<'a> DescriptorSetLayoutBinding<'a> { + pub fn binding(mut self, binding: u32) -> Self { + self.binding = binding; + self + } + pub fn descriptor_type( + mut self, + descriptor_type: crate::vk::DescriptorType, + ) -> Self { + self.descriptor_type = descriptor_type; + self + } + pub fn descriptor_count(mut self, descriptor_count: u32) -> Self { + self.descriptor_count = descriptor_count; + self + } + pub fn stage_flags(mut self, stage_flags: crate::vk::ShaderStageFlags) -> Self { + self.stage_flags = stage_flags; + self + } + pub fn p_immutable_samplers( + mut self, + p_immutable_samplers: &'a [crate::vk::Sampler], + ) -> Self { + self.descriptor_count = p_immutable_samplers.len() as _; + self.p_immutable_samplers = p_immutable_samplers.as_ptr(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct DescriptorSetLayoutCreateInfo<'a> { @@ -2792,12 +4538,58 @@ pub(crate) mod reexport { pub p_bindings: *const crate::vk::DescriptorSetLayoutBinding<'a>, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for DescriptorSetLayoutCreateInfo<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::DESCRIPTOR_SET_LAYOUT_CREATE_INFO; + } + impl<'a> Default for DescriptorSetLayoutCreateInfo<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + flags: Default::default(), + binding_count: Default::default(), + p_bindings: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> DescriptorSetLayoutCreateInfo<'a> { + pub fn flags( + mut self, + flags: crate::vk::DescriptorSetLayoutCreateFlags, + ) -> Self { + self.flags = flags; + self + } + pub fn binding_count(mut self, binding_count: u32) -> Self { + self.binding_count = binding_count; + self + } + pub fn p_bindings( + mut self, + p_bindings: &'a [crate::vk::DescriptorSetLayoutBinding<'a>], + ) -> Self { + self.binding_count = p_bindings.len() as _; + self.p_bindings = p_bindings.as_ptr(); + self + } + } #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct DescriptorPoolSize { pub _type: crate::vk::DescriptorType, pub descriptor_count: u32, } + impl DescriptorPoolSize { + pub fn _type(mut self, _type: crate::vk::DescriptorType) -> Self { + self._type = _type; + self + } + pub fn descriptor_count(mut self, descriptor_count: u32) -> Self { + self.descriptor_count = descriptor_count; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct DescriptorPoolCreateInfo<'a> { @@ -2809,6 +4601,44 @@ pub(crate) mod reexport { pub p_pool_sizes: *const crate::vk::DescriptorPoolSize, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for DescriptorPoolCreateInfo<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::DESCRIPTOR_POOL_CREATE_INFO; + } + impl<'a> Default for DescriptorPoolCreateInfo<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + flags: Default::default(), + max_sets: Default::default(), + pool_size_count: Default::default(), + p_pool_sizes: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> DescriptorPoolCreateInfo<'a> { + pub fn flags(mut self, flags: crate::vk::DescriptorPoolCreateFlags) -> Self { + self.flags = flags; + self + } + pub fn max_sets(mut self, max_sets: u32) -> Self { + self.max_sets = max_sets; + self + } + pub fn pool_size_count(mut self, pool_size_count: u32) -> Self { + self.pool_size_count = pool_size_count; + self + } + pub fn p_pool_sizes( + mut self, + p_pool_sizes: &'a [crate::vk::DescriptorPoolSize], + ) -> Self { + self.pool_size_count = p_pool_sizes.len() as _; + self.p_pool_sizes = p_pool_sizes.as_ptr(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct DescriptorSetAllocateInfo<'a> { @@ -2819,15 +4649,65 @@ pub(crate) mod reexport { pub p_set_layouts: *const crate::vk::DescriptorSetLayout, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for DescriptorSetAllocateInfo<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::DESCRIPTOR_SET_ALLOCATE_INFO; + } + impl<'a> Default for DescriptorSetAllocateInfo<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + descriptor_pool: Default::default(), + descriptor_set_count: Default::default(), + p_set_layouts: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> DescriptorSetAllocateInfo<'a> { + pub fn descriptor_pool( + mut self, + descriptor_pool: crate::vk::DescriptorPool, + ) -> Self { + self.descriptor_pool = descriptor_pool; + self + } + pub fn descriptor_set_count(mut self, descriptor_set_count: u32) -> Self { + self.descriptor_set_count = descriptor_set_count; + self + } + pub fn p_set_layouts( + mut self, + p_set_layouts: &'a [crate::vk::DescriptorSetLayout], + ) -> Self { + self.descriptor_set_count = p_set_layouts.len() as _; + self.p_set_layouts = p_set_layouts.as_ptr(); + self + } + } #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct SpecializationMapEntry { pub constant_id: u32, pub offset: u32, pub size: usize, } + impl SpecializationMapEntry { + pub fn constant_id(mut self, constant_id: u32) -> Self { + self.constant_id = constant_id; + self + } + pub fn offset(mut self, offset: u32) -> Self { + self.offset = offset; + self + } + pub fn size(mut self, size: usize) -> Self { + self.size = size; + self + } + } #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct SpecializationInfo<'a> { pub map_entry_count: u32, pub p_map_entries: *const crate::vk::SpecializationMapEntry, @@ -2835,6 +4715,29 @@ pub(crate) mod reexport { pub p_data: *const core::ffi::c_void, pub _marker: ::core::marker::PhantomData<&'a ()>, } + impl<'a> SpecializationInfo<'a> { + pub fn map_entry_count(mut self, map_entry_count: u32) -> Self { + self.map_entry_count = map_entry_count; + self + } + pub fn p_map_entries( + mut self, + p_map_entries: &'a [crate::vk::SpecializationMapEntry], + ) -> Self { + self.map_entry_count = p_map_entries.len() as _; + self.p_map_entries = p_map_entries.as_ptr(); + self + } + pub fn data_size(mut self, data_size: usize) -> Self { + self.data_size = data_size; + self + } + pub fn p_data(mut self, p_data: &'a [u8]) -> Self { + self.data_size = p_data.len() as _; + self.p_data = p_data.as_ptr().cast(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PipelineShaderStageCreateInfo<'a> { @@ -2847,6 +4750,58 @@ pub(crate) mod reexport { pub p_specialization_info: *const crate::vk::SpecializationInfo<'a>, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for PipelineShaderStageCreateInfo<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PIPELINE_SHADER_STAGE_CREATE_INFO; + } + impl<'a> Default for PipelineShaderStageCreateInfo<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + flags: Default::default(), + stage: Default::default(), + module: Default::default(), + p_name: Default::default(), + p_specialization_info: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PipelineShaderStageCreateInfo<'a> { + pub fn flags( + mut self, + flags: crate::vk::PipelineShaderStageCreateFlags, + ) -> Self { + self.flags = flags; + self + } + pub fn stage(mut self, stage: crate::vk::ShaderStageFlagBits) -> Self { + self.stage = stage; + self + } + pub fn module(mut self, module: crate::vk::ShaderModule) -> Self { + self.module = module; + self + } + pub fn p_name(mut self, p_name: &'a core::ffi::CStr) -> Self { + self.p_name = p_name.as_ptr(); + self + } + pub unsafe fn p_name_as_c_str(&self) -> Option<&core::ffi::CStr> { + if self.p_name.is_null() { + None + } else { + Some(unsafe { core::ffi::CStr::from_ptr(self.p_name) }) + } + } + pub fn p_specialization_info( + mut self, + p_specialization_info: &'a crate::vk::SpecializationInfo<'a>, + ) -> Self { + self.p_specialization_info = p_specialization_info; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct ComputePipelineCreateInfo<'a> { @@ -2859,21 +4814,98 @@ pub(crate) mod reexport { pub base_pipeline_index: i32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for ComputePipelineCreateInfo<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::COMPUTE_PIPELINE_CREATE_INFO; + } + impl<'a> Default for ComputePipelineCreateInfo<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + flags: Default::default(), + stage: Default::default(), + layout: Default::default(), + base_pipeline_handle: Default::default(), + base_pipeline_index: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> ComputePipelineCreateInfo<'a> { + pub fn flags(mut self, flags: crate::vk::PipelineCreateFlags) -> Self { + self.flags = flags; + self + } + pub fn stage( + mut self, + stage: crate::vk::PipelineShaderStageCreateInfo<'a>, + ) -> Self { + self.stage = stage; + self + } + pub fn layout(mut self, layout: crate::vk::PipelineLayout) -> Self { + self.layout = layout; + self + } + pub fn base_pipeline_handle( + mut self, + base_pipeline_handle: crate::vk::Pipeline, + ) -> Self { + self.base_pipeline_handle = base_pipeline_handle; + self + } + pub fn base_pipeline_index(mut self, base_pipeline_index: i32) -> Self { + self.base_pipeline_index = base_pipeline_index; + self + } + } #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct VertexInputBindingDescription { pub binding: u32, pub stride: u32, pub input_rate: crate::vk::VertexInputRate, } + impl VertexInputBindingDescription { + pub fn binding(mut self, binding: u32) -> Self { + self.binding = binding; + self + } + pub fn stride(mut self, stride: u32) -> Self { + self.stride = stride; + self + } + pub fn input_rate(mut self, input_rate: crate::vk::VertexInputRate) -> Self { + self.input_rate = input_rate; + self + } + } #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct VertexInputAttributeDescription { pub location: u32, pub binding: u32, pub format: crate::vk::Format, pub offset: u32, } + impl VertexInputAttributeDescription { + pub fn location(mut self, location: u32) -> Self { + self.location = location; + self + } + pub fn binding(mut self, binding: u32) -> Self { + self.binding = binding; + self + } + pub fn format(mut self, format: crate::vk::Format) -> Self { + self.format = format; + self + } + pub fn offset(mut self, offset: u32) -> Self { + self.offset = offset; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PipelineVertexInputStateCreateInfo<'a> { @@ -2886,6 +4918,66 @@ pub(crate) mod reexport { pub p_vertex_attribute_descriptions: *const crate::vk::VertexInputAttributeDescription, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PipelineVertexInputStateCreateInfo<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO; + } + impl<'a> Default for PipelineVertexInputStateCreateInfo<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + flags: Default::default(), + vertex_binding_description_count: Default::default(), + p_vertex_binding_descriptions: Default::default(), + vertex_attribute_description_count: Default::default(), + p_vertex_attribute_descriptions: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PipelineVertexInputStateCreateInfo<'a> { + pub fn flags( + mut self, + flags: crate::vk::PipelineVertexInputStateCreateFlags, + ) -> Self { + self.flags = flags; + self + } + pub fn vertex_binding_description_count( + mut self, + vertex_binding_description_count: u32, + ) -> Self { + self.vertex_binding_description_count = vertex_binding_description_count; + self + } + pub fn p_vertex_binding_descriptions( + mut self, + p_vertex_binding_descriptions: &'a [crate::vk::VertexInputBindingDescription], + ) -> Self { + self.vertex_binding_description_count = p_vertex_binding_descriptions.len() + as _; + self.p_vertex_binding_descriptions = p_vertex_binding_descriptions.as_ptr(); + self + } + pub fn vertex_attribute_description_count( + mut self, + vertex_attribute_description_count: u32, + ) -> Self { + self.vertex_attribute_description_count = vertex_attribute_description_count; + self + } + pub fn p_vertex_attribute_descriptions( + mut self, + p_vertex_attribute_descriptions: &'a [crate::vk::VertexInputAttributeDescription], + ) -> Self { + self.vertex_attribute_description_count = p_vertex_attribute_descriptions + .len() as _; + self.p_vertex_attribute_descriptions = p_vertex_attribute_descriptions + .as_ptr(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PipelineInputAssemblyStateCreateInfo<'a> { @@ -2896,6 +4988,42 @@ pub(crate) mod reexport { pub primitive_restart_enable: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PipelineInputAssemblyStateCreateInfo<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO; + } + impl<'a> Default for PipelineInputAssemblyStateCreateInfo<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + flags: Default::default(), + topology: Default::default(), + primitive_restart_enable: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PipelineInputAssemblyStateCreateInfo<'a> { + pub fn flags( + mut self, + flags: crate::vk::PipelineInputAssemblyStateCreateFlags, + ) -> Self { + self.flags = flags; + self + } + pub fn topology(mut self, topology: crate::vk::PrimitiveTopology) -> Self { + self.topology = topology; + self + } + pub fn primitive_restart_enable( + mut self, + primitive_restart_enable: bool, + ) -> Self { + self.primitive_restart_enable = primitive_restart_enable.into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PipelineTessellationStateCreateInfo<'a> { @@ -2905,6 +5033,34 @@ pub(crate) mod reexport { pub patch_control_points: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PipelineTessellationStateCreateInfo<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PIPELINE_TESSELLATION_STATE_CREATE_INFO; + } + impl<'a> Default for PipelineTessellationStateCreateInfo<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + flags: Default::default(), + patch_control_points: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PipelineTessellationStateCreateInfo<'a> { + pub fn flags( + mut self, + flags: crate::vk::PipelineTessellationStateCreateFlags, + ) -> Self { + self.flags = flags; + self + } + pub fn patch_control_points(mut self, patch_control_points: u32) -> Self { + self.patch_control_points = patch_control_points; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PipelineViewportStateCreateInfo<'a> { @@ -2917,6 +5073,50 @@ pub(crate) mod reexport { pub p_scissors: *const crate::vk::Rect2D, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for PipelineViewportStateCreateInfo<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PIPELINE_VIEWPORT_STATE_CREATE_INFO; + } + impl<'a> Default for PipelineViewportStateCreateInfo<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + flags: Default::default(), + viewport_count: Default::default(), + p_viewports: Default::default(), + scissor_count: Default::default(), + p_scissors: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PipelineViewportStateCreateInfo<'a> { + pub fn flags( + mut self, + flags: crate::vk::PipelineViewportStateCreateFlags, + ) -> Self { + self.flags = flags; + self + } + pub fn viewport_count(mut self, viewport_count: u32) -> Self { + self.viewport_count = viewport_count; + self + } + pub fn p_viewports(mut self, p_viewports: &'a [crate::vk::Viewport]) -> Self { + self.viewport_count = p_viewports.len() as _; + self.p_viewports = p_viewports.as_ptr(); + self + } + pub fn scissor_count(mut self, scissor_count: u32) -> Self { + self.scissor_count = scissor_count; + self + } + pub fn p_scissors(mut self, p_scissors: &'a [crate::vk::Rect2D]) -> Self { + self.scissor_count = p_scissors.len() as _; + self.p_scissors = p_scissors.as_ptr(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PipelineRasterizationStateCreateInfo<'a> { @@ -2935,6 +5135,88 @@ pub(crate) mod reexport { pub line_width: core::ffi::c_float, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PipelineRasterizationStateCreateInfo<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PIPELINE_RASTERIZATION_STATE_CREATE_INFO; + } + impl<'a> Default for PipelineRasterizationStateCreateInfo<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + flags: Default::default(), + depth_clamp_enable: Default::default(), + rasterizer_discard_enable: Default::default(), + polygon_mode: Default::default(), + cull_mode: Default::default(), + front_face: Default::default(), + depth_bias_enable: Default::default(), + depth_bias_constant_factor: Default::default(), + depth_bias_clamp: Default::default(), + depth_bias_slope_factor: Default::default(), + line_width: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PipelineRasterizationStateCreateInfo<'a> { + pub fn flags( + mut self, + flags: crate::vk::PipelineRasterizationStateCreateFlags, + ) -> Self { + self.flags = flags; + self + } + pub fn depth_clamp_enable(mut self, depth_clamp_enable: bool) -> Self { + self.depth_clamp_enable = depth_clamp_enable.into(); + self + } + pub fn rasterizer_discard_enable( + mut self, + rasterizer_discard_enable: bool, + ) -> Self { + self.rasterizer_discard_enable = rasterizer_discard_enable.into(); + self + } + pub fn polygon_mode(mut self, polygon_mode: crate::vk::PolygonMode) -> Self { + self.polygon_mode = polygon_mode; + self + } + pub fn cull_mode(mut self, cull_mode: crate::vk::CullModeFlags) -> Self { + self.cull_mode = cull_mode; + self + } + pub fn front_face(mut self, front_face: crate::vk::FrontFace) -> Self { + self.front_face = front_face; + self + } + pub fn depth_bias_enable(mut self, depth_bias_enable: bool) -> Self { + self.depth_bias_enable = depth_bias_enable.into(); + self + } + pub fn depth_bias_constant_factor( + mut self, + depth_bias_constant_factor: core::ffi::c_float, + ) -> Self { + self.depth_bias_constant_factor = depth_bias_constant_factor; + self + } + pub fn depth_bias_clamp(mut self, depth_bias_clamp: core::ffi::c_float) -> Self { + self.depth_bias_clamp = depth_bias_clamp; + self + } + pub fn depth_bias_slope_factor( + mut self, + depth_bias_slope_factor: core::ffi::c_float, + ) -> Self { + self.depth_bias_slope_factor = depth_bias_slope_factor; + self + } + pub fn line_width(mut self, line_width: core::ffi::c_float) -> Self { + self.line_width = line_width; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PipelineMultisampleStateCreateInfo<'a> { @@ -2949,8 +5231,73 @@ pub(crate) mod reexport { pub alpha_to_one_enable: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PipelineMultisampleStateCreateInfo<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PIPELINE_MULTISAMPLE_STATE_CREATE_INFO; + } + impl<'a> Default for PipelineMultisampleStateCreateInfo<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + flags: Default::default(), + rasterization_samples: Default::default(), + sample_shading_enable: Default::default(), + min_sample_shading: Default::default(), + p_sample_mask: Default::default(), + alpha_to_coverage_enable: Default::default(), + alpha_to_one_enable: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PipelineMultisampleStateCreateInfo<'a> { + pub fn flags( + mut self, + flags: crate::vk::PipelineMultisampleStateCreateFlags, + ) -> Self { + self.flags = flags; + self + } + pub fn rasterization_samples( + mut self, + rasterization_samples: crate::vk::SampleCountFlagBits, + ) -> Self { + self.rasterization_samples = rasterization_samples; + self + } + pub fn sample_shading_enable(mut self, sample_shading_enable: bool) -> Self { + self.sample_shading_enable = sample_shading_enable.into(); + self + } + pub fn min_sample_shading( + mut self, + min_sample_shading: core::ffi::c_float, + ) -> Self { + self.min_sample_shading = min_sample_shading; + self + } + pub fn p_sample_mask( + mut self, + p_sample_mask: *const crate::vk::SampleMask, + ) -> Self { + self.p_sample_mask = p_sample_mask; + self + } + pub fn alpha_to_coverage_enable( + mut self, + alpha_to_coverage_enable: bool, + ) -> Self { + self.alpha_to_coverage_enable = alpha_to_coverage_enable.into(); + self + } + pub fn alpha_to_one_enable(mut self, alpha_to_one_enable: bool) -> Self { + self.alpha_to_one_enable = alpha_to_one_enable.into(); + self + } + } #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct PipelineColorBlendAttachmentState { pub blend_enable: crate::vk::Bool32, pub src_color_blend_factor: crate::vk::BlendFactor, @@ -2961,6 +5308,55 @@ pub(crate) mod reexport { pub alpha_blend_op: crate::vk::BlendOp, pub color_write_mask: crate::vk::ColorComponentFlags, } + impl PipelineColorBlendAttachmentState { + pub fn blend_enable(mut self, blend_enable: bool) -> Self { + self.blend_enable = blend_enable.into(); + self + } + pub fn src_color_blend_factor( + mut self, + src_color_blend_factor: crate::vk::BlendFactor, + ) -> Self { + self.src_color_blend_factor = src_color_blend_factor; + self + } + pub fn dst_color_blend_factor( + mut self, + dst_color_blend_factor: crate::vk::BlendFactor, + ) -> Self { + self.dst_color_blend_factor = dst_color_blend_factor; + self + } + pub fn color_blend_op(mut self, color_blend_op: crate::vk::BlendOp) -> Self { + self.color_blend_op = color_blend_op; + self + } + pub fn src_alpha_blend_factor( + mut self, + src_alpha_blend_factor: crate::vk::BlendFactor, + ) -> Self { + self.src_alpha_blend_factor = src_alpha_blend_factor; + self + } + pub fn dst_alpha_blend_factor( + mut self, + dst_alpha_blend_factor: crate::vk::BlendFactor, + ) -> Self { + self.dst_alpha_blend_factor = dst_alpha_blend_factor; + self + } + pub fn alpha_blend_op(mut self, alpha_blend_op: crate::vk::BlendOp) -> Self { + self.alpha_blend_op = alpha_blend_op; + self + } + pub fn color_write_mask( + mut self, + color_write_mask: crate::vk::ColorComponentFlags, + ) -> Self { + self.color_write_mask = color_write_mask; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PipelineColorBlendStateCreateInfo<'a> { @@ -2974,6 +5370,61 @@ pub(crate) mod reexport { pub blend_constants: [core::ffi::c_float; 4 as _], pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PipelineColorBlendStateCreateInfo<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PIPELINE_COLOR_BLEND_STATE_CREATE_INFO; + } + impl<'a> Default for PipelineColorBlendStateCreateInfo<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + flags: Default::default(), + logic_op_enable: Default::default(), + logic_op: Default::default(), + attachment_count: Default::default(), + p_attachments: Default::default(), + blend_constants: unsafe { core::mem::zeroed() }, + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PipelineColorBlendStateCreateInfo<'a> { + pub fn flags( + mut self, + flags: crate::vk::PipelineColorBlendStateCreateFlags, + ) -> Self { + self.flags = flags; + self + } + pub fn logic_op_enable(mut self, logic_op_enable: bool) -> Self { + self.logic_op_enable = logic_op_enable.into(); + self + } + pub fn logic_op(mut self, logic_op: crate::vk::LogicOp) -> Self { + self.logic_op = logic_op; + self + } + pub fn attachment_count(mut self, attachment_count: u32) -> Self { + self.attachment_count = attachment_count; + self + } + pub fn p_attachments( + mut self, + p_attachments: &'a [crate::vk::PipelineColorBlendAttachmentState], + ) -> Self { + self.attachment_count = p_attachments.len() as _; + self.p_attachments = p_attachments.as_ptr(); + self + } + pub fn blend_constants( + mut self, + blend_constants: [core::ffi::c_float; 4 as _], + ) -> Self { + self.blend_constants = blend_constants; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PipelineDynamicStateCreateInfo<'a> { @@ -2984,8 +5435,44 @@ pub(crate) mod reexport { pub p_dynamic_states: *const crate::vk::DynamicState, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for PipelineDynamicStateCreateInfo<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PIPELINE_DYNAMIC_STATE_CREATE_INFO; + } + impl<'a> Default for PipelineDynamicStateCreateInfo<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + flags: Default::default(), + dynamic_state_count: Default::default(), + p_dynamic_states: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PipelineDynamicStateCreateInfo<'a> { + pub fn flags( + mut self, + flags: crate::vk::PipelineDynamicStateCreateFlags, + ) -> Self { + self.flags = flags; + self + } + pub fn dynamic_state_count(mut self, dynamic_state_count: u32) -> Self { + self.dynamic_state_count = dynamic_state_count; + self + } + pub fn p_dynamic_states( + mut self, + p_dynamic_states: &'a [crate::vk::DynamicState], + ) -> Self { + self.dynamic_state_count = p_dynamic_states.len() as _; + self.p_dynamic_states = p_dynamic_states.as_ptr(); + self + } + } #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct StencilOpState { pub fail_op: crate::vk::StencilOp, pub pass_op: crate::vk::StencilOp, @@ -2995,6 +5482,36 @@ pub(crate) mod reexport { pub write_mask: u32, pub reference: u32, } + impl StencilOpState { + pub fn fail_op(mut self, fail_op: crate::vk::StencilOp) -> Self { + self.fail_op = fail_op; + self + } + pub fn pass_op(mut self, pass_op: crate::vk::StencilOp) -> Self { + self.pass_op = pass_op; + self + } + pub fn depth_fail_op(mut self, depth_fail_op: crate::vk::StencilOp) -> Self { + self.depth_fail_op = depth_fail_op; + self + } + pub fn compare_op(mut self, compare_op: crate::vk::CompareOp) -> Self { + self.compare_op = compare_op; + self + } + pub fn compare_mask(mut self, compare_mask: u32) -> Self { + self.compare_mask = compare_mask; + self + } + pub fn write_mask(mut self, write_mask: u32) -> Self { + self.write_mask = write_mask; + self + } + pub fn reference(mut self, reference: u32) -> Self { + self.reference = reference; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PipelineDepthStencilStateCreateInfo<'a> { @@ -3012,6 +5529,80 @@ pub(crate) mod reexport { pub max_depth_bounds: core::ffi::c_float, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PipelineDepthStencilStateCreateInfo<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO; + } + impl<'a> Default for PipelineDepthStencilStateCreateInfo<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + flags: Default::default(), + depth_test_enable: Default::default(), + depth_write_enable: Default::default(), + depth_compare_op: Default::default(), + depth_bounds_test_enable: Default::default(), + stencil_test_enable: Default::default(), + front: Default::default(), + back: Default::default(), + min_depth_bounds: Default::default(), + max_depth_bounds: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PipelineDepthStencilStateCreateInfo<'a> { + pub fn flags( + mut self, + flags: crate::vk::PipelineDepthStencilStateCreateFlags, + ) -> Self { + self.flags = flags; + self + } + pub fn depth_test_enable(mut self, depth_test_enable: bool) -> Self { + self.depth_test_enable = depth_test_enable.into(); + self + } + pub fn depth_write_enable(mut self, depth_write_enable: bool) -> Self { + self.depth_write_enable = depth_write_enable.into(); + self + } + pub fn depth_compare_op( + mut self, + depth_compare_op: crate::vk::CompareOp, + ) -> Self { + self.depth_compare_op = depth_compare_op; + self + } + pub fn depth_bounds_test_enable( + mut self, + depth_bounds_test_enable: bool, + ) -> Self { + self.depth_bounds_test_enable = depth_bounds_test_enable.into(); + self + } + pub fn stencil_test_enable(mut self, stencil_test_enable: bool) -> Self { + self.stencil_test_enable = stencil_test_enable.into(); + self + } + pub fn front(mut self, front: crate::vk::StencilOpState) -> Self { + self.front = front; + self + } + pub fn back(mut self, back: crate::vk::StencilOpState) -> Self { + self.back = back; + self + } + pub fn min_depth_bounds(mut self, min_depth_bounds: core::ffi::c_float) -> Self { + self.min_depth_bounds = min_depth_bounds; + self + } + pub fn max_depth_bounds(mut self, max_depth_bounds: core::ffi::c_float) -> Self { + self.max_depth_bounds = max_depth_bounds; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct GraphicsPipelineCreateInfo<'a> { @@ -3048,6 +5639,143 @@ pub(crate) mod reexport { pub base_pipeline_index: i32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for GraphicsPipelineCreateInfo<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::GRAPHICS_PIPELINE_CREATE_INFO; + } + impl<'a> Default for GraphicsPipelineCreateInfo<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + flags: Default::default(), + stage_count: Default::default(), + p_stages: Default::default(), + p_vertex_input_state: Default::default(), + p_input_assembly_state: Default::default(), + p_tessellation_state: Default::default(), + p_viewport_state: Default::default(), + p_rasterization_state: Default::default(), + p_multisample_state: Default::default(), + p_depth_stencil_state: Default::default(), + p_color_blend_state: Default::default(), + p_dynamic_state: Default::default(), + layout: Default::default(), + render_pass: Default::default(), + subpass: Default::default(), + base_pipeline_handle: Default::default(), + base_pipeline_index: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> GraphicsPipelineCreateInfo<'a> { + pub fn flags(mut self, flags: crate::vk::PipelineCreateFlags) -> Self { + self.flags = flags; + self + } + pub fn stage_count(mut self, stage_count: u32) -> Self { + self.stage_count = stage_count; + self + } + pub fn p_stages( + mut self, + p_stages: &'a [crate::vk::PipelineShaderStageCreateInfo<'a>], + ) -> Self { + self.stage_count = p_stages.len() as _; + self.p_stages = p_stages.as_ptr(); + self + } + pub fn p_vertex_input_state( + mut self, + p_vertex_input_state: &'a crate::vk::PipelineVertexInputStateCreateInfo<'a>, + ) -> Self { + self.p_vertex_input_state = p_vertex_input_state; + self + } + pub fn p_input_assembly_state( + mut self, + p_input_assembly_state: &'a crate::vk::PipelineInputAssemblyStateCreateInfo< + 'a, + >, + ) -> Self { + self.p_input_assembly_state = p_input_assembly_state; + self + } + pub fn p_tessellation_state( + mut self, + p_tessellation_state: &'a crate::vk::PipelineTessellationStateCreateInfo<'a>, + ) -> Self { + self.p_tessellation_state = p_tessellation_state; + self + } + pub fn p_viewport_state( + mut self, + p_viewport_state: &'a crate::vk::PipelineViewportStateCreateInfo<'a>, + ) -> Self { + self.p_viewport_state = p_viewport_state; + self + } + pub fn p_rasterization_state( + mut self, + p_rasterization_state: &'a crate::vk::PipelineRasterizationStateCreateInfo< + 'a, + >, + ) -> Self { + self.p_rasterization_state = p_rasterization_state; + self + } + pub fn p_multisample_state( + mut self, + p_multisample_state: &'a crate::vk::PipelineMultisampleStateCreateInfo<'a>, + ) -> Self { + self.p_multisample_state = p_multisample_state; + self + } + pub fn p_depth_stencil_state( + mut self, + p_depth_stencil_state: &'a crate::vk::PipelineDepthStencilStateCreateInfo<'a>, + ) -> Self { + self.p_depth_stencil_state = p_depth_stencil_state; + self + } + pub fn p_color_blend_state( + mut self, + p_color_blend_state: &'a crate::vk::PipelineColorBlendStateCreateInfo<'a>, + ) -> Self { + self.p_color_blend_state = p_color_blend_state; + self + } + pub fn p_dynamic_state( + mut self, + p_dynamic_state: &'a crate::vk::PipelineDynamicStateCreateInfo<'a>, + ) -> Self { + self.p_dynamic_state = p_dynamic_state; + self + } + pub fn layout(mut self, layout: crate::vk::PipelineLayout) -> Self { + self.layout = layout; + self + } + pub fn render_pass(mut self, render_pass: crate::vk::RenderPass) -> Self { + self.render_pass = render_pass; + self + } + pub fn subpass(mut self, subpass: u32) -> Self { + self.subpass = subpass; + self + } + pub fn base_pipeline_handle( + mut self, + base_pipeline_handle: crate::vk::Pipeline, + ) -> Self { + self.base_pipeline_handle = base_pipeline_handle; + self + } + pub fn base_pipeline_index(mut self, base_pipeline_index: i32) -> Self { + self.base_pipeline_index = base_pipeline_index; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PipelineCacheCreateInfo<'a> { @@ -3058,6 +5786,36 @@ pub(crate) mod reexport { pub p_initial_data: *const core::ffi::c_void, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for PipelineCacheCreateInfo<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PIPELINE_CACHE_CREATE_INFO; + } + impl<'a> Default for PipelineCacheCreateInfo<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + flags: Default::default(), + initial_data_size: Default::default(), + p_initial_data: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PipelineCacheCreateInfo<'a> { + pub fn flags(mut self, flags: crate::vk::PipelineCacheCreateFlags) -> Self { + self.flags = flags; + self + } + pub fn initial_data_size(mut self, initial_data_size: usize) -> Self { + self.initial_data_size = initial_data_size; + self + } + pub fn p_initial_data(mut self, p_initial_data: &'a [u8]) -> Self { + self.initial_data_size = p_initial_data.len() as _; + self.p_initial_data = p_initial_data.as_ptr().cast(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PipelineCacheHeaderVersionOne { @@ -3067,13 +5825,66 @@ pub(crate) mod reexport { pub device_id: u32, pub pipeline_cache_uuid: [u8; crate::vk::UUID_SIZE as _], } + impl Default for PipelineCacheHeaderVersionOne { + fn default() -> Self { + Self { + header_size: Default::default(), + header_version: Default::default(), + vendor_id: Default::default(), + device_id: Default::default(), + pipeline_cache_uuid: unsafe { core::mem::zeroed() }, + } + } + } + impl PipelineCacheHeaderVersionOne { + pub fn header_size(mut self, header_size: u32) -> Self { + self.header_size = header_size; + self + } + pub fn header_version( + mut self, + header_version: crate::vk::PipelineCacheHeaderVersion, + ) -> Self { + self.header_version = header_version; + self + } + pub fn vendor_id(mut self, vendor_id: u32) -> Self { + self.vendor_id = vendor_id; + self + } + pub fn device_id(mut self, device_id: u32) -> Self { + self.device_id = device_id; + self + } + pub fn pipeline_cache_uuid( + mut self, + pipeline_cache_uuid: [u8; crate::vk::UUID_SIZE as _], + ) -> Self { + self.pipeline_cache_uuid = pipeline_cache_uuid; + self + } + } #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct PushConstantRange { pub stage_flags: crate::vk::ShaderStageFlags, pub offset: u32, pub size: u32, } + impl PushConstantRange { + pub fn stage_flags(mut self, stage_flags: crate::vk::ShaderStageFlags) -> Self { + self.stage_flags = stage_flags; + self + } + pub fn offset(mut self, offset: u32) -> Self { + self.offset = offset; + self + } + pub fn size(mut self, size: u32) -> Self { + self.size = size; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PipelineLayoutCreateInfo<'a> { @@ -3086,6 +5897,72 @@ pub(crate) mod reexport { pub p_push_constant_ranges: *const crate::vk::PushConstantRange, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for PipelineLayoutCreateInfo<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PIPELINE_LAYOUT_CREATE_INFO; + } + unsafe impl<'a> crate::Extends> + for PipelineLayoutCreateInfo<'a> {} + unsafe impl<'a> crate::Extends> + for PipelineLayoutCreateInfo<'a> {} + unsafe impl<'a> crate::Extends> + for PipelineLayoutCreateInfo<'a> {} + unsafe impl<'a> crate::Extends> + for PipelineLayoutCreateInfo<'a> {} + unsafe impl<'a> crate::Extends> + for PipelineLayoutCreateInfo<'a> {} + unsafe impl< + 'a, + > crate::Extends> + for PipelineLayoutCreateInfo<'a> {} + unsafe impl<'a> crate::Extends> + for PipelineLayoutCreateInfo<'a> {} + impl<'a> Default for PipelineLayoutCreateInfo<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + flags: Default::default(), + set_layout_count: Default::default(), + p_set_layouts: Default::default(), + push_constant_range_count: Default::default(), + p_push_constant_ranges: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PipelineLayoutCreateInfo<'a> { + pub fn flags(mut self, flags: crate::vk::PipelineLayoutCreateFlags) -> Self { + self.flags = flags; + self + } + pub fn set_layout_count(mut self, set_layout_count: u32) -> Self { + self.set_layout_count = set_layout_count; + self + } + pub fn p_set_layouts( + mut self, + p_set_layouts: &'a [crate::vk::DescriptorSetLayout], + ) -> Self { + self.set_layout_count = p_set_layouts.len() as _; + self.p_set_layouts = p_set_layouts.as_ptr(); + self + } + pub fn push_constant_range_count( + mut self, + push_constant_range_count: u32, + ) -> Self { + self.push_constant_range_count = push_constant_range_count; + self + } + pub fn p_push_constant_ranges( + mut self, + p_push_constant_ranges: &'a [crate::vk::PushConstantRange], + ) -> Self { + self.push_constant_range_count = p_push_constant_ranges.len() as _; + self.p_push_constant_ranges = p_push_constant_ranges.as_ptr(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct SamplerCreateInfo<'a> { @@ -3109,6 +5986,112 @@ pub(crate) mod reexport { pub unnormalized_coordinates: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for SamplerCreateInfo<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::SAMPLER_CREATE_INFO; + } + impl<'a> Default for SamplerCreateInfo<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + flags: Default::default(), + mag_filter: Default::default(), + min_filter: Default::default(), + mipmap_mode: Default::default(), + address_mode_u: Default::default(), + address_mode_v: Default::default(), + address_mode_w: Default::default(), + mip_lod_bias: Default::default(), + anisotropy_enable: Default::default(), + max_anisotropy: Default::default(), + compare_enable: Default::default(), + compare_op: Default::default(), + min_lod: Default::default(), + max_lod: Default::default(), + border_color: Default::default(), + unnormalized_coordinates: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> SamplerCreateInfo<'a> { + pub fn flags(mut self, flags: crate::vk::SamplerCreateFlags) -> Self { + self.flags = flags; + self + } + pub fn mag_filter(mut self, mag_filter: crate::vk::Filter) -> Self { + self.mag_filter = mag_filter; + self + } + pub fn min_filter(mut self, min_filter: crate::vk::Filter) -> Self { + self.min_filter = min_filter; + self + } + pub fn mipmap_mode(mut self, mipmap_mode: crate::vk::SamplerMipmapMode) -> Self { + self.mipmap_mode = mipmap_mode; + self + } + pub fn address_mode_u( + mut self, + address_mode_u: crate::vk::SamplerAddressMode, + ) -> Self { + self.address_mode_u = address_mode_u; + self + } + pub fn address_mode_v( + mut self, + address_mode_v: crate::vk::SamplerAddressMode, + ) -> Self { + self.address_mode_v = address_mode_v; + self + } + pub fn address_mode_w( + mut self, + address_mode_w: crate::vk::SamplerAddressMode, + ) -> Self { + self.address_mode_w = address_mode_w; + self + } + pub fn mip_lod_bias(mut self, mip_lod_bias: core::ffi::c_float) -> Self { + self.mip_lod_bias = mip_lod_bias; + self + } + pub fn anisotropy_enable(mut self, anisotropy_enable: bool) -> Self { + self.anisotropy_enable = anisotropy_enable.into(); + self + } + pub fn max_anisotropy(mut self, max_anisotropy: core::ffi::c_float) -> Self { + self.max_anisotropy = max_anisotropy; + self + } + pub fn compare_enable(mut self, compare_enable: bool) -> Self { + self.compare_enable = compare_enable.into(); + self + } + pub fn compare_op(mut self, compare_op: crate::vk::CompareOp) -> Self { + self.compare_op = compare_op; + self + } + pub fn min_lod(mut self, min_lod: core::ffi::c_float) -> Self { + self.min_lod = min_lod; + self + } + pub fn max_lod(mut self, max_lod: core::ffi::c_float) -> Self { + self.max_lod = max_lod; + self + } + pub fn border_color(mut self, border_color: crate::vk::BorderColor) -> Self { + self.border_color = border_color; + self + } + pub fn unnormalized_coordinates( + mut self, + unnormalized_coordinates: bool, + ) -> Self { + self.unnormalized_coordinates = unnormalized_coordinates.into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct CommandPoolCreateInfo<'a> { @@ -3118,6 +6101,30 @@ pub(crate) mod reexport { pub queue_family_index: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for CommandPoolCreateInfo<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::COMMAND_POOL_CREATE_INFO; + } + impl<'a> Default for CommandPoolCreateInfo<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + flags: Default::default(), + queue_family_index: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> CommandPoolCreateInfo<'a> { + pub fn flags(mut self, flags: crate::vk::CommandPoolCreateFlags) -> Self { + self.flags = flags; + self + } + pub fn queue_family_index(mut self, queue_family_index: u32) -> Self { + self.queue_family_index = queue_family_index; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct CommandBufferAllocateInfo<'a> { @@ -3128,6 +6135,35 @@ pub(crate) mod reexport { pub command_buffer_count: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for CommandBufferAllocateInfo<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::COMMAND_BUFFER_ALLOCATE_INFO; + } + impl<'a> Default for CommandBufferAllocateInfo<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + command_pool: Default::default(), + level: Default::default(), + command_buffer_count: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> CommandBufferAllocateInfo<'a> { + pub fn command_pool(mut self, command_pool: crate::vk::CommandPool) -> Self { + self.command_pool = command_pool; + self + } + pub fn level(mut self, level: crate::vk::CommandBufferLevel) -> Self { + self.level = level; + self + } + pub fn command_buffer_count(mut self, command_buffer_count: u32) -> Self { + self.command_buffer_count = command_buffer_count; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct CommandBufferInheritanceInfo<'a> { @@ -3141,6 +6177,53 @@ pub(crate) mod reexport { pub pipeline_statistics: crate::vk::QueryPipelineStatisticFlags, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for CommandBufferInheritanceInfo<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::COMMAND_BUFFER_INHERITANCE_INFO; + } + impl<'a> Default for CommandBufferInheritanceInfo<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + render_pass: Default::default(), + subpass: Default::default(), + framebuffer: Default::default(), + occlusion_query_enable: Default::default(), + query_flags: Default::default(), + pipeline_statistics: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> CommandBufferInheritanceInfo<'a> { + pub fn render_pass(mut self, render_pass: crate::vk::RenderPass) -> Self { + self.render_pass = render_pass; + self + } + pub fn subpass(mut self, subpass: u32) -> Self { + self.subpass = subpass; + self + } + pub fn framebuffer(mut self, framebuffer: crate::vk::Framebuffer) -> Self { + self.framebuffer = framebuffer; + self + } + pub fn occlusion_query_enable(mut self, occlusion_query_enable: bool) -> Self { + self.occlusion_query_enable = occlusion_query_enable.into(); + self + } + pub fn query_flags(mut self, query_flags: crate::vk::QueryControlFlags) -> Self { + self.query_flags = query_flags; + self + } + pub fn pipeline_statistics( + mut self, + pipeline_statistics: crate::vk::QueryPipelineStatisticFlags, + ) -> Self { + self.pipeline_statistics = pipeline_statistics; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct CommandBufferBeginInfo<'a> { @@ -3150,6 +6233,33 @@ pub(crate) mod reexport { pub p_inheritance_info: *const crate::vk::CommandBufferInheritanceInfo<'a>, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for CommandBufferBeginInfo<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::COMMAND_BUFFER_BEGIN_INFO; + } + impl<'a> Default for CommandBufferBeginInfo<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + flags: Default::default(), + p_inheritance_info: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> CommandBufferBeginInfo<'a> { + pub fn flags(mut self, flags: crate::vk::CommandBufferUsageFlags) -> Self { + self.flags = flags; + self + } + pub fn p_inheritance_info( + mut self, + p_inheritance_info: &'a crate::vk::CommandBufferInheritanceInfo<'a>, + ) -> Self { + self.p_inheritance_info = p_inheritance_info; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct RenderPassBeginInfo<'a> { @@ -3162,21 +6272,88 @@ pub(crate) mod reexport { pub p_clear_values: *const crate::vk::ClearValue, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for RenderPassBeginInfo<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::RENDER_PASS_BEGIN_INFO; + } + impl<'a> Default for RenderPassBeginInfo<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + render_pass: Default::default(), + framebuffer: Default::default(), + render_area: Default::default(), + clear_value_count: Default::default(), + p_clear_values: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> RenderPassBeginInfo<'a> { + pub fn render_pass(mut self, render_pass: crate::vk::RenderPass) -> Self { + self.render_pass = render_pass; + self + } + pub fn framebuffer(mut self, framebuffer: crate::vk::Framebuffer) -> Self { + self.framebuffer = framebuffer; + self + } + pub fn render_area(mut self, render_area: crate::vk::Rect2D) -> Self { + self.render_area = render_area; + self + } + pub fn clear_value_count(mut self, clear_value_count: u32) -> Self { + self.clear_value_count = clear_value_count; + self + } + pub fn p_clear_values( + mut self, + p_clear_values: &'a [crate::vk::ClearValue], + ) -> Self { + self.clear_value_count = p_clear_values.len() as _; + self.p_clear_values = p_clear_values.as_ptr(); + self + } + } #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct ClearDepthStencilValue { pub depth: core::ffi::c_float, pub stencil: u32, } + impl ClearDepthStencilValue { + pub fn depth(mut self, depth: core::ffi::c_float) -> Self { + self.depth = depth; + self + } + pub fn stencil(mut self, stencil: u32) -> Self { + self.stencil = stencil; + self + } + } #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct ClearAttachment { pub aspect_mask: crate::vk::ImageAspectFlags, pub color_attachment: u32, pub clear_value: crate::vk::ClearValue, } + impl ClearAttachment { + pub fn aspect_mask(mut self, aspect_mask: crate::vk::ImageAspectFlags) -> Self { + self.aspect_mask = aspect_mask; + self + } + pub fn color_attachment(mut self, color_attachment: u32) -> Self { + self.color_attachment = color_attachment; + self + } + pub fn clear_value(mut self, clear_value: crate::vk::ClearValue) -> Self { + self.clear_value = clear_value; + self + } + } #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct AttachmentDescription { pub flags: crate::vk::AttachmentDescriptionFlags, pub format: crate::vk::Format, @@ -3188,14 +6365,68 @@ pub(crate) mod reexport { pub initial_layout: crate::vk::ImageLayout, pub final_layout: crate::vk::ImageLayout, } + impl AttachmentDescription { + pub fn flags(mut self, flags: crate::vk::AttachmentDescriptionFlags) -> Self { + self.flags = flags; + self + } + pub fn format(mut self, format: crate::vk::Format) -> Self { + self.format = format; + self + } + pub fn samples(mut self, samples: crate::vk::SampleCountFlagBits) -> Self { + self.samples = samples; + self + } + pub fn load_op(mut self, load_op: crate::vk::AttachmentLoadOp) -> Self { + self.load_op = load_op; + self + } + pub fn store_op(mut self, store_op: crate::vk::AttachmentStoreOp) -> Self { + self.store_op = store_op; + self + } + pub fn stencil_load_op( + mut self, + stencil_load_op: crate::vk::AttachmentLoadOp, + ) -> Self { + self.stencil_load_op = stencil_load_op; + self + } + pub fn stencil_store_op( + mut self, + stencil_store_op: crate::vk::AttachmentStoreOp, + ) -> Self { + self.stencil_store_op = stencil_store_op; + self + } + pub fn initial_layout(mut self, initial_layout: crate::vk::ImageLayout) -> Self { + self.initial_layout = initial_layout; + self + } + pub fn final_layout(mut self, final_layout: crate::vk::ImageLayout) -> Self { + self.final_layout = final_layout; + self + } + } #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct AttachmentReference { pub attachment: u32, pub layout: crate::vk::ImageLayout, } + impl AttachmentReference { + pub fn attachment(mut self, attachment: u32) -> Self { + self.attachment = attachment; + self + } + pub fn layout(mut self, layout: crate::vk::ImageLayout) -> Self { + self.layout = layout; + self + } + } #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct SubpassDescription<'a> { pub flags: crate::vk::SubpassDescriptionFlags, pub pipeline_bind_point: crate::vk::PipelineBindPoint, @@ -3209,8 +6440,75 @@ pub(crate) mod reexport { pub p_preserve_attachments: *const u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + impl<'a> SubpassDescription<'a> { + pub fn flags(mut self, flags: crate::vk::SubpassDescriptionFlags) -> Self { + self.flags = flags; + self + } + pub fn pipeline_bind_point( + mut self, + pipeline_bind_point: crate::vk::PipelineBindPoint, + ) -> Self { + self.pipeline_bind_point = pipeline_bind_point; + self + } + pub fn input_attachment_count(mut self, input_attachment_count: u32) -> Self { + self.input_attachment_count = input_attachment_count; + self + } + pub fn p_input_attachments( + mut self, + p_input_attachments: &'a [crate::vk::AttachmentReference], + ) -> Self { + self.input_attachment_count = p_input_attachments.len() as _; + self.p_input_attachments = p_input_attachments.as_ptr(); + self + } + pub fn color_attachment_count(mut self, color_attachment_count: u32) -> Self { + self.color_attachment_count = color_attachment_count; + self + } + pub fn p_color_attachments( + mut self, + p_color_attachments: &'a [crate::vk::AttachmentReference], + ) -> Self { + self.color_attachment_count = p_color_attachments.len() as _; + self.p_color_attachments = p_color_attachments.as_ptr(); + self + } + pub fn p_resolve_attachments( + mut self, + p_resolve_attachments: &'a [crate::vk::AttachmentReference], + ) -> Self { + self.color_attachment_count = p_resolve_attachments.len() as _; + self.p_resolve_attachments = p_resolve_attachments.as_ptr(); + self + } + pub fn p_depth_stencil_attachment( + mut self, + p_depth_stencil_attachment: &'a crate::vk::AttachmentReference, + ) -> Self { + self.p_depth_stencil_attachment = p_depth_stencil_attachment; + self + } + pub fn preserve_attachment_count( + mut self, + preserve_attachment_count: u32, + ) -> Self { + self.preserve_attachment_count = preserve_attachment_count; + self + } + pub fn p_preserve_attachments( + mut self, + p_preserve_attachments: &'a [u32], + ) -> Self { + self.preserve_attachment_count = p_preserve_attachments.len() as _; + self.p_preserve_attachments = p_preserve_attachments.as_ptr(); + self + } + } #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct SubpassDependency { pub src_subpass: u32, pub dst_subpass: u32, @@ -3220,6 +6518,51 @@ pub(crate) mod reexport { pub dst_access_mask: crate::vk::AccessFlags, pub dependency_flags: crate::vk::DependencyFlags, } + impl SubpassDependency { + pub fn src_subpass(mut self, src_subpass: u32) -> Self { + self.src_subpass = src_subpass; + self + } + pub fn dst_subpass(mut self, dst_subpass: u32) -> Self { + self.dst_subpass = dst_subpass; + self + } + pub fn src_stage_mask( + mut self, + src_stage_mask: crate::vk::PipelineStageFlags, + ) -> Self { + self.src_stage_mask = src_stage_mask; + self + } + pub fn dst_stage_mask( + mut self, + dst_stage_mask: crate::vk::PipelineStageFlags, + ) -> Self { + self.dst_stage_mask = dst_stage_mask; + self + } + pub fn src_access_mask( + mut self, + src_access_mask: crate::vk::AccessFlags, + ) -> Self { + self.src_access_mask = src_access_mask; + self + } + pub fn dst_access_mask( + mut self, + dst_access_mask: crate::vk::AccessFlags, + ) -> Self { + self.dst_access_mask = dst_access_mask; + self + } + pub fn dependency_flags( + mut self, + dependency_flags: crate::vk::DependencyFlags, + ) -> Self { + self.dependency_flags = dependency_flags; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct RenderPassCreateInfo<'a> { @@ -3234,6 +6577,67 @@ pub(crate) mod reexport { pub p_dependencies: *const crate::vk::SubpassDependency, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for RenderPassCreateInfo<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::RENDER_PASS_CREATE_INFO; + } + impl<'a> Default for RenderPassCreateInfo<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + flags: Default::default(), + attachment_count: Default::default(), + p_attachments: Default::default(), + subpass_count: Default::default(), + p_subpasses: Default::default(), + dependency_count: Default::default(), + p_dependencies: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> RenderPassCreateInfo<'a> { + pub fn flags(mut self, flags: crate::vk::RenderPassCreateFlags) -> Self { + self.flags = flags; + self + } + pub fn attachment_count(mut self, attachment_count: u32) -> Self { + self.attachment_count = attachment_count; + self + } + pub fn p_attachments( + mut self, + p_attachments: &'a [crate::vk::AttachmentDescription], + ) -> Self { + self.attachment_count = p_attachments.len() as _; + self.p_attachments = p_attachments.as_ptr(); + self + } + pub fn subpass_count(mut self, subpass_count: u32) -> Self { + self.subpass_count = subpass_count; + self + } + pub fn p_subpasses( + mut self, + p_subpasses: &'a [crate::vk::SubpassDescription<'a>], + ) -> Self { + self.subpass_count = p_subpasses.len() as _; + self.p_subpasses = p_subpasses.as_ptr(); + self + } + pub fn dependency_count(mut self, dependency_count: u32) -> Self { + self.dependency_count = dependency_count; + self + } + pub fn p_dependencies( + mut self, + p_dependencies: &'a [crate::vk::SubpassDependency], + ) -> Self { + self.dependency_count = p_dependencies.len() as _; + self.p_dependencies = p_dependencies.as_ptr(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct EventCreateInfo<'a> { @@ -3242,6 +6646,25 @@ pub(crate) mod reexport { pub flags: crate::vk::EventCreateFlags, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for EventCreateInfo<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::EVENT_CREATE_INFO; + } + impl<'a> Default for EventCreateInfo<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + flags: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> EventCreateInfo<'a> { + pub fn flags(mut self, flags: crate::vk::EventCreateFlags) -> Self { + self.flags = flags; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct FenceCreateInfo<'a> { @@ -3250,8 +6673,27 @@ pub(crate) mod reexport { pub flags: crate::vk::FenceCreateFlags, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for FenceCreateInfo<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::FENCE_CREATE_INFO; + } + impl<'a> Default for FenceCreateInfo<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + flags: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> FenceCreateInfo<'a> { + pub fn flags(mut self, flags: crate::vk::FenceCreateFlags) -> Self { + self.flags = flags; + self + } + } #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct PhysicalDeviceFeatures { pub robust_buffer_access: crate::vk::Bool32, pub full_draw_index_uint32: crate::vk::Bool32, @@ -3309,8 +6751,315 @@ pub(crate) mod reexport { pub variable_multisample_rate: crate::vk::Bool32, pub inherited_queries: crate::vk::Bool32, } + impl PhysicalDeviceFeatures { + pub fn robust_buffer_access(mut self, robust_buffer_access: bool) -> Self { + self.robust_buffer_access = robust_buffer_access.into(); + self + } + pub fn full_draw_index_uint32(mut self, full_draw_index_uint32: bool) -> Self { + self.full_draw_index_uint32 = full_draw_index_uint32.into(); + self + } + pub fn image_cube_array(mut self, image_cube_array: bool) -> Self { + self.image_cube_array = image_cube_array.into(); + self + } + pub fn independent_blend(mut self, independent_blend: bool) -> Self { + self.independent_blend = independent_blend.into(); + self + } + pub fn geometry_shader(mut self, geometry_shader: bool) -> Self { + self.geometry_shader = geometry_shader.into(); + self + } + pub fn tessellation_shader(mut self, tessellation_shader: bool) -> Self { + self.tessellation_shader = tessellation_shader.into(); + self + } + pub fn sample_rate_shading(mut self, sample_rate_shading: bool) -> Self { + self.sample_rate_shading = sample_rate_shading.into(); + self + } + pub fn dual_src_blend(mut self, dual_src_blend: bool) -> Self { + self.dual_src_blend = dual_src_blend.into(); + self + } + pub fn logic_op(mut self, logic_op: bool) -> Self { + self.logic_op = logic_op.into(); + self + } + pub fn multi_draw_indirect(mut self, multi_draw_indirect: bool) -> Self { + self.multi_draw_indirect = multi_draw_indirect.into(); + self + } + pub fn draw_indirect_first_instance( + mut self, + draw_indirect_first_instance: bool, + ) -> Self { + self.draw_indirect_first_instance = draw_indirect_first_instance.into(); + self + } + pub fn depth_clamp(mut self, depth_clamp: bool) -> Self { + self.depth_clamp = depth_clamp.into(); + self + } + pub fn depth_bias_clamp(mut self, depth_bias_clamp: bool) -> Self { + self.depth_bias_clamp = depth_bias_clamp.into(); + self + } + pub fn fill_mode_non_solid(mut self, fill_mode_non_solid: bool) -> Self { + self.fill_mode_non_solid = fill_mode_non_solid.into(); + self + } + pub fn depth_bounds(mut self, depth_bounds: bool) -> Self { + self.depth_bounds = depth_bounds.into(); + self + } + pub fn wide_lines(mut self, wide_lines: bool) -> Self { + self.wide_lines = wide_lines.into(); + self + } + pub fn large_points(mut self, large_points: bool) -> Self { + self.large_points = large_points.into(); + self + } + pub fn alpha_to_one(mut self, alpha_to_one: bool) -> Self { + self.alpha_to_one = alpha_to_one.into(); + self + } + pub fn multi_viewport(mut self, multi_viewport: bool) -> Self { + self.multi_viewport = multi_viewport.into(); + self + } + pub fn sampler_anisotropy(mut self, sampler_anisotropy: bool) -> Self { + self.sampler_anisotropy = sampler_anisotropy.into(); + self + } + pub fn texture_compression_etc2( + mut self, + texture_compression_etc2: bool, + ) -> Self { + self.texture_compression_etc2 = texture_compression_etc2.into(); + self + } + pub fn texture_compression_astc_ldr( + mut self, + texture_compression_astc_ldr: bool, + ) -> Self { + self.texture_compression_astc_ldr = texture_compression_astc_ldr.into(); + self + } + pub fn texture_compression_bc(mut self, texture_compression_bc: bool) -> Self { + self.texture_compression_bc = texture_compression_bc.into(); + self + } + pub fn occlusion_query_precise(mut self, occlusion_query_precise: bool) -> Self { + self.occlusion_query_precise = occlusion_query_precise.into(); + self + } + pub fn pipeline_statistics_query( + mut self, + pipeline_statistics_query: bool, + ) -> Self { + self.pipeline_statistics_query = pipeline_statistics_query.into(); + self + } + pub fn vertex_pipeline_stores_and_atomics( + mut self, + vertex_pipeline_stores_and_atomics: bool, + ) -> Self { + self.vertex_pipeline_stores_and_atomics = vertex_pipeline_stores_and_atomics + .into(); + self + } + pub fn fragment_stores_and_atomics( + mut self, + fragment_stores_and_atomics: bool, + ) -> Self { + self.fragment_stores_and_atomics = fragment_stores_and_atomics.into(); + self + } + pub fn shader_tessellation_and_geometry_point_size( + mut self, + shader_tessellation_and_geometry_point_size: bool, + ) -> Self { + self.shader_tessellation_and_geometry_point_size = shader_tessellation_and_geometry_point_size + .into(); + self + } + pub fn shader_image_gather_extended( + mut self, + shader_image_gather_extended: bool, + ) -> Self { + self.shader_image_gather_extended = shader_image_gather_extended.into(); + self + } + pub fn shader_storage_image_extended_formats( + mut self, + shader_storage_image_extended_formats: bool, + ) -> Self { + self.shader_storage_image_extended_formats = shader_storage_image_extended_formats + .into(); + self + } + pub fn shader_storage_image_multisample( + mut self, + shader_storage_image_multisample: bool, + ) -> Self { + self.shader_storage_image_multisample = shader_storage_image_multisample + .into(); + self + } + pub fn shader_storage_image_read_without_format( + mut self, + shader_storage_image_read_without_format: bool, + ) -> Self { + self.shader_storage_image_read_without_format = shader_storage_image_read_without_format + .into(); + self + } + pub fn shader_storage_image_write_without_format( + mut self, + shader_storage_image_write_without_format: bool, + ) -> Self { + self.shader_storage_image_write_without_format = shader_storage_image_write_without_format + .into(); + self + } + pub fn shader_uniform_buffer_array_dynamic_indexing( + mut self, + shader_uniform_buffer_array_dynamic_indexing: bool, + ) -> Self { + self.shader_uniform_buffer_array_dynamic_indexing = shader_uniform_buffer_array_dynamic_indexing + .into(); + self + } + pub fn shader_sampled_image_array_dynamic_indexing( + mut self, + shader_sampled_image_array_dynamic_indexing: bool, + ) -> Self { + self.shader_sampled_image_array_dynamic_indexing = shader_sampled_image_array_dynamic_indexing + .into(); + self + } + pub fn shader_storage_buffer_array_dynamic_indexing( + mut self, + shader_storage_buffer_array_dynamic_indexing: bool, + ) -> Self { + self.shader_storage_buffer_array_dynamic_indexing = shader_storage_buffer_array_dynamic_indexing + .into(); + self + } + pub fn shader_storage_image_array_dynamic_indexing( + mut self, + shader_storage_image_array_dynamic_indexing: bool, + ) -> Self { + self.shader_storage_image_array_dynamic_indexing = shader_storage_image_array_dynamic_indexing + .into(); + self + } + pub fn shader_clip_distance(mut self, shader_clip_distance: bool) -> Self { + self.shader_clip_distance = shader_clip_distance.into(); + self + } + pub fn shader_cull_distance(mut self, shader_cull_distance: bool) -> Self { + self.shader_cull_distance = shader_cull_distance.into(); + self + } + pub fn shader_float64(mut self, shader_float64: bool) -> Self { + self.shader_float64 = shader_float64.into(); + self + } + pub fn shader_int64(mut self, shader_int64: bool) -> Self { + self.shader_int64 = shader_int64.into(); + self + } + pub fn shader_int16(mut self, shader_int16: bool) -> Self { + self.shader_int16 = shader_int16.into(); + self + } + pub fn shader_resource_residency( + mut self, + shader_resource_residency: bool, + ) -> Self { + self.shader_resource_residency = shader_resource_residency.into(); + self + } + pub fn shader_resource_min_lod(mut self, shader_resource_min_lod: bool) -> Self { + self.shader_resource_min_lod = shader_resource_min_lod.into(); + self + } + pub fn sparse_binding(mut self, sparse_binding: bool) -> Self { + self.sparse_binding = sparse_binding.into(); + self + } + pub fn sparse_residency_buffer(mut self, sparse_residency_buffer: bool) -> Self { + self.sparse_residency_buffer = sparse_residency_buffer.into(); + self + } + pub fn sparse_residency_image2_d( + mut self, + sparse_residency_image2_d: bool, + ) -> Self { + self.sparse_residency_image2_d = sparse_residency_image2_d.into(); + self + } + pub fn sparse_residency_image3_d( + mut self, + sparse_residency_image3_d: bool, + ) -> Self { + self.sparse_residency_image3_d = sparse_residency_image3_d.into(); + self + } + pub fn sparse_residency2_samples( + mut self, + sparse_residency2_samples: bool, + ) -> Self { + self.sparse_residency2_samples = sparse_residency2_samples.into(); + self + } + pub fn sparse_residency4_samples( + mut self, + sparse_residency4_samples: bool, + ) -> Self { + self.sparse_residency4_samples = sparse_residency4_samples.into(); + self + } + pub fn sparse_residency8_samples( + mut self, + sparse_residency8_samples: bool, + ) -> Self { + self.sparse_residency8_samples = sparse_residency8_samples.into(); + self + } + pub fn sparse_residency16_samples( + mut self, + sparse_residency16_samples: bool, + ) -> Self { + self.sparse_residency16_samples = sparse_residency16_samples.into(); + self + } + pub fn sparse_residency_aliased( + mut self, + sparse_residency_aliased: bool, + ) -> Self { + self.sparse_residency_aliased = sparse_residency_aliased.into(); + self + } + pub fn variable_multisample_rate( + mut self, + variable_multisample_rate: bool, + ) -> Self { + self.variable_multisample_rate = variable_multisample_rate.into(); + self + } + pub fn inherited_queries(mut self, inherited_queries: bool) -> Self { + self.inherited_queries = inherited_queries.into(); + self + } + } #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct PhysicalDeviceSparseProperties { pub residency_standard2_d_block_shape: crate::vk::Bool32, pub residency_standard2_d_multisample_block_shape: crate::vk::Bool32, @@ -3318,6 +7067,46 @@ pub(crate) mod reexport { pub residency_aligned_mip_size: crate::vk::Bool32, pub residency_non_resident_strict: crate::vk::Bool32, } + impl PhysicalDeviceSparseProperties { + pub fn residency_standard2_d_block_shape( + mut self, + residency_standard2_d_block_shape: bool, + ) -> Self { + self.residency_standard2_d_block_shape = residency_standard2_d_block_shape + .into(); + self + } + pub fn residency_standard2_d_multisample_block_shape( + mut self, + residency_standard2_d_multisample_block_shape: bool, + ) -> Self { + self.residency_standard2_d_multisample_block_shape = residency_standard2_d_multisample_block_shape + .into(); + self + } + pub fn residency_standard3_d_block_shape( + mut self, + residency_standard3_d_block_shape: bool, + ) -> Self { + self.residency_standard3_d_block_shape = residency_standard3_d_block_shape + .into(); + self + } + pub fn residency_aligned_mip_size( + mut self, + residency_aligned_mip_size: bool, + ) -> Self { + self.residency_aligned_mip_size = residency_aligned_mip_size.into(); + self + } + pub fn residency_non_resident_strict( + mut self, + residency_non_resident_strict: bool, + ) -> Self { + self.residency_non_resident_strict = residency_non_resident_strict.into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceLimits { @@ -3428,6 +7217,793 @@ pub(crate) mod reexport { pub optimal_buffer_copy_row_pitch_alignment: crate::vk::DeviceSize, pub non_coherent_atom_size: crate::vk::DeviceSize, } + impl Default for PhysicalDeviceLimits { + fn default() -> Self { + Self { + max_image_dimension1_d: Default::default(), + max_image_dimension2_d: Default::default(), + max_image_dimension3_d: Default::default(), + max_image_dimension_cube: Default::default(), + max_image_array_layers: Default::default(), + max_texel_buffer_elements: Default::default(), + max_uniform_buffer_range: Default::default(), + max_storage_buffer_range: Default::default(), + max_push_constants_size: Default::default(), + max_memory_allocation_count: Default::default(), + max_sampler_allocation_count: Default::default(), + buffer_image_granularity: Default::default(), + sparse_address_space_size: Default::default(), + max_bound_descriptor_sets: Default::default(), + max_per_stage_descriptor_samplers: Default::default(), + max_per_stage_descriptor_uniform_buffers: Default::default(), + max_per_stage_descriptor_storage_buffers: Default::default(), + max_per_stage_descriptor_sampled_images: Default::default(), + max_per_stage_descriptor_storage_images: Default::default(), + max_per_stage_descriptor_input_attachments: Default::default(), + max_per_stage_resources: Default::default(), + max_descriptor_set_samplers: Default::default(), + max_descriptor_set_uniform_buffers: Default::default(), + max_descriptor_set_uniform_buffers_dynamic: Default::default(), + max_descriptor_set_storage_buffers: Default::default(), + max_descriptor_set_storage_buffers_dynamic: Default::default(), + max_descriptor_set_sampled_images: Default::default(), + max_descriptor_set_storage_images: Default::default(), + max_descriptor_set_input_attachments: Default::default(), + max_vertex_input_attributes: Default::default(), + max_vertex_input_bindings: Default::default(), + max_vertex_input_attribute_offset: Default::default(), + max_vertex_input_binding_stride: Default::default(), + max_vertex_output_components: Default::default(), + max_tessellation_generation_level: Default::default(), + max_tessellation_patch_size: Default::default(), + max_tessellation_control_per_vertex_input_components: Default::default(), + max_tessellation_control_per_vertex_output_components: Default::default(), + max_tessellation_control_per_patch_output_components: Default::default(), + max_tessellation_control_total_output_components: Default::default(), + max_tessellation_evaluation_input_components: Default::default(), + max_tessellation_evaluation_output_components: Default::default(), + max_geometry_shader_invocations: Default::default(), + max_geometry_input_components: Default::default(), + max_geometry_output_components: Default::default(), + max_geometry_output_vertices: Default::default(), + max_geometry_total_output_components: Default::default(), + max_fragment_input_components: Default::default(), + max_fragment_output_attachments: Default::default(), + max_fragment_dual_src_attachments: Default::default(), + max_fragment_combined_output_resources: Default::default(), + max_compute_shared_memory_size: Default::default(), + max_compute_work_group_count: unsafe { core::mem::zeroed() }, + max_compute_work_group_invocations: Default::default(), + max_compute_work_group_size: unsafe { core::mem::zeroed() }, + sub_pixel_precision_bits: Default::default(), + sub_texel_precision_bits: Default::default(), + mipmap_precision_bits: Default::default(), + max_draw_indexed_index_value: Default::default(), + max_draw_indirect_count: Default::default(), + max_sampler_lod_bias: Default::default(), + max_sampler_anisotropy: Default::default(), + max_viewports: Default::default(), + max_viewport_dimensions: unsafe { core::mem::zeroed() }, + viewport_bounds_range: unsafe { core::mem::zeroed() }, + viewport_sub_pixel_bits: Default::default(), + min_memory_map_alignment: Default::default(), + min_texel_buffer_offset_alignment: Default::default(), + min_uniform_buffer_offset_alignment: Default::default(), + min_storage_buffer_offset_alignment: Default::default(), + min_texel_offset: Default::default(), + max_texel_offset: Default::default(), + min_texel_gather_offset: Default::default(), + max_texel_gather_offset: Default::default(), + min_interpolation_offset: Default::default(), + max_interpolation_offset: Default::default(), + sub_pixel_interpolation_offset_bits: Default::default(), + max_framebuffer_width: Default::default(), + max_framebuffer_height: Default::default(), + max_framebuffer_layers: Default::default(), + framebuffer_color_sample_counts: Default::default(), + framebuffer_depth_sample_counts: Default::default(), + framebuffer_stencil_sample_counts: Default::default(), + framebuffer_no_attachments_sample_counts: Default::default(), + max_color_attachments: Default::default(), + sampled_image_color_sample_counts: Default::default(), + sampled_image_integer_sample_counts: Default::default(), + sampled_image_depth_sample_counts: Default::default(), + sampled_image_stencil_sample_counts: Default::default(), + storage_image_sample_counts: Default::default(), + max_sample_mask_words: Default::default(), + timestamp_compute_and_graphics: Default::default(), + timestamp_period: Default::default(), + max_clip_distances: Default::default(), + max_cull_distances: Default::default(), + max_combined_clip_and_cull_distances: Default::default(), + discrete_queue_priorities: Default::default(), + point_size_range: unsafe { core::mem::zeroed() }, + line_width_range: unsafe { core::mem::zeroed() }, + point_size_granularity: Default::default(), + line_width_granularity: Default::default(), + strict_lines: Default::default(), + standard_sample_locations: Default::default(), + optimal_buffer_copy_offset_alignment: Default::default(), + optimal_buffer_copy_row_pitch_alignment: Default::default(), + non_coherent_atom_size: Default::default(), + } + } + } + impl PhysicalDeviceLimits { + pub fn max_image_dimension1_d(mut self, max_image_dimension1_d: u32) -> Self { + self.max_image_dimension1_d = max_image_dimension1_d; + self + } + pub fn max_image_dimension2_d(mut self, max_image_dimension2_d: u32) -> Self { + self.max_image_dimension2_d = max_image_dimension2_d; + self + } + pub fn max_image_dimension3_d(mut self, max_image_dimension3_d: u32) -> Self { + self.max_image_dimension3_d = max_image_dimension3_d; + self + } + pub fn max_image_dimension_cube( + mut self, + max_image_dimension_cube: u32, + ) -> Self { + self.max_image_dimension_cube = max_image_dimension_cube; + self + } + pub fn max_image_array_layers(mut self, max_image_array_layers: u32) -> Self { + self.max_image_array_layers = max_image_array_layers; + self + } + pub fn max_texel_buffer_elements( + mut self, + max_texel_buffer_elements: u32, + ) -> Self { + self.max_texel_buffer_elements = max_texel_buffer_elements; + self + } + pub fn max_uniform_buffer_range( + mut self, + max_uniform_buffer_range: u32, + ) -> Self { + self.max_uniform_buffer_range = max_uniform_buffer_range; + self + } + pub fn max_storage_buffer_range( + mut self, + max_storage_buffer_range: u32, + ) -> Self { + self.max_storage_buffer_range = max_storage_buffer_range; + self + } + pub fn max_push_constants_size(mut self, max_push_constants_size: u32) -> Self { + self.max_push_constants_size = max_push_constants_size; + self + } + pub fn max_memory_allocation_count( + mut self, + max_memory_allocation_count: u32, + ) -> Self { + self.max_memory_allocation_count = max_memory_allocation_count; + self + } + pub fn max_sampler_allocation_count( + mut self, + max_sampler_allocation_count: u32, + ) -> Self { + self.max_sampler_allocation_count = max_sampler_allocation_count; + self + } + pub fn buffer_image_granularity( + mut self, + buffer_image_granularity: crate::vk::DeviceSize, + ) -> Self { + self.buffer_image_granularity = buffer_image_granularity; + self + } + pub fn sparse_address_space_size( + mut self, + sparse_address_space_size: crate::vk::DeviceSize, + ) -> Self { + self.sparse_address_space_size = sparse_address_space_size; + self + } + pub fn max_bound_descriptor_sets( + mut self, + max_bound_descriptor_sets: u32, + ) -> Self { + self.max_bound_descriptor_sets = max_bound_descriptor_sets; + self + } + pub fn max_per_stage_descriptor_samplers( + mut self, + max_per_stage_descriptor_samplers: u32, + ) -> Self { + self.max_per_stage_descriptor_samplers = max_per_stage_descriptor_samplers; + self + } + pub fn max_per_stage_descriptor_uniform_buffers( + mut self, + max_per_stage_descriptor_uniform_buffers: u32, + ) -> Self { + self.max_per_stage_descriptor_uniform_buffers = max_per_stage_descriptor_uniform_buffers; + self + } + pub fn max_per_stage_descriptor_storage_buffers( + mut self, + max_per_stage_descriptor_storage_buffers: u32, + ) -> Self { + self.max_per_stage_descriptor_storage_buffers = max_per_stage_descriptor_storage_buffers; + self + } + pub fn max_per_stage_descriptor_sampled_images( + mut self, + max_per_stage_descriptor_sampled_images: u32, + ) -> Self { + self.max_per_stage_descriptor_sampled_images = max_per_stage_descriptor_sampled_images; + self + } + pub fn max_per_stage_descriptor_storage_images( + mut self, + max_per_stage_descriptor_storage_images: u32, + ) -> Self { + self.max_per_stage_descriptor_storage_images = max_per_stage_descriptor_storage_images; + self + } + pub fn max_per_stage_descriptor_input_attachments( + mut self, + max_per_stage_descriptor_input_attachments: u32, + ) -> Self { + self.max_per_stage_descriptor_input_attachments = max_per_stage_descriptor_input_attachments; + self + } + pub fn max_per_stage_resources(mut self, max_per_stage_resources: u32) -> Self { + self.max_per_stage_resources = max_per_stage_resources; + self + } + pub fn max_descriptor_set_samplers( + mut self, + max_descriptor_set_samplers: u32, + ) -> Self { + self.max_descriptor_set_samplers = max_descriptor_set_samplers; + self + } + pub fn max_descriptor_set_uniform_buffers( + mut self, + max_descriptor_set_uniform_buffers: u32, + ) -> Self { + self.max_descriptor_set_uniform_buffers = max_descriptor_set_uniform_buffers; + self + } + pub fn max_descriptor_set_uniform_buffers_dynamic( + mut self, + max_descriptor_set_uniform_buffers_dynamic: u32, + ) -> Self { + self.max_descriptor_set_uniform_buffers_dynamic = max_descriptor_set_uniform_buffers_dynamic; + self + } + pub fn max_descriptor_set_storage_buffers( + mut self, + max_descriptor_set_storage_buffers: u32, + ) -> Self { + self.max_descriptor_set_storage_buffers = max_descriptor_set_storage_buffers; + self + } + pub fn max_descriptor_set_storage_buffers_dynamic( + mut self, + max_descriptor_set_storage_buffers_dynamic: u32, + ) -> Self { + self.max_descriptor_set_storage_buffers_dynamic = max_descriptor_set_storage_buffers_dynamic; + self + } + pub fn max_descriptor_set_sampled_images( + mut self, + max_descriptor_set_sampled_images: u32, + ) -> Self { + self.max_descriptor_set_sampled_images = max_descriptor_set_sampled_images; + self + } + pub fn max_descriptor_set_storage_images( + mut self, + max_descriptor_set_storage_images: u32, + ) -> Self { + self.max_descriptor_set_storage_images = max_descriptor_set_storage_images; + self + } + pub fn max_descriptor_set_input_attachments( + mut self, + max_descriptor_set_input_attachments: u32, + ) -> Self { + self.max_descriptor_set_input_attachments = max_descriptor_set_input_attachments; + self + } + pub fn max_vertex_input_attributes( + mut self, + max_vertex_input_attributes: u32, + ) -> Self { + self.max_vertex_input_attributes = max_vertex_input_attributes; + self + } + pub fn max_vertex_input_bindings( + mut self, + max_vertex_input_bindings: u32, + ) -> Self { + self.max_vertex_input_bindings = max_vertex_input_bindings; + self + } + pub fn max_vertex_input_attribute_offset( + mut self, + max_vertex_input_attribute_offset: u32, + ) -> Self { + self.max_vertex_input_attribute_offset = max_vertex_input_attribute_offset; + self + } + pub fn max_vertex_input_binding_stride( + mut self, + max_vertex_input_binding_stride: u32, + ) -> Self { + self.max_vertex_input_binding_stride = max_vertex_input_binding_stride; + self + } + pub fn max_vertex_output_components( + mut self, + max_vertex_output_components: u32, + ) -> Self { + self.max_vertex_output_components = max_vertex_output_components; + self + } + pub fn max_tessellation_generation_level( + mut self, + max_tessellation_generation_level: u32, + ) -> Self { + self.max_tessellation_generation_level = max_tessellation_generation_level; + self + } + pub fn max_tessellation_patch_size( + mut self, + max_tessellation_patch_size: u32, + ) -> Self { + self.max_tessellation_patch_size = max_tessellation_patch_size; + self + } + pub fn max_tessellation_control_per_vertex_input_components( + mut self, + max_tessellation_control_per_vertex_input_components: u32, + ) -> Self { + self.max_tessellation_control_per_vertex_input_components = max_tessellation_control_per_vertex_input_components; + self + } + pub fn max_tessellation_control_per_vertex_output_components( + mut self, + max_tessellation_control_per_vertex_output_components: u32, + ) -> Self { + self.max_tessellation_control_per_vertex_output_components = max_tessellation_control_per_vertex_output_components; + self + } + pub fn max_tessellation_control_per_patch_output_components( + mut self, + max_tessellation_control_per_patch_output_components: u32, + ) -> Self { + self.max_tessellation_control_per_patch_output_components = max_tessellation_control_per_patch_output_components; + self + } + pub fn max_tessellation_control_total_output_components( + mut self, + max_tessellation_control_total_output_components: u32, + ) -> Self { + self.max_tessellation_control_total_output_components = max_tessellation_control_total_output_components; + self + } + pub fn max_tessellation_evaluation_input_components( + mut self, + max_tessellation_evaluation_input_components: u32, + ) -> Self { + self.max_tessellation_evaluation_input_components = max_tessellation_evaluation_input_components; + self + } + pub fn max_tessellation_evaluation_output_components( + mut self, + max_tessellation_evaluation_output_components: u32, + ) -> Self { + self.max_tessellation_evaluation_output_components = max_tessellation_evaluation_output_components; + self + } + pub fn max_geometry_shader_invocations( + mut self, + max_geometry_shader_invocations: u32, + ) -> Self { + self.max_geometry_shader_invocations = max_geometry_shader_invocations; + self + } + pub fn max_geometry_input_components( + mut self, + max_geometry_input_components: u32, + ) -> Self { + self.max_geometry_input_components = max_geometry_input_components; + self + } + pub fn max_geometry_output_components( + mut self, + max_geometry_output_components: u32, + ) -> Self { + self.max_geometry_output_components = max_geometry_output_components; + self + } + pub fn max_geometry_output_vertices( + mut self, + max_geometry_output_vertices: u32, + ) -> Self { + self.max_geometry_output_vertices = max_geometry_output_vertices; + self + } + pub fn max_geometry_total_output_components( + mut self, + max_geometry_total_output_components: u32, + ) -> Self { + self.max_geometry_total_output_components = max_geometry_total_output_components; + self + } + pub fn max_fragment_input_components( + mut self, + max_fragment_input_components: u32, + ) -> Self { + self.max_fragment_input_components = max_fragment_input_components; + self + } + pub fn max_fragment_output_attachments( + mut self, + max_fragment_output_attachments: u32, + ) -> Self { + self.max_fragment_output_attachments = max_fragment_output_attachments; + self + } + pub fn max_fragment_dual_src_attachments( + mut self, + max_fragment_dual_src_attachments: u32, + ) -> Self { + self.max_fragment_dual_src_attachments = max_fragment_dual_src_attachments; + self + } + pub fn max_fragment_combined_output_resources( + mut self, + max_fragment_combined_output_resources: u32, + ) -> Self { + self.max_fragment_combined_output_resources = max_fragment_combined_output_resources; + self + } + pub fn max_compute_shared_memory_size( + mut self, + max_compute_shared_memory_size: u32, + ) -> Self { + self.max_compute_shared_memory_size = max_compute_shared_memory_size; + self + } + pub fn max_compute_work_group_count( + mut self, + max_compute_work_group_count: [u32; 3 as _], + ) -> Self { + self.max_compute_work_group_count = max_compute_work_group_count; + self + } + pub fn max_compute_work_group_invocations( + mut self, + max_compute_work_group_invocations: u32, + ) -> Self { + self.max_compute_work_group_invocations = max_compute_work_group_invocations; + self + } + pub fn max_compute_work_group_size( + mut self, + max_compute_work_group_size: [u32; 3 as _], + ) -> Self { + self.max_compute_work_group_size = max_compute_work_group_size; + self + } + pub fn sub_pixel_precision_bits( + mut self, + sub_pixel_precision_bits: u32, + ) -> Self { + self.sub_pixel_precision_bits = sub_pixel_precision_bits; + self + } + pub fn sub_texel_precision_bits( + mut self, + sub_texel_precision_bits: u32, + ) -> Self { + self.sub_texel_precision_bits = sub_texel_precision_bits; + self + } + pub fn mipmap_precision_bits(mut self, mipmap_precision_bits: u32) -> Self { + self.mipmap_precision_bits = mipmap_precision_bits; + self + } + pub fn max_draw_indexed_index_value( + mut self, + max_draw_indexed_index_value: u32, + ) -> Self { + self.max_draw_indexed_index_value = max_draw_indexed_index_value; + self + } + pub fn max_draw_indirect_count(mut self, max_draw_indirect_count: u32) -> Self { + self.max_draw_indirect_count = max_draw_indirect_count; + self + } + pub fn max_sampler_lod_bias( + mut self, + max_sampler_lod_bias: core::ffi::c_float, + ) -> Self { + self.max_sampler_lod_bias = max_sampler_lod_bias; + self + } + pub fn max_sampler_anisotropy( + mut self, + max_sampler_anisotropy: core::ffi::c_float, + ) -> Self { + self.max_sampler_anisotropy = max_sampler_anisotropy; + self + } + pub fn max_viewports(mut self, max_viewports: u32) -> Self { + self.max_viewports = max_viewports; + self + } + pub fn max_viewport_dimensions( + mut self, + max_viewport_dimensions: [u32; 2 as _], + ) -> Self { + self.max_viewport_dimensions = max_viewport_dimensions; + self + } + pub fn viewport_bounds_range( + mut self, + viewport_bounds_range: [core::ffi::c_float; 2 as _], + ) -> Self { + self.viewport_bounds_range = viewport_bounds_range; + self + } + pub fn viewport_sub_pixel_bits(mut self, viewport_sub_pixel_bits: u32) -> Self { + self.viewport_sub_pixel_bits = viewport_sub_pixel_bits; + self + } + pub fn min_memory_map_alignment( + mut self, + min_memory_map_alignment: usize, + ) -> Self { + self.min_memory_map_alignment = min_memory_map_alignment; + self + } + pub fn min_texel_buffer_offset_alignment( + mut self, + min_texel_buffer_offset_alignment: crate::vk::DeviceSize, + ) -> Self { + self.min_texel_buffer_offset_alignment = min_texel_buffer_offset_alignment; + self + } + pub fn min_uniform_buffer_offset_alignment( + mut self, + min_uniform_buffer_offset_alignment: crate::vk::DeviceSize, + ) -> Self { + self.min_uniform_buffer_offset_alignment = min_uniform_buffer_offset_alignment; + self + } + pub fn min_storage_buffer_offset_alignment( + mut self, + min_storage_buffer_offset_alignment: crate::vk::DeviceSize, + ) -> Self { + self.min_storage_buffer_offset_alignment = min_storage_buffer_offset_alignment; + self + } + pub fn min_texel_offset(mut self, min_texel_offset: i32) -> Self { + self.min_texel_offset = min_texel_offset; + self + } + pub fn max_texel_offset(mut self, max_texel_offset: u32) -> Self { + self.max_texel_offset = max_texel_offset; + self + } + pub fn min_texel_gather_offset(mut self, min_texel_gather_offset: i32) -> Self { + self.min_texel_gather_offset = min_texel_gather_offset; + self + } + pub fn max_texel_gather_offset(mut self, max_texel_gather_offset: u32) -> Self { + self.max_texel_gather_offset = max_texel_gather_offset; + self + } + pub fn min_interpolation_offset( + mut self, + min_interpolation_offset: core::ffi::c_float, + ) -> Self { + self.min_interpolation_offset = min_interpolation_offset; + self + } + pub fn max_interpolation_offset( + mut self, + max_interpolation_offset: core::ffi::c_float, + ) -> Self { + self.max_interpolation_offset = max_interpolation_offset; + self + } + pub fn sub_pixel_interpolation_offset_bits( + mut self, + sub_pixel_interpolation_offset_bits: u32, + ) -> Self { + self.sub_pixel_interpolation_offset_bits = sub_pixel_interpolation_offset_bits; + self + } + pub fn max_framebuffer_width(mut self, max_framebuffer_width: u32) -> Self { + self.max_framebuffer_width = max_framebuffer_width; + self + } + pub fn max_framebuffer_height(mut self, max_framebuffer_height: u32) -> Self { + self.max_framebuffer_height = max_framebuffer_height; + self + } + pub fn max_framebuffer_layers(mut self, max_framebuffer_layers: u32) -> Self { + self.max_framebuffer_layers = max_framebuffer_layers; + self + } + pub fn framebuffer_color_sample_counts( + mut self, + framebuffer_color_sample_counts: crate::vk::SampleCountFlags, + ) -> Self { + self.framebuffer_color_sample_counts = framebuffer_color_sample_counts; + self + } + pub fn framebuffer_depth_sample_counts( + mut self, + framebuffer_depth_sample_counts: crate::vk::SampleCountFlags, + ) -> Self { + self.framebuffer_depth_sample_counts = framebuffer_depth_sample_counts; + self + } + pub fn framebuffer_stencil_sample_counts( + mut self, + framebuffer_stencil_sample_counts: crate::vk::SampleCountFlags, + ) -> Self { + self.framebuffer_stencil_sample_counts = framebuffer_stencil_sample_counts; + self + } + pub fn framebuffer_no_attachments_sample_counts( + mut self, + framebuffer_no_attachments_sample_counts: crate::vk::SampleCountFlags, + ) -> Self { + self.framebuffer_no_attachments_sample_counts = framebuffer_no_attachments_sample_counts; + self + } + pub fn max_color_attachments(mut self, max_color_attachments: u32) -> Self { + self.max_color_attachments = max_color_attachments; + self + } + pub fn sampled_image_color_sample_counts( + mut self, + sampled_image_color_sample_counts: crate::vk::SampleCountFlags, + ) -> Self { + self.sampled_image_color_sample_counts = sampled_image_color_sample_counts; + self + } + pub fn sampled_image_integer_sample_counts( + mut self, + sampled_image_integer_sample_counts: crate::vk::SampleCountFlags, + ) -> Self { + self.sampled_image_integer_sample_counts = sampled_image_integer_sample_counts; + self + } + pub fn sampled_image_depth_sample_counts( + mut self, + sampled_image_depth_sample_counts: crate::vk::SampleCountFlags, + ) -> Self { + self.sampled_image_depth_sample_counts = sampled_image_depth_sample_counts; + self + } + pub fn sampled_image_stencil_sample_counts( + mut self, + sampled_image_stencil_sample_counts: crate::vk::SampleCountFlags, + ) -> Self { + self.sampled_image_stencil_sample_counts = sampled_image_stencil_sample_counts; + self + } + pub fn storage_image_sample_counts( + mut self, + storage_image_sample_counts: crate::vk::SampleCountFlags, + ) -> Self { + self.storage_image_sample_counts = storage_image_sample_counts; + self + } + pub fn max_sample_mask_words(mut self, max_sample_mask_words: u32) -> Self { + self.max_sample_mask_words = max_sample_mask_words; + self + } + pub fn timestamp_compute_and_graphics( + mut self, + timestamp_compute_and_graphics: bool, + ) -> Self { + self.timestamp_compute_and_graphics = timestamp_compute_and_graphics.into(); + self + } + pub fn timestamp_period(mut self, timestamp_period: core::ffi::c_float) -> Self { + self.timestamp_period = timestamp_period; + self + } + pub fn max_clip_distances(mut self, max_clip_distances: u32) -> Self { + self.max_clip_distances = max_clip_distances; + self + } + pub fn max_cull_distances(mut self, max_cull_distances: u32) -> Self { + self.max_cull_distances = max_cull_distances; + self + } + pub fn max_combined_clip_and_cull_distances( + mut self, + max_combined_clip_and_cull_distances: u32, + ) -> Self { + self.max_combined_clip_and_cull_distances = max_combined_clip_and_cull_distances; + self + } + pub fn discrete_queue_priorities( + mut self, + discrete_queue_priorities: u32, + ) -> Self { + self.discrete_queue_priorities = discrete_queue_priorities; + self + } + pub fn point_size_range( + mut self, + point_size_range: [core::ffi::c_float; 2 as _], + ) -> Self { + self.point_size_range = point_size_range; + self + } + pub fn line_width_range( + mut self, + line_width_range: [core::ffi::c_float; 2 as _], + ) -> Self { + self.line_width_range = line_width_range; + self + } + pub fn point_size_granularity( + mut self, + point_size_granularity: core::ffi::c_float, + ) -> Self { + self.point_size_granularity = point_size_granularity; + self + } + pub fn line_width_granularity( + mut self, + line_width_granularity: core::ffi::c_float, + ) -> Self { + self.line_width_granularity = line_width_granularity; + self + } + pub fn strict_lines(mut self, strict_lines: bool) -> Self { + self.strict_lines = strict_lines.into(); + self + } + pub fn standard_sample_locations( + mut self, + standard_sample_locations: bool, + ) -> Self { + self.standard_sample_locations = standard_sample_locations.into(); + self + } + pub fn optimal_buffer_copy_offset_alignment( + mut self, + optimal_buffer_copy_offset_alignment: crate::vk::DeviceSize, + ) -> Self { + self.optimal_buffer_copy_offset_alignment = optimal_buffer_copy_offset_alignment; + self + } + pub fn optimal_buffer_copy_row_pitch_alignment( + mut self, + optimal_buffer_copy_row_pitch_alignment: crate::vk::DeviceSize, + ) -> Self { + self.optimal_buffer_copy_row_pitch_alignment = optimal_buffer_copy_row_pitch_alignment; + self + } + pub fn non_coherent_atom_size( + mut self, + non_coherent_atom_size: crate::vk::DeviceSize, + ) -> Self { + self.non_coherent_atom_size = non_coherent_atom_size; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct SemaphoreCreateInfo<'a> { @@ -3436,6 +8012,25 @@ pub(crate) mod reexport { pub flags: crate::vk::SemaphoreCreateFlags, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for SemaphoreCreateInfo<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::SEMAPHORE_CREATE_INFO; + } + impl<'a> Default for SemaphoreCreateInfo<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + flags: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> SemaphoreCreateInfo<'a> { + pub fn flags(mut self, flags: crate::vk::SemaphoreCreateFlags) -> Self { + self.flags = flags; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct QueryPoolCreateInfo<'a> { @@ -3447,6 +8042,43 @@ pub(crate) mod reexport { pub pipeline_statistics: crate::vk::QueryPipelineStatisticFlags, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for QueryPoolCreateInfo<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::QUERY_POOL_CREATE_INFO; + } + impl<'a> Default for QueryPoolCreateInfo<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + flags: Default::default(), + query_type: Default::default(), + query_count: Default::default(), + pipeline_statistics: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> QueryPoolCreateInfo<'a> { + pub fn flags(mut self, flags: crate::vk::QueryPoolCreateFlags) -> Self { + self.flags = flags; + self + } + pub fn query_type(mut self, query_type: crate::vk::QueryType) -> Self { + self.query_type = query_type; + self + } + pub fn query_count(mut self, query_count: u32) -> Self { + self.query_count = query_count; + self + } + pub fn pipeline_statistics( + mut self, + pipeline_statistics: crate::vk::QueryPipelineStatisticFlags, + ) -> Self { + self.pipeline_statistics = pipeline_statistics; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct FramebufferCreateInfo<'a> { @@ -3461,16 +8093,87 @@ pub(crate) mod reexport { pub layers: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for FramebufferCreateInfo<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::FRAMEBUFFER_CREATE_INFO; + } + impl<'a> Default for FramebufferCreateInfo<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + flags: Default::default(), + render_pass: Default::default(), + attachment_count: Default::default(), + p_attachments: Default::default(), + width: Default::default(), + height: Default::default(), + layers: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> FramebufferCreateInfo<'a> { + pub fn flags(mut self, flags: crate::vk::FramebufferCreateFlags) -> Self { + self.flags = flags; + self + } + pub fn render_pass(mut self, render_pass: crate::vk::RenderPass) -> Self { + self.render_pass = render_pass; + self + } + pub fn attachment_count(mut self, attachment_count: u32) -> Self { + self.attachment_count = attachment_count; + self + } + pub fn p_attachments( + mut self, + p_attachments: &'a [crate::vk::ImageView], + ) -> Self { + self.attachment_count = p_attachments.len() as _; + self.p_attachments = p_attachments.as_ptr(); + self + } + pub fn width(mut self, width: u32) -> Self { + self.width = width; + self + } + pub fn height(mut self, height: u32) -> Self { + self.height = height; + self + } + pub fn layers(mut self, layers: u32) -> Self { + self.layers = layers; + self + } + } #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct DrawIndirectCommand { pub vertex_count: u32, pub instance_count: u32, pub first_vertex: u32, pub first_instance: u32, } + impl DrawIndirectCommand { + pub fn vertex_count(mut self, vertex_count: u32) -> Self { + self.vertex_count = vertex_count; + self + } + pub fn instance_count(mut self, instance_count: u32) -> Self { + self.instance_count = instance_count; + self + } + pub fn first_vertex(mut self, first_vertex: u32) -> Self { + self.first_vertex = first_vertex; + self + } + pub fn first_instance(mut self, first_instance: u32) -> Self { + self.first_instance = first_instance; + self + } + } #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct DrawIndexedIndirectCommand { pub index_count: u32, pub instance_count: u32, @@ -3478,13 +8181,49 @@ pub(crate) mod reexport { pub vertex_offset: i32, pub first_instance: u32, } + impl DrawIndexedIndirectCommand { + pub fn index_count(mut self, index_count: u32) -> Self { + self.index_count = index_count; + self + } + pub fn instance_count(mut self, instance_count: u32) -> Self { + self.instance_count = instance_count; + self + } + pub fn first_index(mut self, first_index: u32) -> Self { + self.first_index = first_index; + self + } + pub fn vertex_offset(mut self, vertex_offset: i32) -> Self { + self.vertex_offset = vertex_offset; + self + } + pub fn first_instance(mut self, first_instance: u32) -> Self { + self.first_instance = first_instance; + self + } + } #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct DispatchIndirectCommand { pub x: u32, pub y: u32, pub z: u32, } + impl DispatchIndirectCommand { + pub fn x(mut self, x: u32) -> Self { + self.x = x; + self + } + pub fn y(mut self, y: u32) -> Self { + self.y = y; + self + } + pub fn z(mut self, z: u32) -> Self { + self.z = z; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct SubmitInfo<'a> { @@ -3499,6 +8238,71 @@ pub(crate) mod reexport { pub p_signal_semaphores: *const crate::vk::Semaphore, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for SubmitInfo<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::SUBMIT_INFO; + } + impl<'a> Default for SubmitInfo<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + wait_semaphore_count: Default::default(), + p_wait_semaphores: Default::default(), + p_wait_dst_stage_mask: Default::default(), + command_buffer_count: Default::default(), + p_command_buffers: Default::default(), + signal_semaphore_count: Default::default(), + p_signal_semaphores: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> SubmitInfo<'a> { + pub fn wait_semaphore_count(mut self, wait_semaphore_count: u32) -> Self { + self.wait_semaphore_count = wait_semaphore_count; + self + } + pub fn p_wait_semaphores( + mut self, + p_wait_semaphores: &'a [crate::vk::Semaphore], + ) -> Self { + self.wait_semaphore_count = p_wait_semaphores.len() as _; + self.p_wait_semaphores = p_wait_semaphores.as_ptr(); + self + } + pub fn p_wait_dst_stage_mask( + mut self, + p_wait_dst_stage_mask: &'a [crate::vk::PipelineStageFlags], + ) -> Self { + self.wait_semaphore_count = p_wait_dst_stage_mask.len() as _; + self.p_wait_dst_stage_mask = p_wait_dst_stage_mask.as_ptr(); + self + } + pub fn command_buffer_count(mut self, command_buffer_count: u32) -> Self { + self.command_buffer_count = command_buffer_count; + self + } + pub fn p_command_buffers( + mut self, + p_command_buffers: &'a [crate::vk::CommandBuffer], + ) -> Self { + self.command_buffer_count = p_command_buffers.len() as _; + self.p_command_buffers = p_command_buffers.as_ptr(); + self + } + pub fn signal_semaphore_count(mut self, signal_semaphore_count: u32) -> Self { + self.signal_semaphore_count = signal_semaphore_count; + self + } + pub fn p_signal_semaphores( + mut self, + p_signal_semaphores: &'a [crate::vk::Semaphore], + ) -> Self { + self.signal_semaphore_count = p_signal_semaphores.len() as _; + self.p_signal_semaphores = p_signal_semaphores.as_ptr(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub union ClearColorValue { @@ -3506,12 +8310,22 @@ pub(crate) mod reexport { pub int32: [i32; 4 as _], pub uint32: [u32; 4 as _], } + impl Default for ClearColorValue { + fn default() -> Self { + unsafe { core::mem::zeroed() } + } + } #[repr(C)] #[derive(Clone, Copy)] pub union ClearValue { pub color: crate::vk::ClearColorValue, pub depth_stencil: crate::vk::ClearDepthStencilValue, } + impl Default for ClearValue { + fn default() -> Self { + unsafe { core::mem::zeroed() } + } + } #[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[derive(Debug)] @@ -4591,7 +9405,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct FramebufferCreateFlagBits(pub(crate) u32); #[repr(transparent)] #[derive(Clone, Copy)] @@ -4662,7 +9476,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct QueryPoolCreateFlagBits(pub(crate) u32); #[repr(transparent)] #[derive(Clone, Copy)] @@ -4738,7 +9552,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct RenderPassCreateFlagBits(pub(crate) u32); #[repr(transparent)] #[derive(Clone, Copy)] @@ -4821,7 +9635,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct SamplerCreateFlagBits(pub(crate) u32); #[repr(transparent)] #[derive(Clone, Copy)] @@ -4897,7 +9711,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct PipelineLayoutCreateFlagBits(pub(crate) u32); #[repr(transparent)] #[derive(Clone, Copy)] @@ -4976,7 +9790,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct PipelineCacheCreateFlagBits(pub(crate) u32); #[repr(transparent)] #[derive(Clone, Copy)] @@ -5062,7 +9876,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct PipelineDepthStencilStateCreateFlagBits(pub(crate) u32); #[repr(transparent)] #[derive(Clone, Copy)] @@ -5207,7 +10021,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct PipelineColorBlendStateCreateFlagBits(pub(crate) u32); #[repr(transparent)] #[derive(Clone, Copy)] @@ -5691,7 +10505,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct PipelineShaderStageCreateFlagBits(pub(crate) u32); #[repr(transparent)] #[derive(Clone, Copy)] @@ -5791,7 +10605,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct DescriptorSetLayoutCreateFlagBits(pub(crate) u32); #[repr(transparent)] #[derive(Clone, Copy)] @@ -5931,7 +10745,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct InstanceCreateFlagBits(pub(crate) u32); #[repr(transparent)] #[derive(Clone, Copy)] @@ -6072,7 +10886,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct DeviceQueueCreateFlagBits(pub(crate) u32); #[repr(transparent)] #[derive(Clone, Copy)] @@ -6151,7 +10965,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct QueueFlagBits(pub(crate) u32); ///Provided by [`vk1_0`](crate::vk1_0) impl QueueFlagBits { @@ -6245,7 +11059,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct MemoryPropertyFlagBits(pub(crate) u32); ///Provided by [`vk1_0`](crate::vk1_0) impl MemoryPropertyFlagBits { @@ -6329,7 +11143,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct MemoryHeapFlagBits(pub(crate) u32); ///Provided by [`vk1_0`](crate::vk1_0) impl MemoryHeapFlagBits { @@ -6484,7 +11298,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct AccessFlagBits(pub(crate) u32); ///Provided by [`vk1_0`](crate::vk1_0) impl AccessFlagBits { @@ -6649,7 +11463,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct BufferUsageFlagBits(pub(crate) u32); ///Provided by [`vk1_0`](crate::vk1_0) impl BufferUsageFlagBits { @@ -6752,7 +11566,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct BufferCreateFlagBits(pub(crate) u32); ///Provided by [`vk1_0`](crate::vk1_0) impl BufferCreateFlagBits { @@ -6862,7 +11676,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct ShaderStageFlagBits(pub(crate) u32); ///Provided by [`vk1_0`](crate::vk1_0) impl ShaderStageFlagBits { @@ -7008,7 +11822,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct ImageUsageFlagBits(pub(crate) u32); ///Provided by [`vk1_0`](crate::vk1_0) impl ImageUsageFlagBits { @@ -7152,7 +11966,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct ImageCreateFlagBits(pub(crate) u32); ///Provided by [`vk1_0`](crate::vk1_0) impl ImageCreateFlagBits { @@ -7239,7 +12053,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct ImageViewCreateFlagBits(pub(crate) u32); #[repr(transparent)] #[derive(Clone, Copy)] @@ -7414,7 +12228,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct PipelineCreateFlagBits(pub(crate) u32); ///Provided by [`vk1_0`](crate::vk1_0) impl PipelineCreateFlagBits { @@ -7494,7 +12308,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct ColorComponentFlagBits(pub(crate) u32); ///Provided by [`vk1_0`](crate::vk1_0) impl ColorComponentFlagBits { @@ -7572,7 +12386,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct FenceCreateFlagBits(pub(crate) u32); ///Provided by [`vk1_0`](crate::vk1_0) impl FenceCreateFlagBits { @@ -7827,7 +12641,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct FormatFeatureFlagBits(pub(crate) u32); ///Provided by [`vk1_0`](crate::vk1_0) impl FormatFeatureFlagBits { @@ -7914,7 +12728,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct QueryControlFlagBits(pub(crate) u32); ///Provided by [`vk1_0`](crate::vk1_0) impl QueryControlFlagBits { @@ -7995,7 +12809,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct QueryResultFlagBits(pub(crate) u32); ///Provided by [`vk1_0`](crate::vk1_0) impl QueryResultFlagBits { @@ -8141,7 +12955,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct EventCreateFlagBits(pub(crate) u32); #[repr(transparent)] #[derive(Clone, Copy)] @@ -8216,7 +13030,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct CommandPoolCreateFlagBits(pub(crate) u32); ///Provided by [`vk1_0`](crate::vk1_0) impl CommandPoolCreateFlagBits { @@ -8294,7 +13108,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct CommandPoolResetFlagBits(pub(crate) u32); ///Provided by [`vk1_0`](crate::vk1_0) impl CommandPoolResetFlagBits { @@ -8371,7 +13185,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct CommandBufferResetFlagBits(pub(crate) u32); ///Provided by [`vk1_0`](crate::vk1_0) impl CommandBufferResetFlagBits { @@ -8454,7 +13268,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct CommandBufferUsageFlagBits(pub(crate) u32); ///Provided by [`vk1_0`](crate::vk1_0) impl CommandBufferUsageFlagBits { @@ -8572,7 +13386,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct QueryPipelineStatisticFlagBits(pub(crate) u32); ///Provided by [`vk1_0`](crate::vk1_0) impl QueryPipelineStatisticFlagBits { @@ -8657,7 +13471,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct MemoryMapFlagBits(pub(crate) u32); #[repr(transparent)] #[derive(Clone, Copy)] @@ -8751,7 +13565,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct ImageAspectFlagBits(pub(crate) u32); ///Provided by [`vk1_0`](crate::vk1_0) impl ImageAspectFlagBits { @@ -8829,7 +13643,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct SparseMemoryBindFlagBits(pub(crate) u32); ///Provided by [`vk1_0`](crate::vk1_0) impl SparseMemoryBindFlagBits { @@ -8912,7 +13726,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct SparseImageFormatFlagBits(pub(crate) u32); ///Provided by [`vk1_0`](crate::vk1_0) impl SparseImageFormatFlagBits { @@ -9032,7 +13846,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct SubpassDescriptionFlagBits(pub(crate) u32); #[repr(transparent)] #[derive(Clone, Copy)] @@ -9168,7 +13982,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct PipelineStageFlagBits(pub(crate) u32); ///Provided by [`vk1_0`](crate::vk1_0) impl PipelineStageFlagBits { @@ -9265,7 +14079,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct SampleCountFlagBits(pub(crate) u32); ///Provided by [`vk1_0`](crate::vk1_0) impl SampleCountFlagBits { @@ -9352,7 +14166,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct AttachmentDescriptionFlagBits(pub(crate) u32); ///Provided by [`vk1_0`](crate::vk1_0) impl AttachmentDescriptionFlagBits { @@ -9429,7 +14243,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct StencilFaceFlagBits(pub(crate) u32); ///Provided by [`vk1_0`](crate::vk1_0) impl StencilFaceFlagBits { @@ -9509,7 +14323,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct CullModeFlagBits(pub(crate) u32); ///Provided by [`vk1_0`](crate::vk1_0) impl CullModeFlagBits { @@ -9607,7 +14421,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct DescriptorPoolCreateFlagBits(pub(crate) u32); ///Provided by [`vk1_0`](crate::vk1_0) impl DescriptorPoolCreateFlagBits { @@ -9762,7 +14576,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct DependencyFlagBits(pub(crate) u32); ///Provided by [`vk1_0`](crate::vk1_0) impl DependencyFlagBits { diff --git a/ash-rewrite/src/generated/vk1_1.rs b/ash-rewrite/src/generated/vk1_1.rs index 02d3274da..818f528d5 100644 --- a/ash-rewrite/src/generated/vk1_1.rs +++ b/ash-rewrite/src/generated/vk1_1.rs @@ -521,6 +521,27 @@ pub(crate) mod reexport { pub features: crate::vk::PhysicalDeviceFeatures, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for PhysicalDeviceFeatures2<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_FEATURES_2; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceFeatures2<'a> {} + impl<'a> Default for PhysicalDeviceFeatures2<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + features: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceFeatures2<'a> { + pub fn features(mut self, features: crate::vk::PhysicalDeviceFeatures) -> Self { + self.features = features; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceProperties2<'a> { @@ -529,6 +550,28 @@ pub(crate) mod reexport { pub properties: crate::vk::PhysicalDeviceProperties, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for PhysicalDeviceProperties2<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_PROPERTIES_2; + } + impl<'a> Default for PhysicalDeviceProperties2<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + properties: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceProperties2<'a> { + pub fn properties( + mut self, + properties: crate::vk::PhysicalDeviceProperties, + ) -> Self { + self.properties = properties; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct FormatProperties2<'a> { @@ -537,6 +580,28 @@ pub(crate) mod reexport { pub format_properties: crate::vk::FormatProperties, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for FormatProperties2<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::FORMAT_PROPERTIES_2; + } + impl<'a> Default for FormatProperties2<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + format_properties: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> FormatProperties2<'a> { + pub fn format_properties( + mut self, + format_properties: crate::vk::FormatProperties, + ) -> Self { + self.format_properties = format_properties; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct ImageFormatProperties2<'a> { @@ -545,6 +610,28 @@ pub(crate) mod reexport { pub image_format_properties: crate::vk::ImageFormatProperties, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for ImageFormatProperties2<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::IMAGE_FORMAT_PROPERTIES_2; + } + impl<'a> Default for ImageFormatProperties2<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + image_format_properties: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> ImageFormatProperties2<'a> { + pub fn image_format_properties( + mut self, + image_format_properties: crate::vk::ImageFormatProperties, + ) -> Self { + self.image_format_properties = image_format_properties; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceImageFormatInfo2<'a> { @@ -557,6 +644,45 @@ pub(crate) mod reexport { pub flags: crate::vk::ImageCreateFlags, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for PhysicalDeviceImageFormatInfo2<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2; + } + impl<'a> Default for PhysicalDeviceImageFormatInfo2<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + format: Default::default(), + _type: Default::default(), + tiling: Default::default(), + usage: Default::default(), + flags: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceImageFormatInfo2<'a> { + pub fn format(mut self, format: crate::vk::Format) -> Self { + self.format = format; + self + } + pub fn _type(mut self, _type: crate::vk::ImageType) -> Self { + self._type = _type; + self + } + pub fn tiling(mut self, tiling: crate::vk::ImageTiling) -> Self { + self.tiling = tiling; + self + } + pub fn usage(mut self, usage: crate::vk::ImageUsageFlags) -> Self { + self.usage = usage; + self + } + pub fn flags(mut self, flags: crate::vk::ImageCreateFlags) -> Self { + self.flags = flags; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct QueueFamilyProperties2<'a> { @@ -565,6 +691,28 @@ pub(crate) mod reexport { pub queue_family_properties: crate::vk::QueueFamilyProperties, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for QueueFamilyProperties2<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::QUEUE_FAMILY_PROPERTIES_2; + } + impl<'a> Default for QueueFamilyProperties2<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + queue_family_properties: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> QueueFamilyProperties2<'a> { + pub fn queue_family_properties( + mut self, + queue_family_properties: crate::vk::QueueFamilyProperties, + ) -> Self { + self.queue_family_properties = queue_family_properties; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceMemoryProperties2<'a> { @@ -573,6 +721,28 @@ pub(crate) mod reexport { pub memory_properties: crate::vk::PhysicalDeviceMemoryProperties, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for PhysicalDeviceMemoryProperties2<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_MEMORY_PROPERTIES_2; + } + impl<'a> Default for PhysicalDeviceMemoryProperties2<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + memory_properties: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceMemoryProperties2<'a> { + pub fn memory_properties( + mut self, + memory_properties: crate::vk::PhysicalDeviceMemoryProperties, + ) -> Self { + self.memory_properties = memory_properties; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct SparseImageFormatProperties2<'a> { @@ -581,6 +751,28 @@ pub(crate) mod reexport { pub properties: crate::vk::SparseImageFormatProperties, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for SparseImageFormatProperties2<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::SPARSE_IMAGE_FORMAT_PROPERTIES_2; + } + impl<'a> Default for SparseImageFormatProperties2<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + properties: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> SparseImageFormatProperties2<'a> { + pub fn properties( + mut self, + properties: crate::vk::SparseImageFormatProperties, + ) -> Self { + self.properties = properties; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceSparseImageFormatInfo2<'a> { @@ -593,6 +785,46 @@ pub(crate) mod reexport { pub tiling: crate::vk::ImageTiling, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceSparseImageFormatInfo2<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2; + } + impl<'a> Default for PhysicalDeviceSparseImageFormatInfo2<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + format: Default::default(), + _type: Default::default(), + samples: Default::default(), + usage: Default::default(), + tiling: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceSparseImageFormatInfo2<'a> { + pub fn format(mut self, format: crate::vk::Format) -> Self { + self.format = format; + self + } + pub fn _type(mut self, _type: crate::vk::ImageType) -> Self { + self._type = _type; + self + } + pub fn samples(mut self, samples: crate::vk::SampleCountFlagBits) -> Self { + self.samples = samples; + self + } + pub fn usage(mut self, usage: crate::vk::ImageUsageFlags) -> Self { + self.usage = usage; + self + } + pub fn tiling(mut self, tiling: crate::vk::ImageTiling) -> Self { + self.tiling = tiling; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceVariablePointersFeatures<'a> { @@ -602,13 +834,69 @@ pub(crate) mod reexport { pub variable_pointers: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceVariablePointersFeatures<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceVariablePointersFeatures<'a> {} + unsafe impl<'a> crate::Extends> + for PhysicalDeviceVariablePointersFeatures<'a> {} + impl<'a> Default for PhysicalDeviceVariablePointersFeatures<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + variable_pointers_storage_buffer: Default::default(), + variable_pointers: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceVariablePointersFeatures<'a> { + pub fn variable_pointers_storage_buffer( + mut self, + variable_pointers_storage_buffer: bool, + ) -> Self { + self.variable_pointers_storage_buffer = variable_pointers_storage_buffer + .into(); + self + } + pub fn variable_pointers(mut self, variable_pointers: bool) -> Self { + self.variable_pointers = variable_pointers.into(); + self + } + } #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct ExternalMemoryProperties { pub external_memory_features: crate::vk::ExternalMemoryFeatureFlags, pub export_from_imported_handle_types: crate::vk::ExternalMemoryHandleTypeFlags, pub compatible_handle_types: crate::vk::ExternalMemoryHandleTypeFlags, } + impl ExternalMemoryProperties { + pub fn external_memory_features( + mut self, + external_memory_features: crate::vk::ExternalMemoryFeatureFlags, + ) -> Self { + self.external_memory_features = external_memory_features; + self + } + pub fn export_from_imported_handle_types( + mut self, + export_from_imported_handle_types: crate::vk::ExternalMemoryHandleTypeFlags, + ) -> Self { + self.export_from_imported_handle_types = export_from_imported_handle_types; + self + } + pub fn compatible_handle_types( + mut self, + compatible_handle_types: crate::vk::ExternalMemoryHandleTypeFlags, + ) -> Self { + self.compatible_handle_types = compatible_handle_types; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceExternalImageFormatInfo<'a> { @@ -617,6 +905,31 @@ pub(crate) mod reexport { pub handle_type: crate::vk::ExternalMemoryHandleTypeFlagBits, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceExternalImageFormatInfo<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceExternalImageFormatInfo<'a> {} + impl<'a> Default for PhysicalDeviceExternalImageFormatInfo<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + handle_type: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceExternalImageFormatInfo<'a> { + pub fn handle_type( + mut self, + handle_type: crate::vk::ExternalMemoryHandleTypeFlagBits, + ) -> Self { + self.handle_type = handle_type; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct ExternalImageFormatProperties<'a> { @@ -625,6 +938,30 @@ pub(crate) mod reexport { pub external_memory_properties: crate::vk::ExternalMemoryProperties, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for ExternalImageFormatProperties<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::EXTERNAL_IMAGE_FORMAT_PROPERTIES; + } + unsafe impl<'a> crate::Extends> + for ExternalImageFormatProperties<'a> {} + impl<'a> Default for ExternalImageFormatProperties<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + external_memory_properties: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> ExternalImageFormatProperties<'a> { + pub fn external_memory_properties( + mut self, + external_memory_properties: crate::vk::ExternalMemoryProperties, + ) -> Self { + self.external_memory_properties = external_memory_properties; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceExternalBufferInfo<'a> { @@ -635,6 +972,38 @@ pub(crate) mod reexport { pub handle_type: crate::vk::ExternalMemoryHandleTypeFlagBits, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for PhysicalDeviceExternalBufferInfo<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO; + } + impl<'a> Default for PhysicalDeviceExternalBufferInfo<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + flags: Default::default(), + usage: Default::default(), + handle_type: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceExternalBufferInfo<'a> { + pub fn flags(mut self, flags: crate::vk::BufferCreateFlags) -> Self { + self.flags = flags; + self + } + pub fn usage(mut self, usage: crate::vk::BufferUsageFlags) -> Self { + self.usage = usage; + self + } + pub fn handle_type( + mut self, + handle_type: crate::vk::ExternalMemoryHandleTypeFlagBits, + ) -> Self { + self.handle_type = handle_type; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct ExternalBufferProperties<'a> { @@ -643,6 +1012,28 @@ pub(crate) mod reexport { pub external_memory_properties: crate::vk::ExternalMemoryProperties, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for ExternalBufferProperties<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::EXTERNAL_BUFFER_PROPERTIES; + } + impl<'a> Default for ExternalBufferProperties<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + external_memory_properties: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> ExternalBufferProperties<'a> { + pub fn external_memory_properties( + mut self, + external_memory_properties: crate::vk::ExternalMemoryProperties, + ) -> Self { + self.external_memory_properties = external_memory_properties; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceIDProperties<'a> { @@ -655,6 +1046,56 @@ pub(crate) mod reexport { pub device_luid_valid: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for PhysicalDeviceIDProperties<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_ID_PROPERTIES; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceIDProperties<'a> {} + impl<'a> Default for PhysicalDeviceIDProperties<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + device_uuid: unsafe { core::mem::zeroed() }, + driver_uuid: unsafe { core::mem::zeroed() }, + device_luid: unsafe { core::mem::zeroed() }, + device_node_mask: Default::default(), + device_luid_valid: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceIDProperties<'a> { + pub fn device_uuid( + mut self, + device_uuid: [u8; crate::vk::UUID_SIZE as _], + ) -> Self { + self.device_uuid = device_uuid; + self + } + pub fn driver_uuid( + mut self, + driver_uuid: [u8; crate::vk::UUID_SIZE as _], + ) -> Self { + self.driver_uuid = driver_uuid; + self + } + pub fn device_luid( + mut self, + device_luid: [u8; crate::vk::LUID_SIZE as _], + ) -> Self { + self.device_luid = device_luid; + self + } + pub fn device_node_mask(mut self, device_node_mask: u32) -> Self { + self.device_node_mask = device_node_mask; + self + } + pub fn device_luid_valid(mut self, device_luid_valid: bool) -> Self { + self.device_luid_valid = device_luid_valid.into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct ExternalMemoryImageCreateInfo<'a> { @@ -663,6 +1104,30 @@ pub(crate) mod reexport { pub handle_types: crate::vk::ExternalMemoryHandleTypeFlags, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for ExternalMemoryImageCreateInfo<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::EXTERNAL_MEMORY_IMAGE_CREATE_INFO; + } + unsafe impl<'a> crate::Extends> + for ExternalMemoryImageCreateInfo<'a> {} + impl<'a> Default for ExternalMemoryImageCreateInfo<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + handle_types: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> ExternalMemoryImageCreateInfo<'a> { + pub fn handle_types( + mut self, + handle_types: crate::vk::ExternalMemoryHandleTypeFlags, + ) -> Self { + self.handle_types = handle_types; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct ExternalMemoryBufferCreateInfo<'a> { @@ -671,6 +1136,30 @@ pub(crate) mod reexport { pub handle_types: crate::vk::ExternalMemoryHandleTypeFlags, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for ExternalMemoryBufferCreateInfo<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::EXTERNAL_MEMORY_BUFFER_CREATE_INFO; + } + unsafe impl<'a> crate::Extends> + for ExternalMemoryBufferCreateInfo<'a> {} + impl<'a> Default for ExternalMemoryBufferCreateInfo<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + handle_types: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> ExternalMemoryBufferCreateInfo<'a> { + pub fn handle_types( + mut self, + handle_types: crate::vk::ExternalMemoryHandleTypeFlags, + ) -> Self { + self.handle_types = handle_types; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct ExportMemoryAllocateInfo<'a> { @@ -679,6 +1168,30 @@ pub(crate) mod reexport { pub handle_types: crate::vk::ExternalMemoryHandleTypeFlags, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for ExportMemoryAllocateInfo<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::EXPORT_MEMORY_ALLOCATE_INFO; + } + unsafe impl<'a> crate::Extends> + for ExportMemoryAllocateInfo<'a> {} + impl<'a> Default for ExportMemoryAllocateInfo<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + handle_types: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> ExportMemoryAllocateInfo<'a> { + pub fn handle_types( + mut self, + handle_types: crate::vk::ExternalMemoryHandleTypeFlags, + ) -> Self { + self.handle_types = handle_types; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceExternalSemaphoreInfo<'a> { @@ -687,6 +1200,29 @@ pub(crate) mod reexport { pub handle_type: crate::vk::ExternalSemaphoreHandleTypeFlagBits, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceExternalSemaphoreInfo<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO; + } + impl<'a> Default for PhysicalDeviceExternalSemaphoreInfo<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + handle_type: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceExternalSemaphoreInfo<'a> { + pub fn handle_type( + mut self, + handle_type: crate::vk::ExternalSemaphoreHandleTypeFlagBits, + ) -> Self { + self.handle_type = handle_type; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct ExternalSemaphoreProperties<'a> { @@ -697,6 +1233,44 @@ pub(crate) mod reexport { pub external_semaphore_features: crate::vk::ExternalSemaphoreFeatureFlags, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for ExternalSemaphoreProperties<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::EXTERNAL_SEMAPHORE_PROPERTIES; + } + impl<'a> Default for ExternalSemaphoreProperties<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + export_from_imported_handle_types: Default::default(), + compatible_handle_types: Default::default(), + external_semaphore_features: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> ExternalSemaphoreProperties<'a> { + pub fn export_from_imported_handle_types( + mut self, + export_from_imported_handle_types: crate::vk::ExternalSemaphoreHandleTypeFlags, + ) -> Self { + self.export_from_imported_handle_types = export_from_imported_handle_types; + self + } + pub fn compatible_handle_types( + mut self, + compatible_handle_types: crate::vk::ExternalSemaphoreHandleTypeFlags, + ) -> Self { + self.compatible_handle_types = compatible_handle_types; + self + } + pub fn external_semaphore_features( + mut self, + external_semaphore_features: crate::vk::ExternalSemaphoreFeatureFlags, + ) -> Self { + self.external_semaphore_features = external_semaphore_features; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct ExportSemaphoreCreateInfo<'a> { @@ -705,6 +1279,30 @@ pub(crate) mod reexport { pub handle_types: crate::vk::ExternalSemaphoreHandleTypeFlags, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for ExportSemaphoreCreateInfo<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::EXPORT_SEMAPHORE_CREATE_INFO; + } + unsafe impl<'a> crate::Extends> + for ExportSemaphoreCreateInfo<'a> {} + impl<'a> Default for ExportSemaphoreCreateInfo<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + handle_types: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> ExportSemaphoreCreateInfo<'a> { + pub fn handle_types( + mut self, + handle_types: crate::vk::ExternalSemaphoreHandleTypeFlags, + ) -> Self { + self.handle_types = handle_types; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceExternalFenceInfo<'a> { @@ -713,6 +1311,28 @@ pub(crate) mod reexport { pub handle_type: crate::vk::ExternalFenceHandleTypeFlagBits, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for PhysicalDeviceExternalFenceInfo<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO; + } + impl<'a> Default for PhysicalDeviceExternalFenceInfo<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + handle_type: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceExternalFenceInfo<'a> { + pub fn handle_type( + mut self, + handle_type: crate::vk::ExternalFenceHandleTypeFlagBits, + ) -> Self { + self.handle_type = handle_type; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct ExternalFenceProperties<'a> { @@ -723,6 +1343,44 @@ pub(crate) mod reexport { pub external_fence_features: crate::vk::ExternalFenceFeatureFlags, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for ExternalFenceProperties<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::EXTERNAL_FENCE_PROPERTIES; + } + impl<'a> Default for ExternalFenceProperties<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + export_from_imported_handle_types: Default::default(), + compatible_handle_types: Default::default(), + external_fence_features: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> ExternalFenceProperties<'a> { + pub fn export_from_imported_handle_types( + mut self, + export_from_imported_handle_types: crate::vk::ExternalFenceHandleTypeFlags, + ) -> Self { + self.export_from_imported_handle_types = export_from_imported_handle_types; + self + } + pub fn compatible_handle_types( + mut self, + compatible_handle_types: crate::vk::ExternalFenceHandleTypeFlags, + ) -> Self { + self.compatible_handle_types = compatible_handle_types; + self + } + pub fn external_fence_features( + mut self, + external_fence_features: crate::vk::ExternalFenceFeatureFlags, + ) -> Self { + self.external_fence_features = external_fence_features; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct ExportFenceCreateInfo<'a> { @@ -731,6 +1389,30 @@ pub(crate) mod reexport { pub handle_types: crate::vk::ExternalFenceHandleTypeFlags, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for ExportFenceCreateInfo<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::EXPORT_FENCE_CREATE_INFO; + } + unsafe impl<'a> crate::Extends> + for ExportFenceCreateInfo<'a> {} + impl<'a> Default for ExportFenceCreateInfo<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + handle_types: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> ExportFenceCreateInfo<'a> { + pub fn handle_types( + mut self, + handle_types: crate::vk::ExternalFenceHandleTypeFlags, + ) -> Self { + self.handle_types = handle_types; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceMultiviewFeatures<'a> { @@ -741,6 +1423,45 @@ pub(crate) mod reexport { pub multiview_tessellation_shader: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for PhysicalDeviceMultiviewFeatures<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_MULTIVIEW_FEATURES; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceMultiviewFeatures<'a> {} + unsafe impl<'a> crate::Extends> + for PhysicalDeviceMultiviewFeatures<'a> {} + impl<'a> Default for PhysicalDeviceMultiviewFeatures<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + multiview: Default::default(), + multiview_geometry_shader: Default::default(), + multiview_tessellation_shader: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceMultiviewFeatures<'a> { + pub fn multiview(mut self, multiview: bool) -> Self { + self.multiview = multiview.into(); + self + } + pub fn multiview_geometry_shader( + mut self, + multiview_geometry_shader: bool, + ) -> Self { + self.multiview_geometry_shader = multiview_geometry_shader.into(); + self + } + pub fn multiview_tessellation_shader( + mut self, + multiview_tessellation_shader: bool, + ) -> Self { + self.multiview_tessellation_shader = multiview_tessellation_shader.into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceMultiviewProperties<'a> { @@ -750,6 +1471,39 @@ pub(crate) mod reexport { pub max_multiview_instance_index: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceMultiviewProperties<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceMultiviewProperties<'a> {} + impl<'a> Default for PhysicalDeviceMultiviewProperties<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + max_multiview_view_count: Default::default(), + max_multiview_instance_index: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceMultiviewProperties<'a> { + pub fn max_multiview_view_count( + mut self, + max_multiview_view_count: u32, + ) -> Self { + self.max_multiview_view_count = max_multiview_view_count; + self + } + pub fn max_multiview_instance_index( + mut self, + max_multiview_instance_index: u32, + ) -> Self { + self.max_multiview_instance_index = max_multiview_instance_index; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct RenderPassMultiviewCreateInfo<'a> { @@ -763,6 +1517,55 @@ pub(crate) mod reexport { pub p_correlation_masks: *const u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for RenderPassMultiviewCreateInfo<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::RENDER_PASS_MULTIVIEW_CREATE_INFO; + } + unsafe impl<'a> crate::Extends> + for RenderPassMultiviewCreateInfo<'a> {} + impl<'a> Default for RenderPassMultiviewCreateInfo<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + subpass_count: Default::default(), + p_view_masks: Default::default(), + dependency_count: Default::default(), + p_view_offsets: Default::default(), + correlation_mask_count: Default::default(), + p_correlation_masks: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> RenderPassMultiviewCreateInfo<'a> { + pub fn subpass_count(mut self, subpass_count: u32) -> Self { + self.subpass_count = subpass_count; + self + } + pub fn p_view_masks(mut self, p_view_masks: &'a [u32]) -> Self { + self.subpass_count = p_view_masks.len() as _; + self.p_view_masks = p_view_masks.as_ptr(); + self + } + pub fn dependency_count(mut self, dependency_count: u32) -> Self { + self.dependency_count = dependency_count; + self + } + pub fn p_view_offsets(mut self, p_view_offsets: &'a [i32]) -> Self { + self.dependency_count = p_view_offsets.len() as _; + self.p_view_offsets = p_view_offsets.as_ptr(); + self + } + pub fn correlation_mask_count(mut self, correlation_mask_count: u32) -> Self { + self.correlation_mask_count = correlation_mask_count; + self + } + pub fn p_correlation_masks(mut self, p_correlation_masks: &'a [u32]) -> Self { + self.correlation_mask_count = p_correlation_masks.len() as _; + self.p_correlation_masks = p_correlation_masks.as_ptr(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceGroupProperties<'a> { @@ -774,6 +1577,43 @@ pub(crate) mod reexport { pub subset_allocation: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for PhysicalDeviceGroupProperties<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_GROUP_PROPERTIES; + } + impl<'a> Default for PhysicalDeviceGroupProperties<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + physical_device_count: Default::default(), + physical_devices: unsafe { core::mem::zeroed() }, + subset_allocation: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceGroupProperties<'a> { + pub fn physical_device_count(mut self, physical_device_count: u32) -> Self { + self.physical_device_count = physical_device_count; + self + } + pub fn physical_devices( + mut self, + physical_devices: &[crate::vk::PhysicalDevice], + ) -> Self { + self.physical_device_count = physical_devices.len() as _; + self.physical_devices[..physical_devices.len()] + .copy_from_slice(physical_devices); + self + } + pub fn physical_devices_as_slice(&self) -> &[crate::vk::PhysicalDevice] { + &self.physical_devices[..self.physical_device_count as _] + } + pub fn subset_allocation(mut self, subset_allocation: bool) -> Self { + self.subset_allocation = subset_allocation.into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct MemoryAllocateFlagsInfo<'a> { @@ -783,6 +1623,32 @@ pub(crate) mod reexport { pub device_mask: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for MemoryAllocateFlagsInfo<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::MEMORY_ALLOCATE_FLAGS_INFO; + } + unsafe impl<'a> crate::Extends> + for MemoryAllocateFlagsInfo<'a> {} + impl<'a> Default for MemoryAllocateFlagsInfo<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + flags: Default::default(), + device_mask: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> MemoryAllocateFlagsInfo<'a> { + pub fn flags(mut self, flags: crate::vk::MemoryAllocateFlags) -> Self { + self.flags = flags; + self + } + pub fn device_mask(mut self, device_mask: u32) -> Self { + self.device_mask = device_mask; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct BindBufferMemoryInfo<'a> { @@ -793,6 +1659,35 @@ pub(crate) mod reexport { pub memory_offset: crate::vk::DeviceSize, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for BindBufferMemoryInfo<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::BIND_BUFFER_MEMORY_INFO; + } + impl<'a> Default for BindBufferMemoryInfo<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + buffer: Default::default(), + memory: Default::default(), + memory_offset: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> BindBufferMemoryInfo<'a> { + pub fn buffer(mut self, buffer: crate::vk::Buffer) -> Self { + self.buffer = buffer; + self + } + pub fn memory(mut self, memory: crate::vk::DeviceMemory) -> Self { + self.memory = memory; + self + } + pub fn memory_offset(mut self, memory_offset: crate::vk::DeviceSize) -> Self { + self.memory_offset = memory_offset; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct BindBufferMemoryDeviceGroupInfo<'a> { @@ -802,6 +1697,33 @@ pub(crate) mod reexport { pub p_device_indices: *const u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for BindBufferMemoryDeviceGroupInfo<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO; + } + unsafe impl<'a> crate::Extends> + for BindBufferMemoryDeviceGroupInfo<'a> {} + impl<'a> Default for BindBufferMemoryDeviceGroupInfo<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + device_index_count: Default::default(), + p_device_indices: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> BindBufferMemoryDeviceGroupInfo<'a> { + pub fn device_index_count(mut self, device_index_count: u32) -> Self { + self.device_index_count = device_index_count; + self + } + pub fn p_device_indices(mut self, p_device_indices: &'a [u32]) -> Self { + self.device_index_count = p_device_indices.len() as _; + self.p_device_indices = p_device_indices.as_ptr(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct BindImageMemoryInfo<'a> { @@ -812,6 +1734,35 @@ pub(crate) mod reexport { pub memory_offset: crate::vk::DeviceSize, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for BindImageMemoryInfo<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::BIND_IMAGE_MEMORY_INFO; + } + impl<'a> Default for BindImageMemoryInfo<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + image: Default::default(), + memory: Default::default(), + memory_offset: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> BindImageMemoryInfo<'a> { + pub fn image(mut self, image: crate::vk::Image) -> Self { + self.image = image; + self + } + pub fn memory(mut self, memory: crate::vk::DeviceMemory) -> Self { + self.memory = memory; + self + } + pub fn memory_offset(mut self, memory_offset: crate::vk::DeviceSize) -> Self { + self.memory_offset = memory_offset; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct BindImageMemoryDeviceGroupInfo<'a> { @@ -823,6 +1774,51 @@ pub(crate) mod reexport { pub p_split_instance_bind_regions: *const crate::vk::Rect2D, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for BindImageMemoryDeviceGroupInfo<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO; + } + unsafe impl<'a> crate::Extends> + for BindImageMemoryDeviceGroupInfo<'a> {} + impl<'a> Default for BindImageMemoryDeviceGroupInfo<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + device_index_count: Default::default(), + p_device_indices: Default::default(), + split_instance_bind_region_count: Default::default(), + p_split_instance_bind_regions: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> BindImageMemoryDeviceGroupInfo<'a> { + pub fn device_index_count(mut self, device_index_count: u32) -> Self { + self.device_index_count = device_index_count; + self + } + pub fn p_device_indices(mut self, p_device_indices: &'a [u32]) -> Self { + self.device_index_count = p_device_indices.len() as _; + self.p_device_indices = p_device_indices.as_ptr(); + self + } + pub fn split_instance_bind_region_count( + mut self, + split_instance_bind_region_count: u32, + ) -> Self { + self.split_instance_bind_region_count = split_instance_bind_region_count; + self + } + pub fn p_split_instance_bind_regions( + mut self, + p_split_instance_bind_regions: &'a [crate::vk::Rect2D], + ) -> Self { + self.split_instance_bind_region_count = p_split_instance_bind_regions.len() + as _; + self.p_split_instance_bind_regions = p_split_instance_bind_regions.as_ptr(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct DeviceGroupRenderPassBeginInfo<'a> { @@ -833,6 +1829,46 @@ pub(crate) mod reexport { pub p_device_render_areas: *const crate::vk::Rect2D, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for DeviceGroupRenderPassBeginInfo<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::DEVICE_GROUP_RENDER_PASS_BEGIN_INFO; + } + unsafe impl<'a> crate::Extends> + for DeviceGroupRenderPassBeginInfo<'a> {} + unsafe impl<'a> crate::Extends> + for DeviceGroupRenderPassBeginInfo<'a> {} + impl<'a> Default for DeviceGroupRenderPassBeginInfo<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + device_mask: Default::default(), + device_render_area_count: Default::default(), + p_device_render_areas: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> DeviceGroupRenderPassBeginInfo<'a> { + pub fn device_mask(mut self, device_mask: u32) -> Self { + self.device_mask = device_mask; + self + } + pub fn device_render_area_count( + mut self, + device_render_area_count: u32, + ) -> Self { + self.device_render_area_count = device_render_area_count; + self + } + pub fn p_device_render_areas( + mut self, + p_device_render_areas: &'a [crate::vk::Rect2D], + ) -> Self { + self.device_render_area_count = p_device_render_areas.len() as _; + self.p_device_render_areas = p_device_render_areas.as_ptr(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct DeviceGroupCommandBufferBeginInfo<'a> { @@ -841,6 +1877,28 @@ pub(crate) mod reexport { pub device_mask: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for DeviceGroupCommandBufferBeginInfo<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO; + } + unsafe impl<'a> crate::Extends> + for DeviceGroupCommandBufferBeginInfo<'a> {} + impl<'a> Default for DeviceGroupCommandBufferBeginInfo<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + device_mask: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> DeviceGroupCommandBufferBeginInfo<'a> { + pub fn device_mask(mut self, device_mask: u32) -> Self { + self.device_mask = device_mask; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct DeviceGroupSubmitInfo<'a> { @@ -854,6 +1912,66 @@ pub(crate) mod reexport { pub p_signal_semaphore_device_indices: *const u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for DeviceGroupSubmitInfo<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::DEVICE_GROUP_SUBMIT_INFO; + } + unsafe impl<'a> crate::Extends> + for DeviceGroupSubmitInfo<'a> {} + impl<'a> Default for DeviceGroupSubmitInfo<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + wait_semaphore_count: Default::default(), + p_wait_semaphore_device_indices: Default::default(), + command_buffer_count: Default::default(), + p_command_buffer_device_masks: Default::default(), + signal_semaphore_count: Default::default(), + p_signal_semaphore_device_indices: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> DeviceGroupSubmitInfo<'a> { + pub fn wait_semaphore_count(mut self, wait_semaphore_count: u32) -> Self { + self.wait_semaphore_count = wait_semaphore_count; + self + } + pub fn p_wait_semaphore_device_indices( + mut self, + p_wait_semaphore_device_indices: &'a [u32], + ) -> Self { + self.wait_semaphore_count = p_wait_semaphore_device_indices.len() as _; + self.p_wait_semaphore_device_indices = p_wait_semaphore_device_indices + .as_ptr(); + self + } + pub fn command_buffer_count(mut self, command_buffer_count: u32) -> Self { + self.command_buffer_count = command_buffer_count; + self + } + pub fn p_command_buffer_device_masks( + mut self, + p_command_buffer_device_masks: &'a [u32], + ) -> Self { + self.command_buffer_count = p_command_buffer_device_masks.len() as _; + self.p_command_buffer_device_masks = p_command_buffer_device_masks.as_ptr(); + self + } + pub fn signal_semaphore_count(mut self, signal_semaphore_count: u32) -> Self { + self.signal_semaphore_count = signal_semaphore_count; + self + } + pub fn p_signal_semaphore_device_indices( + mut self, + p_signal_semaphore_device_indices: &'a [u32], + ) -> Self { + self.signal_semaphore_count = p_signal_semaphore_device_indices.len() as _; + self.p_signal_semaphore_device_indices = p_signal_semaphore_device_indices + .as_ptr(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct DeviceGroupBindSparseInfo<'a> { @@ -863,6 +1981,32 @@ pub(crate) mod reexport { pub memory_device_index: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for DeviceGroupBindSparseInfo<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::DEVICE_GROUP_BIND_SPARSE_INFO; + } + unsafe impl<'a> crate::Extends> + for DeviceGroupBindSparseInfo<'a> {} + impl<'a> Default for DeviceGroupBindSparseInfo<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + resource_device_index: Default::default(), + memory_device_index: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> DeviceGroupBindSparseInfo<'a> { + pub fn resource_device_index(mut self, resource_device_index: u32) -> Self { + self.resource_device_index = resource_device_index; + self + } + pub fn memory_device_index(mut self, memory_device_index: u32) -> Self { + self.memory_device_index = memory_device_index; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct DeviceGroupDeviceCreateInfo<'a> { @@ -872,8 +2016,38 @@ pub(crate) mod reexport { pub p_physical_devices: *const crate::vk::PhysicalDevice, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for DeviceGroupDeviceCreateInfo<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::DEVICE_GROUP_DEVICE_CREATE_INFO; + } + unsafe impl<'a> crate::Extends> + for DeviceGroupDeviceCreateInfo<'a> {} + impl<'a> Default for DeviceGroupDeviceCreateInfo<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + physical_device_count: Default::default(), + p_physical_devices: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> DeviceGroupDeviceCreateInfo<'a> { + pub fn physical_device_count(mut self, physical_device_count: u32) -> Self { + self.physical_device_count = physical_device_count; + self + } + pub fn p_physical_devices( + mut self, + p_physical_devices: &'a [crate::vk::PhysicalDevice], + ) -> Self { + self.physical_device_count = p_physical_devices.len() as _; + self.p_physical_devices = p_physical_devices.as_ptr(); + self + } + } #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct DescriptorUpdateTemplateEntry { pub dst_binding: u32, pub dst_array_element: u32, @@ -882,6 +2056,35 @@ pub(crate) mod reexport { pub offset: usize, pub stride: usize, } + impl DescriptorUpdateTemplateEntry { + pub fn dst_binding(mut self, dst_binding: u32) -> Self { + self.dst_binding = dst_binding; + self + } + pub fn dst_array_element(mut self, dst_array_element: u32) -> Self { + self.dst_array_element = dst_array_element; + self + } + pub fn descriptor_count(mut self, descriptor_count: u32) -> Self { + self.descriptor_count = descriptor_count; + self + } + pub fn descriptor_type( + mut self, + descriptor_type: crate::vk::DescriptorType, + ) -> Self { + self.descriptor_type = descriptor_type; + self + } + pub fn offset(mut self, offset: usize) -> Self { + self.offset = offset; + self + } + pub fn stride(mut self, stride: usize) -> Self { + self.stride = stride; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct DescriptorUpdateTemplateCreateInfo<'a> { @@ -897,13 +2100,104 @@ pub(crate) mod reexport { pub set: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for DescriptorUpdateTemplateCreateInfo<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO; + } + impl<'a> Default for DescriptorUpdateTemplateCreateInfo<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + flags: Default::default(), + descriptor_update_entry_count: Default::default(), + p_descriptor_update_entries: Default::default(), + template_type: Default::default(), + descriptor_set_layout: Default::default(), + pipeline_bind_point: Default::default(), + pipeline_layout: Default::default(), + set: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> DescriptorUpdateTemplateCreateInfo<'a> { + pub fn flags( + mut self, + flags: crate::vk::DescriptorUpdateTemplateCreateFlags, + ) -> Self { + self.flags = flags; + self + } + pub fn descriptor_update_entry_count( + mut self, + descriptor_update_entry_count: u32, + ) -> Self { + self.descriptor_update_entry_count = descriptor_update_entry_count; + self + } + pub fn p_descriptor_update_entries( + mut self, + p_descriptor_update_entries: &'a [crate::vk::DescriptorUpdateTemplateEntry], + ) -> Self { + self.descriptor_update_entry_count = p_descriptor_update_entries.len() as _; + self.p_descriptor_update_entries = p_descriptor_update_entries.as_ptr(); + self + } + pub fn template_type( + mut self, + template_type: crate::vk::DescriptorUpdateTemplateType, + ) -> Self { + self.template_type = template_type; + self + } + pub fn descriptor_set_layout( + mut self, + descriptor_set_layout: crate::vk::DescriptorSetLayout, + ) -> Self { + self.descriptor_set_layout = descriptor_set_layout; + self + } + pub fn pipeline_bind_point( + mut self, + pipeline_bind_point: crate::vk::PipelineBindPoint, + ) -> Self { + self.pipeline_bind_point = pipeline_bind_point; + self + } + pub fn pipeline_layout( + mut self, + pipeline_layout: crate::vk::PipelineLayout, + ) -> Self { + self.pipeline_layout = pipeline_layout; + self + } + pub fn set(mut self, set: u32) -> Self { + self.set = set; + self + } + } #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct InputAttachmentAspectReference { pub subpass: u32, pub input_attachment_index: u32, pub aspect_mask: crate::vk::ImageAspectFlags, } + impl InputAttachmentAspectReference { + pub fn subpass(mut self, subpass: u32) -> Self { + self.subpass = subpass; + self + } + pub fn input_attachment_index(mut self, input_attachment_index: u32) -> Self { + self.input_attachment_index = input_attachment_index; + self + } + pub fn aspect_mask(mut self, aspect_mask: crate::vk::ImageAspectFlags) -> Self { + self.aspect_mask = aspect_mask; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct RenderPassInputAttachmentAspectCreateInfo<'a> { @@ -913,6 +2207,37 @@ pub(crate) mod reexport { pub p_aspect_references: *const crate::vk::InputAttachmentAspectReference, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for RenderPassInputAttachmentAspectCreateInfo<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO; + } + unsafe impl<'a> crate::Extends> + for RenderPassInputAttachmentAspectCreateInfo<'a> {} + impl<'a> Default for RenderPassInputAttachmentAspectCreateInfo<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + aspect_reference_count: Default::default(), + p_aspect_references: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> RenderPassInputAttachmentAspectCreateInfo<'a> { + pub fn aspect_reference_count(mut self, aspect_reference_count: u32) -> Self { + self.aspect_reference_count = aspect_reference_count; + self + } + pub fn p_aspect_references( + mut self, + p_aspect_references: &'a [crate::vk::InputAttachmentAspectReference], + ) -> Self { + self.aspect_reference_count = p_aspect_references.len() as _; + self.p_aspect_references = p_aspect_references.as_ptr(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDevice16BitStorageFeatures<'a> { @@ -924,6 +2249,52 @@ pub(crate) mod reexport { pub storage_input_output16: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDevice16BitStorageFeatures<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES; + } + unsafe impl<'a> crate::Extends> + for PhysicalDevice16BitStorageFeatures<'a> {} + unsafe impl<'a> crate::Extends> + for PhysicalDevice16BitStorageFeatures<'a> {} + impl<'a> Default for PhysicalDevice16BitStorageFeatures<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + storage_buffer16_bit_access: Default::default(), + uniform_and_storage_buffer16_bit_access: Default::default(), + storage_push_constant16: Default::default(), + storage_input_output16: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDevice16BitStorageFeatures<'a> { + pub fn storage_buffer16_bit_access( + mut self, + storage_buffer16_bit_access: bool, + ) -> Self { + self.storage_buffer16_bit_access = storage_buffer16_bit_access.into(); + self + } + pub fn uniform_and_storage_buffer16_bit_access( + mut self, + uniform_and_storage_buffer16_bit_access: bool, + ) -> Self { + self.uniform_and_storage_buffer16_bit_access = uniform_and_storage_buffer16_bit_access + .into(); + self + } + pub fn storage_push_constant16(mut self, storage_push_constant16: bool) -> Self { + self.storage_push_constant16 = storage_push_constant16.into(); + self + } + pub fn storage_input_output16(mut self, storage_input_output16: bool) -> Self { + self.storage_input_output16 = storage_input_output16.into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceSubgroupProperties<'a> { @@ -935,6 +2306,51 @@ pub(crate) mod reexport { pub quad_operations_in_all_stages: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for PhysicalDeviceSubgroupProperties<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_SUBGROUP_PROPERTIES; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceSubgroupProperties<'a> {} + impl<'a> Default for PhysicalDeviceSubgroupProperties<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + subgroup_size: Default::default(), + supported_stages: Default::default(), + supported_operations: Default::default(), + quad_operations_in_all_stages: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceSubgroupProperties<'a> { + pub fn subgroup_size(mut self, subgroup_size: u32) -> Self { + self.subgroup_size = subgroup_size; + self + } + pub fn supported_stages( + mut self, + supported_stages: crate::vk::ShaderStageFlags, + ) -> Self { + self.supported_stages = supported_stages; + self + } + pub fn supported_operations( + mut self, + supported_operations: crate::vk::SubgroupFeatureFlags, + ) -> Self { + self.supported_operations = supported_operations; + self + } + pub fn quad_operations_in_all_stages( + mut self, + quad_operations_in_all_stages: bool, + ) -> Self { + self.quad_operations_in_all_stages = quad_operations_in_all_stages.into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct BufferMemoryRequirementsInfo2<'a> { @@ -943,6 +2359,25 @@ pub(crate) mod reexport { pub buffer: crate::vk::Buffer, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for BufferMemoryRequirementsInfo2<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::BUFFER_MEMORY_REQUIREMENTS_INFO_2; + } + impl<'a> Default for BufferMemoryRequirementsInfo2<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + buffer: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> BufferMemoryRequirementsInfo2<'a> { + pub fn buffer(mut self, buffer: crate::vk::Buffer) -> Self { + self.buffer = buffer; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct ImageMemoryRequirementsInfo2<'a> { @@ -951,6 +2386,25 @@ pub(crate) mod reexport { pub image: crate::vk::Image, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for ImageMemoryRequirementsInfo2<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::IMAGE_MEMORY_REQUIREMENTS_INFO_2; + } + impl<'a> Default for ImageMemoryRequirementsInfo2<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + image: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> ImageMemoryRequirementsInfo2<'a> { + pub fn image(mut self, image: crate::vk::Image) -> Self { + self.image = image; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct ImageSparseMemoryRequirementsInfo2<'a> { @@ -959,6 +2413,26 @@ pub(crate) mod reexport { pub image: crate::vk::Image, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for ImageSparseMemoryRequirementsInfo2<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2; + } + impl<'a> Default for ImageSparseMemoryRequirementsInfo2<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + image: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> ImageSparseMemoryRequirementsInfo2<'a> { + pub fn image(mut self, image: crate::vk::Image) -> Self { + self.image = image; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct MemoryRequirements2<'a> { @@ -967,6 +2441,28 @@ pub(crate) mod reexport { pub memory_requirements: crate::vk::MemoryRequirements, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for MemoryRequirements2<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::MEMORY_REQUIREMENTS_2; + } + impl<'a> Default for MemoryRequirements2<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + memory_requirements: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> MemoryRequirements2<'a> { + pub fn memory_requirements( + mut self, + memory_requirements: crate::vk::MemoryRequirements, + ) -> Self { + self.memory_requirements = memory_requirements; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct SparseImageMemoryRequirements2<'a> { @@ -975,6 +2471,28 @@ pub(crate) mod reexport { pub memory_requirements: crate::vk::SparseImageMemoryRequirements, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for SparseImageMemoryRequirements2<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::SPARSE_IMAGE_MEMORY_REQUIREMENTS_2; + } + impl<'a> Default for SparseImageMemoryRequirements2<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + memory_requirements: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> SparseImageMemoryRequirements2<'a> { + pub fn memory_requirements( + mut self, + memory_requirements: crate::vk::SparseImageMemoryRequirements, + ) -> Self { + self.memory_requirements = memory_requirements; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDevicePointClippingProperties<'a> { @@ -983,6 +2501,31 @@ pub(crate) mod reexport { pub point_clipping_behavior: crate::vk::PointClippingBehavior, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDevicePointClippingProperties<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES; + } + unsafe impl<'a> crate::Extends> + for PhysicalDevicePointClippingProperties<'a> {} + impl<'a> Default for PhysicalDevicePointClippingProperties<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + point_clipping_behavior: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDevicePointClippingProperties<'a> { + pub fn point_clipping_behavior( + mut self, + point_clipping_behavior: crate::vk::PointClippingBehavior, + ) -> Self { + self.point_clipping_behavior = point_clipping_behavior; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct MemoryDedicatedRequirements<'a> { @@ -992,6 +2535,38 @@ pub(crate) mod reexport { pub requires_dedicated_allocation: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for MemoryDedicatedRequirements<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::MEMORY_DEDICATED_REQUIREMENTS; + } + unsafe impl<'a> crate::Extends> + for MemoryDedicatedRequirements<'a> {} + impl<'a> Default for MemoryDedicatedRequirements<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + prefers_dedicated_allocation: Default::default(), + requires_dedicated_allocation: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> MemoryDedicatedRequirements<'a> { + pub fn prefers_dedicated_allocation( + mut self, + prefers_dedicated_allocation: bool, + ) -> Self { + self.prefers_dedicated_allocation = prefers_dedicated_allocation.into(); + self + } + pub fn requires_dedicated_allocation( + mut self, + requires_dedicated_allocation: bool, + ) -> Self { + self.requires_dedicated_allocation = requires_dedicated_allocation.into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct MemoryDedicatedAllocateInfo<'a> { @@ -1001,6 +2576,32 @@ pub(crate) mod reexport { pub buffer: crate::vk::Buffer, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for MemoryDedicatedAllocateInfo<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::MEMORY_DEDICATED_ALLOCATE_INFO; + } + unsafe impl<'a> crate::Extends> + for MemoryDedicatedAllocateInfo<'a> {} + impl<'a> Default for MemoryDedicatedAllocateInfo<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + image: Default::default(), + buffer: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> MemoryDedicatedAllocateInfo<'a> { + pub fn image(mut self, image: crate::vk::Image) -> Self { + self.image = image; + self + } + pub fn buffer(mut self, buffer: crate::vk::Buffer) -> Self { + self.buffer = buffer; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct ImageViewUsageCreateInfo<'a> { @@ -1009,6 +2610,27 @@ pub(crate) mod reexport { pub usage: crate::vk::ImageUsageFlags, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for ImageViewUsageCreateInfo<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::IMAGE_VIEW_USAGE_CREATE_INFO; + } + unsafe impl<'a> crate::Extends> + for ImageViewUsageCreateInfo<'a> {} + impl<'a> Default for ImageViewUsageCreateInfo<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + usage: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> ImageViewUsageCreateInfo<'a> { + pub fn usage(mut self, usage: crate::vk::ImageUsageFlags) -> Self { + self.usage = usage; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PipelineTessellationDomainOriginStateCreateInfo<'a> { @@ -1017,6 +2639,31 @@ pub(crate) mod reexport { pub domain_origin: crate::vk::TessellationDomainOrigin, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PipelineTessellationDomainOriginStateCreateInfo<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO; + } + unsafe impl<'a> crate::Extends> + for PipelineTessellationDomainOriginStateCreateInfo<'a> {} + impl<'a> Default for PipelineTessellationDomainOriginStateCreateInfo<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + domain_origin: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PipelineTessellationDomainOriginStateCreateInfo<'a> { + pub fn domain_origin( + mut self, + domain_origin: crate::vk::TessellationDomainOrigin, + ) -> Self { + self.domain_origin = domain_origin; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct SamplerYcbcrConversionInfo<'a> { @@ -1025,6 +2672,32 @@ pub(crate) mod reexport { pub conversion: crate::vk::SamplerYcbcrConversion, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for SamplerYcbcrConversionInfo<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::SAMPLER_YCBCR_CONVERSION_INFO; + } + unsafe impl<'a> crate::Extends> + for SamplerYcbcrConversionInfo<'a> {} + unsafe impl<'a> crate::Extends> + for SamplerYcbcrConversionInfo<'a> {} + impl<'a> Default for SamplerYcbcrConversionInfo<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + conversion: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> SamplerYcbcrConversionInfo<'a> { + pub fn conversion( + mut self, + conversion: crate::vk::SamplerYcbcrConversion, + ) -> Self { + self.conversion = conversion; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct SamplerYcbcrConversionCreateInfo<'a> { @@ -1040,6 +2713,72 @@ pub(crate) mod reexport { pub force_explicit_reconstruction: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for SamplerYcbcrConversionCreateInfo<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::SAMPLER_YCBCR_CONVERSION_CREATE_INFO; + } + impl<'a> Default for SamplerYcbcrConversionCreateInfo<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + format: Default::default(), + ycbcr_model: Default::default(), + ycbcr_range: Default::default(), + components: Default::default(), + x_chroma_offset: Default::default(), + y_chroma_offset: Default::default(), + chroma_filter: Default::default(), + force_explicit_reconstruction: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> SamplerYcbcrConversionCreateInfo<'a> { + pub fn format(mut self, format: crate::vk::Format) -> Self { + self.format = format; + self + } + pub fn ycbcr_model( + mut self, + ycbcr_model: crate::vk::SamplerYcbcrModelConversion, + ) -> Self { + self.ycbcr_model = ycbcr_model; + self + } + pub fn ycbcr_range(mut self, ycbcr_range: crate::vk::SamplerYcbcrRange) -> Self { + self.ycbcr_range = ycbcr_range; + self + } + pub fn components(mut self, components: crate::vk::ComponentMapping) -> Self { + self.components = components; + self + } + pub fn x_chroma_offset( + mut self, + x_chroma_offset: crate::vk::ChromaLocation, + ) -> Self { + self.x_chroma_offset = x_chroma_offset; + self + } + pub fn y_chroma_offset( + mut self, + y_chroma_offset: crate::vk::ChromaLocation, + ) -> Self { + self.y_chroma_offset = y_chroma_offset; + self + } + pub fn chroma_filter(mut self, chroma_filter: crate::vk::Filter) -> Self { + self.chroma_filter = chroma_filter; + self + } + pub fn force_explicit_reconstruction( + mut self, + force_explicit_reconstruction: bool, + ) -> Self { + self.force_explicit_reconstruction = force_explicit_reconstruction.into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct BindImagePlaneMemoryInfo<'a> { @@ -1048,6 +2787,30 @@ pub(crate) mod reexport { pub plane_aspect: crate::vk::ImageAspectFlagBits, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for BindImagePlaneMemoryInfo<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::BIND_IMAGE_PLANE_MEMORY_INFO; + } + unsafe impl<'a> crate::Extends> + for BindImagePlaneMemoryInfo<'a> {} + impl<'a> Default for BindImagePlaneMemoryInfo<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + plane_aspect: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> BindImagePlaneMemoryInfo<'a> { + pub fn plane_aspect( + mut self, + plane_aspect: crate::vk::ImageAspectFlagBits, + ) -> Self { + self.plane_aspect = plane_aspect; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct ImagePlaneMemoryRequirementsInfo<'a> { @@ -1056,6 +2819,30 @@ pub(crate) mod reexport { pub plane_aspect: crate::vk::ImageAspectFlagBits, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for ImagePlaneMemoryRequirementsInfo<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO; + } + unsafe impl<'a> crate::Extends> + for ImagePlaneMemoryRequirementsInfo<'a> {} + impl<'a> Default for ImagePlaneMemoryRequirementsInfo<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + plane_aspect: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> ImagePlaneMemoryRequirementsInfo<'a> { + pub fn plane_aspect( + mut self, + plane_aspect: crate::vk::ImageAspectFlagBits, + ) -> Self { + self.plane_aspect = plane_aspect; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceSamplerYcbcrConversionFeatures<'a> { @@ -1064,6 +2851,33 @@ pub(crate) mod reexport { pub sampler_ycbcr_conversion: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceSamplerYcbcrConversionFeatures<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceSamplerYcbcrConversionFeatures<'a> {} + unsafe impl<'a> crate::Extends> + for PhysicalDeviceSamplerYcbcrConversionFeatures<'a> {} + impl<'a> Default for PhysicalDeviceSamplerYcbcrConversionFeatures<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + sampler_ycbcr_conversion: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceSamplerYcbcrConversionFeatures<'a> { + pub fn sampler_ycbcr_conversion( + mut self, + sampler_ycbcr_conversion: bool, + ) -> Self { + self.sampler_ycbcr_conversion = sampler_ycbcr_conversion.into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct SamplerYcbcrConversionImageFormatProperties<'a> { @@ -1072,6 +2886,31 @@ pub(crate) mod reexport { pub combined_image_sampler_descriptor_count: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for SamplerYcbcrConversionImageFormatProperties<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES; + } + unsafe impl<'a> crate::Extends> + for SamplerYcbcrConversionImageFormatProperties<'a> {} + impl<'a> Default for SamplerYcbcrConversionImageFormatProperties<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + combined_image_sampler_descriptor_count: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> SamplerYcbcrConversionImageFormatProperties<'a> { + pub fn combined_image_sampler_descriptor_count( + mut self, + combined_image_sampler_descriptor_count: u32, + ) -> Self { + self.combined_image_sampler_descriptor_count = combined_image_sampler_descriptor_count; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct ProtectedSubmitInfo<'a> { @@ -1080,6 +2919,27 @@ pub(crate) mod reexport { pub protected_submit: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for ProtectedSubmitInfo<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PROTECTED_SUBMIT_INFO; + } + unsafe impl<'a> crate::Extends> + for ProtectedSubmitInfo<'a> {} + impl<'a> Default for ProtectedSubmitInfo<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + protected_submit: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> ProtectedSubmitInfo<'a> { + pub fn protected_submit(mut self, protected_submit: bool) -> Self { + self.protected_submit = protected_submit.into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceProtectedMemoryFeatures<'a> { @@ -1088,6 +2948,30 @@ pub(crate) mod reexport { pub protected_memory: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceProtectedMemoryFeatures<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceProtectedMemoryFeatures<'a> {} + unsafe impl<'a> crate::Extends> + for PhysicalDeviceProtectedMemoryFeatures<'a> {} + impl<'a> Default for PhysicalDeviceProtectedMemoryFeatures<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + protected_memory: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceProtectedMemoryFeatures<'a> { + pub fn protected_memory(mut self, protected_memory: bool) -> Self { + self.protected_memory = protected_memory.into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceProtectedMemoryProperties<'a> { @@ -1096,6 +2980,28 @@ pub(crate) mod reexport { pub protected_no_fault: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceProtectedMemoryProperties<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceProtectedMemoryProperties<'a> {} + impl<'a> Default for PhysicalDeviceProtectedMemoryProperties<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + protected_no_fault: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceProtectedMemoryProperties<'a> { + pub fn protected_no_fault(mut self, protected_no_fault: bool) -> Self { + self.protected_no_fault = protected_no_fault.into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct DeviceQueueInfo2<'a> { @@ -1106,6 +3012,35 @@ pub(crate) mod reexport { pub queue_index: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for DeviceQueueInfo2<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::DEVICE_QUEUE_INFO_2; + } + impl<'a> Default for DeviceQueueInfo2<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + flags: Default::default(), + queue_family_index: Default::default(), + queue_index: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> DeviceQueueInfo2<'a> { + pub fn flags(mut self, flags: crate::vk::DeviceQueueCreateFlags) -> Self { + self.flags = flags; + self + } + pub fn queue_family_index(mut self, queue_family_index: u32) -> Self { + self.queue_family_index = queue_family_index; + self + } + pub fn queue_index(mut self, queue_index: u32) -> Self { + self.queue_index = queue_index; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceMaintenance3Properties<'a> { @@ -1115,6 +3050,36 @@ pub(crate) mod reexport { pub max_memory_allocation_size: crate::vk::DeviceSize, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceMaintenance3Properties<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceMaintenance3Properties<'a> {} + impl<'a> Default for PhysicalDeviceMaintenance3Properties<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + max_per_set_descriptors: Default::default(), + max_memory_allocation_size: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceMaintenance3Properties<'a> { + pub fn max_per_set_descriptors(mut self, max_per_set_descriptors: u32) -> Self { + self.max_per_set_descriptors = max_per_set_descriptors; + self + } + pub fn max_memory_allocation_size( + mut self, + max_memory_allocation_size: crate::vk::DeviceSize, + ) -> Self { + self.max_memory_allocation_size = max_memory_allocation_size; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct DescriptorSetLayoutSupport<'a> { @@ -1123,6 +3088,25 @@ pub(crate) mod reexport { pub supported: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for DescriptorSetLayoutSupport<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::DESCRIPTOR_SET_LAYOUT_SUPPORT; + } + impl<'a> Default for DescriptorSetLayoutSupport<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + supported: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> DescriptorSetLayoutSupport<'a> { + pub fn supported(mut self, supported: bool) -> Self { + self.supported = supported.into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceShaderDrawParametersFeatures<'a> { @@ -1131,6 +3115,30 @@ pub(crate) mod reexport { pub shader_draw_parameters: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceShaderDrawParametersFeatures<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceShaderDrawParametersFeatures<'a> {} + unsafe impl<'a> crate::Extends> + for PhysicalDeviceShaderDrawParametersFeatures<'a> {} + impl<'a> Default for PhysicalDeviceShaderDrawParametersFeatures<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + shader_draw_parameters: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceShaderDrawParametersFeatures<'a> { + pub fn shader_draw_parameters(mut self, shader_draw_parameters: bool) -> Self { + self.shader_draw_parameters = shader_draw_parameters.into(); + self + } + } pub type PhysicalDeviceVariablePointerFeatures<'a> = crate::vk::PhysicalDeviceVariablePointersFeatures< 'a, >; @@ -1531,7 +3539,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct SubgroupFeatureFlagBits(pub(crate) u32); ///Provided by [`vk1_1`](crate::vk1_1) impl SubgroupFeatureFlagBits { @@ -1691,7 +3699,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct PeerMemoryFeatureFlagBits(pub(crate) u32); ///Provided by [`vk1_1`](crate::vk1_1) impl PeerMemoryFeatureFlagBits { @@ -1785,7 +3793,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct MemoryAllocateFlagBits(pub(crate) u32); ///Provided by [`vk1_1`](crate::vk1_1) impl MemoryAllocateFlagBits { @@ -1999,7 +4007,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct ExternalMemoryHandleTypeFlagBits(pub(crate) u32); ///Provided by [`vk1_1`](crate::vk1_1) impl ExternalMemoryHandleTypeFlagBits { @@ -2093,7 +4101,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct ExternalMemoryFeatureFlagBits(pub(crate) u32); ///Provided by [`vk1_1`](crate::vk1_1) impl ExternalMemoryFeatureFlagBits { @@ -2203,7 +4211,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct ExternalSemaphoreHandleTypeFlagBits(pub(crate) u32); ///Provided by [`vk1_1`](crate::vk1_1) impl ExternalSemaphoreHandleTypeFlagBits { @@ -2294,7 +4302,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct ExternalSemaphoreFeatureFlagBits(pub(crate) u32); ///Provided by [`vk1_1`](crate::vk1_1) impl ExternalSemaphoreFeatureFlagBits { @@ -2371,7 +4379,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct SemaphoreImportFlagBits(pub(crate) u32); ///Provided by [`vk1_1`](crate::vk1_1) impl SemaphoreImportFlagBits { @@ -2465,7 +4473,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct ExternalFenceHandleTypeFlagBits(pub(crate) u32); ///Provided by [`vk1_1`](crate::vk1_1) impl ExternalFenceHandleTypeFlagBits { @@ -2550,7 +4558,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct ExternalFenceFeatureFlagBits(pub(crate) u32); ///Provided by [`vk1_1`](crate::vk1_1) impl ExternalFenceFeatureFlagBits { @@ -2627,7 +4635,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct FenceImportFlagBits(pub(crate) u32); ///Provided by [`vk1_1`](crate::vk1_1) impl FenceImportFlagBits { diff --git a/ash-rewrite/src/generated/vk1_2.rs b/ash-rewrite/src/generated/vk1_2.rs index abc1364a3..65340cce9 100644 --- a/ash-rewrite/src/generated/vk1_2.rs +++ b/ash-rewrite/src/generated/vk1_2.rs @@ -230,13 +230,31 @@ impl DeviceFnV1_2 { } pub(crate) mod reexport { #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct ConformanceVersion { pub major: u8, pub minor: u8, pub subminor: u8, pub patch: u8, } + impl ConformanceVersion { + pub fn major(mut self, major: u8) -> Self { + self.major = major; + self + } + pub fn minor(mut self, minor: u8) -> Self { + self.minor = minor; + self + } + pub fn subminor(mut self, subminor: u8) -> Self { + self.subminor = subminor; + self + } + pub fn patch(mut self, patch: u8) -> Self { + self.patch = patch; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceDriverProperties<'a> { @@ -248,6 +266,61 @@ pub(crate) mod reexport { pub conformance_version: crate::vk::ConformanceVersion, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for PhysicalDeviceDriverProperties<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_DRIVER_PROPERTIES; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceDriverProperties<'a> {} + impl<'a> Default for PhysicalDeviceDriverProperties<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + driver_id: Default::default(), + driver_name: unsafe { core::mem::zeroed() }, + driver_info: unsafe { core::mem::zeroed() }, + conformance_version: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceDriverProperties<'a> { + pub fn driver_id(mut self, driver_id: crate::vk::DriverId) -> Self { + self.driver_id = driver_id; + self + } + pub fn driver_name( + mut self, + driver_name: &core::ffi::CStr, + ) -> core::result::Result { + crate::write_c_str_slice_with_nul(&mut self.driver_name, driver_name) + .map(|_| self) + } + pub fn driver_name_as_c_str( + &self, + ) -> core::result::Result<&core::ffi::CStr, core::ffi::FromBytesUntilNulError> { + crate::wrap_c_str_slice_until_nul(&self.driver_name) + } + pub fn driver_info( + mut self, + driver_info: &core::ffi::CStr, + ) -> core::result::Result { + crate::write_c_str_slice_with_nul(&mut self.driver_info, driver_info) + .map(|_| self) + } + pub fn driver_info_as_c_str( + &self, + ) -> core::result::Result<&core::ffi::CStr, core::ffi::FromBytesUntilNulError> { + crate::wrap_c_str_slice_until_nul(&self.driver_info) + } + pub fn conformance_version( + mut self, + conformance_version: crate::vk::ConformanceVersion, + ) -> Self { + self.conformance_version = conformance_version; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceShaderSubgroupExtendedTypesFeatures<'a> { @@ -256,6 +329,33 @@ pub(crate) mod reexport { pub shader_subgroup_extended_types: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceShaderSubgroupExtendedTypesFeatures<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceShaderSubgroupExtendedTypesFeatures<'a> {} + unsafe impl<'a> crate::Extends> + for PhysicalDeviceShaderSubgroupExtendedTypesFeatures<'a> {} + impl<'a> Default for PhysicalDeviceShaderSubgroupExtendedTypesFeatures<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + shader_subgroup_extended_types: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceShaderSubgroupExtendedTypesFeatures<'a> { + pub fn shader_subgroup_extended_types( + mut self, + shader_subgroup_extended_types: bool, + ) -> Self { + self.shader_subgroup_extended_types = shader_subgroup_extended_types.into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceSamplerFilterMinmaxProperties<'a> { @@ -265,6 +365,41 @@ pub(crate) mod reexport { pub filter_minmax_image_component_mapping: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceSamplerFilterMinmaxProperties<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceSamplerFilterMinmaxProperties<'a> {} + impl<'a> Default for PhysicalDeviceSamplerFilterMinmaxProperties<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + filter_minmax_single_component_formats: Default::default(), + filter_minmax_image_component_mapping: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceSamplerFilterMinmaxProperties<'a> { + pub fn filter_minmax_single_component_formats( + mut self, + filter_minmax_single_component_formats: bool, + ) -> Self { + self.filter_minmax_single_component_formats = filter_minmax_single_component_formats + .into(); + self + } + pub fn filter_minmax_image_component_mapping( + mut self, + filter_minmax_image_component_mapping: bool, + ) -> Self { + self.filter_minmax_image_component_mapping = filter_minmax_image_component_mapping + .into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct SamplerReductionModeCreateInfo<'a> { @@ -273,6 +408,30 @@ pub(crate) mod reexport { pub reduction_mode: crate::vk::SamplerReductionMode, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for SamplerReductionModeCreateInfo<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::SAMPLER_REDUCTION_MODE_CREATE_INFO; + } + unsafe impl<'a> crate::Extends> + for SamplerReductionModeCreateInfo<'a> {} + impl<'a> Default for SamplerReductionModeCreateInfo<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + reduction_mode: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> SamplerReductionModeCreateInfo<'a> { + pub fn reduction_mode( + mut self, + reduction_mode: crate::vk::SamplerReductionMode, + ) -> Self { + self.reduction_mode = reduction_mode; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct ImageFormatListCreateInfo<'a> { @@ -282,6 +441,40 @@ pub(crate) mod reexport { pub p_view_formats: *const crate::vk::Format, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for ImageFormatListCreateInfo<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::IMAGE_FORMAT_LIST_CREATE_INFO; + } + unsafe impl<'a> crate::Extends> + for ImageFormatListCreateInfo<'a> {} + unsafe impl<'a> crate::Extends> + for ImageFormatListCreateInfo<'a> {} + unsafe impl<'a> crate::Extends> + for ImageFormatListCreateInfo<'a> {} + impl<'a> Default for ImageFormatListCreateInfo<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + view_format_count: Default::default(), + p_view_formats: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> ImageFormatListCreateInfo<'a> { + pub fn view_format_count(mut self, view_format_count: u32) -> Self { + self.view_format_count = view_format_count; + self + } + pub fn p_view_formats( + mut self, + p_view_formats: &'a [crate::vk::Format], + ) -> Self { + self.view_format_count = p_view_formats.len() as _; + self.p_view_formats = p_view_formats.as_ptr(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceShaderFloat16Int8Features<'a> { @@ -291,6 +484,35 @@ pub(crate) mod reexport { pub shader_int8: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceShaderFloat16Int8Features<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceShaderFloat16Int8Features<'a> {} + unsafe impl<'a> crate::Extends> + for PhysicalDeviceShaderFloat16Int8Features<'a> {} + impl<'a> Default for PhysicalDeviceShaderFloat16Int8Features<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + shader_float16: Default::default(), + shader_int8: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceShaderFloat16Int8Features<'a> { + pub fn shader_float16(mut self, shader_float16: bool) -> Self { + self.shader_float16 = shader_float16.into(); + self + } + pub fn shader_int8(mut self, shader_int8: bool) -> Self { + self.shader_int8 = shader_int8.into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceFloatControlsProperties<'a> { @@ -315,6 +537,171 @@ pub(crate) mod reexport { pub shader_rounding_mode_rtz_float64: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceFloatControlsProperties<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceFloatControlsProperties<'a> {} + impl<'a> Default for PhysicalDeviceFloatControlsProperties<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + denorm_behavior_independence: Default::default(), + rounding_mode_independence: Default::default(), + shader_signed_zero_inf_nan_preserve_float16: Default::default(), + shader_signed_zero_inf_nan_preserve_float32: Default::default(), + shader_signed_zero_inf_nan_preserve_float64: Default::default(), + shader_denorm_preserve_float16: Default::default(), + shader_denorm_preserve_float32: Default::default(), + shader_denorm_preserve_float64: Default::default(), + shader_denorm_flush_to_zero_float16: Default::default(), + shader_denorm_flush_to_zero_float32: Default::default(), + shader_denorm_flush_to_zero_float64: Default::default(), + shader_rounding_mode_rte_float16: Default::default(), + shader_rounding_mode_rte_float32: Default::default(), + shader_rounding_mode_rte_float64: Default::default(), + shader_rounding_mode_rtz_float16: Default::default(), + shader_rounding_mode_rtz_float32: Default::default(), + shader_rounding_mode_rtz_float64: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceFloatControlsProperties<'a> { + pub fn denorm_behavior_independence( + mut self, + denorm_behavior_independence: crate::vk::ShaderFloatControlsIndependence, + ) -> Self { + self.denorm_behavior_independence = denorm_behavior_independence; + self + } + pub fn rounding_mode_independence( + mut self, + rounding_mode_independence: crate::vk::ShaderFloatControlsIndependence, + ) -> Self { + self.rounding_mode_independence = rounding_mode_independence; + self + } + pub fn shader_signed_zero_inf_nan_preserve_float16( + mut self, + shader_signed_zero_inf_nan_preserve_float16: bool, + ) -> Self { + self.shader_signed_zero_inf_nan_preserve_float16 = shader_signed_zero_inf_nan_preserve_float16 + .into(); + self + } + pub fn shader_signed_zero_inf_nan_preserve_float32( + mut self, + shader_signed_zero_inf_nan_preserve_float32: bool, + ) -> Self { + self.shader_signed_zero_inf_nan_preserve_float32 = shader_signed_zero_inf_nan_preserve_float32 + .into(); + self + } + pub fn shader_signed_zero_inf_nan_preserve_float64( + mut self, + shader_signed_zero_inf_nan_preserve_float64: bool, + ) -> Self { + self.shader_signed_zero_inf_nan_preserve_float64 = shader_signed_zero_inf_nan_preserve_float64 + .into(); + self + } + pub fn shader_denorm_preserve_float16( + mut self, + shader_denorm_preserve_float16: bool, + ) -> Self { + self.shader_denorm_preserve_float16 = shader_denorm_preserve_float16.into(); + self + } + pub fn shader_denorm_preserve_float32( + mut self, + shader_denorm_preserve_float32: bool, + ) -> Self { + self.shader_denorm_preserve_float32 = shader_denorm_preserve_float32.into(); + self + } + pub fn shader_denorm_preserve_float64( + mut self, + shader_denorm_preserve_float64: bool, + ) -> Self { + self.shader_denorm_preserve_float64 = shader_denorm_preserve_float64.into(); + self + } + pub fn shader_denorm_flush_to_zero_float16( + mut self, + shader_denorm_flush_to_zero_float16: bool, + ) -> Self { + self.shader_denorm_flush_to_zero_float16 = shader_denorm_flush_to_zero_float16 + .into(); + self + } + pub fn shader_denorm_flush_to_zero_float32( + mut self, + shader_denorm_flush_to_zero_float32: bool, + ) -> Self { + self.shader_denorm_flush_to_zero_float32 = shader_denorm_flush_to_zero_float32 + .into(); + self + } + pub fn shader_denorm_flush_to_zero_float64( + mut self, + shader_denorm_flush_to_zero_float64: bool, + ) -> Self { + self.shader_denorm_flush_to_zero_float64 = shader_denorm_flush_to_zero_float64 + .into(); + self + } + pub fn shader_rounding_mode_rte_float16( + mut self, + shader_rounding_mode_rte_float16: bool, + ) -> Self { + self.shader_rounding_mode_rte_float16 = shader_rounding_mode_rte_float16 + .into(); + self + } + pub fn shader_rounding_mode_rte_float32( + mut self, + shader_rounding_mode_rte_float32: bool, + ) -> Self { + self.shader_rounding_mode_rte_float32 = shader_rounding_mode_rte_float32 + .into(); + self + } + pub fn shader_rounding_mode_rte_float64( + mut self, + shader_rounding_mode_rte_float64: bool, + ) -> Self { + self.shader_rounding_mode_rte_float64 = shader_rounding_mode_rte_float64 + .into(); + self + } + pub fn shader_rounding_mode_rtz_float16( + mut self, + shader_rounding_mode_rtz_float16: bool, + ) -> Self { + self.shader_rounding_mode_rtz_float16 = shader_rounding_mode_rtz_float16 + .into(); + self + } + pub fn shader_rounding_mode_rtz_float32( + mut self, + shader_rounding_mode_rtz_float32: bool, + ) -> Self { + self.shader_rounding_mode_rtz_float32 = shader_rounding_mode_rtz_float32 + .into(); + self + } + pub fn shader_rounding_mode_rtz_float64( + mut self, + shader_rounding_mode_rtz_float64: bool, + ) -> Self { + self.shader_rounding_mode_rtz_float64 = shader_rounding_mode_rtz_float64 + .into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceHostQueryResetFeatures<'a> { @@ -323,6 +710,30 @@ pub(crate) mod reexport { pub host_query_reset: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceHostQueryResetFeatures<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceHostQueryResetFeatures<'a> {} + unsafe impl<'a> crate::Extends> + for PhysicalDeviceHostQueryResetFeatures<'a> {} + impl<'a> Default for PhysicalDeviceHostQueryResetFeatures<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + host_query_reset: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceHostQueryResetFeatures<'a> { + pub fn host_query_reset(mut self, host_query_reset: bool) -> Self { + self.host_query_reset = host_query_reset.into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceDescriptorIndexingFeatures<'a> { @@ -350,6 +761,204 @@ pub(crate) mod reexport { pub runtime_descriptor_array: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceDescriptorIndexingFeatures<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceDescriptorIndexingFeatures<'a> {} + unsafe impl<'a> crate::Extends> + for PhysicalDeviceDescriptorIndexingFeatures<'a> {} + impl<'a> Default for PhysicalDeviceDescriptorIndexingFeatures<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + shader_input_attachment_array_dynamic_indexing: Default::default(), + shader_uniform_texel_buffer_array_dynamic_indexing: Default::default(), + shader_storage_texel_buffer_array_dynamic_indexing: Default::default(), + shader_uniform_buffer_array_non_uniform_indexing: Default::default(), + shader_sampled_image_array_non_uniform_indexing: Default::default(), + shader_storage_buffer_array_non_uniform_indexing: Default::default(), + shader_storage_image_array_non_uniform_indexing: Default::default(), + shader_input_attachment_array_non_uniform_indexing: Default::default(), + shader_uniform_texel_buffer_array_non_uniform_indexing: Default::default(), + shader_storage_texel_buffer_array_non_uniform_indexing: Default::default(), + descriptor_binding_uniform_buffer_update_after_bind: Default::default(), + descriptor_binding_sampled_image_update_after_bind: Default::default(), + descriptor_binding_storage_image_update_after_bind: Default::default(), + descriptor_binding_storage_buffer_update_after_bind: Default::default(), + descriptor_binding_uniform_texel_buffer_update_after_bind: Default::default(), + descriptor_binding_storage_texel_buffer_update_after_bind: Default::default(), + descriptor_binding_update_unused_while_pending: Default::default(), + descriptor_binding_partially_bound: Default::default(), + descriptor_binding_variable_descriptor_count: Default::default(), + runtime_descriptor_array: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceDescriptorIndexingFeatures<'a> { + pub fn shader_input_attachment_array_dynamic_indexing( + mut self, + shader_input_attachment_array_dynamic_indexing: bool, + ) -> Self { + self.shader_input_attachment_array_dynamic_indexing = shader_input_attachment_array_dynamic_indexing + .into(); + self + } + pub fn shader_uniform_texel_buffer_array_dynamic_indexing( + mut self, + shader_uniform_texel_buffer_array_dynamic_indexing: bool, + ) -> Self { + self.shader_uniform_texel_buffer_array_dynamic_indexing = shader_uniform_texel_buffer_array_dynamic_indexing + .into(); + self + } + pub fn shader_storage_texel_buffer_array_dynamic_indexing( + mut self, + shader_storage_texel_buffer_array_dynamic_indexing: bool, + ) -> Self { + self.shader_storage_texel_buffer_array_dynamic_indexing = shader_storage_texel_buffer_array_dynamic_indexing + .into(); + self + } + pub fn shader_uniform_buffer_array_non_uniform_indexing( + mut self, + shader_uniform_buffer_array_non_uniform_indexing: bool, + ) -> Self { + self.shader_uniform_buffer_array_non_uniform_indexing = shader_uniform_buffer_array_non_uniform_indexing + .into(); + self + } + pub fn shader_sampled_image_array_non_uniform_indexing( + mut self, + shader_sampled_image_array_non_uniform_indexing: bool, + ) -> Self { + self.shader_sampled_image_array_non_uniform_indexing = shader_sampled_image_array_non_uniform_indexing + .into(); + self + } + pub fn shader_storage_buffer_array_non_uniform_indexing( + mut self, + shader_storage_buffer_array_non_uniform_indexing: bool, + ) -> Self { + self.shader_storage_buffer_array_non_uniform_indexing = shader_storage_buffer_array_non_uniform_indexing + .into(); + self + } + pub fn shader_storage_image_array_non_uniform_indexing( + mut self, + shader_storage_image_array_non_uniform_indexing: bool, + ) -> Self { + self.shader_storage_image_array_non_uniform_indexing = shader_storage_image_array_non_uniform_indexing + .into(); + self + } + pub fn shader_input_attachment_array_non_uniform_indexing( + mut self, + shader_input_attachment_array_non_uniform_indexing: bool, + ) -> Self { + self.shader_input_attachment_array_non_uniform_indexing = shader_input_attachment_array_non_uniform_indexing + .into(); + self + } + pub fn shader_uniform_texel_buffer_array_non_uniform_indexing( + mut self, + shader_uniform_texel_buffer_array_non_uniform_indexing: bool, + ) -> Self { + self.shader_uniform_texel_buffer_array_non_uniform_indexing = shader_uniform_texel_buffer_array_non_uniform_indexing + .into(); + self + } + pub fn shader_storage_texel_buffer_array_non_uniform_indexing( + mut self, + shader_storage_texel_buffer_array_non_uniform_indexing: bool, + ) -> Self { + self.shader_storage_texel_buffer_array_non_uniform_indexing = shader_storage_texel_buffer_array_non_uniform_indexing + .into(); + self + } + pub fn descriptor_binding_uniform_buffer_update_after_bind( + mut self, + descriptor_binding_uniform_buffer_update_after_bind: bool, + ) -> Self { + self.descriptor_binding_uniform_buffer_update_after_bind = descriptor_binding_uniform_buffer_update_after_bind + .into(); + self + } + pub fn descriptor_binding_sampled_image_update_after_bind( + mut self, + descriptor_binding_sampled_image_update_after_bind: bool, + ) -> Self { + self.descriptor_binding_sampled_image_update_after_bind = descriptor_binding_sampled_image_update_after_bind + .into(); + self + } + pub fn descriptor_binding_storage_image_update_after_bind( + mut self, + descriptor_binding_storage_image_update_after_bind: bool, + ) -> Self { + self.descriptor_binding_storage_image_update_after_bind = descriptor_binding_storage_image_update_after_bind + .into(); + self + } + pub fn descriptor_binding_storage_buffer_update_after_bind( + mut self, + descriptor_binding_storage_buffer_update_after_bind: bool, + ) -> Self { + self.descriptor_binding_storage_buffer_update_after_bind = descriptor_binding_storage_buffer_update_after_bind + .into(); + self + } + pub fn descriptor_binding_uniform_texel_buffer_update_after_bind( + mut self, + descriptor_binding_uniform_texel_buffer_update_after_bind: bool, + ) -> Self { + self.descriptor_binding_uniform_texel_buffer_update_after_bind = descriptor_binding_uniform_texel_buffer_update_after_bind + .into(); + self + } + pub fn descriptor_binding_storage_texel_buffer_update_after_bind( + mut self, + descriptor_binding_storage_texel_buffer_update_after_bind: bool, + ) -> Self { + self.descriptor_binding_storage_texel_buffer_update_after_bind = descriptor_binding_storage_texel_buffer_update_after_bind + .into(); + self + } + pub fn descriptor_binding_update_unused_while_pending( + mut self, + descriptor_binding_update_unused_while_pending: bool, + ) -> Self { + self.descriptor_binding_update_unused_while_pending = descriptor_binding_update_unused_while_pending + .into(); + self + } + pub fn descriptor_binding_partially_bound( + mut self, + descriptor_binding_partially_bound: bool, + ) -> Self { + self.descriptor_binding_partially_bound = descriptor_binding_partially_bound + .into(); + self + } + pub fn descriptor_binding_variable_descriptor_count( + mut self, + descriptor_binding_variable_descriptor_count: bool, + ) -> Self { + self.descriptor_binding_variable_descriptor_count = descriptor_binding_variable_descriptor_count + .into(); + self + } + pub fn runtime_descriptor_array( + mut self, + runtime_descriptor_array: bool, + ) -> Self { + self.runtime_descriptor_array = runtime_descriptor_array.into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceDescriptorIndexingProperties<'a> { @@ -380,6 +989,213 @@ pub(crate) mod reexport { pub max_descriptor_set_update_after_bind_input_attachments: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceDescriptorIndexingProperties<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceDescriptorIndexingProperties<'a> {} + impl<'a> Default for PhysicalDeviceDescriptorIndexingProperties<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + max_update_after_bind_descriptors_in_all_pools: Default::default(), + shader_uniform_buffer_array_non_uniform_indexing_native: Default::default(), + shader_sampled_image_array_non_uniform_indexing_native: Default::default(), + shader_storage_buffer_array_non_uniform_indexing_native: Default::default(), + shader_storage_image_array_non_uniform_indexing_native: Default::default(), + shader_input_attachment_array_non_uniform_indexing_native: Default::default(), + robust_buffer_access_update_after_bind: Default::default(), + quad_divergent_implicit_lod: Default::default(), + max_per_stage_descriptor_update_after_bind_samplers: Default::default(), + max_per_stage_descriptor_update_after_bind_uniform_buffers: Default::default(), + max_per_stage_descriptor_update_after_bind_storage_buffers: Default::default(), + max_per_stage_descriptor_update_after_bind_sampled_images: Default::default(), + max_per_stage_descriptor_update_after_bind_storage_images: Default::default(), + max_per_stage_descriptor_update_after_bind_input_attachments: Default::default(), + max_per_stage_update_after_bind_resources: Default::default(), + max_descriptor_set_update_after_bind_samplers: Default::default(), + max_descriptor_set_update_after_bind_uniform_buffers: Default::default(), + max_descriptor_set_update_after_bind_uniform_buffers_dynamic: Default::default(), + max_descriptor_set_update_after_bind_storage_buffers: Default::default(), + max_descriptor_set_update_after_bind_storage_buffers_dynamic: Default::default(), + max_descriptor_set_update_after_bind_sampled_images: Default::default(), + max_descriptor_set_update_after_bind_storage_images: Default::default(), + max_descriptor_set_update_after_bind_input_attachments: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceDescriptorIndexingProperties<'a> { + pub fn max_update_after_bind_descriptors_in_all_pools( + mut self, + max_update_after_bind_descriptors_in_all_pools: u32, + ) -> Self { + self.max_update_after_bind_descriptors_in_all_pools = max_update_after_bind_descriptors_in_all_pools; + self + } + pub fn shader_uniform_buffer_array_non_uniform_indexing_native( + mut self, + shader_uniform_buffer_array_non_uniform_indexing_native: bool, + ) -> Self { + self.shader_uniform_buffer_array_non_uniform_indexing_native = shader_uniform_buffer_array_non_uniform_indexing_native + .into(); + self + } + pub fn shader_sampled_image_array_non_uniform_indexing_native( + mut self, + shader_sampled_image_array_non_uniform_indexing_native: bool, + ) -> Self { + self.shader_sampled_image_array_non_uniform_indexing_native = shader_sampled_image_array_non_uniform_indexing_native + .into(); + self + } + pub fn shader_storage_buffer_array_non_uniform_indexing_native( + mut self, + shader_storage_buffer_array_non_uniform_indexing_native: bool, + ) -> Self { + self.shader_storage_buffer_array_non_uniform_indexing_native = shader_storage_buffer_array_non_uniform_indexing_native + .into(); + self + } + pub fn shader_storage_image_array_non_uniform_indexing_native( + mut self, + shader_storage_image_array_non_uniform_indexing_native: bool, + ) -> Self { + self.shader_storage_image_array_non_uniform_indexing_native = shader_storage_image_array_non_uniform_indexing_native + .into(); + self + } + pub fn shader_input_attachment_array_non_uniform_indexing_native( + mut self, + shader_input_attachment_array_non_uniform_indexing_native: bool, + ) -> Self { + self.shader_input_attachment_array_non_uniform_indexing_native = shader_input_attachment_array_non_uniform_indexing_native + .into(); + self + } + pub fn robust_buffer_access_update_after_bind( + mut self, + robust_buffer_access_update_after_bind: bool, + ) -> Self { + self.robust_buffer_access_update_after_bind = robust_buffer_access_update_after_bind + .into(); + self + } + pub fn quad_divergent_implicit_lod( + mut self, + quad_divergent_implicit_lod: bool, + ) -> Self { + self.quad_divergent_implicit_lod = quad_divergent_implicit_lod.into(); + self + } + pub fn max_per_stage_descriptor_update_after_bind_samplers( + mut self, + max_per_stage_descriptor_update_after_bind_samplers: u32, + ) -> Self { + self.max_per_stage_descriptor_update_after_bind_samplers = max_per_stage_descriptor_update_after_bind_samplers; + self + } + pub fn max_per_stage_descriptor_update_after_bind_uniform_buffers( + mut self, + max_per_stage_descriptor_update_after_bind_uniform_buffers: u32, + ) -> Self { + self.max_per_stage_descriptor_update_after_bind_uniform_buffers = max_per_stage_descriptor_update_after_bind_uniform_buffers; + self + } + pub fn max_per_stage_descriptor_update_after_bind_storage_buffers( + mut self, + max_per_stage_descriptor_update_after_bind_storage_buffers: u32, + ) -> Self { + self.max_per_stage_descriptor_update_after_bind_storage_buffers = max_per_stage_descriptor_update_after_bind_storage_buffers; + self + } + pub fn max_per_stage_descriptor_update_after_bind_sampled_images( + mut self, + max_per_stage_descriptor_update_after_bind_sampled_images: u32, + ) -> Self { + self.max_per_stage_descriptor_update_after_bind_sampled_images = max_per_stage_descriptor_update_after_bind_sampled_images; + self + } + pub fn max_per_stage_descriptor_update_after_bind_storage_images( + mut self, + max_per_stage_descriptor_update_after_bind_storage_images: u32, + ) -> Self { + self.max_per_stage_descriptor_update_after_bind_storage_images = max_per_stage_descriptor_update_after_bind_storage_images; + self + } + pub fn max_per_stage_descriptor_update_after_bind_input_attachments( + mut self, + max_per_stage_descriptor_update_after_bind_input_attachments: u32, + ) -> Self { + self.max_per_stage_descriptor_update_after_bind_input_attachments = max_per_stage_descriptor_update_after_bind_input_attachments; + self + } + pub fn max_per_stage_update_after_bind_resources( + mut self, + max_per_stage_update_after_bind_resources: u32, + ) -> Self { + self.max_per_stage_update_after_bind_resources = max_per_stage_update_after_bind_resources; + self + } + pub fn max_descriptor_set_update_after_bind_samplers( + mut self, + max_descriptor_set_update_after_bind_samplers: u32, + ) -> Self { + self.max_descriptor_set_update_after_bind_samplers = max_descriptor_set_update_after_bind_samplers; + self + } + pub fn max_descriptor_set_update_after_bind_uniform_buffers( + mut self, + max_descriptor_set_update_after_bind_uniform_buffers: u32, + ) -> Self { + self.max_descriptor_set_update_after_bind_uniform_buffers = max_descriptor_set_update_after_bind_uniform_buffers; + self + } + pub fn max_descriptor_set_update_after_bind_uniform_buffers_dynamic( + mut self, + max_descriptor_set_update_after_bind_uniform_buffers_dynamic: u32, + ) -> Self { + self.max_descriptor_set_update_after_bind_uniform_buffers_dynamic = max_descriptor_set_update_after_bind_uniform_buffers_dynamic; + self + } + pub fn max_descriptor_set_update_after_bind_storage_buffers( + mut self, + max_descriptor_set_update_after_bind_storage_buffers: u32, + ) -> Self { + self.max_descriptor_set_update_after_bind_storage_buffers = max_descriptor_set_update_after_bind_storage_buffers; + self + } + pub fn max_descriptor_set_update_after_bind_storage_buffers_dynamic( + mut self, + max_descriptor_set_update_after_bind_storage_buffers_dynamic: u32, + ) -> Self { + self.max_descriptor_set_update_after_bind_storage_buffers_dynamic = max_descriptor_set_update_after_bind_storage_buffers_dynamic; + self + } + pub fn max_descriptor_set_update_after_bind_sampled_images( + mut self, + max_descriptor_set_update_after_bind_sampled_images: u32, + ) -> Self { + self.max_descriptor_set_update_after_bind_sampled_images = max_descriptor_set_update_after_bind_sampled_images; + self + } + pub fn max_descriptor_set_update_after_bind_storage_images( + mut self, + max_descriptor_set_update_after_bind_storage_images: u32, + ) -> Self { + self.max_descriptor_set_update_after_bind_storage_images = max_descriptor_set_update_after_bind_storage_images; + self + } + pub fn max_descriptor_set_update_after_bind_input_attachments( + mut self, + max_descriptor_set_update_after_bind_input_attachments: u32, + ) -> Self { + self.max_descriptor_set_update_after_bind_input_attachments = max_descriptor_set_update_after_bind_input_attachments; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct DescriptorSetLayoutBindingFlagsCreateInfo<'a> { @@ -389,6 +1205,37 @@ pub(crate) mod reexport { pub p_binding_flags: *const crate::vk::DescriptorBindingFlags, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for DescriptorSetLayoutBindingFlagsCreateInfo<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO; + } + unsafe impl<'a> crate::Extends> + for DescriptorSetLayoutBindingFlagsCreateInfo<'a> {} + impl<'a> Default for DescriptorSetLayoutBindingFlagsCreateInfo<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + binding_count: Default::default(), + p_binding_flags: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> DescriptorSetLayoutBindingFlagsCreateInfo<'a> { + pub fn binding_count(mut self, binding_count: u32) -> Self { + self.binding_count = binding_count; + self + } + pub fn p_binding_flags( + mut self, + p_binding_flags: &'a [crate::vk::DescriptorBindingFlags], + ) -> Self { + self.binding_count = p_binding_flags.len() as _; + self.p_binding_flags = p_binding_flags.as_ptr(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct DescriptorSetVariableDescriptorCountAllocateInfo<'a> { @@ -398,6 +1245,34 @@ pub(crate) mod reexport { pub p_descriptor_counts: *const u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for DescriptorSetVariableDescriptorCountAllocateInfo<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO; + } + unsafe impl<'a> crate::Extends> + for DescriptorSetVariableDescriptorCountAllocateInfo<'a> {} + impl<'a> Default for DescriptorSetVariableDescriptorCountAllocateInfo<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + descriptor_set_count: Default::default(), + p_descriptor_counts: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> DescriptorSetVariableDescriptorCountAllocateInfo<'a> { + pub fn descriptor_set_count(mut self, descriptor_set_count: u32) -> Self { + self.descriptor_set_count = descriptor_set_count; + self + } + pub fn p_descriptor_counts(mut self, p_descriptor_counts: &'a [u32]) -> Self { + self.descriptor_set_count = p_descriptor_counts.len() as _; + self.p_descriptor_counts = p_descriptor_counts.as_ptr(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct DescriptorSetVariableDescriptorCountLayoutSupport<'a> { @@ -406,6 +1281,31 @@ pub(crate) mod reexport { pub max_variable_descriptor_count: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for DescriptorSetVariableDescriptorCountLayoutSupport<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT; + } + unsafe impl<'a> crate::Extends> + for DescriptorSetVariableDescriptorCountLayoutSupport<'a> {} + impl<'a> Default for DescriptorSetVariableDescriptorCountLayoutSupport<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + max_variable_descriptor_count: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> DescriptorSetVariableDescriptorCountLayoutSupport<'a> { + pub fn max_variable_descriptor_count( + mut self, + max_variable_descriptor_count: u32, + ) -> Self { + self.max_variable_descriptor_count = max_variable_descriptor_count; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct AttachmentDescription2<'a> { @@ -422,6 +1322,71 @@ pub(crate) mod reexport { pub final_layout: crate::vk::ImageLayout, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for AttachmentDescription2<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::ATTACHMENT_DESCRIPTION_2; + } + impl<'a> Default for AttachmentDescription2<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + flags: Default::default(), + format: Default::default(), + samples: Default::default(), + load_op: Default::default(), + store_op: Default::default(), + stencil_load_op: Default::default(), + stencil_store_op: Default::default(), + initial_layout: Default::default(), + final_layout: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> AttachmentDescription2<'a> { + pub fn flags(mut self, flags: crate::vk::AttachmentDescriptionFlags) -> Self { + self.flags = flags; + self + } + pub fn format(mut self, format: crate::vk::Format) -> Self { + self.format = format; + self + } + pub fn samples(mut self, samples: crate::vk::SampleCountFlagBits) -> Self { + self.samples = samples; + self + } + pub fn load_op(mut self, load_op: crate::vk::AttachmentLoadOp) -> Self { + self.load_op = load_op; + self + } + pub fn store_op(mut self, store_op: crate::vk::AttachmentStoreOp) -> Self { + self.store_op = store_op; + self + } + pub fn stencil_load_op( + mut self, + stencil_load_op: crate::vk::AttachmentLoadOp, + ) -> Self { + self.stencil_load_op = stencil_load_op; + self + } + pub fn stencil_store_op( + mut self, + stencil_store_op: crate::vk::AttachmentStoreOp, + ) -> Self { + self.stencil_store_op = stencil_store_op; + self + } + pub fn initial_layout(mut self, initial_layout: crate::vk::ImageLayout) -> Self { + self.initial_layout = initial_layout; + self + } + pub fn final_layout(mut self, final_layout: crate::vk::ImageLayout) -> Self { + self.final_layout = final_layout; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct AttachmentReference2<'a> { @@ -432,6 +1397,35 @@ pub(crate) mod reexport { pub aspect_mask: crate::vk::ImageAspectFlags, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for AttachmentReference2<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::ATTACHMENT_REFERENCE_2; + } + impl<'a> Default for AttachmentReference2<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + attachment: Default::default(), + layout: Default::default(), + aspect_mask: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> AttachmentReference2<'a> { + pub fn attachment(mut self, attachment: u32) -> Self { + self.attachment = attachment; + self + } + pub fn layout(mut self, layout: crate::vk::ImageLayout) -> Self { + self.layout = layout; + self + } + pub fn aspect_mask(mut self, aspect_mask: crate::vk::ImageAspectFlags) -> Self { + self.aspect_mask = aspect_mask; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct SubpassDescription2<'a> { @@ -450,6 +1444,100 @@ pub(crate) mod reexport { pub p_preserve_attachments: *const u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for SubpassDescription2<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::SUBPASS_DESCRIPTION_2; + } + impl<'a> Default for SubpassDescription2<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + flags: Default::default(), + pipeline_bind_point: Default::default(), + view_mask: Default::default(), + input_attachment_count: Default::default(), + p_input_attachments: Default::default(), + color_attachment_count: Default::default(), + p_color_attachments: Default::default(), + p_resolve_attachments: Default::default(), + p_depth_stencil_attachment: Default::default(), + preserve_attachment_count: Default::default(), + p_preserve_attachments: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> SubpassDescription2<'a> { + pub fn flags(mut self, flags: crate::vk::SubpassDescriptionFlags) -> Self { + self.flags = flags; + self + } + pub fn pipeline_bind_point( + mut self, + pipeline_bind_point: crate::vk::PipelineBindPoint, + ) -> Self { + self.pipeline_bind_point = pipeline_bind_point; + self + } + pub fn view_mask(mut self, view_mask: u32) -> Self { + self.view_mask = view_mask; + self + } + pub fn input_attachment_count(mut self, input_attachment_count: u32) -> Self { + self.input_attachment_count = input_attachment_count; + self + } + pub fn p_input_attachments( + mut self, + p_input_attachments: &'a [crate::vk::AttachmentReference2<'a>], + ) -> Self { + self.input_attachment_count = p_input_attachments.len() as _; + self.p_input_attachments = p_input_attachments.as_ptr(); + self + } + pub fn color_attachment_count(mut self, color_attachment_count: u32) -> Self { + self.color_attachment_count = color_attachment_count; + self + } + pub fn p_color_attachments( + mut self, + p_color_attachments: &'a [crate::vk::AttachmentReference2<'a>], + ) -> Self { + self.color_attachment_count = p_color_attachments.len() as _; + self.p_color_attachments = p_color_attachments.as_ptr(); + self + } + pub fn p_resolve_attachments( + mut self, + p_resolve_attachments: &'a [crate::vk::AttachmentReference2<'a>], + ) -> Self { + self.color_attachment_count = p_resolve_attachments.len() as _; + self.p_resolve_attachments = p_resolve_attachments.as_ptr(); + self + } + pub fn p_depth_stencil_attachment( + mut self, + p_depth_stencil_attachment: &'a crate::vk::AttachmentReference2<'a>, + ) -> Self { + self.p_depth_stencil_attachment = p_depth_stencil_attachment; + self + } + pub fn preserve_attachment_count( + mut self, + preserve_attachment_count: u32, + ) -> Self { + self.preserve_attachment_count = preserve_attachment_count; + self + } + pub fn p_preserve_attachments( + mut self, + p_preserve_attachments: &'a [u32], + ) -> Self { + self.preserve_attachment_count = p_preserve_attachments.len() as _; + self.p_preserve_attachments = p_preserve_attachments.as_ptr(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct SubpassDependency2<'a> { @@ -465,6 +1553,75 @@ pub(crate) mod reexport { pub view_offset: i32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for SubpassDependency2<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::SUBPASS_DEPENDENCY_2; + } + impl<'a> Default for SubpassDependency2<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + src_subpass: Default::default(), + dst_subpass: Default::default(), + src_stage_mask: Default::default(), + dst_stage_mask: Default::default(), + src_access_mask: Default::default(), + dst_access_mask: Default::default(), + dependency_flags: Default::default(), + view_offset: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> SubpassDependency2<'a> { + pub fn src_subpass(mut self, src_subpass: u32) -> Self { + self.src_subpass = src_subpass; + self + } + pub fn dst_subpass(mut self, dst_subpass: u32) -> Self { + self.dst_subpass = dst_subpass; + self + } + pub fn src_stage_mask( + mut self, + src_stage_mask: crate::vk::PipelineStageFlags, + ) -> Self { + self.src_stage_mask = src_stage_mask; + self + } + pub fn dst_stage_mask( + mut self, + dst_stage_mask: crate::vk::PipelineStageFlags, + ) -> Self { + self.dst_stage_mask = dst_stage_mask; + self + } + pub fn src_access_mask( + mut self, + src_access_mask: crate::vk::AccessFlags, + ) -> Self { + self.src_access_mask = src_access_mask; + self + } + pub fn dst_access_mask( + mut self, + dst_access_mask: crate::vk::AccessFlags, + ) -> Self { + self.dst_access_mask = dst_access_mask; + self + } + pub fn dependency_flags( + mut self, + dependency_flags: crate::vk::DependencyFlags, + ) -> Self { + self.dependency_flags = dependency_flags; + self + } + pub fn view_offset(mut self, view_offset: i32) -> Self { + self.view_offset = view_offset; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct RenderPassCreateInfo2<'a> { @@ -481,6 +1638,84 @@ pub(crate) mod reexport { pub p_correlated_view_masks: *const u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for RenderPassCreateInfo2<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::RENDER_PASS_CREATE_INFO_2; + } + impl<'a> Default for RenderPassCreateInfo2<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + flags: Default::default(), + attachment_count: Default::default(), + p_attachments: Default::default(), + subpass_count: Default::default(), + p_subpasses: Default::default(), + dependency_count: Default::default(), + p_dependencies: Default::default(), + correlated_view_mask_count: Default::default(), + p_correlated_view_masks: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> RenderPassCreateInfo2<'a> { + pub fn flags(mut self, flags: crate::vk::RenderPassCreateFlags) -> Self { + self.flags = flags; + self + } + pub fn attachment_count(mut self, attachment_count: u32) -> Self { + self.attachment_count = attachment_count; + self + } + pub fn p_attachments( + mut self, + p_attachments: &'a [crate::vk::AttachmentDescription2<'a>], + ) -> Self { + self.attachment_count = p_attachments.len() as _; + self.p_attachments = p_attachments.as_ptr(); + self + } + pub fn subpass_count(mut self, subpass_count: u32) -> Self { + self.subpass_count = subpass_count; + self + } + pub fn p_subpasses( + mut self, + p_subpasses: &'a [crate::vk::SubpassDescription2<'a>], + ) -> Self { + self.subpass_count = p_subpasses.len() as _; + self.p_subpasses = p_subpasses.as_ptr(); + self + } + pub fn dependency_count(mut self, dependency_count: u32) -> Self { + self.dependency_count = dependency_count; + self + } + pub fn p_dependencies( + mut self, + p_dependencies: &'a [crate::vk::SubpassDependency2<'a>], + ) -> Self { + self.dependency_count = p_dependencies.len() as _; + self.p_dependencies = p_dependencies.as_ptr(); + self + } + pub fn correlated_view_mask_count( + mut self, + correlated_view_mask_count: u32, + ) -> Self { + self.correlated_view_mask_count = correlated_view_mask_count; + self + } + pub fn p_correlated_view_masks( + mut self, + p_correlated_view_masks: &'a [u32], + ) -> Self { + self.correlated_view_mask_count = p_correlated_view_masks.len() as _; + self.p_correlated_view_masks = p_correlated_view_masks.as_ptr(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct SubpassBeginInfo<'a> { @@ -489,6 +1724,25 @@ pub(crate) mod reexport { pub contents: crate::vk::SubpassContents, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for SubpassBeginInfo<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::SUBPASS_BEGIN_INFO; + } + impl<'a> Default for SubpassBeginInfo<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + contents: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> SubpassBeginInfo<'a> { + pub fn contents(mut self, contents: crate::vk::SubpassContents) -> Self { + self.contents = contents; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct SubpassEndInfo<'a> { @@ -496,6 +1750,19 @@ pub(crate) mod reexport { pub p_next: *const core::ffi::c_void, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for SubpassEndInfo<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::SUBPASS_END_INFO; + } + impl<'a> Default for SubpassEndInfo<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> SubpassEndInfo<'a> {} #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceTimelineSemaphoreFeatures<'a> { @@ -504,6 +1771,30 @@ pub(crate) mod reexport { pub timeline_semaphore: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceTimelineSemaphoreFeatures<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceTimelineSemaphoreFeatures<'a> {} + unsafe impl<'a> crate::Extends> + for PhysicalDeviceTimelineSemaphoreFeatures<'a> {} + impl<'a> Default for PhysicalDeviceTimelineSemaphoreFeatures<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + timeline_semaphore: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceTimelineSemaphoreFeatures<'a> { + pub fn timeline_semaphore(mut self, timeline_semaphore: bool) -> Self { + self.timeline_semaphore = timeline_semaphore.into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceTimelineSemaphoreProperties<'a> { @@ -512,6 +1803,31 @@ pub(crate) mod reexport { pub max_timeline_semaphore_value_difference: u64, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceTimelineSemaphoreProperties<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceTimelineSemaphoreProperties<'a> {} + impl<'a> Default for PhysicalDeviceTimelineSemaphoreProperties<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + max_timeline_semaphore_value_difference: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceTimelineSemaphoreProperties<'a> { + pub fn max_timeline_semaphore_value_difference( + mut self, + max_timeline_semaphore_value_difference: u64, + ) -> Self { + self.max_timeline_semaphore_value_difference = max_timeline_semaphore_value_difference; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct SemaphoreTypeCreateInfo<'a> { @@ -521,6 +1837,37 @@ pub(crate) mod reexport { pub initial_value: u64, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for SemaphoreTypeCreateInfo<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::SEMAPHORE_TYPE_CREATE_INFO; + } + unsafe impl<'a> crate::Extends> + for SemaphoreTypeCreateInfo<'a> {} + unsafe impl<'a> crate::Extends> + for SemaphoreTypeCreateInfo<'a> {} + impl<'a> Default for SemaphoreTypeCreateInfo<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + semaphore_type: Default::default(), + initial_value: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> SemaphoreTypeCreateInfo<'a> { + pub fn semaphore_type( + mut self, + semaphore_type: crate::vk::SemaphoreType, + ) -> Self { + self.semaphore_type = semaphore_type; + self + } + pub fn initial_value(mut self, initial_value: u64) -> Self { + self.initial_value = initial_value; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct TimelineSemaphoreSubmitInfo<'a> { @@ -532,6 +1879,58 @@ pub(crate) mod reexport { pub p_signal_semaphore_values: *const u64, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for TimelineSemaphoreSubmitInfo<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::TIMELINE_SEMAPHORE_SUBMIT_INFO; + } + unsafe impl<'a> crate::Extends> + for TimelineSemaphoreSubmitInfo<'a> {} + unsafe impl<'a> crate::Extends> + for TimelineSemaphoreSubmitInfo<'a> {} + impl<'a> Default for TimelineSemaphoreSubmitInfo<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + wait_semaphore_value_count: Default::default(), + p_wait_semaphore_values: Default::default(), + signal_semaphore_value_count: Default::default(), + p_signal_semaphore_values: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> TimelineSemaphoreSubmitInfo<'a> { + pub fn wait_semaphore_value_count( + mut self, + wait_semaphore_value_count: u32, + ) -> Self { + self.wait_semaphore_value_count = wait_semaphore_value_count; + self + } + pub fn p_wait_semaphore_values( + mut self, + p_wait_semaphore_values: &'a [u64], + ) -> Self { + self.wait_semaphore_value_count = p_wait_semaphore_values.len() as _; + self.p_wait_semaphore_values = p_wait_semaphore_values.as_ptr(); + self + } + pub fn signal_semaphore_value_count( + mut self, + signal_semaphore_value_count: u32, + ) -> Self { + self.signal_semaphore_value_count = signal_semaphore_value_count; + self + } + pub fn p_signal_semaphore_values( + mut self, + p_signal_semaphore_values: &'a [u64], + ) -> Self { + self.signal_semaphore_value_count = p_signal_semaphore_values.len() as _; + self.p_signal_semaphore_values = p_signal_semaphore_values.as_ptr(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct SemaphoreWaitInfo<'a> { @@ -543,6 +1942,42 @@ pub(crate) mod reexport { pub p_values: *const u64, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for SemaphoreWaitInfo<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::SEMAPHORE_WAIT_INFO; + } + impl<'a> Default for SemaphoreWaitInfo<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + flags: Default::default(), + semaphore_count: Default::default(), + p_semaphores: Default::default(), + p_values: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> SemaphoreWaitInfo<'a> { + pub fn flags(mut self, flags: crate::vk::SemaphoreWaitFlags) -> Self { + self.flags = flags; + self + } + pub fn semaphore_count(mut self, semaphore_count: u32) -> Self { + self.semaphore_count = semaphore_count; + self + } + pub fn p_semaphores(mut self, p_semaphores: &'a [crate::vk::Semaphore]) -> Self { + self.semaphore_count = p_semaphores.len() as _; + self.p_semaphores = p_semaphores.as_ptr(); + self + } + pub fn p_values(mut self, p_values: &'a [u64]) -> Self { + self.semaphore_count = p_values.len() as _; + self.p_values = p_values.as_ptr(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct SemaphoreSignalInfo<'a> { @@ -552,6 +1987,30 @@ pub(crate) mod reexport { pub value: u64, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for SemaphoreSignalInfo<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::SEMAPHORE_SIGNAL_INFO; + } + impl<'a> Default for SemaphoreSignalInfo<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + semaphore: Default::default(), + value: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> SemaphoreSignalInfo<'a> { + pub fn semaphore(mut self, semaphore: crate::vk::Semaphore) -> Self { + self.semaphore = semaphore; + self + } + pub fn value(mut self, value: u64) -> Self { + self.value = value; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDevice8BitStorageFeatures<'a> { @@ -562,6 +2021,47 @@ pub(crate) mod reexport { pub storage_push_constant8: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDevice8BitStorageFeatures<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES; + } + unsafe impl<'a> crate::Extends> + for PhysicalDevice8BitStorageFeatures<'a> {} + unsafe impl<'a> crate::Extends> + for PhysicalDevice8BitStorageFeatures<'a> {} + impl<'a> Default for PhysicalDevice8BitStorageFeatures<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + storage_buffer8_bit_access: Default::default(), + uniform_and_storage_buffer8_bit_access: Default::default(), + storage_push_constant8: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDevice8BitStorageFeatures<'a> { + pub fn storage_buffer8_bit_access( + mut self, + storage_buffer8_bit_access: bool, + ) -> Self { + self.storage_buffer8_bit_access = storage_buffer8_bit_access.into(); + self + } + pub fn uniform_and_storage_buffer8_bit_access( + mut self, + uniform_and_storage_buffer8_bit_access: bool, + ) -> Self { + self.uniform_and_storage_buffer8_bit_access = uniform_and_storage_buffer8_bit_access + .into(); + self + } + pub fn storage_push_constant8(mut self, storage_push_constant8: bool) -> Self { + self.storage_push_constant8 = storage_push_constant8.into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceVulkanMemoryModelFeatures<'a> { @@ -572,6 +2072,48 @@ pub(crate) mod reexport { pub vulkan_memory_model_availability_visibility_chains: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceVulkanMemoryModelFeatures<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceVulkanMemoryModelFeatures<'a> {} + unsafe impl<'a> crate::Extends> + for PhysicalDeviceVulkanMemoryModelFeatures<'a> {} + impl<'a> Default for PhysicalDeviceVulkanMemoryModelFeatures<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + vulkan_memory_model: Default::default(), + vulkan_memory_model_device_scope: Default::default(), + vulkan_memory_model_availability_visibility_chains: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceVulkanMemoryModelFeatures<'a> { + pub fn vulkan_memory_model(mut self, vulkan_memory_model: bool) -> Self { + self.vulkan_memory_model = vulkan_memory_model.into(); + self + } + pub fn vulkan_memory_model_device_scope( + mut self, + vulkan_memory_model_device_scope: bool, + ) -> Self { + self.vulkan_memory_model_device_scope = vulkan_memory_model_device_scope + .into(); + self + } + pub fn vulkan_memory_model_availability_visibility_chains( + mut self, + vulkan_memory_model_availability_visibility_chains: bool, + ) -> Self { + self.vulkan_memory_model_availability_visibility_chains = vulkan_memory_model_availability_visibility_chains + .into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceShaderAtomicInt64Features<'a> { @@ -581,6 +2123,41 @@ pub(crate) mod reexport { pub shader_shared_int64_atomics: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceShaderAtomicInt64Features<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceShaderAtomicInt64Features<'a> {} + unsafe impl<'a> crate::Extends> + for PhysicalDeviceShaderAtomicInt64Features<'a> {} + impl<'a> Default for PhysicalDeviceShaderAtomicInt64Features<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + shader_buffer_int64_atomics: Default::default(), + shader_shared_int64_atomics: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceShaderAtomicInt64Features<'a> { + pub fn shader_buffer_int64_atomics( + mut self, + shader_buffer_int64_atomics: bool, + ) -> Self { + self.shader_buffer_int64_atomics = shader_buffer_int64_atomics.into(); + self + } + pub fn shader_shared_int64_atomics( + mut self, + shader_shared_int64_atomics: bool, + ) -> Self { + self.shader_shared_int64_atomics = shader_shared_int64_atomics.into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceDepthStencilResolveProperties<'a> { @@ -592,6 +2169,52 @@ pub(crate) mod reexport { pub independent_resolve: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceDepthStencilResolveProperties<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceDepthStencilResolveProperties<'a> {} + impl<'a> Default for PhysicalDeviceDepthStencilResolveProperties<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + supported_depth_resolve_modes: Default::default(), + supported_stencil_resolve_modes: Default::default(), + independent_resolve_none: Default::default(), + independent_resolve: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceDepthStencilResolveProperties<'a> { + pub fn supported_depth_resolve_modes( + mut self, + supported_depth_resolve_modes: crate::vk::ResolveModeFlags, + ) -> Self { + self.supported_depth_resolve_modes = supported_depth_resolve_modes; + self + } + pub fn supported_stencil_resolve_modes( + mut self, + supported_stencil_resolve_modes: crate::vk::ResolveModeFlags, + ) -> Self { + self.supported_stencil_resolve_modes = supported_stencil_resolve_modes; + self + } + pub fn independent_resolve_none( + mut self, + independent_resolve_none: bool, + ) -> Self { + self.independent_resolve_none = independent_resolve_none.into(); + self + } + pub fn independent_resolve(mut self, independent_resolve: bool) -> Self { + self.independent_resolve = independent_resolve.into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct SubpassDescriptionDepthStencilResolve<'a> { @@ -604,6 +2227,47 @@ pub(crate) mod reexport { >, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for SubpassDescriptionDepthStencilResolve<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE; + } + unsafe impl<'a> crate::Extends> + for SubpassDescriptionDepthStencilResolve<'a> {} + impl<'a> Default for SubpassDescriptionDepthStencilResolve<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + depth_resolve_mode: Default::default(), + stencil_resolve_mode: Default::default(), + p_depth_stencil_resolve_attachment: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> SubpassDescriptionDepthStencilResolve<'a> { + pub fn depth_resolve_mode( + mut self, + depth_resolve_mode: crate::vk::ResolveModeFlagBits, + ) -> Self { + self.depth_resolve_mode = depth_resolve_mode; + self + } + pub fn stencil_resolve_mode( + mut self, + stencil_resolve_mode: crate::vk::ResolveModeFlagBits, + ) -> Self { + self.stencil_resolve_mode = stencil_resolve_mode; + self + } + pub fn p_depth_stencil_resolve_attachment( + mut self, + p_depth_stencil_resolve_attachment: &'a crate::vk::AttachmentReference2<'a>, + ) -> Self { + self.p_depth_stencil_resolve_attachment = p_depth_stencil_resolve_attachment; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct ImageStencilUsageCreateInfo<'a> { @@ -612,6 +2276,32 @@ pub(crate) mod reexport { pub stencil_usage: crate::vk::ImageUsageFlags, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for ImageStencilUsageCreateInfo<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::IMAGE_STENCIL_USAGE_CREATE_INFO; + } + unsafe impl<'a> crate::Extends> + for ImageStencilUsageCreateInfo<'a> {} + unsafe impl<'a> crate::Extends> + for ImageStencilUsageCreateInfo<'a> {} + impl<'a> Default for ImageStencilUsageCreateInfo<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + stencil_usage: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> ImageStencilUsageCreateInfo<'a> { + pub fn stencil_usage( + mut self, + stencil_usage: crate::vk::ImageUsageFlags, + ) -> Self { + self.stencil_usage = stencil_usage; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceScalarBlockLayoutFeatures<'a> { @@ -620,6 +2310,30 @@ pub(crate) mod reexport { pub scalar_block_layout: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceScalarBlockLayoutFeatures<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceScalarBlockLayoutFeatures<'a> {} + unsafe impl<'a> crate::Extends> + for PhysicalDeviceScalarBlockLayoutFeatures<'a> {} + impl<'a> Default for PhysicalDeviceScalarBlockLayoutFeatures<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + scalar_block_layout: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceScalarBlockLayoutFeatures<'a> { + pub fn scalar_block_layout(mut self, scalar_block_layout: bool) -> Self { + self.scalar_block_layout = scalar_block_layout.into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceUniformBufferStandardLayoutFeatures<'a> { @@ -628,6 +2342,33 @@ pub(crate) mod reexport { pub uniform_buffer_standard_layout: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceUniformBufferStandardLayoutFeatures<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceUniformBufferStandardLayoutFeatures<'a> {} + unsafe impl<'a> crate::Extends> + for PhysicalDeviceUniformBufferStandardLayoutFeatures<'a> {} + impl<'a> Default for PhysicalDeviceUniformBufferStandardLayoutFeatures<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + uniform_buffer_standard_layout: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceUniformBufferStandardLayoutFeatures<'a> { + pub fn uniform_buffer_standard_layout( + mut self, + uniform_buffer_standard_layout: bool, + ) -> Self { + self.uniform_buffer_standard_layout = uniform_buffer_standard_layout.into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceBufferDeviceAddressFeatures<'a> { @@ -638,6 +2379,48 @@ pub(crate) mod reexport { pub buffer_device_address_multi_device: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceBufferDeviceAddressFeatures<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceBufferDeviceAddressFeatures<'a> {} + unsafe impl<'a> crate::Extends> + for PhysicalDeviceBufferDeviceAddressFeatures<'a> {} + impl<'a> Default for PhysicalDeviceBufferDeviceAddressFeatures<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + buffer_device_address: Default::default(), + buffer_device_address_capture_replay: Default::default(), + buffer_device_address_multi_device: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceBufferDeviceAddressFeatures<'a> { + pub fn buffer_device_address(mut self, buffer_device_address: bool) -> Self { + self.buffer_device_address = buffer_device_address.into(); + self + } + pub fn buffer_device_address_capture_replay( + mut self, + buffer_device_address_capture_replay: bool, + ) -> Self { + self.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, + ) -> Self { + self.buffer_device_address_multi_device = buffer_device_address_multi_device + .into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct BufferDeviceAddressInfo<'a> { @@ -646,6 +2429,25 @@ pub(crate) mod reexport { pub buffer: crate::vk::Buffer, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for BufferDeviceAddressInfo<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::BUFFER_DEVICE_ADDRESS_INFO; + } + impl<'a> Default for BufferDeviceAddressInfo<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + buffer: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> BufferDeviceAddressInfo<'a> { + pub fn buffer(mut self, buffer: crate::vk::Buffer) -> Self { + self.buffer = buffer; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct BufferOpaqueCaptureAddressCreateInfo<'a> { @@ -654,6 +2456,28 @@ pub(crate) mod reexport { pub opaque_capture_address: u64, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for BufferOpaqueCaptureAddressCreateInfo<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO; + } + unsafe impl<'a> crate::Extends> + for BufferOpaqueCaptureAddressCreateInfo<'a> {} + impl<'a> Default for BufferOpaqueCaptureAddressCreateInfo<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + opaque_capture_address: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> BufferOpaqueCaptureAddressCreateInfo<'a> { + pub fn opaque_capture_address(mut self, opaque_capture_address: u64) -> Self { + self.opaque_capture_address = opaque_capture_address; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceImagelessFramebufferFeatures<'a> { @@ -662,6 +2486,30 @@ pub(crate) mod reexport { pub imageless_framebuffer: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceImagelessFramebufferFeatures<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceImagelessFramebufferFeatures<'a> {} + unsafe impl<'a> crate::Extends> + for PhysicalDeviceImagelessFramebufferFeatures<'a> {} + impl<'a> Default for PhysicalDeviceImagelessFramebufferFeatures<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + imageless_framebuffer: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceImagelessFramebufferFeatures<'a> { + pub fn imageless_framebuffer(mut self, imageless_framebuffer: bool) -> Self { + self.imageless_framebuffer = imageless_framebuffer.into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct FramebufferAttachmentsCreateInfo<'a> { @@ -673,6 +2521,39 @@ pub(crate) mod reexport { >, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for FramebufferAttachmentsCreateInfo<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::FRAMEBUFFER_ATTACHMENTS_CREATE_INFO; + } + unsafe impl<'a> crate::Extends> + for FramebufferAttachmentsCreateInfo<'a> {} + impl<'a> Default for FramebufferAttachmentsCreateInfo<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + attachment_image_info_count: Default::default(), + p_attachment_image_infos: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> FramebufferAttachmentsCreateInfo<'a> { + pub fn attachment_image_info_count( + mut self, + attachment_image_info_count: u32, + ) -> Self { + self.attachment_image_info_count = attachment_image_info_count; + self + } + pub fn p_attachment_image_infos( + mut self, + p_attachment_image_infos: &'a [crate::vk::FramebufferAttachmentImageInfo<'a>], + ) -> Self { + self.attachment_image_info_count = p_attachment_image_infos.len() as _; + self.p_attachment_image_infos = p_attachment_image_infos.as_ptr(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct FramebufferAttachmentImageInfo<'a> { @@ -687,6 +2568,59 @@ pub(crate) mod reexport { pub p_view_formats: *const crate::vk::Format, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for FramebufferAttachmentImageInfo<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::FRAMEBUFFER_ATTACHMENT_IMAGE_INFO; + } + impl<'a> Default for FramebufferAttachmentImageInfo<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + flags: Default::default(), + usage: Default::default(), + width: Default::default(), + height: Default::default(), + layer_count: Default::default(), + view_format_count: Default::default(), + p_view_formats: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> FramebufferAttachmentImageInfo<'a> { + pub fn flags(mut self, flags: crate::vk::ImageCreateFlags) -> Self { + self.flags = flags; + self + } + pub fn usage(mut self, usage: crate::vk::ImageUsageFlags) -> Self { + self.usage = usage; + self + } + pub fn width(mut self, width: u32) -> Self { + self.width = width; + self + } + pub fn height(mut self, height: u32) -> Self { + self.height = height; + self + } + pub fn layer_count(mut self, layer_count: u32) -> Self { + self.layer_count = layer_count; + self + } + pub fn view_format_count(mut self, view_format_count: u32) -> Self { + self.view_format_count = view_format_count; + self + } + pub fn p_view_formats( + mut self, + p_view_formats: &'a [crate::vk::Format], + ) -> Self { + self.view_format_count = p_view_formats.len() as _; + self.p_view_formats = p_view_formats.as_ptr(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct RenderPassAttachmentBeginInfo<'a> { @@ -696,6 +2630,36 @@ pub(crate) mod reexport { pub p_attachments: *const crate::vk::ImageView, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for RenderPassAttachmentBeginInfo<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::RENDER_PASS_ATTACHMENT_BEGIN_INFO; + } + unsafe impl<'a> crate::Extends> + for RenderPassAttachmentBeginInfo<'a> {} + impl<'a> Default for RenderPassAttachmentBeginInfo<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + attachment_count: Default::default(), + p_attachments: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> RenderPassAttachmentBeginInfo<'a> { + pub fn attachment_count(mut self, attachment_count: u32) -> Self { + self.attachment_count = attachment_count; + self + } + pub fn p_attachments( + mut self, + p_attachments: &'a [crate::vk::ImageView], + ) -> Self { + self.attachment_count = p_attachments.len() as _; + self.p_attachments = p_attachments.as_ptr(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceSeparateDepthStencilLayoutsFeatures<'a> { @@ -704,6 +2668,33 @@ pub(crate) mod reexport { pub separate_depth_stencil_layouts: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceSeparateDepthStencilLayoutsFeatures<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceSeparateDepthStencilLayoutsFeatures<'a> {} + unsafe impl<'a> crate::Extends> + for PhysicalDeviceSeparateDepthStencilLayoutsFeatures<'a> {} + impl<'a> Default for PhysicalDeviceSeparateDepthStencilLayoutsFeatures<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + separate_depth_stencil_layouts: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceSeparateDepthStencilLayoutsFeatures<'a> { + pub fn separate_depth_stencil_layouts( + mut self, + separate_depth_stencil_layouts: bool, + ) -> Self { + self.separate_depth_stencil_layouts = separate_depth_stencil_layouts.into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct AttachmentReferenceStencilLayout<'a> { @@ -712,6 +2703,27 @@ pub(crate) mod reexport { pub stencil_layout: crate::vk::ImageLayout, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for AttachmentReferenceStencilLayout<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::ATTACHMENT_REFERENCE_STENCIL_LAYOUT; + } + unsafe impl<'a> crate::Extends> + for AttachmentReferenceStencilLayout<'a> {} + impl<'a> Default for AttachmentReferenceStencilLayout<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + stencil_layout: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> AttachmentReferenceStencilLayout<'a> { + pub fn stencil_layout(mut self, stencil_layout: crate::vk::ImageLayout) -> Self { + self.stencil_layout = stencil_layout; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct AttachmentDescriptionStencilLayout<'a> { @@ -721,6 +2733,39 @@ pub(crate) mod reexport { pub stencil_final_layout: crate::vk::ImageLayout, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for AttachmentDescriptionStencilLayout<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT; + } + unsafe impl<'a> crate::Extends> + for AttachmentDescriptionStencilLayout<'a> {} + impl<'a> Default for AttachmentDescriptionStencilLayout<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + stencil_initial_layout: Default::default(), + stencil_final_layout: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> AttachmentDescriptionStencilLayout<'a> { + pub fn stencil_initial_layout( + mut self, + stencil_initial_layout: crate::vk::ImageLayout, + ) -> Self { + self.stencil_initial_layout = stencil_initial_layout; + self + } + pub fn stencil_final_layout( + mut self, + stencil_final_layout: crate::vk::ImageLayout, + ) -> Self { + self.stencil_final_layout = stencil_final_layout; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct MemoryOpaqueCaptureAddressAllocateInfo<'a> { @@ -729,6 +2774,28 @@ pub(crate) mod reexport { pub opaque_capture_address: u64, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for MemoryOpaqueCaptureAddressAllocateInfo<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO; + } + unsafe impl<'a> crate::Extends> + for MemoryOpaqueCaptureAddressAllocateInfo<'a> {} + impl<'a> Default for MemoryOpaqueCaptureAddressAllocateInfo<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + opaque_capture_address: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> MemoryOpaqueCaptureAddressAllocateInfo<'a> { + pub fn opaque_capture_address(mut self, opaque_capture_address: u64) -> Self { + self.opaque_capture_address = opaque_capture_address; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct DeviceMemoryOpaqueCaptureAddressInfo<'a> { @@ -737,6 +2804,26 @@ pub(crate) mod reexport { pub memory: crate::vk::DeviceMemory, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for DeviceMemoryOpaqueCaptureAddressInfo<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO; + } + impl<'a> Default for DeviceMemoryOpaqueCaptureAddressInfo<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + memory: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> DeviceMemoryOpaqueCaptureAddressInfo<'a> { + pub fn memory(mut self, memory: crate::vk::DeviceMemory) -> Self { + self.memory = memory; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceVulkan11Features<'a> { @@ -756,6 +2843,104 @@ pub(crate) mod reexport { pub shader_draw_parameters: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for PhysicalDeviceVulkan11Features<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_VULKAN_1_1_FEATURES; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceVulkan11Features<'a> {} + unsafe impl<'a> crate::Extends> + for PhysicalDeviceVulkan11Features<'a> {} + impl<'a> Default for PhysicalDeviceVulkan11Features<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + storage_buffer16_bit_access: Default::default(), + uniform_and_storage_buffer16_bit_access: Default::default(), + storage_push_constant16: Default::default(), + storage_input_output16: Default::default(), + multiview: Default::default(), + multiview_geometry_shader: Default::default(), + multiview_tessellation_shader: Default::default(), + variable_pointers_storage_buffer: Default::default(), + variable_pointers: Default::default(), + protected_memory: Default::default(), + sampler_ycbcr_conversion: Default::default(), + shader_draw_parameters: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceVulkan11Features<'a> { + pub fn storage_buffer16_bit_access( + mut self, + storage_buffer16_bit_access: bool, + ) -> Self { + self.storage_buffer16_bit_access = storage_buffer16_bit_access.into(); + self + } + pub fn uniform_and_storage_buffer16_bit_access( + mut self, + uniform_and_storage_buffer16_bit_access: bool, + ) -> Self { + self.uniform_and_storage_buffer16_bit_access = uniform_and_storage_buffer16_bit_access + .into(); + self + } + pub fn storage_push_constant16(mut self, storage_push_constant16: bool) -> Self { + self.storage_push_constant16 = storage_push_constant16.into(); + self + } + pub fn storage_input_output16(mut self, storage_input_output16: bool) -> Self { + self.storage_input_output16 = storage_input_output16.into(); + self + } + pub fn multiview(mut self, multiview: bool) -> Self { + self.multiview = multiview.into(); + self + } + pub fn multiview_geometry_shader( + mut self, + multiview_geometry_shader: bool, + ) -> Self { + self.multiview_geometry_shader = multiview_geometry_shader.into(); + self + } + pub fn multiview_tessellation_shader( + mut self, + multiview_tessellation_shader: bool, + ) -> Self { + self.multiview_tessellation_shader = multiview_tessellation_shader.into(); + self + } + pub fn variable_pointers_storage_buffer( + mut self, + variable_pointers_storage_buffer: bool, + ) -> Self { + self.variable_pointers_storage_buffer = variable_pointers_storage_buffer + .into(); + self + } + pub fn variable_pointers(mut self, variable_pointers: bool) -> Self { + self.variable_pointers = variable_pointers.into(); + self + } + pub fn protected_memory(mut self, protected_memory: bool) -> Self { + self.protected_memory = protected_memory.into(); + self + } + pub fn sampler_ycbcr_conversion( + mut self, + sampler_ycbcr_conversion: bool, + ) -> Self { + self.sampler_ycbcr_conversion = sampler_ycbcr_conversion.into(); + self + } + pub fn shader_draw_parameters(mut self, shader_draw_parameters: bool) -> Self { + self.shader_draw_parameters = shader_draw_parameters.into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceVulkan11Properties<'a> { @@ -778,6 +2963,128 @@ pub(crate) mod reexport { pub max_memory_allocation_size: crate::vk::DeviceSize, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for PhysicalDeviceVulkan11Properties<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceVulkan11Properties<'a> {} + impl<'a> Default for PhysicalDeviceVulkan11Properties<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + device_uuid: unsafe { core::mem::zeroed() }, + driver_uuid: unsafe { core::mem::zeroed() }, + device_luid: unsafe { core::mem::zeroed() }, + device_node_mask: Default::default(), + device_luid_valid: Default::default(), + subgroup_size: Default::default(), + subgroup_supported_stages: Default::default(), + subgroup_supported_operations: Default::default(), + subgroup_quad_operations_in_all_stages: Default::default(), + point_clipping_behavior: Default::default(), + max_multiview_view_count: Default::default(), + max_multiview_instance_index: Default::default(), + protected_no_fault: Default::default(), + max_per_set_descriptors: Default::default(), + max_memory_allocation_size: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceVulkan11Properties<'a> { + pub fn device_uuid( + mut self, + device_uuid: [u8; crate::vk::UUID_SIZE as _], + ) -> Self { + self.device_uuid = device_uuid; + self + } + pub fn driver_uuid( + mut self, + driver_uuid: [u8; crate::vk::UUID_SIZE as _], + ) -> Self { + self.driver_uuid = driver_uuid; + self + } + pub fn device_luid( + mut self, + device_luid: [u8; crate::vk::LUID_SIZE as _], + ) -> Self { + self.device_luid = device_luid; + self + } + pub fn device_node_mask(mut self, device_node_mask: u32) -> Self { + self.device_node_mask = device_node_mask; + self + } + pub fn device_luid_valid(mut self, device_luid_valid: bool) -> Self { + self.device_luid_valid = device_luid_valid.into(); + self + } + pub fn subgroup_size(mut self, subgroup_size: u32) -> Self { + self.subgroup_size = subgroup_size; + self + } + pub fn subgroup_supported_stages( + mut self, + subgroup_supported_stages: crate::vk::ShaderStageFlags, + ) -> Self { + self.subgroup_supported_stages = subgroup_supported_stages; + self + } + pub fn subgroup_supported_operations( + mut self, + subgroup_supported_operations: crate::vk::SubgroupFeatureFlags, + ) -> Self { + self.subgroup_supported_operations = subgroup_supported_operations; + self + } + pub fn subgroup_quad_operations_in_all_stages( + mut self, + subgroup_quad_operations_in_all_stages: bool, + ) -> Self { + self.subgroup_quad_operations_in_all_stages = subgroup_quad_operations_in_all_stages + .into(); + self + } + pub fn point_clipping_behavior( + mut self, + point_clipping_behavior: crate::vk::PointClippingBehavior, + ) -> Self { + self.point_clipping_behavior = point_clipping_behavior; + self + } + pub fn max_multiview_view_count( + mut self, + max_multiview_view_count: u32, + ) -> Self { + self.max_multiview_view_count = max_multiview_view_count; + self + } + pub fn max_multiview_instance_index( + mut self, + max_multiview_instance_index: u32, + ) -> Self { + self.max_multiview_instance_index = max_multiview_instance_index; + self + } + pub fn protected_no_fault(mut self, protected_no_fault: bool) -> Self { + self.protected_no_fault = protected_no_fault.into(); + self + } + pub fn max_per_set_descriptors(mut self, max_per_set_descriptors: u32) -> Self { + self.max_per_set_descriptors = max_per_set_descriptors; + self + } + pub fn max_memory_allocation_size( + mut self, + max_memory_allocation_size: crate::vk::DeviceSize, + ) -> Self { + self.max_memory_allocation_size = max_memory_allocation_size; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceVulkan12Features<'a> { @@ -832,6 +3139,385 @@ pub(crate) mod reexport { pub subgroup_broadcast_dynamic_id: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for PhysicalDeviceVulkan12Features<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_VULKAN_1_2_FEATURES; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceVulkan12Features<'a> {} + unsafe impl<'a> crate::Extends> + for PhysicalDeviceVulkan12Features<'a> {} + impl<'a> Default for PhysicalDeviceVulkan12Features<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + sampler_mirror_clamp_to_edge: Default::default(), + draw_indirect_count: Default::default(), + storage_buffer8_bit_access: Default::default(), + uniform_and_storage_buffer8_bit_access: Default::default(), + storage_push_constant8: Default::default(), + shader_buffer_int64_atomics: Default::default(), + shader_shared_int64_atomics: Default::default(), + shader_float16: Default::default(), + shader_int8: Default::default(), + descriptor_indexing: Default::default(), + shader_input_attachment_array_dynamic_indexing: Default::default(), + shader_uniform_texel_buffer_array_dynamic_indexing: Default::default(), + shader_storage_texel_buffer_array_dynamic_indexing: Default::default(), + shader_uniform_buffer_array_non_uniform_indexing: Default::default(), + shader_sampled_image_array_non_uniform_indexing: Default::default(), + shader_storage_buffer_array_non_uniform_indexing: Default::default(), + shader_storage_image_array_non_uniform_indexing: Default::default(), + shader_input_attachment_array_non_uniform_indexing: Default::default(), + shader_uniform_texel_buffer_array_non_uniform_indexing: Default::default(), + shader_storage_texel_buffer_array_non_uniform_indexing: Default::default(), + descriptor_binding_uniform_buffer_update_after_bind: Default::default(), + descriptor_binding_sampled_image_update_after_bind: Default::default(), + descriptor_binding_storage_image_update_after_bind: Default::default(), + descriptor_binding_storage_buffer_update_after_bind: Default::default(), + descriptor_binding_uniform_texel_buffer_update_after_bind: Default::default(), + descriptor_binding_storage_texel_buffer_update_after_bind: Default::default(), + descriptor_binding_update_unused_while_pending: Default::default(), + descriptor_binding_partially_bound: Default::default(), + descriptor_binding_variable_descriptor_count: Default::default(), + runtime_descriptor_array: Default::default(), + sampler_filter_minmax: Default::default(), + scalar_block_layout: Default::default(), + imageless_framebuffer: Default::default(), + uniform_buffer_standard_layout: Default::default(), + shader_subgroup_extended_types: Default::default(), + separate_depth_stencil_layouts: Default::default(), + host_query_reset: Default::default(), + timeline_semaphore: Default::default(), + buffer_device_address: Default::default(), + buffer_device_address_capture_replay: Default::default(), + buffer_device_address_multi_device: Default::default(), + vulkan_memory_model: Default::default(), + vulkan_memory_model_device_scope: Default::default(), + vulkan_memory_model_availability_visibility_chains: Default::default(), + shader_output_viewport_index: Default::default(), + shader_output_layer: Default::default(), + subgroup_broadcast_dynamic_id: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceVulkan12Features<'a> { + pub fn sampler_mirror_clamp_to_edge( + mut self, + sampler_mirror_clamp_to_edge: bool, + ) -> Self { + self.sampler_mirror_clamp_to_edge = sampler_mirror_clamp_to_edge.into(); + self + } + pub fn draw_indirect_count(mut self, draw_indirect_count: bool) -> Self { + self.draw_indirect_count = draw_indirect_count.into(); + self + } + pub fn storage_buffer8_bit_access( + mut self, + storage_buffer8_bit_access: bool, + ) -> Self { + self.storage_buffer8_bit_access = storage_buffer8_bit_access.into(); + self + } + pub fn uniform_and_storage_buffer8_bit_access( + mut self, + uniform_and_storage_buffer8_bit_access: bool, + ) -> Self { + self.uniform_and_storage_buffer8_bit_access = uniform_and_storage_buffer8_bit_access + .into(); + self + } + pub fn storage_push_constant8(mut self, storage_push_constant8: bool) -> Self { + self.storage_push_constant8 = storage_push_constant8.into(); + self + } + pub fn shader_buffer_int64_atomics( + mut self, + shader_buffer_int64_atomics: bool, + ) -> Self { + self.shader_buffer_int64_atomics = shader_buffer_int64_atomics.into(); + self + } + pub fn shader_shared_int64_atomics( + mut self, + shader_shared_int64_atomics: bool, + ) -> Self { + self.shader_shared_int64_atomics = shader_shared_int64_atomics.into(); + self + } + pub fn shader_float16(mut self, shader_float16: bool) -> Self { + self.shader_float16 = shader_float16.into(); + self + } + pub fn shader_int8(mut self, shader_int8: bool) -> Self { + self.shader_int8 = shader_int8.into(); + self + } + pub fn descriptor_indexing(mut self, descriptor_indexing: bool) -> Self { + self.descriptor_indexing = descriptor_indexing.into(); + self + } + pub fn shader_input_attachment_array_dynamic_indexing( + mut self, + shader_input_attachment_array_dynamic_indexing: bool, + ) -> Self { + self.shader_input_attachment_array_dynamic_indexing = shader_input_attachment_array_dynamic_indexing + .into(); + self + } + pub fn shader_uniform_texel_buffer_array_dynamic_indexing( + mut self, + shader_uniform_texel_buffer_array_dynamic_indexing: bool, + ) -> Self { + self.shader_uniform_texel_buffer_array_dynamic_indexing = shader_uniform_texel_buffer_array_dynamic_indexing + .into(); + self + } + pub fn shader_storage_texel_buffer_array_dynamic_indexing( + mut self, + shader_storage_texel_buffer_array_dynamic_indexing: bool, + ) -> Self { + self.shader_storage_texel_buffer_array_dynamic_indexing = shader_storage_texel_buffer_array_dynamic_indexing + .into(); + self + } + pub fn shader_uniform_buffer_array_non_uniform_indexing( + mut self, + shader_uniform_buffer_array_non_uniform_indexing: bool, + ) -> Self { + self.shader_uniform_buffer_array_non_uniform_indexing = shader_uniform_buffer_array_non_uniform_indexing + .into(); + self + } + pub fn shader_sampled_image_array_non_uniform_indexing( + mut self, + shader_sampled_image_array_non_uniform_indexing: bool, + ) -> Self { + self.shader_sampled_image_array_non_uniform_indexing = shader_sampled_image_array_non_uniform_indexing + .into(); + self + } + pub fn shader_storage_buffer_array_non_uniform_indexing( + mut self, + shader_storage_buffer_array_non_uniform_indexing: bool, + ) -> Self { + self.shader_storage_buffer_array_non_uniform_indexing = shader_storage_buffer_array_non_uniform_indexing + .into(); + self + } + pub fn shader_storage_image_array_non_uniform_indexing( + mut self, + shader_storage_image_array_non_uniform_indexing: bool, + ) -> Self { + self.shader_storage_image_array_non_uniform_indexing = shader_storage_image_array_non_uniform_indexing + .into(); + self + } + pub fn shader_input_attachment_array_non_uniform_indexing( + mut self, + shader_input_attachment_array_non_uniform_indexing: bool, + ) -> Self { + self.shader_input_attachment_array_non_uniform_indexing = shader_input_attachment_array_non_uniform_indexing + .into(); + self + } + pub fn shader_uniform_texel_buffer_array_non_uniform_indexing( + mut self, + shader_uniform_texel_buffer_array_non_uniform_indexing: bool, + ) -> Self { + self.shader_uniform_texel_buffer_array_non_uniform_indexing = shader_uniform_texel_buffer_array_non_uniform_indexing + .into(); + self + } + pub fn shader_storage_texel_buffer_array_non_uniform_indexing( + mut self, + shader_storage_texel_buffer_array_non_uniform_indexing: bool, + ) -> Self { + self.shader_storage_texel_buffer_array_non_uniform_indexing = shader_storage_texel_buffer_array_non_uniform_indexing + .into(); + self + } + pub fn descriptor_binding_uniform_buffer_update_after_bind( + mut self, + descriptor_binding_uniform_buffer_update_after_bind: bool, + ) -> Self { + self.descriptor_binding_uniform_buffer_update_after_bind = descriptor_binding_uniform_buffer_update_after_bind + .into(); + self + } + pub fn descriptor_binding_sampled_image_update_after_bind( + mut self, + descriptor_binding_sampled_image_update_after_bind: bool, + ) -> Self { + self.descriptor_binding_sampled_image_update_after_bind = descriptor_binding_sampled_image_update_after_bind + .into(); + self + } + pub fn descriptor_binding_storage_image_update_after_bind( + mut self, + descriptor_binding_storage_image_update_after_bind: bool, + ) -> Self { + self.descriptor_binding_storage_image_update_after_bind = descriptor_binding_storage_image_update_after_bind + .into(); + self + } + pub fn descriptor_binding_storage_buffer_update_after_bind( + mut self, + descriptor_binding_storage_buffer_update_after_bind: bool, + ) -> Self { + self.descriptor_binding_storage_buffer_update_after_bind = descriptor_binding_storage_buffer_update_after_bind + .into(); + self + } + pub fn descriptor_binding_uniform_texel_buffer_update_after_bind( + mut self, + descriptor_binding_uniform_texel_buffer_update_after_bind: bool, + ) -> Self { + self.descriptor_binding_uniform_texel_buffer_update_after_bind = descriptor_binding_uniform_texel_buffer_update_after_bind + .into(); + self + } + pub fn descriptor_binding_storage_texel_buffer_update_after_bind( + mut self, + descriptor_binding_storage_texel_buffer_update_after_bind: bool, + ) -> Self { + self.descriptor_binding_storage_texel_buffer_update_after_bind = descriptor_binding_storage_texel_buffer_update_after_bind + .into(); + self + } + pub fn descriptor_binding_update_unused_while_pending( + mut self, + descriptor_binding_update_unused_while_pending: bool, + ) -> Self { + self.descriptor_binding_update_unused_while_pending = descriptor_binding_update_unused_while_pending + .into(); + self + } + pub fn descriptor_binding_partially_bound( + mut self, + descriptor_binding_partially_bound: bool, + ) -> Self { + self.descriptor_binding_partially_bound = descriptor_binding_partially_bound + .into(); + self + } + pub fn descriptor_binding_variable_descriptor_count( + mut self, + descriptor_binding_variable_descriptor_count: bool, + ) -> Self { + self.descriptor_binding_variable_descriptor_count = descriptor_binding_variable_descriptor_count + .into(); + self + } + pub fn runtime_descriptor_array( + mut self, + runtime_descriptor_array: bool, + ) -> Self { + self.runtime_descriptor_array = runtime_descriptor_array.into(); + self + } + pub fn sampler_filter_minmax(mut self, sampler_filter_minmax: bool) -> Self { + self.sampler_filter_minmax = sampler_filter_minmax.into(); + self + } + pub fn scalar_block_layout(mut self, scalar_block_layout: bool) -> Self { + self.scalar_block_layout = scalar_block_layout.into(); + self + } + pub fn imageless_framebuffer(mut self, imageless_framebuffer: bool) -> Self { + self.imageless_framebuffer = imageless_framebuffer.into(); + self + } + pub fn uniform_buffer_standard_layout( + mut self, + uniform_buffer_standard_layout: bool, + ) -> Self { + self.uniform_buffer_standard_layout = uniform_buffer_standard_layout.into(); + self + } + pub fn shader_subgroup_extended_types( + mut self, + shader_subgroup_extended_types: bool, + ) -> Self { + self.shader_subgroup_extended_types = shader_subgroup_extended_types.into(); + self + } + pub fn separate_depth_stencil_layouts( + mut self, + separate_depth_stencil_layouts: bool, + ) -> Self { + self.separate_depth_stencil_layouts = separate_depth_stencil_layouts.into(); + self + } + pub fn host_query_reset(mut self, host_query_reset: bool) -> Self { + self.host_query_reset = host_query_reset.into(); + self + } + pub fn timeline_semaphore(mut self, timeline_semaphore: bool) -> Self { + self.timeline_semaphore = timeline_semaphore.into(); + self + } + pub fn buffer_device_address(mut self, buffer_device_address: bool) -> Self { + self.buffer_device_address = buffer_device_address.into(); + self + } + pub fn buffer_device_address_capture_replay( + mut self, + buffer_device_address_capture_replay: bool, + ) -> Self { + self.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, + ) -> Self { + self.buffer_device_address_multi_device = buffer_device_address_multi_device + .into(); + self + } + pub fn vulkan_memory_model(mut self, vulkan_memory_model: bool) -> Self { + self.vulkan_memory_model = vulkan_memory_model.into(); + self + } + pub fn vulkan_memory_model_device_scope( + mut self, + vulkan_memory_model_device_scope: bool, + ) -> Self { + self.vulkan_memory_model_device_scope = vulkan_memory_model_device_scope + .into(); + self + } + pub fn vulkan_memory_model_availability_visibility_chains( + mut self, + vulkan_memory_model_availability_visibility_chains: bool, + ) -> Self { + self.vulkan_memory_model_availability_visibility_chains = vulkan_memory_model_availability_visibility_chains + .into(); + self + } + pub fn shader_output_viewport_index( + mut self, + shader_output_viewport_index: bool, + ) -> Self { + self.shader_output_viewport_index = shader_output_viewport_index.into(); + self + } + pub fn shader_output_layer(mut self, shader_output_layer: bool) -> Self { + self.shader_output_layer = shader_output_layer.into(); + self + } + pub fn subgroup_broadcast_dynamic_id( + mut self, + subgroup_broadcast_dynamic_id: bool, + ) -> Self { + self.subgroup_broadcast_dynamic_id = subgroup_broadcast_dynamic_id.into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceVulkan12Properties<'a> { @@ -891,6 +3577,462 @@ pub(crate) mod reexport { pub framebuffer_integer_color_sample_counts: crate::vk::SampleCountFlags, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for PhysicalDeviceVulkan12Properties<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceVulkan12Properties<'a> {} + impl<'a> Default for PhysicalDeviceVulkan12Properties<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + driver_id: Default::default(), + driver_name: unsafe { core::mem::zeroed() }, + driver_info: unsafe { core::mem::zeroed() }, + conformance_version: Default::default(), + denorm_behavior_independence: Default::default(), + rounding_mode_independence: Default::default(), + shader_signed_zero_inf_nan_preserve_float16: Default::default(), + shader_signed_zero_inf_nan_preserve_float32: Default::default(), + shader_signed_zero_inf_nan_preserve_float64: Default::default(), + shader_denorm_preserve_float16: Default::default(), + shader_denorm_preserve_float32: Default::default(), + shader_denorm_preserve_float64: Default::default(), + shader_denorm_flush_to_zero_float16: Default::default(), + shader_denorm_flush_to_zero_float32: Default::default(), + shader_denorm_flush_to_zero_float64: Default::default(), + shader_rounding_mode_rte_float16: Default::default(), + shader_rounding_mode_rte_float32: Default::default(), + shader_rounding_mode_rte_float64: Default::default(), + shader_rounding_mode_rtz_float16: Default::default(), + shader_rounding_mode_rtz_float32: Default::default(), + shader_rounding_mode_rtz_float64: Default::default(), + max_update_after_bind_descriptors_in_all_pools: Default::default(), + shader_uniform_buffer_array_non_uniform_indexing_native: Default::default(), + shader_sampled_image_array_non_uniform_indexing_native: Default::default(), + shader_storage_buffer_array_non_uniform_indexing_native: Default::default(), + shader_storage_image_array_non_uniform_indexing_native: Default::default(), + shader_input_attachment_array_non_uniform_indexing_native: Default::default(), + robust_buffer_access_update_after_bind: Default::default(), + quad_divergent_implicit_lod: Default::default(), + max_per_stage_descriptor_update_after_bind_samplers: Default::default(), + max_per_stage_descriptor_update_after_bind_uniform_buffers: Default::default(), + max_per_stage_descriptor_update_after_bind_storage_buffers: Default::default(), + max_per_stage_descriptor_update_after_bind_sampled_images: Default::default(), + max_per_stage_descriptor_update_after_bind_storage_images: Default::default(), + max_per_stage_descriptor_update_after_bind_input_attachments: Default::default(), + max_per_stage_update_after_bind_resources: Default::default(), + max_descriptor_set_update_after_bind_samplers: Default::default(), + max_descriptor_set_update_after_bind_uniform_buffers: Default::default(), + max_descriptor_set_update_after_bind_uniform_buffers_dynamic: Default::default(), + max_descriptor_set_update_after_bind_storage_buffers: Default::default(), + max_descriptor_set_update_after_bind_storage_buffers_dynamic: Default::default(), + max_descriptor_set_update_after_bind_sampled_images: Default::default(), + max_descriptor_set_update_after_bind_storage_images: Default::default(), + max_descriptor_set_update_after_bind_input_attachments: Default::default(), + supported_depth_resolve_modes: Default::default(), + supported_stencil_resolve_modes: Default::default(), + independent_resolve_none: Default::default(), + independent_resolve: Default::default(), + filter_minmax_single_component_formats: Default::default(), + filter_minmax_image_component_mapping: Default::default(), + max_timeline_semaphore_value_difference: Default::default(), + framebuffer_integer_color_sample_counts: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceVulkan12Properties<'a> { + pub fn driver_id(mut self, driver_id: crate::vk::DriverId) -> Self { + self.driver_id = driver_id; + self + } + pub fn driver_name( + mut self, + driver_name: &core::ffi::CStr, + ) -> core::result::Result { + crate::write_c_str_slice_with_nul(&mut self.driver_name, driver_name) + .map(|_| self) + } + pub fn driver_name_as_c_str( + &self, + ) -> core::result::Result<&core::ffi::CStr, core::ffi::FromBytesUntilNulError> { + crate::wrap_c_str_slice_until_nul(&self.driver_name) + } + pub fn driver_info( + mut self, + driver_info: &core::ffi::CStr, + ) -> core::result::Result { + crate::write_c_str_slice_with_nul(&mut self.driver_info, driver_info) + .map(|_| self) + } + pub fn driver_info_as_c_str( + &self, + ) -> core::result::Result<&core::ffi::CStr, core::ffi::FromBytesUntilNulError> { + crate::wrap_c_str_slice_until_nul(&self.driver_info) + } + pub fn conformance_version( + mut self, + conformance_version: crate::vk::ConformanceVersion, + ) -> Self { + self.conformance_version = conformance_version; + self + } + pub fn denorm_behavior_independence( + mut self, + denorm_behavior_independence: crate::vk::ShaderFloatControlsIndependence, + ) -> Self { + self.denorm_behavior_independence = denorm_behavior_independence; + self + } + pub fn rounding_mode_independence( + mut self, + rounding_mode_independence: crate::vk::ShaderFloatControlsIndependence, + ) -> Self { + self.rounding_mode_independence = rounding_mode_independence; + self + } + pub fn shader_signed_zero_inf_nan_preserve_float16( + mut self, + shader_signed_zero_inf_nan_preserve_float16: bool, + ) -> Self { + self.shader_signed_zero_inf_nan_preserve_float16 = shader_signed_zero_inf_nan_preserve_float16 + .into(); + self + } + pub fn shader_signed_zero_inf_nan_preserve_float32( + mut self, + shader_signed_zero_inf_nan_preserve_float32: bool, + ) -> Self { + self.shader_signed_zero_inf_nan_preserve_float32 = shader_signed_zero_inf_nan_preserve_float32 + .into(); + self + } + pub fn shader_signed_zero_inf_nan_preserve_float64( + mut self, + shader_signed_zero_inf_nan_preserve_float64: bool, + ) -> Self { + self.shader_signed_zero_inf_nan_preserve_float64 = shader_signed_zero_inf_nan_preserve_float64 + .into(); + self + } + pub fn shader_denorm_preserve_float16( + mut self, + shader_denorm_preserve_float16: bool, + ) -> Self { + self.shader_denorm_preserve_float16 = shader_denorm_preserve_float16.into(); + self + } + pub fn shader_denorm_preserve_float32( + mut self, + shader_denorm_preserve_float32: bool, + ) -> Self { + self.shader_denorm_preserve_float32 = shader_denorm_preserve_float32.into(); + self + } + pub fn shader_denorm_preserve_float64( + mut self, + shader_denorm_preserve_float64: bool, + ) -> Self { + self.shader_denorm_preserve_float64 = shader_denorm_preserve_float64.into(); + self + } + pub fn shader_denorm_flush_to_zero_float16( + mut self, + shader_denorm_flush_to_zero_float16: bool, + ) -> Self { + self.shader_denorm_flush_to_zero_float16 = shader_denorm_flush_to_zero_float16 + .into(); + self + } + pub fn shader_denorm_flush_to_zero_float32( + mut self, + shader_denorm_flush_to_zero_float32: bool, + ) -> Self { + self.shader_denorm_flush_to_zero_float32 = shader_denorm_flush_to_zero_float32 + .into(); + self + } + pub fn shader_denorm_flush_to_zero_float64( + mut self, + shader_denorm_flush_to_zero_float64: bool, + ) -> Self { + self.shader_denorm_flush_to_zero_float64 = shader_denorm_flush_to_zero_float64 + .into(); + self + } + pub fn shader_rounding_mode_rte_float16( + mut self, + shader_rounding_mode_rte_float16: bool, + ) -> Self { + self.shader_rounding_mode_rte_float16 = shader_rounding_mode_rte_float16 + .into(); + self + } + pub fn shader_rounding_mode_rte_float32( + mut self, + shader_rounding_mode_rte_float32: bool, + ) -> Self { + self.shader_rounding_mode_rte_float32 = shader_rounding_mode_rte_float32 + .into(); + self + } + pub fn shader_rounding_mode_rte_float64( + mut self, + shader_rounding_mode_rte_float64: bool, + ) -> Self { + self.shader_rounding_mode_rte_float64 = shader_rounding_mode_rte_float64 + .into(); + self + } + pub fn shader_rounding_mode_rtz_float16( + mut self, + shader_rounding_mode_rtz_float16: bool, + ) -> Self { + self.shader_rounding_mode_rtz_float16 = shader_rounding_mode_rtz_float16 + .into(); + self + } + pub fn shader_rounding_mode_rtz_float32( + mut self, + shader_rounding_mode_rtz_float32: bool, + ) -> Self { + self.shader_rounding_mode_rtz_float32 = shader_rounding_mode_rtz_float32 + .into(); + self + } + pub fn shader_rounding_mode_rtz_float64( + mut self, + shader_rounding_mode_rtz_float64: bool, + ) -> Self { + self.shader_rounding_mode_rtz_float64 = shader_rounding_mode_rtz_float64 + .into(); + self + } + pub fn max_update_after_bind_descriptors_in_all_pools( + mut self, + max_update_after_bind_descriptors_in_all_pools: u32, + ) -> Self { + self.max_update_after_bind_descriptors_in_all_pools = max_update_after_bind_descriptors_in_all_pools; + self + } + pub fn shader_uniform_buffer_array_non_uniform_indexing_native( + mut self, + shader_uniform_buffer_array_non_uniform_indexing_native: bool, + ) -> Self { + self.shader_uniform_buffer_array_non_uniform_indexing_native = shader_uniform_buffer_array_non_uniform_indexing_native + .into(); + self + } + pub fn shader_sampled_image_array_non_uniform_indexing_native( + mut self, + shader_sampled_image_array_non_uniform_indexing_native: bool, + ) -> Self { + self.shader_sampled_image_array_non_uniform_indexing_native = shader_sampled_image_array_non_uniform_indexing_native + .into(); + self + } + pub fn shader_storage_buffer_array_non_uniform_indexing_native( + mut self, + shader_storage_buffer_array_non_uniform_indexing_native: bool, + ) -> Self { + self.shader_storage_buffer_array_non_uniform_indexing_native = shader_storage_buffer_array_non_uniform_indexing_native + .into(); + self + } + pub fn shader_storage_image_array_non_uniform_indexing_native( + mut self, + shader_storage_image_array_non_uniform_indexing_native: bool, + ) -> Self { + self.shader_storage_image_array_non_uniform_indexing_native = shader_storage_image_array_non_uniform_indexing_native + .into(); + self + } + pub fn shader_input_attachment_array_non_uniform_indexing_native( + mut self, + shader_input_attachment_array_non_uniform_indexing_native: bool, + ) -> Self { + self.shader_input_attachment_array_non_uniform_indexing_native = shader_input_attachment_array_non_uniform_indexing_native + .into(); + self + } + pub fn robust_buffer_access_update_after_bind( + mut self, + robust_buffer_access_update_after_bind: bool, + ) -> Self { + self.robust_buffer_access_update_after_bind = robust_buffer_access_update_after_bind + .into(); + self + } + pub fn quad_divergent_implicit_lod( + mut self, + quad_divergent_implicit_lod: bool, + ) -> Self { + self.quad_divergent_implicit_lod = quad_divergent_implicit_lod.into(); + self + } + pub fn max_per_stage_descriptor_update_after_bind_samplers( + mut self, + max_per_stage_descriptor_update_after_bind_samplers: u32, + ) -> Self { + self.max_per_stage_descriptor_update_after_bind_samplers = max_per_stage_descriptor_update_after_bind_samplers; + self + } + pub fn max_per_stage_descriptor_update_after_bind_uniform_buffers( + mut self, + max_per_stage_descriptor_update_after_bind_uniform_buffers: u32, + ) -> Self { + self.max_per_stage_descriptor_update_after_bind_uniform_buffers = max_per_stage_descriptor_update_after_bind_uniform_buffers; + self + } + pub fn max_per_stage_descriptor_update_after_bind_storage_buffers( + mut self, + max_per_stage_descriptor_update_after_bind_storage_buffers: u32, + ) -> Self { + self.max_per_stage_descriptor_update_after_bind_storage_buffers = max_per_stage_descriptor_update_after_bind_storage_buffers; + self + } + pub fn max_per_stage_descriptor_update_after_bind_sampled_images( + mut self, + max_per_stage_descriptor_update_after_bind_sampled_images: u32, + ) -> Self { + self.max_per_stage_descriptor_update_after_bind_sampled_images = max_per_stage_descriptor_update_after_bind_sampled_images; + self + } + pub fn max_per_stage_descriptor_update_after_bind_storage_images( + mut self, + max_per_stage_descriptor_update_after_bind_storage_images: u32, + ) -> Self { + self.max_per_stage_descriptor_update_after_bind_storage_images = max_per_stage_descriptor_update_after_bind_storage_images; + self + } + pub fn max_per_stage_descriptor_update_after_bind_input_attachments( + mut self, + max_per_stage_descriptor_update_after_bind_input_attachments: u32, + ) -> Self { + self.max_per_stage_descriptor_update_after_bind_input_attachments = max_per_stage_descriptor_update_after_bind_input_attachments; + self + } + pub fn max_per_stage_update_after_bind_resources( + mut self, + max_per_stage_update_after_bind_resources: u32, + ) -> Self { + self.max_per_stage_update_after_bind_resources = max_per_stage_update_after_bind_resources; + self + } + pub fn max_descriptor_set_update_after_bind_samplers( + mut self, + max_descriptor_set_update_after_bind_samplers: u32, + ) -> Self { + self.max_descriptor_set_update_after_bind_samplers = max_descriptor_set_update_after_bind_samplers; + self + } + pub fn max_descriptor_set_update_after_bind_uniform_buffers( + mut self, + max_descriptor_set_update_after_bind_uniform_buffers: u32, + ) -> Self { + self.max_descriptor_set_update_after_bind_uniform_buffers = max_descriptor_set_update_after_bind_uniform_buffers; + self + } + pub fn max_descriptor_set_update_after_bind_uniform_buffers_dynamic( + mut self, + max_descriptor_set_update_after_bind_uniform_buffers_dynamic: u32, + ) -> Self { + self.max_descriptor_set_update_after_bind_uniform_buffers_dynamic = max_descriptor_set_update_after_bind_uniform_buffers_dynamic; + self + } + pub fn max_descriptor_set_update_after_bind_storage_buffers( + mut self, + max_descriptor_set_update_after_bind_storage_buffers: u32, + ) -> Self { + self.max_descriptor_set_update_after_bind_storage_buffers = max_descriptor_set_update_after_bind_storage_buffers; + self + } + pub fn max_descriptor_set_update_after_bind_storage_buffers_dynamic( + mut self, + max_descriptor_set_update_after_bind_storage_buffers_dynamic: u32, + ) -> Self { + self.max_descriptor_set_update_after_bind_storage_buffers_dynamic = max_descriptor_set_update_after_bind_storage_buffers_dynamic; + self + } + pub fn max_descriptor_set_update_after_bind_sampled_images( + mut self, + max_descriptor_set_update_after_bind_sampled_images: u32, + ) -> Self { + self.max_descriptor_set_update_after_bind_sampled_images = max_descriptor_set_update_after_bind_sampled_images; + self + } + pub fn max_descriptor_set_update_after_bind_storage_images( + mut self, + max_descriptor_set_update_after_bind_storage_images: u32, + ) -> Self { + self.max_descriptor_set_update_after_bind_storage_images = max_descriptor_set_update_after_bind_storage_images; + self + } + pub fn max_descriptor_set_update_after_bind_input_attachments( + mut self, + max_descriptor_set_update_after_bind_input_attachments: u32, + ) -> Self { + self.max_descriptor_set_update_after_bind_input_attachments = max_descriptor_set_update_after_bind_input_attachments; + self + } + pub fn supported_depth_resolve_modes( + mut self, + supported_depth_resolve_modes: crate::vk::ResolveModeFlags, + ) -> Self { + self.supported_depth_resolve_modes = supported_depth_resolve_modes; + self + } + pub fn supported_stencil_resolve_modes( + mut self, + supported_stencil_resolve_modes: crate::vk::ResolveModeFlags, + ) -> Self { + self.supported_stencil_resolve_modes = supported_stencil_resolve_modes; + self + } + pub fn independent_resolve_none( + mut self, + independent_resolve_none: bool, + ) -> Self { + self.independent_resolve_none = independent_resolve_none.into(); + self + } + pub fn independent_resolve(mut self, independent_resolve: bool) -> Self { + self.independent_resolve = independent_resolve.into(); + self + } + pub fn filter_minmax_single_component_formats( + mut self, + filter_minmax_single_component_formats: bool, + ) -> Self { + self.filter_minmax_single_component_formats = filter_minmax_single_component_formats + .into(); + self + } + pub fn filter_minmax_image_component_mapping( + mut self, + filter_minmax_image_component_mapping: bool, + ) -> Self { + self.filter_minmax_image_component_mapping = filter_minmax_image_component_mapping + .into(); + self + } + pub fn max_timeline_semaphore_value_difference( + mut self, + max_timeline_semaphore_value_difference: u64, + ) -> Self { + self.max_timeline_semaphore_value_difference = max_timeline_semaphore_value_difference; + self + } + pub fn framebuffer_integer_color_sample_counts( + mut self, + framebuffer_integer_color_sample_counts: crate::vk::SampleCountFlags, + ) -> Self { + self.framebuffer_integer_color_sample_counts = framebuffer_integer_color_sample_counts; + self + } + } ///Provided by [`vk1_2`](crate::vk1_2) impl crate::vk::ImageLayout { pub const DEPTH_ATTACHMENT_OPTIMAL: Self = Self(1000241000); @@ -1172,7 +4314,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct SemaphoreWaitFlagBits(pub(crate) u32); ///Provided by [`vk1_2`](crate::vk1_2) impl SemaphoreWaitFlagBits { @@ -1275,7 +4417,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct DescriptorBindingFlagBits(pub(crate) u32); ///Provided by [`vk1_2`](crate::vk1_2) impl DescriptorBindingFlagBits { @@ -1366,7 +4508,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct ResolveModeFlagBits(pub(crate) u32); ///Provided by [`vk1_2`](crate::vk1_2) impl ResolveModeFlagBits { diff --git a/ash-rewrite/src/generated/vk1_3.rs b/ash-rewrite/src/generated/vk1_3.rs index 73f881b89..50f6d2fe8 100644 --- a/ash-rewrite/src/generated/vk1_3.rs +++ b/ash-rewrite/src/generated/vk1_3.rs @@ -617,6 +617,30 @@ pub(crate) mod reexport { pub private_data_slot_request_count: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for DevicePrivateDataCreateInfo<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::DEVICE_PRIVATE_DATA_CREATE_INFO; + } + unsafe impl<'a> crate::Extends> + for DevicePrivateDataCreateInfo<'a> {} + impl<'a> Default for DevicePrivateDataCreateInfo<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + private_data_slot_request_count: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> DevicePrivateDataCreateInfo<'a> { + pub fn private_data_slot_request_count( + mut self, + private_data_slot_request_count: u32, + ) -> Self { + self.private_data_slot_request_count = private_data_slot_request_count; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PrivateDataSlotCreateInfo<'a> { @@ -625,6 +649,25 @@ pub(crate) mod reexport { pub flags: crate::vk::PrivateDataSlotCreateFlags, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for PrivateDataSlotCreateInfo<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PRIVATE_DATA_SLOT_CREATE_INFO; + } + impl<'a> Default for PrivateDataSlotCreateInfo<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + flags: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PrivateDataSlotCreateInfo<'a> { + pub fn flags(mut self, flags: crate::vk::PrivateDataSlotCreateFlags) -> Self { + self.flags = flags; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDevicePrivateDataFeatures<'a> { @@ -633,6 +676,30 @@ pub(crate) mod reexport { pub private_data: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDevicePrivateDataFeatures<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES; + } + unsafe impl<'a> crate::Extends> + for PhysicalDevicePrivateDataFeatures<'a> {} + unsafe impl<'a> crate::Extends> + for PhysicalDevicePrivateDataFeatures<'a> {} + impl<'a> Default for PhysicalDevicePrivateDataFeatures<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + private_data: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDevicePrivateDataFeatures<'a> { + pub fn private_data(mut self, private_data: bool) -> Self { + self.private_data = private_data.into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct DeviceBufferMemoryRequirements<'a> { @@ -641,6 +708,28 @@ pub(crate) mod reexport { pub p_create_info: *const crate::vk::BufferCreateInfo<'a>, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for DeviceBufferMemoryRequirements<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::DEVICE_BUFFER_MEMORY_REQUIREMENTS; + } + impl<'a> Default for DeviceBufferMemoryRequirements<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + p_create_info: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> DeviceBufferMemoryRequirements<'a> { + pub fn p_create_info( + mut self, + p_create_info: &'a crate::vk::BufferCreateInfo<'a>, + ) -> Self { + self.p_create_info = p_create_info; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct DeviceImageMemoryRequirements<'a> { @@ -650,6 +739,36 @@ pub(crate) mod reexport { pub plane_aspect: crate::vk::ImageAspectFlagBits, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for DeviceImageMemoryRequirements<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::DEVICE_IMAGE_MEMORY_REQUIREMENTS; + } + impl<'a> Default for DeviceImageMemoryRequirements<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + p_create_info: Default::default(), + plane_aspect: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> DeviceImageMemoryRequirements<'a> { + pub fn p_create_info( + mut self, + p_create_info: &'a crate::vk::ImageCreateInfo<'a>, + ) -> Self { + self.p_create_info = p_create_info; + self + } + pub fn plane_aspect( + mut self, + plane_aspect: crate::vk::ImageAspectFlagBits, + ) -> Self { + self.plane_aspect = plane_aspect; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceInlineUniformBlockFeatures<'a> { @@ -659,6 +778,39 @@ pub(crate) mod reexport { pub descriptor_binding_inline_uniform_block_update_after_bind: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceInlineUniformBlockFeatures<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceInlineUniformBlockFeatures<'a> {} + unsafe impl<'a> crate::Extends> + for PhysicalDeviceInlineUniformBlockFeatures<'a> {} + impl<'a> Default for PhysicalDeviceInlineUniformBlockFeatures<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + inline_uniform_block: Default::default(), + descriptor_binding_inline_uniform_block_update_after_bind: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceInlineUniformBlockFeatures<'a> { + pub fn inline_uniform_block(mut self, inline_uniform_block: bool) -> Self { + self.inline_uniform_block = inline_uniform_block.into(); + self + } + pub fn descriptor_binding_inline_uniform_block_update_after_bind( + mut self, + descriptor_binding_inline_uniform_block_update_after_bind: bool, + ) -> Self { + self.descriptor_binding_inline_uniform_block_update_after_bind = descriptor_binding_inline_uniform_block_update_after_bind + .into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceInlineUniformBlockProperties<'a> { @@ -671,6 +823,63 @@ pub(crate) mod reexport { pub max_descriptor_set_update_after_bind_inline_uniform_blocks: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceInlineUniformBlockProperties<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceInlineUniformBlockProperties<'a> {} + impl<'a> Default for PhysicalDeviceInlineUniformBlockProperties<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + max_inline_uniform_block_size: Default::default(), + max_per_stage_descriptor_inline_uniform_blocks: Default::default(), + max_per_stage_descriptor_update_after_bind_inline_uniform_blocks: Default::default(), + max_descriptor_set_inline_uniform_blocks: Default::default(), + max_descriptor_set_update_after_bind_inline_uniform_blocks: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceInlineUniformBlockProperties<'a> { + pub fn max_inline_uniform_block_size( + mut self, + max_inline_uniform_block_size: u32, + ) -> Self { + self.max_inline_uniform_block_size = max_inline_uniform_block_size; + self + } + pub fn max_per_stage_descriptor_inline_uniform_blocks( + mut self, + max_per_stage_descriptor_inline_uniform_blocks: u32, + ) -> Self { + self.max_per_stage_descriptor_inline_uniform_blocks = max_per_stage_descriptor_inline_uniform_blocks; + self + } + pub fn max_per_stage_descriptor_update_after_bind_inline_uniform_blocks( + mut self, + max_per_stage_descriptor_update_after_bind_inline_uniform_blocks: u32, + ) -> Self { + self.max_per_stage_descriptor_update_after_bind_inline_uniform_blocks = max_per_stage_descriptor_update_after_bind_inline_uniform_blocks; + self + } + pub fn max_descriptor_set_inline_uniform_blocks( + mut self, + max_descriptor_set_inline_uniform_blocks: u32, + ) -> Self { + self.max_descriptor_set_inline_uniform_blocks = max_descriptor_set_inline_uniform_blocks; + self + } + pub fn max_descriptor_set_update_after_bind_inline_uniform_blocks( + mut self, + max_descriptor_set_update_after_bind_inline_uniform_blocks: u32, + ) -> Self { + self.max_descriptor_set_update_after_bind_inline_uniform_blocks = max_descriptor_set_update_after_bind_inline_uniform_blocks; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct WriteDescriptorSetInlineUniformBlock<'a> { @@ -680,6 +889,34 @@ pub(crate) mod reexport { pub p_data: *const core::ffi::c_void, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for WriteDescriptorSetInlineUniformBlock<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK; + } + unsafe impl<'a> crate::Extends> + for WriteDescriptorSetInlineUniformBlock<'a> {} + impl<'a> Default for WriteDescriptorSetInlineUniformBlock<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + data_size: Default::default(), + p_data: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> WriteDescriptorSetInlineUniformBlock<'a> { + pub fn data_size(mut self, data_size: u32) -> Self { + self.data_size = data_size; + self + } + pub fn p_data(mut self, p_data: &'a [u8]) -> Self { + self.data_size = p_data.len() as _; + self.p_data = p_data.as_ptr().cast(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct DescriptorPoolInlineUniformBlockCreateInfo<'a> { @@ -688,6 +925,31 @@ pub(crate) mod reexport { pub max_inline_uniform_block_bindings: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for DescriptorPoolInlineUniformBlockCreateInfo<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO; + } + unsafe impl<'a> crate::Extends> + for DescriptorPoolInlineUniformBlockCreateInfo<'a> {} + impl<'a> Default for DescriptorPoolInlineUniformBlockCreateInfo<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + max_inline_uniform_block_bindings: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> DescriptorPoolInlineUniformBlockCreateInfo<'a> { + pub fn max_inline_uniform_block_bindings( + mut self, + max_inline_uniform_block_bindings: u32, + ) -> Self { + self.max_inline_uniform_block_bindings = max_inline_uniform_block_bindings; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceMaintenance4Features<'a> { @@ -696,6 +958,30 @@ pub(crate) mod reexport { pub maintenance4: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceMaintenance4Features<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceMaintenance4Features<'a> {} + unsafe impl<'a> crate::Extends> + for PhysicalDeviceMaintenance4Features<'a> {} + impl<'a> Default for PhysicalDeviceMaintenance4Features<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + maintenance4: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceMaintenance4Features<'a> { + pub fn maintenance4(mut self, maintenance4: bool) -> Self { + self.maintenance4 = maintenance4.into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceMaintenance4Properties<'a> { @@ -704,6 +990,31 @@ pub(crate) mod reexport { pub max_buffer_size: crate::vk::DeviceSize, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceMaintenance4Properties<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceMaintenance4Properties<'a> {} + impl<'a> Default for PhysicalDeviceMaintenance4Properties<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + max_buffer_size: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceMaintenance4Properties<'a> { + pub fn max_buffer_size( + mut self, + max_buffer_size: crate::vk::DeviceSize, + ) -> Self { + self.max_buffer_size = max_buffer_size; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceTextureCompressionASTCHDRFeatures<'a> { @@ -712,12 +1023,49 @@ pub(crate) mod reexport { pub texture_compression_astc_hdr: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceTextureCompressionASTCHDRFeatures<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceTextureCompressionASTCHDRFeatures<'a> {} + unsafe impl<'a> crate::Extends> + for PhysicalDeviceTextureCompressionASTCHDRFeatures<'a> {} + impl<'a> Default for PhysicalDeviceTextureCompressionASTCHDRFeatures<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + texture_compression_astc_hdr: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceTextureCompressionASTCHDRFeatures<'a> { + pub fn texture_compression_astc_hdr( + mut self, + texture_compression_astc_hdr: bool, + ) -> Self { + self.texture_compression_astc_hdr = texture_compression_astc_hdr.into(); + self + } + } #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct PipelineCreationFeedback { pub flags: crate::vk::PipelineCreationFeedbackFlags, pub duration: u64, } + impl PipelineCreationFeedback { + pub fn flags(mut self, flags: crate::vk::PipelineCreationFeedbackFlags) -> Self { + self.flags = flags; + self + } + pub fn duration(mut self, duration: u64) -> Self { + self.duration = duration; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PipelineCreationFeedbackCreateInfo<'a> { @@ -728,6 +1076,60 @@ pub(crate) mod reexport { pub p_pipeline_stage_creation_feedbacks: *mut crate::vk::PipelineCreationFeedback, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PipelineCreationFeedbackCreateInfo<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PIPELINE_CREATION_FEEDBACK_CREATE_INFO; + } + unsafe impl<'a> crate::Extends> + for PipelineCreationFeedbackCreateInfo<'a> {} + unsafe impl<'a> crate::Extends> + for PipelineCreationFeedbackCreateInfo<'a> {} + unsafe impl<'a> crate::Extends> + for PipelineCreationFeedbackCreateInfo<'a> {} + unsafe impl<'a> crate::Extends> + for PipelineCreationFeedbackCreateInfo<'a> {} + unsafe impl<'a> crate::Extends> + for PipelineCreationFeedbackCreateInfo<'a> {} + unsafe impl<'a> crate::Extends> + for PipelineCreationFeedbackCreateInfo<'a> {} + impl<'a> Default for PipelineCreationFeedbackCreateInfo<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + p_pipeline_creation_feedback: Default::default(), + pipeline_stage_creation_feedback_count: Default::default(), + p_pipeline_stage_creation_feedbacks: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PipelineCreationFeedbackCreateInfo<'a> { + pub fn p_pipeline_creation_feedback( + mut self, + p_pipeline_creation_feedback: &'a mut crate::vk::PipelineCreationFeedback, + ) -> Self { + self.p_pipeline_creation_feedback = p_pipeline_creation_feedback; + self + } + pub fn pipeline_stage_creation_feedback_count( + mut self, + pipeline_stage_creation_feedback_count: u32, + ) -> Self { + self.pipeline_stage_creation_feedback_count = pipeline_stage_creation_feedback_count; + self + } + pub fn p_pipeline_stage_creation_feedbacks( + mut self, + p_pipeline_stage_creation_feedbacks: &'a mut [crate::vk::PipelineCreationFeedback], + ) -> Self { + self.pipeline_stage_creation_feedback_count = p_pipeline_stage_creation_feedbacks + .len() as _; + self.p_pipeline_stage_creation_feedbacks = p_pipeline_stage_creation_feedbacks + .as_mut_ptr(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceShaderDemoteToHelperInvocationFeatures<'a> { @@ -736,6 +1138,34 @@ pub(crate) mod reexport { pub shader_demote_to_helper_invocation: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceShaderDemoteToHelperInvocationFeatures<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceShaderDemoteToHelperInvocationFeatures<'a> {} + unsafe impl<'a> crate::Extends> + for PhysicalDeviceShaderDemoteToHelperInvocationFeatures<'a> {} + impl<'a> Default for PhysicalDeviceShaderDemoteToHelperInvocationFeatures<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + shader_demote_to_helper_invocation: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceShaderDemoteToHelperInvocationFeatures<'a> { + pub fn shader_demote_to_helper_invocation( + mut self, + shader_demote_to_helper_invocation: bool, + ) -> Self { + self.shader_demote_to_helper_invocation = shader_demote_to_helper_invocation + .into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceTexelBufferAlignmentProperties<'a> { @@ -747,6 +1177,57 @@ pub(crate) mod reexport { pub uniform_texel_buffer_offset_single_texel_alignment: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceTexelBufferAlignmentProperties<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceTexelBufferAlignmentProperties<'a> {} + impl<'a> Default for PhysicalDeviceTexelBufferAlignmentProperties<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + storage_texel_buffer_offset_alignment_bytes: Default::default(), + storage_texel_buffer_offset_single_texel_alignment: Default::default(), + uniform_texel_buffer_offset_alignment_bytes: Default::default(), + uniform_texel_buffer_offset_single_texel_alignment: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceTexelBufferAlignmentProperties<'a> { + pub fn storage_texel_buffer_offset_alignment_bytes( + mut self, + storage_texel_buffer_offset_alignment_bytes: crate::vk::DeviceSize, + ) -> Self { + self.storage_texel_buffer_offset_alignment_bytes = storage_texel_buffer_offset_alignment_bytes; + self + } + pub fn storage_texel_buffer_offset_single_texel_alignment( + mut self, + storage_texel_buffer_offset_single_texel_alignment: bool, + ) -> Self { + self.storage_texel_buffer_offset_single_texel_alignment = storage_texel_buffer_offset_single_texel_alignment + .into(); + self + } + pub fn uniform_texel_buffer_offset_alignment_bytes( + mut self, + uniform_texel_buffer_offset_alignment_bytes: crate::vk::DeviceSize, + ) -> Self { + self.uniform_texel_buffer_offset_alignment_bytes = uniform_texel_buffer_offset_alignment_bytes; + self + } + pub fn uniform_texel_buffer_offset_single_texel_alignment( + mut self, + uniform_texel_buffer_offset_single_texel_alignment: bool, + ) -> Self { + self.uniform_texel_buffer_offset_single_texel_alignment = uniform_texel_buffer_offset_single_texel_alignment + .into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceSubgroupSizeControlFeatures<'a> { @@ -756,6 +1237,35 @@ pub(crate) mod reexport { pub compute_full_subgroups: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceSubgroupSizeControlFeatures<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceSubgroupSizeControlFeatures<'a> {} + unsafe impl<'a> crate::Extends> + for PhysicalDeviceSubgroupSizeControlFeatures<'a> {} + impl<'a> Default for PhysicalDeviceSubgroupSizeControlFeatures<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + subgroup_size_control: Default::default(), + compute_full_subgroups: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceSubgroupSizeControlFeatures<'a> { + pub fn subgroup_size_control(mut self, subgroup_size_control: bool) -> Self { + self.subgroup_size_control = subgroup_size_control.into(); + self + } + pub fn compute_full_subgroups(mut self, compute_full_subgroups: bool) -> Self { + self.compute_full_subgroups = compute_full_subgroups.into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceSubgroupSizeControlProperties<'a> { @@ -767,6 +1277,49 @@ pub(crate) mod reexport { pub required_subgroup_size_stages: crate::vk::ShaderStageFlags, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceSubgroupSizeControlProperties<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceSubgroupSizeControlProperties<'a> {} + impl<'a> Default for PhysicalDeviceSubgroupSizeControlProperties<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + min_subgroup_size: Default::default(), + max_subgroup_size: Default::default(), + max_compute_workgroup_subgroups: Default::default(), + required_subgroup_size_stages: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceSubgroupSizeControlProperties<'a> { + pub fn min_subgroup_size(mut self, min_subgroup_size: u32) -> Self { + self.min_subgroup_size = min_subgroup_size; + self + } + pub fn max_subgroup_size(mut self, max_subgroup_size: u32) -> Self { + self.max_subgroup_size = max_subgroup_size; + self + } + pub fn max_compute_workgroup_subgroups( + mut self, + max_compute_workgroup_subgroups: u32, + ) -> Self { + self.max_compute_workgroup_subgroups = max_compute_workgroup_subgroups; + self + } + pub fn required_subgroup_size_stages( + mut self, + required_subgroup_size_stages: crate::vk::ShaderStageFlags, + ) -> Self { + self.required_subgroup_size_stages = required_subgroup_size_stages; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PipelineShaderStageRequiredSubgroupSizeCreateInfo<'a> { @@ -775,6 +1328,30 @@ pub(crate) mod reexport { pub required_subgroup_size: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PipelineShaderStageRequiredSubgroupSizeCreateInfo<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO; + } + unsafe impl<'a> crate::Extends> + for PipelineShaderStageRequiredSubgroupSizeCreateInfo<'a> {} + unsafe impl<'a> crate::Extends> + for PipelineShaderStageRequiredSubgroupSizeCreateInfo<'a> {} + impl<'a> Default for PipelineShaderStageRequiredSubgroupSizeCreateInfo<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + required_subgroup_size: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PipelineShaderStageRequiredSubgroupSizeCreateInfo<'a> { + pub fn required_subgroup_size(mut self, required_subgroup_size: u32) -> Self { + self.required_subgroup_size = required_subgroup_size; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDevicePipelineCreationCacheControlFeatures<'a> { @@ -783,6 +1360,34 @@ pub(crate) mod reexport { pub pipeline_creation_cache_control: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDevicePipelineCreationCacheControlFeatures<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES; + } + unsafe impl<'a> crate::Extends> + for PhysicalDevicePipelineCreationCacheControlFeatures<'a> {} + unsafe impl<'a> crate::Extends> + for PhysicalDevicePipelineCreationCacheControlFeatures<'a> {} + impl<'a> Default for PhysicalDevicePipelineCreationCacheControlFeatures<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + pipeline_creation_cache_control: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDevicePipelineCreationCacheControlFeatures<'a> { + pub fn pipeline_creation_cache_control( + mut self, + pipeline_creation_cache_control: bool, + ) -> Self { + self.pipeline_creation_cache_control = pipeline_creation_cache_control + .into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceVulkan13Features<'a> { @@ -805,6 +1410,124 @@ pub(crate) mod reexport { pub maintenance4: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for PhysicalDeviceVulkan13Features<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_VULKAN_1_3_FEATURES; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceVulkan13Features<'a> {} + unsafe impl<'a> crate::Extends> + for PhysicalDeviceVulkan13Features<'a> {} + impl<'a> Default for PhysicalDeviceVulkan13Features<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + robust_image_access: Default::default(), + inline_uniform_block: Default::default(), + descriptor_binding_inline_uniform_block_update_after_bind: Default::default(), + pipeline_creation_cache_control: Default::default(), + private_data: Default::default(), + shader_demote_to_helper_invocation: Default::default(), + shader_terminate_invocation: Default::default(), + subgroup_size_control: Default::default(), + compute_full_subgroups: Default::default(), + synchronization2: Default::default(), + texture_compression_astc_hdr: Default::default(), + shader_zero_initialize_workgroup_memory: Default::default(), + dynamic_rendering: Default::default(), + shader_integer_dot_product: Default::default(), + maintenance4: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceVulkan13Features<'a> { + pub fn robust_image_access(mut self, robust_image_access: bool) -> Self { + self.robust_image_access = robust_image_access.into(); + self + } + pub fn inline_uniform_block(mut self, inline_uniform_block: bool) -> Self { + self.inline_uniform_block = inline_uniform_block.into(); + self + } + pub fn descriptor_binding_inline_uniform_block_update_after_bind( + mut self, + descriptor_binding_inline_uniform_block_update_after_bind: bool, + ) -> Self { + self.descriptor_binding_inline_uniform_block_update_after_bind = descriptor_binding_inline_uniform_block_update_after_bind + .into(); + self + } + pub fn pipeline_creation_cache_control( + mut self, + pipeline_creation_cache_control: bool, + ) -> Self { + self.pipeline_creation_cache_control = pipeline_creation_cache_control + .into(); + self + } + pub fn private_data(mut self, private_data: bool) -> Self { + self.private_data = private_data.into(); + self + } + pub fn shader_demote_to_helper_invocation( + mut self, + shader_demote_to_helper_invocation: bool, + ) -> Self { + self.shader_demote_to_helper_invocation = shader_demote_to_helper_invocation + .into(); + self + } + pub fn shader_terminate_invocation( + mut self, + shader_terminate_invocation: bool, + ) -> Self { + self.shader_terminate_invocation = shader_terminate_invocation.into(); + self + } + pub fn subgroup_size_control(mut self, subgroup_size_control: bool) -> Self { + self.subgroup_size_control = subgroup_size_control.into(); + self + } + pub fn compute_full_subgroups(mut self, compute_full_subgroups: bool) -> Self { + self.compute_full_subgroups = compute_full_subgroups.into(); + self + } + pub fn synchronization2(mut self, synchronization2: bool) -> Self { + self.synchronization2 = synchronization2.into(); + self + } + pub fn texture_compression_astc_hdr( + mut self, + texture_compression_astc_hdr: bool, + ) -> Self { + self.texture_compression_astc_hdr = texture_compression_astc_hdr.into(); + self + } + pub fn shader_zero_initialize_workgroup_memory( + mut self, + shader_zero_initialize_workgroup_memory: bool, + ) -> Self { + self.shader_zero_initialize_workgroup_memory = shader_zero_initialize_workgroup_memory + .into(); + self + } + pub fn dynamic_rendering(mut self, dynamic_rendering: bool) -> Self { + self.dynamic_rendering = dynamic_rendering.into(); + self + } + pub fn shader_integer_dot_product( + mut self, + shader_integer_dot_product: bool, + ) -> Self { + self.shader_integer_dot_product = shader_integer_dot_product.into(); + self + } + pub fn maintenance4(mut self, maintenance4: bool) -> Self { + self.maintenance4 = maintenance4.into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceVulkan13Properties<'a> { @@ -857,6 +1580,418 @@ pub(crate) mod reexport { pub max_buffer_size: crate::vk::DeviceSize, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for PhysicalDeviceVulkan13Properties<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceVulkan13Properties<'a> {} + impl<'a> Default for PhysicalDeviceVulkan13Properties<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + min_subgroup_size: Default::default(), + max_subgroup_size: Default::default(), + max_compute_workgroup_subgroups: Default::default(), + required_subgroup_size_stages: Default::default(), + max_inline_uniform_block_size: Default::default(), + max_per_stage_descriptor_inline_uniform_blocks: Default::default(), + max_per_stage_descriptor_update_after_bind_inline_uniform_blocks: Default::default(), + max_descriptor_set_inline_uniform_blocks: Default::default(), + max_descriptor_set_update_after_bind_inline_uniform_blocks: Default::default(), + max_inline_uniform_total_size: Default::default(), + integer_dot_product8_bit_unsigned_accelerated: Default::default(), + integer_dot_product8_bit_signed_accelerated: Default::default(), + integer_dot_product8_bit_mixed_signedness_accelerated: Default::default(), + integer_dot_product4x8_bit_packed_unsigned_accelerated: Default::default(), + integer_dot_product4x8_bit_packed_signed_accelerated: Default::default(), + integer_dot_product4x8_bit_packed_mixed_signedness_accelerated: Default::default(), + integer_dot_product16_bit_unsigned_accelerated: Default::default(), + integer_dot_product16_bit_signed_accelerated: Default::default(), + integer_dot_product16_bit_mixed_signedness_accelerated: Default::default(), + integer_dot_product32_bit_unsigned_accelerated: Default::default(), + integer_dot_product32_bit_signed_accelerated: Default::default(), + integer_dot_product32_bit_mixed_signedness_accelerated: Default::default(), + integer_dot_product64_bit_unsigned_accelerated: Default::default(), + integer_dot_product64_bit_signed_accelerated: Default::default(), + integer_dot_product64_bit_mixed_signedness_accelerated: Default::default(), + integer_dot_product_accumulating_saturating8_bit_unsigned_accelerated: Default::default(), + integer_dot_product_accumulating_saturating8_bit_signed_accelerated: Default::default(), + integer_dot_product_accumulating_saturating8_bit_mixed_signedness_accelerated: Default::default(), + integer_dot_product_accumulating_saturating4x8_bit_packed_unsigned_accelerated: Default::default(), + integer_dot_product_accumulating_saturating4x8_bit_packed_signed_accelerated: Default::default(), + integer_dot_product_accumulating_saturating4x8_bit_packed_mixed_signedness_accelerated: Default::default(), + integer_dot_product_accumulating_saturating16_bit_unsigned_accelerated: Default::default(), + integer_dot_product_accumulating_saturating16_bit_signed_accelerated: Default::default(), + integer_dot_product_accumulating_saturating16_bit_mixed_signedness_accelerated: Default::default(), + integer_dot_product_accumulating_saturating32_bit_unsigned_accelerated: Default::default(), + integer_dot_product_accumulating_saturating32_bit_signed_accelerated: Default::default(), + integer_dot_product_accumulating_saturating32_bit_mixed_signedness_accelerated: Default::default(), + integer_dot_product_accumulating_saturating64_bit_unsigned_accelerated: Default::default(), + integer_dot_product_accumulating_saturating64_bit_signed_accelerated: Default::default(), + integer_dot_product_accumulating_saturating64_bit_mixed_signedness_accelerated: Default::default(), + storage_texel_buffer_offset_alignment_bytes: Default::default(), + storage_texel_buffer_offset_single_texel_alignment: Default::default(), + uniform_texel_buffer_offset_alignment_bytes: Default::default(), + uniform_texel_buffer_offset_single_texel_alignment: Default::default(), + max_buffer_size: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceVulkan13Properties<'a> { + pub fn min_subgroup_size(mut self, min_subgroup_size: u32) -> Self { + self.min_subgroup_size = min_subgroup_size; + self + } + pub fn max_subgroup_size(mut self, max_subgroup_size: u32) -> Self { + self.max_subgroup_size = max_subgroup_size; + self + } + pub fn max_compute_workgroup_subgroups( + mut self, + max_compute_workgroup_subgroups: u32, + ) -> Self { + self.max_compute_workgroup_subgroups = max_compute_workgroup_subgroups; + self + } + pub fn required_subgroup_size_stages( + mut self, + required_subgroup_size_stages: crate::vk::ShaderStageFlags, + ) -> Self { + self.required_subgroup_size_stages = required_subgroup_size_stages; + self + } + pub fn max_inline_uniform_block_size( + mut self, + max_inline_uniform_block_size: u32, + ) -> Self { + self.max_inline_uniform_block_size = max_inline_uniform_block_size; + self + } + pub fn max_per_stage_descriptor_inline_uniform_blocks( + mut self, + max_per_stage_descriptor_inline_uniform_blocks: u32, + ) -> Self { + self.max_per_stage_descriptor_inline_uniform_blocks = max_per_stage_descriptor_inline_uniform_blocks; + self + } + pub fn max_per_stage_descriptor_update_after_bind_inline_uniform_blocks( + mut self, + max_per_stage_descriptor_update_after_bind_inline_uniform_blocks: u32, + ) -> Self { + self.max_per_stage_descriptor_update_after_bind_inline_uniform_blocks = max_per_stage_descriptor_update_after_bind_inline_uniform_blocks; + self + } + pub fn max_descriptor_set_inline_uniform_blocks( + mut self, + max_descriptor_set_inline_uniform_blocks: u32, + ) -> Self { + self.max_descriptor_set_inline_uniform_blocks = max_descriptor_set_inline_uniform_blocks; + self + } + pub fn max_descriptor_set_update_after_bind_inline_uniform_blocks( + mut self, + max_descriptor_set_update_after_bind_inline_uniform_blocks: u32, + ) -> Self { + self.max_descriptor_set_update_after_bind_inline_uniform_blocks = max_descriptor_set_update_after_bind_inline_uniform_blocks; + self + } + pub fn max_inline_uniform_total_size( + mut self, + max_inline_uniform_total_size: u32, + ) -> Self { + self.max_inline_uniform_total_size = max_inline_uniform_total_size; + self + } + pub fn integer_dot_product8_bit_unsigned_accelerated( + mut self, + integer_dot_product8_bit_unsigned_accelerated: bool, + ) -> Self { + self.integer_dot_product8_bit_unsigned_accelerated = integer_dot_product8_bit_unsigned_accelerated + .into(); + self + } + pub fn integer_dot_product8_bit_signed_accelerated( + mut self, + integer_dot_product8_bit_signed_accelerated: bool, + ) -> Self { + self.integer_dot_product8_bit_signed_accelerated = integer_dot_product8_bit_signed_accelerated + .into(); + self + } + pub fn integer_dot_product8_bit_mixed_signedness_accelerated( + mut self, + integer_dot_product8_bit_mixed_signedness_accelerated: bool, + ) -> Self { + self.integer_dot_product8_bit_mixed_signedness_accelerated = integer_dot_product8_bit_mixed_signedness_accelerated + .into(); + self + } + pub fn integer_dot_product4x8_bit_packed_unsigned_accelerated( + mut self, + integer_dot_product4x8_bit_packed_unsigned_accelerated: bool, + ) -> Self { + self.integer_dot_product4x8_bit_packed_unsigned_accelerated = integer_dot_product4x8_bit_packed_unsigned_accelerated + .into(); + self + } + pub fn integer_dot_product4x8_bit_packed_signed_accelerated( + mut self, + integer_dot_product4x8_bit_packed_signed_accelerated: bool, + ) -> Self { + self.integer_dot_product4x8_bit_packed_signed_accelerated = integer_dot_product4x8_bit_packed_signed_accelerated + .into(); + self + } + pub fn integer_dot_product4x8_bit_packed_mixed_signedness_accelerated( + mut self, + integer_dot_product4x8_bit_packed_mixed_signedness_accelerated: bool, + ) -> Self { + self.integer_dot_product4x8_bit_packed_mixed_signedness_accelerated = integer_dot_product4x8_bit_packed_mixed_signedness_accelerated + .into(); + self + } + pub fn integer_dot_product16_bit_unsigned_accelerated( + mut self, + integer_dot_product16_bit_unsigned_accelerated: bool, + ) -> Self { + self.integer_dot_product16_bit_unsigned_accelerated = integer_dot_product16_bit_unsigned_accelerated + .into(); + self + } + pub fn integer_dot_product16_bit_signed_accelerated( + mut self, + integer_dot_product16_bit_signed_accelerated: bool, + ) -> Self { + self.integer_dot_product16_bit_signed_accelerated = integer_dot_product16_bit_signed_accelerated + .into(); + self + } + pub fn integer_dot_product16_bit_mixed_signedness_accelerated( + mut self, + integer_dot_product16_bit_mixed_signedness_accelerated: bool, + ) -> Self { + self.integer_dot_product16_bit_mixed_signedness_accelerated = integer_dot_product16_bit_mixed_signedness_accelerated + .into(); + self + } + pub fn integer_dot_product32_bit_unsigned_accelerated( + mut self, + integer_dot_product32_bit_unsigned_accelerated: bool, + ) -> Self { + self.integer_dot_product32_bit_unsigned_accelerated = integer_dot_product32_bit_unsigned_accelerated + .into(); + self + } + pub fn integer_dot_product32_bit_signed_accelerated( + mut self, + integer_dot_product32_bit_signed_accelerated: bool, + ) -> Self { + self.integer_dot_product32_bit_signed_accelerated = integer_dot_product32_bit_signed_accelerated + .into(); + self + } + pub fn integer_dot_product32_bit_mixed_signedness_accelerated( + mut self, + integer_dot_product32_bit_mixed_signedness_accelerated: bool, + ) -> Self { + self.integer_dot_product32_bit_mixed_signedness_accelerated = integer_dot_product32_bit_mixed_signedness_accelerated + .into(); + self + } + pub fn integer_dot_product64_bit_unsigned_accelerated( + mut self, + integer_dot_product64_bit_unsigned_accelerated: bool, + ) -> Self { + self.integer_dot_product64_bit_unsigned_accelerated = integer_dot_product64_bit_unsigned_accelerated + .into(); + self + } + pub fn integer_dot_product64_bit_signed_accelerated( + mut self, + integer_dot_product64_bit_signed_accelerated: bool, + ) -> Self { + self.integer_dot_product64_bit_signed_accelerated = integer_dot_product64_bit_signed_accelerated + .into(); + self + } + pub fn integer_dot_product64_bit_mixed_signedness_accelerated( + mut self, + integer_dot_product64_bit_mixed_signedness_accelerated: bool, + ) -> Self { + self.integer_dot_product64_bit_mixed_signedness_accelerated = integer_dot_product64_bit_mixed_signedness_accelerated + .into(); + self + } + pub fn integer_dot_product_accumulating_saturating8_bit_unsigned_accelerated( + mut self, + integer_dot_product_accumulating_saturating8_bit_unsigned_accelerated: bool, + ) -> Self { + self.integer_dot_product_accumulating_saturating8_bit_unsigned_accelerated = integer_dot_product_accumulating_saturating8_bit_unsigned_accelerated + .into(); + self + } + pub fn integer_dot_product_accumulating_saturating8_bit_signed_accelerated( + mut self, + integer_dot_product_accumulating_saturating8_bit_signed_accelerated: bool, + ) -> Self { + self.integer_dot_product_accumulating_saturating8_bit_signed_accelerated = integer_dot_product_accumulating_saturating8_bit_signed_accelerated + .into(); + self + } + pub fn integer_dot_product_accumulating_saturating8_bit_mixed_signedness_accelerated( + mut self, + integer_dot_product_accumulating_saturating8_bit_mixed_signedness_accelerated: bool, + ) -> Self { + self + .integer_dot_product_accumulating_saturating8_bit_mixed_signedness_accelerated = integer_dot_product_accumulating_saturating8_bit_mixed_signedness_accelerated + .into(); + self + } + pub fn integer_dot_product_accumulating_saturating4x8_bit_packed_unsigned_accelerated( + mut self, + integer_dot_product_accumulating_saturating4x8_bit_packed_unsigned_accelerated: bool, + ) -> Self { + self + .integer_dot_product_accumulating_saturating4x8_bit_packed_unsigned_accelerated = integer_dot_product_accumulating_saturating4x8_bit_packed_unsigned_accelerated + .into(); + self + } + pub fn integer_dot_product_accumulating_saturating4x8_bit_packed_signed_accelerated( + mut self, + integer_dot_product_accumulating_saturating4x8_bit_packed_signed_accelerated: bool, + ) -> Self { + self + .integer_dot_product_accumulating_saturating4x8_bit_packed_signed_accelerated = integer_dot_product_accumulating_saturating4x8_bit_packed_signed_accelerated + .into(); + self + } + pub fn integer_dot_product_accumulating_saturating4x8_bit_packed_mixed_signedness_accelerated( + mut self, + integer_dot_product_accumulating_saturating4x8_bit_packed_mixed_signedness_accelerated: bool, + ) -> Self { + self + .integer_dot_product_accumulating_saturating4x8_bit_packed_mixed_signedness_accelerated = integer_dot_product_accumulating_saturating4x8_bit_packed_mixed_signedness_accelerated + .into(); + self + } + pub fn integer_dot_product_accumulating_saturating16_bit_unsigned_accelerated( + mut self, + integer_dot_product_accumulating_saturating16_bit_unsigned_accelerated: bool, + ) -> Self { + self + .integer_dot_product_accumulating_saturating16_bit_unsigned_accelerated = integer_dot_product_accumulating_saturating16_bit_unsigned_accelerated + .into(); + self + } + pub fn integer_dot_product_accumulating_saturating16_bit_signed_accelerated( + mut self, + integer_dot_product_accumulating_saturating16_bit_signed_accelerated: bool, + ) -> Self { + self.integer_dot_product_accumulating_saturating16_bit_signed_accelerated = integer_dot_product_accumulating_saturating16_bit_signed_accelerated + .into(); + self + } + pub fn integer_dot_product_accumulating_saturating16_bit_mixed_signedness_accelerated( + mut self, + integer_dot_product_accumulating_saturating16_bit_mixed_signedness_accelerated: bool, + ) -> Self { + self + .integer_dot_product_accumulating_saturating16_bit_mixed_signedness_accelerated = integer_dot_product_accumulating_saturating16_bit_mixed_signedness_accelerated + .into(); + self + } + pub fn integer_dot_product_accumulating_saturating32_bit_unsigned_accelerated( + mut self, + integer_dot_product_accumulating_saturating32_bit_unsigned_accelerated: bool, + ) -> Self { + self + .integer_dot_product_accumulating_saturating32_bit_unsigned_accelerated = integer_dot_product_accumulating_saturating32_bit_unsigned_accelerated + .into(); + self + } + pub fn integer_dot_product_accumulating_saturating32_bit_signed_accelerated( + mut self, + integer_dot_product_accumulating_saturating32_bit_signed_accelerated: bool, + ) -> Self { + self.integer_dot_product_accumulating_saturating32_bit_signed_accelerated = integer_dot_product_accumulating_saturating32_bit_signed_accelerated + .into(); + self + } + pub fn integer_dot_product_accumulating_saturating32_bit_mixed_signedness_accelerated( + mut self, + integer_dot_product_accumulating_saturating32_bit_mixed_signedness_accelerated: bool, + ) -> Self { + self + .integer_dot_product_accumulating_saturating32_bit_mixed_signedness_accelerated = integer_dot_product_accumulating_saturating32_bit_mixed_signedness_accelerated + .into(); + self + } + pub fn integer_dot_product_accumulating_saturating64_bit_unsigned_accelerated( + mut self, + integer_dot_product_accumulating_saturating64_bit_unsigned_accelerated: bool, + ) -> Self { + self + .integer_dot_product_accumulating_saturating64_bit_unsigned_accelerated = integer_dot_product_accumulating_saturating64_bit_unsigned_accelerated + .into(); + self + } + pub fn integer_dot_product_accumulating_saturating64_bit_signed_accelerated( + mut self, + integer_dot_product_accumulating_saturating64_bit_signed_accelerated: bool, + ) -> Self { + self.integer_dot_product_accumulating_saturating64_bit_signed_accelerated = integer_dot_product_accumulating_saturating64_bit_signed_accelerated + .into(); + self + } + pub fn integer_dot_product_accumulating_saturating64_bit_mixed_signedness_accelerated( + mut self, + integer_dot_product_accumulating_saturating64_bit_mixed_signedness_accelerated: bool, + ) -> Self { + self + .integer_dot_product_accumulating_saturating64_bit_mixed_signedness_accelerated = integer_dot_product_accumulating_saturating64_bit_mixed_signedness_accelerated + .into(); + self + } + pub fn storage_texel_buffer_offset_alignment_bytes( + mut self, + storage_texel_buffer_offset_alignment_bytes: crate::vk::DeviceSize, + ) -> Self { + self.storage_texel_buffer_offset_alignment_bytes = storage_texel_buffer_offset_alignment_bytes; + self + } + pub fn storage_texel_buffer_offset_single_texel_alignment( + mut self, + storage_texel_buffer_offset_single_texel_alignment: bool, + ) -> Self { + self.storage_texel_buffer_offset_single_texel_alignment = storage_texel_buffer_offset_single_texel_alignment + .into(); + self + } + pub fn uniform_texel_buffer_offset_alignment_bytes( + mut self, + uniform_texel_buffer_offset_alignment_bytes: crate::vk::DeviceSize, + ) -> Self { + self.uniform_texel_buffer_offset_alignment_bytes = uniform_texel_buffer_offset_alignment_bytes; + self + } + pub fn uniform_texel_buffer_offset_single_texel_alignment( + mut self, + uniform_texel_buffer_offset_single_texel_alignment: bool, + ) -> Self { + self.uniform_texel_buffer_offset_single_texel_alignment = uniform_texel_buffer_offset_single_texel_alignment + .into(); + self + } + pub fn max_buffer_size( + mut self, + max_buffer_size: crate::vk::DeviceSize, + ) -> Self { + self.max_buffer_size = max_buffer_size; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceToolProperties<'a> { @@ -869,6 +2004,74 @@ pub(crate) mod reexport { pub layer: [core::ffi::c_char; crate::vk::MAX_EXTENSION_NAME_SIZE as _], pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for PhysicalDeviceToolProperties<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_TOOL_PROPERTIES; + } + impl<'a> Default for PhysicalDeviceToolProperties<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + name: unsafe { core::mem::zeroed() }, + version: unsafe { core::mem::zeroed() }, + purposes: Default::default(), + description: unsafe { core::mem::zeroed() }, + layer: unsafe { core::mem::zeroed() }, + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceToolProperties<'a> { + pub fn name( + mut self, + name: &core::ffi::CStr, + ) -> core::result::Result { + crate::write_c_str_slice_with_nul(&mut self.name, name).map(|_| self) + } + pub fn name_as_c_str( + &self, + ) -> core::result::Result<&core::ffi::CStr, core::ffi::FromBytesUntilNulError> { + crate::wrap_c_str_slice_until_nul(&self.name) + } + pub fn version( + mut self, + version: &core::ffi::CStr, + ) -> core::result::Result { + crate::write_c_str_slice_with_nul(&mut self.version, version).map(|_| self) + } + pub fn version_as_c_str( + &self, + ) -> core::result::Result<&core::ffi::CStr, core::ffi::FromBytesUntilNulError> { + crate::wrap_c_str_slice_until_nul(&self.version) + } + pub fn purposes(mut self, purposes: crate::vk::ToolPurposeFlags) -> Self { + self.purposes = purposes; + self + } + pub fn description( + mut self, + description: &core::ffi::CStr, + ) -> core::result::Result { + crate::write_c_str_slice_with_nul(&mut self.description, description) + .map(|_| self) + } + pub fn description_as_c_str( + &self, + ) -> core::result::Result<&core::ffi::CStr, core::ffi::FromBytesUntilNulError> { + crate::wrap_c_str_slice_until_nul(&self.description) + } + pub fn layer( + mut self, + layer: &core::ffi::CStr, + ) -> core::result::Result { + crate::write_c_str_slice_with_nul(&mut self.layer, layer).map(|_| self) + } + pub fn layer_as_c_str( + &self, + ) -> core::result::Result<&core::ffi::CStr, core::ffi::FromBytesUntilNulError> { + crate::wrap_c_str_slice_until_nul(&self.layer) + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures<'a> { @@ -877,6 +2080,34 @@ pub(crate) mod reexport { pub shader_zero_initialize_workgroup_memory: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures<'a> {} + unsafe impl<'a> crate::Extends> + for PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures<'a> {} + impl<'a> Default for PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + shader_zero_initialize_workgroup_memory: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures<'a> { + pub fn shader_zero_initialize_workgroup_memory( + mut self, + shader_zero_initialize_workgroup_memory: bool, + ) -> Self { + self.shader_zero_initialize_workgroup_memory = shader_zero_initialize_workgroup_memory + .into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceImageRobustnessFeatures<'a> { @@ -885,6 +2116,30 @@ pub(crate) mod reexport { pub robust_image_access: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceImageRobustnessFeatures<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceImageRobustnessFeatures<'a> {} + unsafe impl<'a> crate::Extends> + for PhysicalDeviceImageRobustnessFeatures<'a> {} + impl<'a> Default for PhysicalDeviceImageRobustnessFeatures<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + robust_image_access: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceImageRobustnessFeatures<'a> { + pub fn robust_image_access(mut self, robust_image_access: bool) -> Self { + self.robust_image_access = robust_image_access.into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct BufferCopy2<'a> { @@ -895,6 +2150,35 @@ pub(crate) mod reexport { pub size: crate::vk::DeviceSize, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for BufferCopy2<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::BUFFER_COPY_2; + } + impl<'a> Default for BufferCopy2<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + src_offset: Default::default(), + dst_offset: Default::default(), + size: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> BufferCopy2<'a> { + pub fn src_offset(mut self, src_offset: crate::vk::DeviceSize) -> Self { + self.src_offset = src_offset; + self + } + pub fn dst_offset(mut self, dst_offset: crate::vk::DeviceSize) -> Self { + self.dst_offset = dst_offset; + self + } + pub fn size(mut self, size: crate::vk::DeviceSize) -> Self { + self.size = size; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct ImageCopy2<'a> { @@ -907,6 +2191,51 @@ pub(crate) mod reexport { pub extent: crate::vk::Extent3D, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for ImageCopy2<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::IMAGE_COPY_2; + } + impl<'a> Default for ImageCopy2<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + src_subresource: Default::default(), + src_offset: Default::default(), + dst_subresource: Default::default(), + dst_offset: Default::default(), + extent: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> ImageCopy2<'a> { + pub fn src_subresource( + mut self, + src_subresource: crate::vk::ImageSubresourceLayers, + ) -> Self { + self.src_subresource = src_subresource; + self + } + pub fn src_offset(mut self, src_offset: crate::vk::Offset3D) -> Self { + self.src_offset = src_offset; + self + } + pub fn dst_subresource( + mut self, + dst_subresource: crate::vk::ImageSubresourceLayers, + ) -> Self { + self.dst_subresource = dst_subresource; + self + } + pub fn dst_offset(mut self, dst_offset: crate::vk::Offset3D) -> Self { + self.dst_offset = dst_offset; + self + } + pub fn extent(mut self, extent: crate::vk::Extent3D) -> Self { + self.extent = extent; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct ImageBlit2<'a> { @@ -918,6 +2247,52 @@ pub(crate) mod reexport { pub dst_offsets: [crate::vk::Offset3D; 2 as _], pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for ImageBlit2<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::IMAGE_BLIT_2; + } + impl<'a> Default for ImageBlit2<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + src_subresource: Default::default(), + src_offsets: unsafe { core::mem::zeroed() }, + dst_subresource: Default::default(), + dst_offsets: unsafe { core::mem::zeroed() }, + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> ImageBlit2<'a> { + pub fn src_subresource( + mut self, + src_subresource: crate::vk::ImageSubresourceLayers, + ) -> Self { + self.src_subresource = src_subresource; + self + } + pub fn src_offsets( + mut self, + src_offsets: [crate::vk::Offset3D; 2 as _], + ) -> Self { + self.src_offsets = src_offsets; + self + } + pub fn dst_subresource( + mut self, + dst_subresource: crate::vk::ImageSubresourceLayers, + ) -> Self { + self.dst_subresource = dst_subresource; + self + } + pub fn dst_offsets( + mut self, + dst_offsets: [crate::vk::Offset3D; 2 as _], + ) -> Self { + self.dst_offsets = dst_offsets; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct BufferImageCopy2<'a> { @@ -931,6 +2306,53 @@ pub(crate) mod reexport { pub image_extent: crate::vk::Extent3D, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for BufferImageCopy2<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::BUFFER_IMAGE_COPY_2; + } + impl<'a> Default for BufferImageCopy2<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + buffer_offset: Default::default(), + buffer_row_length: Default::default(), + buffer_image_height: Default::default(), + image_subresource: Default::default(), + image_offset: Default::default(), + image_extent: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> BufferImageCopy2<'a> { + pub fn buffer_offset(mut self, buffer_offset: crate::vk::DeviceSize) -> Self { + self.buffer_offset = buffer_offset; + self + } + pub fn buffer_row_length(mut self, buffer_row_length: u32) -> Self { + self.buffer_row_length = buffer_row_length; + self + } + pub fn buffer_image_height(mut self, buffer_image_height: u32) -> Self { + self.buffer_image_height = buffer_image_height; + self + } + pub fn image_subresource( + mut self, + image_subresource: crate::vk::ImageSubresourceLayers, + ) -> Self { + self.image_subresource = image_subresource; + self + } + pub fn image_offset(mut self, image_offset: crate::vk::Offset3D) -> Self { + self.image_offset = image_offset; + self + } + pub fn image_extent(mut self, image_extent: crate::vk::Extent3D) -> Self { + self.image_extent = image_extent; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct ImageResolve2<'a> { @@ -943,6 +2365,51 @@ pub(crate) mod reexport { pub extent: crate::vk::Extent3D, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for ImageResolve2<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::IMAGE_RESOLVE_2; + } + impl<'a> Default for ImageResolve2<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + src_subresource: Default::default(), + src_offset: Default::default(), + dst_subresource: Default::default(), + dst_offset: Default::default(), + extent: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> ImageResolve2<'a> { + pub fn src_subresource( + mut self, + src_subresource: crate::vk::ImageSubresourceLayers, + ) -> Self { + self.src_subresource = src_subresource; + self + } + pub fn src_offset(mut self, src_offset: crate::vk::Offset3D) -> Self { + self.src_offset = src_offset; + self + } + pub fn dst_subresource( + mut self, + dst_subresource: crate::vk::ImageSubresourceLayers, + ) -> Self { + self.dst_subresource = dst_subresource; + self + } + pub fn dst_offset(mut self, dst_offset: crate::vk::Offset3D) -> Self { + self.dst_offset = dst_offset; + self + } + pub fn extent(mut self, extent: crate::vk::Extent3D) -> Self { + self.extent = extent; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct CopyBufferInfo2<'a> { @@ -954,6 +2421,41 @@ pub(crate) mod reexport { pub p_regions: *const crate::vk::BufferCopy2<'a>, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for CopyBufferInfo2<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::COPY_BUFFER_INFO_2; + } + impl<'a> Default for CopyBufferInfo2<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + src_buffer: Default::default(), + dst_buffer: Default::default(), + region_count: Default::default(), + p_regions: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> CopyBufferInfo2<'a> { + pub fn src_buffer(mut self, src_buffer: crate::vk::Buffer) -> Self { + self.src_buffer = src_buffer; + self + } + pub fn dst_buffer(mut self, dst_buffer: crate::vk::Buffer) -> Self { + self.dst_buffer = dst_buffer; + self + } + pub fn region_count(mut self, region_count: u32) -> Self { + self.region_count = region_count; + self + } + pub fn p_regions(mut self, p_regions: &'a [crate::vk::BufferCopy2<'a>]) -> Self { + self.region_count = p_regions.len() as _; + self.p_regions = p_regions.as_ptr(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct CopyImageInfo2<'a> { @@ -967,6 +2469,57 @@ pub(crate) mod reexport { pub p_regions: *const crate::vk::ImageCopy2<'a>, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for CopyImageInfo2<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::COPY_IMAGE_INFO_2; + } + impl<'a> Default for CopyImageInfo2<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + src_image: Default::default(), + src_image_layout: Default::default(), + dst_image: Default::default(), + dst_image_layout: Default::default(), + region_count: Default::default(), + p_regions: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> CopyImageInfo2<'a> { + pub fn src_image(mut self, src_image: crate::vk::Image) -> Self { + self.src_image = src_image; + self + } + pub fn src_image_layout( + mut self, + src_image_layout: crate::vk::ImageLayout, + ) -> Self { + self.src_image_layout = src_image_layout; + self + } + pub fn dst_image(mut self, dst_image: crate::vk::Image) -> Self { + self.dst_image = dst_image; + self + } + pub fn dst_image_layout( + mut self, + dst_image_layout: crate::vk::ImageLayout, + ) -> Self { + self.dst_image_layout = dst_image_layout; + self + } + pub fn region_count(mut self, region_count: u32) -> Self { + self.region_count = region_count; + self + } + pub fn p_regions(mut self, p_regions: &'a [crate::vk::ImageCopy2<'a>]) -> Self { + self.region_count = p_regions.len() as _; + self.p_regions = p_regions.as_ptr(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct BlitImageInfo2<'a> { @@ -981,6 +2534,62 @@ pub(crate) mod reexport { pub filter: crate::vk::Filter, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for BlitImageInfo2<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::BLIT_IMAGE_INFO_2; + } + impl<'a> Default for BlitImageInfo2<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + src_image: Default::default(), + src_image_layout: Default::default(), + dst_image: Default::default(), + dst_image_layout: Default::default(), + region_count: Default::default(), + p_regions: Default::default(), + filter: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> BlitImageInfo2<'a> { + pub fn src_image(mut self, src_image: crate::vk::Image) -> Self { + self.src_image = src_image; + self + } + pub fn src_image_layout( + mut self, + src_image_layout: crate::vk::ImageLayout, + ) -> Self { + self.src_image_layout = src_image_layout; + self + } + pub fn dst_image(mut self, dst_image: crate::vk::Image) -> Self { + self.dst_image = dst_image; + self + } + pub fn dst_image_layout( + mut self, + dst_image_layout: crate::vk::ImageLayout, + ) -> Self { + self.dst_image_layout = dst_image_layout; + self + } + pub fn region_count(mut self, region_count: u32) -> Self { + self.region_count = region_count; + self + } + pub fn p_regions(mut self, p_regions: &'a [crate::vk::ImageBlit2<'a>]) -> Self { + self.region_count = p_regions.len() as _; + self.p_regions = p_regions.as_ptr(); + self + } + pub fn filter(mut self, filter: crate::vk::Filter) -> Self { + self.filter = filter; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct CopyBufferToImageInfo2<'a> { @@ -993,6 +2602,52 @@ pub(crate) mod reexport { pub p_regions: *const crate::vk::BufferImageCopy2<'a>, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for CopyBufferToImageInfo2<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::COPY_BUFFER_TO_IMAGE_INFO_2; + } + impl<'a> Default for CopyBufferToImageInfo2<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + src_buffer: Default::default(), + dst_image: Default::default(), + dst_image_layout: Default::default(), + region_count: Default::default(), + p_regions: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> CopyBufferToImageInfo2<'a> { + pub fn src_buffer(mut self, src_buffer: crate::vk::Buffer) -> Self { + self.src_buffer = src_buffer; + self + } + pub fn dst_image(mut self, dst_image: crate::vk::Image) -> Self { + self.dst_image = dst_image; + self + } + pub fn dst_image_layout( + mut self, + dst_image_layout: crate::vk::ImageLayout, + ) -> Self { + self.dst_image_layout = dst_image_layout; + self + } + pub fn region_count(mut self, region_count: u32) -> Self { + self.region_count = region_count; + self + } + pub fn p_regions( + mut self, + p_regions: &'a [crate::vk::BufferImageCopy2<'a>], + ) -> Self { + self.region_count = p_regions.len() as _; + self.p_regions = p_regions.as_ptr(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct CopyImageToBufferInfo2<'a> { @@ -1005,6 +2660,52 @@ pub(crate) mod reexport { pub p_regions: *const crate::vk::BufferImageCopy2<'a>, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for CopyImageToBufferInfo2<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::COPY_IMAGE_TO_BUFFER_INFO_2; + } + impl<'a> Default for CopyImageToBufferInfo2<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + src_image: Default::default(), + src_image_layout: Default::default(), + dst_buffer: Default::default(), + region_count: Default::default(), + p_regions: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> CopyImageToBufferInfo2<'a> { + pub fn src_image(mut self, src_image: crate::vk::Image) -> Self { + self.src_image = src_image; + self + } + pub fn src_image_layout( + mut self, + src_image_layout: crate::vk::ImageLayout, + ) -> Self { + self.src_image_layout = src_image_layout; + self + } + pub fn dst_buffer(mut self, dst_buffer: crate::vk::Buffer) -> Self { + self.dst_buffer = dst_buffer; + self + } + pub fn region_count(mut self, region_count: u32) -> Self { + self.region_count = region_count; + self + } + pub fn p_regions( + mut self, + p_regions: &'a [crate::vk::BufferImageCopy2<'a>], + ) -> Self { + self.region_count = p_regions.len() as _; + self.p_regions = p_regions.as_ptr(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct ResolveImageInfo2<'a> { @@ -1018,6 +2719,60 @@ pub(crate) mod reexport { pub p_regions: *const crate::vk::ImageResolve2<'a>, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for ResolveImageInfo2<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::RESOLVE_IMAGE_INFO_2; + } + impl<'a> Default for ResolveImageInfo2<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + src_image: Default::default(), + src_image_layout: Default::default(), + dst_image: Default::default(), + dst_image_layout: Default::default(), + region_count: Default::default(), + p_regions: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> ResolveImageInfo2<'a> { + pub fn src_image(mut self, src_image: crate::vk::Image) -> Self { + self.src_image = src_image; + self + } + pub fn src_image_layout( + mut self, + src_image_layout: crate::vk::ImageLayout, + ) -> Self { + self.src_image_layout = src_image_layout; + self + } + pub fn dst_image(mut self, dst_image: crate::vk::Image) -> Self { + self.dst_image = dst_image; + self + } + pub fn dst_image_layout( + mut self, + dst_image_layout: crate::vk::ImageLayout, + ) -> Self { + self.dst_image_layout = dst_image_layout; + self + } + pub fn region_count(mut self, region_count: u32) -> Self { + self.region_count = region_count; + self + } + pub fn p_regions( + mut self, + p_regions: &'a [crate::vk::ImageResolve2<'a>], + ) -> Self { + self.region_count = p_regions.len() as _; + self.p_regions = p_regions.as_ptr(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceShaderTerminateInvocationFeatures<'a> { @@ -1026,6 +2781,33 @@ pub(crate) mod reexport { pub shader_terminate_invocation: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceShaderTerminateInvocationFeatures<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceShaderTerminateInvocationFeatures<'a> {} + unsafe impl<'a> crate::Extends> + for PhysicalDeviceShaderTerminateInvocationFeatures<'a> {} + impl<'a> Default for PhysicalDeviceShaderTerminateInvocationFeatures<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + shader_terminate_invocation: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceShaderTerminateInvocationFeatures<'a> { + pub fn shader_terminate_invocation( + mut self, + shader_terminate_invocation: bool, + ) -> Self { + self.shader_terminate_invocation = shader_terminate_invocation.into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct MemoryBarrier2<'a> { @@ -1037,6 +2819,54 @@ pub(crate) mod reexport { pub dst_access_mask: crate::vk::AccessFlags2, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for MemoryBarrier2<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::MEMORY_BARRIER_2; + } + unsafe impl<'a> crate::Extends> + for MemoryBarrier2<'a> {} + impl<'a> Default for MemoryBarrier2<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + src_stage_mask: Default::default(), + src_access_mask: Default::default(), + dst_stage_mask: Default::default(), + dst_access_mask: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> MemoryBarrier2<'a> { + pub fn src_stage_mask( + mut self, + src_stage_mask: crate::vk::PipelineStageFlags2, + ) -> Self { + self.src_stage_mask = src_stage_mask; + self + } + pub fn src_access_mask( + mut self, + src_access_mask: crate::vk::AccessFlags2, + ) -> Self { + self.src_access_mask = src_access_mask; + self + } + pub fn dst_stage_mask( + mut self, + dst_stage_mask: crate::vk::PipelineStageFlags2, + ) -> Self { + self.dst_stage_mask = dst_stage_mask; + self + } + pub fn dst_access_mask( + mut self, + dst_access_mask: crate::vk::AccessFlags2, + ) -> Self { + self.dst_access_mask = dst_access_mask; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct ImageMemoryBarrier2<'a> { @@ -1054,6 +2884,85 @@ pub(crate) mod reexport { pub subresource_range: crate::vk::ImageSubresourceRange, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for ImageMemoryBarrier2<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::IMAGE_MEMORY_BARRIER_2; + } + impl<'a> Default for ImageMemoryBarrier2<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + src_stage_mask: Default::default(), + src_access_mask: Default::default(), + dst_stage_mask: Default::default(), + dst_access_mask: Default::default(), + old_layout: Default::default(), + new_layout: Default::default(), + src_queue_family_index: Default::default(), + dst_queue_family_index: Default::default(), + image: Default::default(), + subresource_range: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> ImageMemoryBarrier2<'a> { + pub fn src_stage_mask( + mut self, + src_stage_mask: crate::vk::PipelineStageFlags2, + ) -> Self { + self.src_stage_mask = src_stage_mask; + self + } + pub fn src_access_mask( + mut self, + src_access_mask: crate::vk::AccessFlags2, + ) -> Self { + self.src_access_mask = src_access_mask; + self + } + pub fn dst_stage_mask( + mut self, + dst_stage_mask: crate::vk::PipelineStageFlags2, + ) -> Self { + self.dst_stage_mask = dst_stage_mask; + self + } + pub fn dst_access_mask( + mut self, + dst_access_mask: crate::vk::AccessFlags2, + ) -> Self { + self.dst_access_mask = dst_access_mask; + self + } + pub fn old_layout(mut self, old_layout: crate::vk::ImageLayout) -> Self { + self.old_layout = old_layout; + self + } + pub fn new_layout(mut self, new_layout: crate::vk::ImageLayout) -> Self { + self.new_layout = new_layout; + self + } + pub fn src_queue_family_index(mut self, src_queue_family_index: u32) -> Self { + self.src_queue_family_index = src_queue_family_index; + self + } + pub fn dst_queue_family_index(mut self, dst_queue_family_index: u32) -> Self { + self.dst_queue_family_index = dst_queue_family_index; + self + } + pub fn image(mut self, image: crate::vk::Image) -> Self { + self.image = image; + self + } + pub fn subresource_range( + mut self, + subresource_range: crate::vk::ImageSubresourceRange, + ) -> Self { + self.subresource_range = subresource_range; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct BufferMemoryBarrier2<'a> { @@ -1070,6 +2979,77 @@ pub(crate) mod reexport { pub size: crate::vk::DeviceSize, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for BufferMemoryBarrier2<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::BUFFER_MEMORY_BARRIER_2; + } + impl<'a> Default for BufferMemoryBarrier2<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + src_stage_mask: Default::default(), + src_access_mask: Default::default(), + dst_stage_mask: Default::default(), + dst_access_mask: Default::default(), + src_queue_family_index: Default::default(), + dst_queue_family_index: Default::default(), + buffer: Default::default(), + offset: Default::default(), + size: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> BufferMemoryBarrier2<'a> { + pub fn src_stage_mask( + mut self, + src_stage_mask: crate::vk::PipelineStageFlags2, + ) -> Self { + self.src_stage_mask = src_stage_mask; + self + } + pub fn src_access_mask( + mut self, + src_access_mask: crate::vk::AccessFlags2, + ) -> Self { + self.src_access_mask = src_access_mask; + self + } + pub fn dst_stage_mask( + mut self, + dst_stage_mask: crate::vk::PipelineStageFlags2, + ) -> Self { + self.dst_stage_mask = dst_stage_mask; + self + } + pub fn dst_access_mask( + mut self, + dst_access_mask: crate::vk::AccessFlags2, + ) -> Self { + self.dst_access_mask = dst_access_mask; + self + } + pub fn src_queue_family_index(mut self, src_queue_family_index: u32) -> Self { + self.src_queue_family_index = src_queue_family_index; + self + } + pub fn dst_queue_family_index(mut self, dst_queue_family_index: u32) -> Self { + self.dst_queue_family_index = dst_queue_family_index; + self + } + pub fn buffer(mut self, buffer: crate::vk::Buffer) -> Self { + self.buffer = buffer; + self + } + pub fn offset(mut self, offset: crate::vk::DeviceSize) -> Self { + self.offset = offset; + self + } + pub fn size(mut self, size: crate::vk::DeviceSize) -> Self { + self.size = size; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct DependencyInfo<'a> { @@ -1084,6 +3064,76 @@ pub(crate) mod reexport { pub p_image_memory_barriers: *const crate::vk::ImageMemoryBarrier2<'a>, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for DependencyInfo<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::DEPENDENCY_INFO; + } + impl<'a> Default for DependencyInfo<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + dependency_flags: Default::default(), + memory_barrier_count: Default::default(), + p_memory_barriers: Default::default(), + buffer_memory_barrier_count: Default::default(), + p_buffer_memory_barriers: Default::default(), + image_memory_barrier_count: Default::default(), + p_image_memory_barriers: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> DependencyInfo<'a> { + pub fn dependency_flags( + mut self, + dependency_flags: crate::vk::DependencyFlags, + ) -> Self { + self.dependency_flags = dependency_flags; + self + } + pub fn memory_barrier_count(mut self, memory_barrier_count: u32) -> Self { + self.memory_barrier_count = memory_barrier_count; + self + } + pub fn p_memory_barriers( + mut self, + p_memory_barriers: &'a [crate::vk::MemoryBarrier2<'a>], + ) -> Self { + self.memory_barrier_count = p_memory_barriers.len() as _; + self.p_memory_barriers = p_memory_barriers.as_ptr(); + self + } + pub fn buffer_memory_barrier_count( + mut self, + buffer_memory_barrier_count: u32, + ) -> Self { + self.buffer_memory_barrier_count = buffer_memory_barrier_count; + self + } + pub fn p_buffer_memory_barriers( + mut self, + p_buffer_memory_barriers: &'a [crate::vk::BufferMemoryBarrier2<'a>], + ) -> Self { + self.buffer_memory_barrier_count = p_buffer_memory_barriers.len() as _; + self.p_buffer_memory_barriers = p_buffer_memory_barriers.as_ptr(); + self + } + pub fn image_memory_barrier_count( + mut self, + image_memory_barrier_count: u32, + ) -> Self { + self.image_memory_barrier_count = image_memory_barrier_count; + self + } + pub fn p_image_memory_barriers( + mut self, + p_image_memory_barriers: &'a [crate::vk::ImageMemoryBarrier2<'a>], + ) -> Self { + self.image_memory_barrier_count = p_image_memory_barriers.len() as _; + self.p_image_memory_barriers = p_image_memory_barriers.as_ptr(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct SemaphoreSubmitInfo<'a> { @@ -1095,6 +3145,40 @@ pub(crate) mod reexport { pub device_index: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for SemaphoreSubmitInfo<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::SEMAPHORE_SUBMIT_INFO; + } + impl<'a> Default for SemaphoreSubmitInfo<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + semaphore: Default::default(), + value: Default::default(), + stage_mask: Default::default(), + device_index: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> SemaphoreSubmitInfo<'a> { + pub fn semaphore(mut self, semaphore: crate::vk::Semaphore) -> Self { + self.semaphore = semaphore; + self + } + pub fn value(mut self, value: u64) -> Self { + self.value = value; + self + } + pub fn stage_mask(mut self, stage_mask: crate::vk::PipelineStageFlags2) -> Self { + self.stage_mask = stage_mask; + self + } + pub fn device_index(mut self, device_index: u32) -> Self { + self.device_index = device_index; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct CommandBufferSubmitInfo<'a> { @@ -1104,6 +3188,33 @@ pub(crate) mod reexport { pub device_mask: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for CommandBufferSubmitInfo<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::COMMAND_BUFFER_SUBMIT_INFO; + } + impl<'a> Default for CommandBufferSubmitInfo<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + command_buffer: Default::default(), + device_mask: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> CommandBufferSubmitInfo<'a> { + pub fn command_buffer( + mut self, + command_buffer: crate::vk::CommandBuffer, + ) -> Self { + self.command_buffer = command_buffer; + self + } + pub fn device_mask(mut self, device_mask: u32) -> Self { + self.device_mask = device_mask; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct SubmitInfo2<'a> { @@ -1118,6 +3229,76 @@ pub(crate) mod reexport { pub p_signal_semaphore_infos: *const crate::vk::SemaphoreSubmitInfo<'a>, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for SubmitInfo2<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::SUBMIT_INFO_2; + } + impl<'a> Default for SubmitInfo2<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + flags: Default::default(), + wait_semaphore_info_count: Default::default(), + p_wait_semaphore_infos: Default::default(), + command_buffer_info_count: Default::default(), + p_command_buffer_infos: Default::default(), + signal_semaphore_info_count: Default::default(), + p_signal_semaphore_infos: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> SubmitInfo2<'a> { + pub fn flags(mut self, flags: crate::vk::SubmitFlags) -> Self { + self.flags = flags; + self + } + pub fn wait_semaphore_info_count( + mut self, + wait_semaphore_info_count: u32, + ) -> Self { + self.wait_semaphore_info_count = wait_semaphore_info_count; + self + } + pub fn p_wait_semaphore_infos( + mut self, + p_wait_semaphore_infos: &'a [crate::vk::SemaphoreSubmitInfo<'a>], + ) -> Self { + self.wait_semaphore_info_count = p_wait_semaphore_infos.len() as _; + self.p_wait_semaphore_infos = p_wait_semaphore_infos.as_ptr(); + self + } + pub fn command_buffer_info_count( + mut self, + command_buffer_info_count: u32, + ) -> Self { + self.command_buffer_info_count = command_buffer_info_count; + self + } + pub fn p_command_buffer_infos( + mut self, + p_command_buffer_infos: &'a [crate::vk::CommandBufferSubmitInfo<'a>], + ) -> Self { + self.command_buffer_info_count = p_command_buffer_infos.len() as _; + self.p_command_buffer_infos = p_command_buffer_infos.as_ptr(); + self + } + pub fn signal_semaphore_info_count( + mut self, + signal_semaphore_info_count: u32, + ) -> Self { + self.signal_semaphore_info_count = signal_semaphore_info_count; + self + } + pub fn p_signal_semaphore_infos( + mut self, + p_signal_semaphore_infos: &'a [crate::vk::SemaphoreSubmitInfo<'a>], + ) -> Self { + self.signal_semaphore_info_count = p_signal_semaphore_infos.len() as _; + self.p_signal_semaphore_infos = p_signal_semaphore_infos.as_ptr(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceSynchronization2Features<'a> { @@ -1126,6 +3307,30 @@ pub(crate) mod reexport { pub synchronization2: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceSynchronization2Features<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceSynchronization2Features<'a> {} + unsafe impl<'a> crate::Extends> + for PhysicalDeviceSynchronization2Features<'a> {} + impl<'a> Default for PhysicalDeviceSynchronization2Features<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + synchronization2: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceSynchronization2Features<'a> { + pub fn synchronization2(mut self, synchronization2: bool) -> Self { + self.synchronization2 = synchronization2.into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceShaderIntegerDotProductFeatures<'a> { @@ -1134,6 +3339,33 @@ pub(crate) mod reexport { pub shader_integer_dot_product: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceShaderIntegerDotProductFeatures<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceShaderIntegerDotProductFeatures<'a> {} + unsafe impl<'a> crate::Extends> + for PhysicalDeviceShaderIntegerDotProductFeatures<'a> {} + impl<'a> Default for PhysicalDeviceShaderIntegerDotProductFeatures<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + shader_integer_dot_product: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceShaderIntegerDotProductFeatures<'a> { + pub fn shader_integer_dot_product( + mut self, + shader_integer_dot_product: bool, + ) -> Self { + self.shader_integer_dot_product = shader_integer_dot_product.into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceShaderIntegerDotProductProperties<'a> { @@ -1171,6 +3403,303 @@ pub(crate) mod reexport { pub integer_dot_product_accumulating_saturating64_bit_mixed_signedness_accelerated: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceShaderIntegerDotProductProperties<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceShaderIntegerDotProductProperties<'a> {} + impl<'a> Default for PhysicalDeviceShaderIntegerDotProductProperties<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + integer_dot_product8_bit_unsigned_accelerated: Default::default(), + integer_dot_product8_bit_signed_accelerated: Default::default(), + integer_dot_product8_bit_mixed_signedness_accelerated: Default::default(), + integer_dot_product4x8_bit_packed_unsigned_accelerated: Default::default(), + integer_dot_product4x8_bit_packed_signed_accelerated: Default::default(), + integer_dot_product4x8_bit_packed_mixed_signedness_accelerated: Default::default(), + integer_dot_product16_bit_unsigned_accelerated: Default::default(), + integer_dot_product16_bit_signed_accelerated: Default::default(), + integer_dot_product16_bit_mixed_signedness_accelerated: Default::default(), + integer_dot_product32_bit_unsigned_accelerated: Default::default(), + integer_dot_product32_bit_signed_accelerated: Default::default(), + integer_dot_product32_bit_mixed_signedness_accelerated: Default::default(), + integer_dot_product64_bit_unsigned_accelerated: Default::default(), + integer_dot_product64_bit_signed_accelerated: Default::default(), + integer_dot_product64_bit_mixed_signedness_accelerated: Default::default(), + integer_dot_product_accumulating_saturating8_bit_unsigned_accelerated: Default::default(), + integer_dot_product_accumulating_saturating8_bit_signed_accelerated: Default::default(), + integer_dot_product_accumulating_saturating8_bit_mixed_signedness_accelerated: Default::default(), + integer_dot_product_accumulating_saturating4x8_bit_packed_unsigned_accelerated: Default::default(), + integer_dot_product_accumulating_saturating4x8_bit_packed_signed_accelerated: Default::default(), + integer_dot_product_accumulating_saturating4x8_bit_packed_mixed_signedness_accelerated: Default::default(), + integer_dot_product_accumulating_saturating16_bit_unsigned_accelerated: Default::default(), + integer_dot_product_accumulating_saturating16_bit_signed_accelerated: Default::default(), + integer_dot_product_accumulating_saturating16_bit_mixed_signedness_accelerated: Default::default(), + integer_dot_product_accumulating_saturating32_bit_unsigned_accelerated: Default::default(), + integer_dot_product_accumulating_saturating32_bit_signed_accelerated: Default::default(), + integer_dot_product_accumulating_saturating32_bit_mixed_signedness_accelerated: Default::default(), + integer_dot_product_accumulating_saturating64_bit_unsigned_accelerated: Default::default(), + integer_dot_product_accumulating_saturating64_bit_signed_accelerated: Default::default(), + integer_dot_product_accumulating_saturating64_bit_mixed_signedness_accelerated: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceShaderIntegerDotProductProperties<'a> { + pub fn integer_dot_product8_bit_unsigned_accelerated( + mut self, + integer_dot_product8_bit_unsigned_accelerated: bool, + ) -> Self { + self.integer_dot_product8_bit_unsigned_accelerated = integer_dot_product8_bit_unsigned_accelerated + .into(); + self + } + pub fn integer_dot_product8_bit_signed_accelerated( + mut self, + integer_dot_product8_bit_signed_accelerated: bool, + ) -> Self { + self.integer_dot_product8_bit_signed_accelerated = integer_dot_product8_bit_signed_accelerated + .into(); + self + } + pub fn integer_dot_product8_bit_mixed_signedness_accelerated( + mut self, + integer_dot_product8_bit_mixed_signedness_accelerated: bool, + ) -> Self { + self.integer_dot_product8_bit_mixed_signedness_accelerated = integer_dot_product8_bit_mixed_signedness_accelerated + .into(); + self + } + pub fn integer_dot_product4x8_bit_packed_unsigned_accelerated( + mut self, + integer_dot_product4x8_bit_packed_unsigned_accelerated: bool, + ) -> Self { + self.integer_dot_product4x8_bit_packed_unsigned_accelerated = integer_dot_product4x8_bit_packed_unsigned_accelerated + .into(); + self + } + pub fn integer_dot_product4x8_bit_packed_signed_accelerated( + mut self, + integer_dot_product4x8_bit_packed_signed_accelerated: bool, + ) -> Self { + self.integer_dot_product4x8_bit_packed_signed_accelerated = integer_dot_product4x8_bit_packed_signed_accelerated + .into(); + self + } + pub fn integer_dot_product4x8_bit_packed_mixed_signedness_accelerated( + mut self, + integer_dot_product4x8_bit_packed_mixed_signedness_accelerated: bool, + ) -> Self { + self.integer_dot_product4x8_bit_packed_mixed_signedness_accelerated = integer_dot_product4x8_bit_packed_mixed_signedness_accelerated + .into(); + self + } + pub fn integer_dot_product16_bit_unsigned_accelerated( + mut self, + integer_dot_product16_bit_unsigned_accelerated: bool, + ) -> Self { + self.integer_dot_product16_bit_unsigned_accelerated = integer_dot_product16_bit_unsigned_accelerated + .into(); + self + } + pub fn integer_dot_product16_bit_signed_accelerated( + mut self, + integer_dot_product16_bit_signed_accelerated: bool, + ) -> Self { + self.integer_dot_product16_bit_signed_accelerated = integer_dot_product16_bit_signed_accelerated + .into(); + self + } + pub fn integer_dot_product16_bit_mixed_signedness_accelerated( + mut self, + integer_dot_product16_bit_mixed_signedness_accelerated: bool, + ) -> Self { + self.integer_dot_product16_bit_mixed_signedness_accelerated = integer_dot_product16_bit_mixed_signedness_accelerated + .into(); + self + } + pub fn integer_dot_product32_bit_unsigned_accelerated( + mut self, + integer_dot_product32_bit_unsigned_accelerated: bool, + ) -> Self { + self.integer_dot_product32_bit_unsigned_accelerated = integer_dot_product32_bit_unsigned_accelerated + .into(); + self + } + pub fn integer_dot_product32_bit_signed_accelerated( + mut self, + integer_dot_product32_bit_signed_accelerated: bool, + ) -> Self { + self.integer_dot_product32_bit_signed_accelerated = integer_dot_product32_bit_signed_accelerated + .into(); + self + } + pub fn integer_dot_product32_bit_mixed_signedness_accelerated( + mut self, + integer_dot_product32_bit_mixed_signedness_accelerated: bool, + ) -> Self { + self.integer_dot_product32_bit_mixed_signedness_accelerated = integer_dot_product32_bit_mixed_signedness_accelerated + .into(); + self + } + pub fn integer_dot_product64_bit_unsigned_accelerated( + mut self, + integer_dot_product64_bit_unsigned_accelerated: bool, + ) -> Self { + self.integer_dot_product64_bit_unsigned_accelerated = integer_dot_product64_bit_unsigned_accelerated + .into(); + self + } + pub fn integer_dot_product64_bit_signed_accelerated( + mut self, + integer_dot_product64_bit_signed_accelerated: bool, + ) -> Self { + self.integer_dot_product64_bit_signed_accelerated = integer_dot_product64_bit_signed_accelerated + .into(); + self + } + pub fn integer_dot_product64_bit_mixed_signedness_accelerated( + mut self, + integer_dot_product64_bit_mixed_signedness_accelerated: bool, + ) -> Self { + self.integer_dot_product64_bit_mixed_signedness_accelerated = integer_dot_product64_bit_mixed_signedness_accelerated + .into(); + self + } + pub fn integer_dot_product_accumulating_saturating8_bit_unsigned_accelerated( + mut self, + integer_dot_product_accumulating_saturating8_bit_unsigned_accelerated: bool, + ) -> Self { + self.integer_dot_product_accumulating_saturating8_bit_unsigned_accelerated = integer_dot_product_accumulating_saturating8_bit_unsigned_accelerated + .into(); + self + } + pub fn integer_dot_product_accumulating_saturating8_bit_signed_accelerated( + mut self, + integer_dot_product_accumulating_saturating8_bit_signed_accelerated: bool, + ) -> Self { + self.integer_dot_product_accumulating_saturating8_bit_signed_accelerated = integer_dot_product_accumulating_saturating8_bit_signed_accelerated + .into(); + self + } + pub fn integer_dot_product_accumulating_saturating8_bit_mixed_signedness_accelerated( + mut self, + integer_dot_product_accumulating_saturating8_bit_mixed_signedness_accelerated: bool, + ) -> Self { + self + .integer_dot_product_accumulating_saturating8_bit_mixed_signedness_accelerated = integer_dot_product_accumulating_saturating8_bit_mixed_signedness_accelerated + .into(); + self + } + pub fn integer_dot_product_accumulating_saturating4x8_bit_packed_unsigned_accelerated( + mut self, + integer_dot_product_accumulating_saturating4x8_bit_packed_unsigned_accelerated: bool, + ) -> Self { + self + .integer_dot_product_accumulating_saturating4x8_bit_packed_unsigned_accelerated = integer_dot_product_accumulating_saturating4x8_bit_packed_unsigned_accelerated + .into(); + self + } + pub fn integer_dot_product_accumulating_saturating4x8_bit_packed_signed_accelerated( + mut self, + integer_dot_product_accumulating_saturating4x8_bit_packed_signed_accelerated: bool, + ) -> Self { + self + .integer_dot_product_accumulating_saturating4x8_bit_packed_signed_accelerated = integer_dot_product_accumulating_saturating4x8_bit_packed_signed_accelerated + .into(); + self + } + pub fn integer_dot_product_accumulating_saturating4x8_bit_packed_mixed_signedness_accelerated( + mut self, + integer_dot_product_accumulating_saturating4x8_bit_packed_mixed_signedness_accelerated: bool, + ) -> Self { + self + .integer_dot_product_accumulating_saturating4x8_bit_packed_mixed_signedness_accelerated = integer_dot_product_accumulating_saturating4x8_bit_packed_mixed_signedness_accelerated + .into(); + self + } + pub fn integer_dot_product_accumulating_saturating16_bit_unsigned_accelerated( + mut self, + integer_dot_product_accumulating_saturating16_bit_unsigned_accelerated: bool, + ) -> Self { + self + .integer_dot_product_accumulating_saturating16_bit_unsigned_accelerated = integer_dot_product_accumulating_saturating16_bit_unsigned_accelerated + .into(); + self + } + pub fn integer_dot_product_accumulating_saturating16_bit_signed_accelerated( + mut self, + integer_dot_product_accumulating_saturating16_bit_signed_accelerated: bool, + ) -> Self { + self.integer_dot_product_accumulating_saturating16_bit_signed_accelerated = integer_dot_product_accumulating_saturating16_bit_signed_accelerated + .into(); + self + } + pub fn integer_dot_product_accumulating_saturating16_bit_mixed_signedness_accelerated( + mut self, + integer_dot_product_accumulating_saturating16_bit_mixed_signedness_accelerated: bool, + ) -> Self { + self + .integer_dot_product_accumulating_saturating16_bit_mixed_signedness_accelerated = integer_dot_product_accumulating_saturating16_bit_mixed_signedness_accelerated + .into(); + self + } + pub fn integer_dot_product_accumulating_saturating32_bit_unsigned_accelerated( + mut self, + integer_dot_product_accumulating_saturating32_bit_unsigned_accelerated: bool, + ) -> Self { + self + .integer_dot_product_accumulating_saturating32_bit_unsigned_accelerated = integer_dot_product_accumulating_saturating32_bit_unsigned_accelerated + .into(); + self + } + pub fn integer_dot_product_accumulating_saturating32_bit_signed_accelerated( + mut self, + integer_dot_product_accumulating_saturating32_bit_signed_accelerated: bool, + ) -> Self { + self.integer_dot_product_accumulating_saturating32_bit_signed_accelerated = integer_dot_product_accumulating_saturating32_bit_signed_accelerated + .into(); + self + } + pub fn integer_dot_product_accumulating_saturating32_bit_mixed_signedness_accelerated( + mut self, + integer_dot_product_accumulating_saturating32_bit_mixed_signedness_accelerated: bool, + ) -> Self { + self + .integer_dot_product_accumulating_saturating32_bit_mixed_signedness_accelerated = integer_dot_product_accumulating_saturating32_bit_mixed_signedness_accelerated + .into(); + self + } + pub fn integer_dot_product_accumulating_saturating64_bit_unsigned_accelerated( + mut self, + integer_dot_product_accumulating_saturating64_bit_unsigned_accelerated: bool, + ) -> Self { + self + .integer_dot_product_accumulating_saturating64_bit_unsigned_accelerated = integer_dot_product_accumulating_saturating64_bit_unsigned_accelerated + .into(); + self + } + pub fn integer_dot_product_accumulating_saturating64_bit_signed_accelerated( + mut self, + integer_dot_product_accumulating_saturating64_bit_signed_accelerated: bool, + ) -> Self { + self.integer_dot_product_accumulating_saturating64_bit_signed_accelerated = integer_dot_product_accumulating_saturating64_bit_signed_accelerated + .into(); + self + } + pub fn integer_dot_product_accumulating_saturating64_bit_mixed_signedness_accelerated( + mut self, + integer_dot_product_accumulating_saturating64_bit_mixed_signedness_accelerated: bool, + ) -> Self { + self + .integer_dot_product_accumulating_saturating64_bit_mixed_signedness_accelerated = integer_dot_product_accumulating_saturating64_bit_mixed_signedness_accelerated + .into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct FormatProperties3<'a> { @@ -1181,6 +3710,46 @@ pub(crate) mod reexport { pub buffer_features: crate::vk::FormatFeatureFlags2, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for FormatProperties3<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::FORMAT_PROPERTIES_3; + } + unsafe impl<'a> crate::Extends> + for FormatProperties3<'a> {} + impl<'a> Default for FormatProperties3<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + linear_tiling_features: Default::default(), + optimal_tiling_features: Default::default(), + buffer_features: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> FormatProperties3<'a> { + pub fn linear_tiling_features( + mut self, + linear_tiling_features: crate::vk::FormatFeatureFlags2, + ) -> Self { + self.linear_tiling_features = linear_tiling_features; + self + } + pub fn optimal_tiling_features( + mut self, + optimal_tiling_features: crate::vk::FormatFeatureFlags2, + ) -> Self { + self.optimal_tiling_features = optimal_tiling_features; + self + } + pub fn buffer_features( + mut self, + buffer_features: crate::vk::FormatFeatureFlags2, + ) -> Self { + self.buffer_features = buffer_features; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PipelineRenderingCreateInfo<'a> { @@ -1193,6 +3762,57 @@ pub(crate) mod reexport { pub stencil_attachment_format: crate::vk::Format, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for PipelineRenderingCreateInfo<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PIPELINE_RENDERING_CREATE_INFO; + } + unsafe impl<'a> crate::Extends> + for PipelineRenderingCreateInfo<'a> {} + impl<'a> Default for PipelineRenderingCreateInfo<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + view_mask: Default::default(), + color_attachment_count: Default::default(), + p_color_attachment_formats: Default::default(), + depth_attachment_format: Default::default(), + stencil_attachment_format: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PipelineRenderingCreateInfo<'a> { + pub fn view_mask(mut self, view_mask: u32) -> Self { + self.view_mask = view_mask; + self + } + pub fn color_attachment_count(mut self, color_attachment_count: u32) -> Self { + self.color_attachment_count = color_attachment_count; + self + } + pub fn p_color_attachment_formats( + mut self, + p_color_attachment_formats: &'a [crate::vk::Format], + ) -> Self { + self.color_attachment_count = p_color_attachment_formats.len() as _; + self.p_color_attachment_formats = p_color_attachment_formats.as_ptr(); + self + } + pub fn depth_attachment_format( + mut self, + depth_attachment_format: crate::vk::Format, + ) -> Self { + self.depth_attachment_format = depth_attachment_format; + self + } + pub fn stencil_attachment_format( + mut self, + stencil_attachment_format: crate::vk::Format, + ) -> Self { + self.stencil_attachment_format = stencil_attachment_format; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct RenderingInfo<'a> { @@ -1208,6 +3828,70 @@ pub(crate) mod reexport { pub p_stencil_attachment: *const crate::vk::RenderingAttachmentInfo<'a>, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for RenderingInfo<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::RENDERING_INFO; + } + impl<'a> Default for RenderingInfo<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + flags: Default::default(), + render_area: Default::default(), + layer_count: Default::default(), + view_mask: Default::default(), + color_attachment_count: Default::default(), + p_color_attachments: Default::default(), + p_depth_attachment: Default::default(), + p_stencil_attachment: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> RenderingInfo<'a> { + pub fn flags(mut self, flags: crate::vk::RenderingFlags) -> Self { + self.flags = flags; + self + } + pub fn render_area(mut self, render_area: crate::vk::Rect2D) -> Self { + self.render_area = render_area; + self + } + pub fn layer_count(mut self, layer_count: u32) -> Self { + self.layer_count = layer_count; + self + } + pub fn view_mask(mut self, view_mask: u32) -> Self { + self.view_mask = view_mask; + self + } + pub fn color_attachment_count(mut self, color_attachment_count: u32) -> Self { + self.color_attachment_count = color_attachment_count; + self + } + pub fn p_color_attachments( + mut self, + p_color_attachments: &'a [crate::vk::RenderingAttachmentInfo<'a>], + ) -> Self { + self.color_attachment_count = p_color_attachments.len() as _; + self.p_color_attachments = p_color_attachments.as_ptr(); + self + } + pub fn p_depth_attachment( + mut self, + p_depth_attachment: &'a crate::vk::RenderingAttachmentInfo<'a>, + ) -> Self { + self.p_depth_attachment = p_depth_attachment; + self + } + pub fn p_stencil_attachment( + mut self, + p_stencil_attachment: &'a crate::vk::RenderingAttachmentInfo<'a>, + ) -> Self { + self.p_stencil_attachment = p_stencil_attachment; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct RenderingAttachmentInfo<'a> { @@ -1223,6 +3907,69 @@ pub(crate) mod reexport { pub clear_value: crate::vk::ClearValue, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for RenderingAttachmentInfo<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::RENDERING_ATTACHMENT_INFO; + } + impl<'a> Default for RenderingAttachmentInfo<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + image_view: Default::default(), + image_layout: Default::default(), + resolve_mode: Default::default(), + resolve_image_view: Default::default(), + resolve_image_layout: Default::default(), + load_op: Default::default(), + store_op: Default::default(), + clear_value: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> RenderingAttachmentInfo<'a> { + pub fn image_view(mut self, image_view: crate::vk::ImageView) -> Self { + self.image_view = image_view; + self + } + pub fn image_layout(mut self, image_layout: crate::vk::ImageLayout) -> Self { + self.image_layout = image_layout; + self + } + pub fn resolve_mode( + mut self, + resolve_mode: crate::vk::ResolveModeFlagBits, + ) -> Self { + self.resolve_mode = resolve_mode; + self + } + pub fn resolve_image_view( + mut self, + resolve_image_view: crate::vk::ImageView, + ) -> Self { + self.resolve_image_view = resolve_image_view; + self + } + pub fn resolve_image_layout( + mut self, + resolve_image_layout: crate::vk::ImageLayout, + ) -> Self { + self.resolve_image_layout = resolve_image_layout; + self + } + pub fn load_op(mut self, load_op: crate::vk::AttachmentLoadOp) -> Self { + self.load_op = load_op; + self + } + pub fn store_op(mut self, store_op: crate::vk::AttachmentStoreOp) -> Self { + self.store_op = store_op; + self + } + pub fn clear_value(mut self, clear_value: crate::vk::ClearValue) -> Self { + self.clear_value = clear_value; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceDynamicRenderingFeatures<'a> { @@ -1231,6 +3978,30 @@ pub(crate) mod reexport { pub dynamic_rendering: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceDynamicRenderingFeatures<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceDynamicRenderingFeatures<'a> {} + unsafe impl<'a> crate::Extends> + for PhysicalDeviceDynamicRenderingFeatures<'a> {} + impl<'a> Default for PhysicalDeviceDynamicRenderingFeatures<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + dynamic_rendering: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceDynamicRenderingFeatures<'a> { + pub fn dynamic_rendering(mut self, dynamic_rendering: bool) -> Self { + self.dynamic_rendering = dynamic_rendering.into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct CommandBufferInheritanceRenderingInfo<'a> { @@ -1245,6 +4016,71 @@ pub(crate) mod reexport { pub rasterization_samples: crate::vk::SampleCountFlagBits, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for CommandBufferInheritanceRenderingInfo<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::COMMAND_BUFFER_INHERITANCE_RENDERING_INFO; + } + unsafe impl<'a> crate::Extends> + for CommandBufferInheritanceRenderingInfo<'a> {} + impl<'a> Default for CommandBufferInheritanceRenderingInfo<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + flags: Default::default(), + view_mask: Default::default(), + color_attachment_count: Default::default(), + p_color_attachment_formats: Default::default(), + depth_attachment_format: Default::default(), + stencil_attachment_format: Default::default(), + rasterization_samples: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> CommandBufferInheritanceRenderingInfo<'a> { + pub fn flags(mut self, flags: crate::vk::RenderingFlags) -> Self { + self.flags = flags; + self + } + pub fn view_mask(mut self, view_mask: u32) -> Self { + self.view_mask = view_mask; + self + } + pub fn color_attachment_count(mut self, color_attachment_count: u32) -> Self { + self.color_attachment_count = color_attachment_count; + self + } + pub fn p_color_attachment_formats( + mut self, + p_color_attachment_formats: &'a [crate::vk::Format], + ) -> Self { + self.color_attachment_count = p_color_attachment_formats.len() as _; + self.p_color_attachment_formats = p_color_attachment_formats.as_ptr(); + self + } + pub fn depth_attachment_format( + mut self, + depth_attachment_format: crate::vk::Format, + ) -> Self { + self.depth_attachment_format = depth_attachment_format; + self + } + pub fn stencil_attachment_format( + mut self, + stencil_attachment_format: crate::vk::Format, + ) -> Self { + self.stencil_attachment_format = stencil_attachment_format; + self + } + pub fn rasterization_samples( + mut self, + rasterization_samples: crate::vk::SampleCountFlagBits, + ) -> Self { + self.rasterization_samples = rasterization_samples; + self + } + } ///Provided by [`vk1_3`](crate::vk1_3) impl crate::vk::ImageLayout { pub const READ_ONLY_OPTIMAL: Self = Self(1000314000); @@ -1567,7 +4403,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct PipelineCreationFeedbackFlagBits(pub(crate) u32); ///Provided by [`vk1_3`](crate::vk1_3) impl PipelineCreationFeedbackFlagBits { @@ -1826,7 +4662,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct AccessFlagBits2(pub(crate) u64); ///Provided by [`vk1_3`](crate::vk1_3) impl AccessFlagBits2 { @@ -2103,7 +4939,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct PipelineStageFlagBits2(pub(crate) u64); ///Provided by [`vk1_3`](crate::vk1_3) impl PipelineStageFlagBits2 { @@ -2441,7 +5277,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct FormatFeatureFlagBits2(pub(crate) u64); ///Provided by [`vk1_3`](crate::vk1_3) impl FormatFeatureFlagBits2 { @@ -2578,7 +5414,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct RenderingFlagBits(pub(crate) u32); ///Provided by [`vk1_3`](crate::vk1_3) impl RenderingFlagBits { @@ -2678,7 +5514,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct ToolPurposeFlagBits(pub(crate) u32); ///Provided by [`vk1_3`](crate::vk1_3) impl ToolPurposeFlagBits { @@ -2758,7 +5594,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct SubmitFlagBits(pub(crate) u32); ///Provided by [`vk1_3`](crate::vk1_3) impl SubmitFlagBits { diff --git a/ash-rewrite/src/generated/vk1_4.rs b/ash-rewrite/src/generated/vk1_4.rs index 2dc20cdc6..5e05cda00 100644 --- a/ash-rewrite/src/generated/vk1_4.rs +++ b/ash-rewrite/src/generated/vk1_4.rs @@ -322,6 +322,33 @@ pub(crate) mod reexport { pub usage: crate::vk::BufferUsageFlags2, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for BufferUsageFlags2CreateInfo<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::BUFFER_USAGE_FLAGS_2_CREATE_INFO; + } + unsafe impl<'a> crate::Extends> + for BufferUsageFlags2CreateInfo<'a> {} + unsafe impl<'a> crate::Extends> + for BufferUsageFlags2CreateInfo<'a> {} + unsafe impl<'a> crate::Extends> + for BufferUsageFlags2CreateInfo<'a> {} + unsafe impl<'a> crate::Extends> + for BufferUsageFlags2CreateInfo<'a> {} + impl<'a> Default for BufferUsageFlags2CreateInfo<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + usage: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> BufferUsageFlags2CreateInfo<'a> { + pub fn usage(mut self, usage: crate::vk::BufferUsageFlags2) -> Self { + self.usage = usage; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PipelineCreateFlags2CreateInfo<'a> { @@ -330,6 +357,33 @@ pub(crate) mod reexport { pub flags: crate::vk::PipelineCreateFlags2, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for PipelineCreateFlags2CreateInfo<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PIPELINE_CREATE_FLAGS_2_CREATE_INFO; + } + unsafe impl<'a> crate::Extends> + for PipelineCreateFlags2CreateInfo<'a> {} + unsafe impl<'a> crate::Extends> + for PipelineCreateFlags2CreateInfo<'a> {} + unsafe impl<'a> crate::Extends> + for PipelineCreateFlags2CreateInfo<'a> {} + unsafe impl<'a> crate::Extends> + for PipelineCreateFlags2CreateInfo<'a> {} + impl<'a> Default for PipelineCreateFlags2CreateInfo<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + flags: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PipelineCreateFlags2CreateInfo<'a> { + pub fn flags(mut self, flags: crate::vk::PipelineCreateFlags2) -> Self { + self.flags = flags; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDevicePushDescriptorProperties<'a> { @@ -338,6 +392,28 @@ pub(crate) mod reexport { pub max_push_descriptors: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDevicePushDescriptorProperties<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES; + } + unsafe impl<'a> crate::Extends> + for PhysicalDevicePushDescriptorProperties<'a> {} + impl<'a> Default for PhysicalDevicePushDescriptorProperties<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + max_push_descriptors: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDevicePushDescriptorProperties<'a> { + pub fn max_push_descriptors(mut self, max_push_descriptors: u32) -> Self { + self.max_push_descriptors = max_push_descriptors; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceMaintenance5Features<'a> { @@ -346,6 +422,30 @@ pub(crate) mod reexport { pub maintenance5: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceMaintenance5Features<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceMaintenance5Features<'a> {} + unsafe impl<'a> crate::Extends> + for PhysicalDeviceMaintenance5Features<'a> {} + impl<'a> Default for PhysicalDeviceMaintenance5Features<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + maintenance5: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceMaintenance5Features<'a> { + pub fn maintenance5(mut self, maintenance5: bool) -> Self { + self.maintenance5 = maintenance5.into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceMaintenance5Properties<'a> { @@ -359,6 +459,73 @@ pub(crate) mod reexport { pub non_strict_wide_lines_use_parallelogram: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceMaintenance5Properties<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceMaintenance5Properties<'a> {} + impl<'a> Default for PhysicalDeviceMaintenance5Properties<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + early_fragment_multisample_coverage_after_sample_counting: Default::default(), + early_fragment_sample_mask_test_before_sample_counting: Default::default(), + depth_stencil_swizzle_one_support: Default::default(), + polygon_mode_point_size: Default::default(), + non_strict_single_pixel_wide_lines_use_parallelogram: Default::default(), + non_strict_wide_lines_use_parallelogram: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceMaintenance5Properties<'a> { + pub fn early_fragment_multisample_coverage_after_sample_counting( + mut self, + early_fragment_multisample_coverage_after_sample_counting: bool, + ) -> Self { + self.early_fragment_multisample_coverage_after_sample_counting = early_fragment_multisample_coverage_after_sample_counting + .into(); + self + } + pub fn early_fragment_sample_mask_test_before_sample_counting( + mut self, + early_fragment_sample_mask_test_before_sample_counting: bool, + ) -> Self { + self.early_fragment_sample_mask_test_before_sample_counting = early_fragment_sample_mask_test_before_sample_counting + .into(); + self + } + pub fn depth_stencil_swizzle_one_support( + mut self, + depth_stencil_swizzle_one_support: bool, + ) -> Self { + self.depth_stencil_swizzle_one_support = depth_stencil_swizzle_one_support + .into(); + self + } + pub fn polygon_mode_point_size(mut self, polygon_mode_point_size: bool) -> Self { + self.polygon_mode_point_size = polygon_mode_point_size.into(); + self + } + pub fn non_strict_single_pixel_wide_lines_use_parallelogram( + mut self, + non_strict_single_pixel_wide_lines_use_parallelogram: bool, + ) -> Self { + self.non_strict_single_pixel_wide_lines_use_parallelogram = non_strict_single_pixel_wide_lines_use_parallelogram + .into(); + self + } + pub fn non_strict_wide_lines_use_parallelogram( + mut self, + non_strict_wide_lines_use_parallelogram: bool, + ) -> Self { + self.non_strict_wide_lines_use_parallelogram = non_strict_wide_lines_use_parallelogram + .into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceMaintenance6Features<'a> { @@ -367,6 +534,30 @@ pub(crate) mod reexport { pub maintenance6: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceMaintenance6Features<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceMaintenance6Features<'a> {} + unsafe impl<'a> crate::Extends> + for PhysicalDeviceMaintenance6Features<'a> {} + impl<'a> Default for PhysicalDeviceMaintenance6Features<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + maintenance6: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceMaintenance6Features<'a> { + pub fn maintenance6(mut self, maintenance6: bool) -> Self { + self.maintenance6 = maintenance6.into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceMaintenance6Properties<'a> { @@ -377,6 +568,49 @@ pub(crate) mod reexport { pub fragment_shading_rate_clamp_combiner_inputs: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceMaintenance6Properties<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceMaintenance6Properties<'a> {} + impl<'a> Default for PhysicalDeviceMaintenance6Properties<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + block_texel_view_compatible_multiple_layers: Default::default(), + max_combined_image_sampler_descriptor_count: Default::default(), + fragment_shading_rate_clamp_combiner_inputs: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceMaintenance6Properties<'a> { + pub fn block_texel_view_compatible_multiple_layers( + mut self, + block_texel_view_compatible_multiple_layers: bool, + ) -> Self { + self.block_texel_view_compatible_multiple_layers = block_texel_view_compatible_multiple_layers + .into(); + self + } + pub fn max_combined_image_sampler_descriptor_count( + mut self, + max_combined_image_sampler_descriptor_count: u32, + ) -> Self { + self.max_combined_image_sampler_descriptor_count = max_combined_image_sampler_descriptor_count; + self + } + pub fn fragment_shading_rate_clamp_combiner_inputs( + mut self, + fragment_shading_rate_clamp_combiner_inputs: bool, + ) -> Self { + self.fragment_shading_rate_clamp_combiner_inputs = fragment_shading_rate_clamp_combiner_inputs + .into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct RenderingAreaInfo<'a> { @@ -389,6 +623,55 @@ pub(crate) mod reexport { pub stencil_attachment_format: crate::vk::Format, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for RenderingAreaInfo<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::RENDERING_AREA_INFO; + } + impl<'a> Default for RenderingAreaInfo<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + view_mask: Default::default(), + color_attachment_count: Default::default(), + p_color_attachment_formats: Default::default(), + depth_attachment_format: Default::default(), + stencil_attachment_format: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> RenderingAreaInfo<'a> { + pub fn view_mask(mut self, view_mask: u32) -> Self { + self.view_mask = view_mask; + self + } + pub fn color_attachment_count(mut self, color_attachment_count: u32) -> Self { + self.color_attachment_count = color_attachment_count; + self + } + pub fn p_color_attachment_formats( + mut self, + p_color_attachment_formats: &'a [crate::vk::Format], + ) -> Self { + self.color_attachment_count = p_color_attachment_formats.len() as _; + self.p_color_attachment_formats = p_color_attachment_formats.as_ptr(); + self + } + pub fn depth_attachment_format( + mut self, + depth_attachment_format: crate::vk::Format, + ) -> Self { + self.depth_attachment_format = depth_attachment_format; + self + } + pub fn stencil_attachment_format( + mut self, + stencil_attachment_format: crate::vk::Format, + ) -> Self { + self.stencil_attachment_format = stencil_attachment_format; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct DeviceQueueGlobalPriorityCreateInfo<'a> { @@ -397,6 +680,31 @@ pub(crate) mod reexport { pub global_priority: crate::vk::QueueGlobalPriority, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for DeviceQueueGlobalPriorityCreateInfo<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO; + } + unsafe impl<'a> crate::Extends> + for DeviceQueueGlobalPriorityCreateInfo<'a> {} + impl<'a> Default for DeviceQueueGlobalPriorityCreateInfo<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + global_priority: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> DeviceQueueGlobalPriorityCreateInfo<'a> { + pub fn global_priority( + mut self, + global_priority: crate::vk::QueueGlobalPriority, + ) -> Self { + self.global_priority = global_priority; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceGlobalPriorityQueryFeatures<'a> { @@ -405,6 +713,30 @@ pub(crate) mod reexport { pub global_priority_query: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceGlobalPriorityQueryFeatures<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceGlobalPriorityQueryFeatures<'a> {} + unsafe impl<'a> crate::Extends> + for PhysicalDeviceGlobalPriorityQueryFeatures<'a> {} + impl<'a> Default for PhysicalDeviceGlobalPriorityQueryFeatures<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + global_priority_query: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceGlobalPriorityQueryFeatures<'a> { + pub fn global_priority_query(mut self, global_priority_query: bool) -> Self { + self.global_priority_query = global_priority_query.into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct QueueFamilyGlobalPriorityProperties<'a> { @@ -415,12 +747,56 @@ pub(crate) mod reexport { as _], pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for QueueFamilyGlobalPriorityProperties<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES; + } + unsafe impl<'a> crate::Extends> + for QueueFamilyGlobalPriorityProperties<'a> {} + impl<'a> Default for QueueFamilyGlobalPriorityProperties<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + priority_count: Default::default(), + priorities: unsafe { core::mem::zeroed() }, + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> QueueFamilyGlobalPriorityProperties<'a> { + pub fn priority_count(mut self, priority_count: u32) -> Self { + self.priority_count = priority_count; + self + } + pub fn priorities( + mut self, + priorities: &[crate::vk::QueueGlobalPriority], + ) -> Self { + self.priority_count = priorities.len() as _; + self.priorities[..priorities.len()].copy_from_slice(priorities); + self + } + pub fn priorities_as_slice(&self) -> &[crate::vk::QueueGlobalPriority] { + &self.priorities[..self.priority_count as _] + } + } #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct VertexInputBindingDivisorDescription { pub binding: u32, pub divisor: u32, } + impl VertexInputBindingDivisorDescription { + pub fn binding(mut self, binding: u32) -> Self { + self.binding = binding; + self + } + pub fn divisor(mut self, divisor: u32) -> Self { + self.divisor = divisor; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PipelineVertexInputDivisorStateCreateInfo<'a> { @@ -430,6 +806,40 @@ pub(crate) mod reexport { pub p_vertex_binding_divisors: *const crate::vk::VertexInputBindingDivisorDescription, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PipelineVertexInputDivisorStateCreateInfo<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO; + } + unsafe impl<'a> crate::Extends> + for PipelineVertexInputDivisorStateCreateInfo<'a> {} + impl<'a> Default for PipelineVertexInputDivisorStateCreateInfo<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + vertex_binding_divisor_count: Default::default(), + p_vertex_binding_divisors: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PipelineVertexInputDivisorStateCreateInfo<'a> { + pub fn vertex_binding_divisor_count( + mut self, + vertex_binding_divisor_count: u32, + ) -> Self { + self.vertex_binding_divisor_count = vertex_binding_divisor_count; + self + } + pub fn p_vertex_binding_divisors( + mut self, + p_vertex_binding_divisors: &'a [crate::vk::VertexInputBindingDivisorDescription], + ) -> Self { + self.vertex_binding_divisor_count = p_vertex_binding_divisors.len() as _; + self.p_vertex_binding_divisors = p_vertex_binding_divisors.as_ptr(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceVertexAttributeDivisorProperties<'a> { @@ -439,6 +849,40 @@ pub(crate) mod reexport { pub supports_non_zero_first_instance: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceVertexAttributeDivisorProperties<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceVertexAttributeDivisorProperties<'a> {} + impl<'a> Default for PhysicalDeviceVertexAttributeDivisorProperties<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + max_vertex_attrib_divisor: Default::default(), + supports_non_zero_first_instance: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceVertexAttributeDivisorProperties<'a> { + pub fn max_vertex_attrib_divisor( + mut self, + max_vertex_attrib_divisor: u32, + ) -> Self { + self.max_vertex_attrib_divisor = max_vertex_attrib_divisor; + self + } + pub fn supports_non_zero_first_instance( + mut self, + supports_non_zero_first_instance: bool, + ) -> Self { + self.supports_non_zero_first_instance = supports_non_zero_first_instance + .into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceVertexAttributeDivisorFeatures<'a> { @@ -448,6 +892,43 @@ pub(crate) mod reexport { pub vertex_attribute_instance_rate_zero_divisor: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceVertexAttributeDivisorFeatures<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceVertexAttributeDivisorFeatures<'a> {} + unsafe impl<'a> crate::Extends> + for PhysicalDeviceVertexAttributeDivisorFeatures<'a> {} + impl<'a> Default for PhysicalDeviceVertexAttributeDivisorFeatures<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + vertex_attribute_instance_rate_divisor: Default::default(), + vertex_attribute_instance_rate_zero_divisor: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceVertexAttributeDivisorFeatures<'a> { + pub fn vertex_attribute_instance_rate_divisor( + mut self, + vertex_attribute_instance_rate_divisor: bool, + ) -> Self { + self.vertex_attribute_instance_rate_divisor = vertex_attribute_instance_rate_divisor + .into(); + self + } + pub fn vertex_attribute_instance_rate_zero_divisor( + mut self, + vertex_attribute_instance_rate_zero_divisor: bool, + ) -> Self { + self.vertex_attribute_instance_rate_zero_divisor = vertex_attribute_instance_rate_zero_divisor + .into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceIndexTypeUint8Features<'a> { @@ -456,6 +937,30 @@ pub(crate) mod reexport { pub index_type_uint8: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceIndexTypeUint8Features<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceIndexTypeUint8Features<'a> {} + unsafe impl<'a> crate::Extends> + for PhysicalDeviceIndexTypeUint8Features<'a> {} + impl<'a> Default for PhysicalDeviceIndexTypeUint8Features<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + index_type_uint8: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceIndexTypeUint8Features<'a> { + pub fn index_type_uint8(mut self, index_type_uint8: bool) -> Self { + self.index_type_uint8 = index_type_uint8.into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceLineRasterizationFeatures<'a> { @@ -469,6 +974,61 @@ pub(crate) mod reexport { pub stippled_smooth_lines: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceLineRasterizationFeatures<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceLineRasterizationFeatures<'a> {} + unsafe impl<'a> crate::Extends> + for PhysicalDeviceLineRasterizationFeatures<'a> {} + impl<'a> Default for PhysicalDeviceLineRasterizationFeatures<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + rectangular_lines: Default::default(), + bresenham_lines: Default::default(), + smooth_lines: Default::default(), + stippled_rectangular_lines: Default::default(), + stippled_bresenham_lines: Default::default(), + stippled_smooth_lines: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceLineRasterizationFeatures<'a> { + pub fn rectangular_lines(mut self, rectangular_lines: bool) -> Self { + self.rectangular_lines = rectangular_lines.into(); + self + } + pub fn bresenham_lines(mut self, bresenham_lines: bool) -> Self { + self.bresenham_lines = bresenham_lines.into(); + self + } + pub fn smooth_lines(mut self, smooth_lines: bool) -> Self { + self.smooth_lines = smooth_lines.into(); + self + } + pub fn stippled_rectangular_lines( + mut self, + stippled_rectangular_lines: bool, + ) -> Self { + self.stippled_rectangular_lines = stippled_rectangular_lines.into(); + self + } + pub fn stippled_bresenham_lines( + mut self, + stippled_bresenham_lines: bool, + ) -> Self { + self.stippled_bresenham_lines = stippled_bresenham_lines.into(); + self + } + pub fn stippled_smooth_lines(mut self, stippled_smooth_lines: bool) -> Self { + self.stippled_smooth_lines = stippled_smooth_lines.into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceLineRasterizationProperties<'a> { @@ -477,6 +1037,31 @@ pub(crate) mod reexport { pub line_sub_pixel_precision_bits: u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceLineRasterizationProperties<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceLineRasterizationProperties<'a> {} + impl<'a> Default for PhysicalDeviceLineRasterizationProperties<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + line_sub_pixel_precision_bits: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceLineRasterizationProperties<'a> { + pub fn line_sub_pixel_precision_bits( + mut self, + line_sub_pixel_precision_bits: u32, + ) -> Self { + self.line_sub_pixel_precision_bits = line_sub_pixel_precision_bits; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PipelineRasterizationLineStateCreateInfo<'a> { @@ -488,6 +1073,46 @@ pub(crate) mod reexport { pub line_stipple_pattern: u16, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PipelineRasterizationLineStateCreateInfo<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO; + } + unsafe impl<'a> crate::Extends> + for PipelineRasterizationLineStateCreateInfo<'a> {} + impl<'a> Default for PipelineRasterizationLineStateCreateInfo<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + line_rasterization_mode: Default::default(), + stippled_line_enable: Default::default(), + line_stipple_factor: Default::default(), + line_stipple_pattern: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PipelineRasterizationLineStateCreateInfo<'a> { + pub fn line_rasterization_mode( + mut self, + line_rasterization_mode: crate::vk::LineRasterizationMode, + ) -> Self { + self.line_rasterization_mode = line_rasterization_mode; + self + } + pub fn stippled_line_enable(mut self, stippled_line_enable: bool) -> Self { + self.stippled_line_enable = stippled_line_enable.into(); + self + } + pub fn line_stipple_factor(mut self, line_stipple_factor: u32) -> Self { + self.line_stipple_factor = line_stipple_factor; + self + } + pub fn line_stipple_pattern(mut self, line_stipple_pattern: u16) -> Self { + self.line_stipple_pattern = line_stipple_pattern; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceVulkan14Features<'a> { @@ -516,6 +1141,153 @@ pub(crate) mod reexport { pub push_descriptor: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for PhysicalDeviceVulkan14Features<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_VULKAN_1_4_FEATURES; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceVulkan14Features<'a> {} + unsafe impl<'a> crate::Extends> + for PhysicalDeviceVulkan14Features<'a> {} + impl<'a> Default for PhysicalDeviceVulkan14Features<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + global_priority_query: Default::default(), + shader_subgroup_rotate: Default::default(), + shader_subgroup_rotate_clustered: Default::default(), + shader_float_controls2: Default::default(), + shader_expect_assume: Default::default(), + rectangular_lines: Default::default(), + bresenham_lines: Default::default(), + smooth_lines: Default::default(), + stippled_rectangular_lines: Default::default(), + stippled_bresenham_lines: Default::default(), + stippled_smooth_lines: Default::default(), + vertex_attribute_instance_rate_divisor: Default::default(), + vertex_attribute_instance_rate_zero_divisor: Default::default(), + index_type_uint8: Default::default(), + dynamic_rendering_local_read: Default::default(), + maintenance5: Default::default(), + maintenance6: Default::default(), + pipeline_protected_access: Default::default(), + pipeline_robustness: Default::default(), + host_image_copy: Default::default(), + push_descriptor: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceVulkan14Features<'a> { + pub fn global_priority_query(mut self, global_priority_query: bool) -> Self { + self.global_priority_query = global_priority_query.into(); + self + } + pub fn shader_subgroup_rotate(mut self, shader_subgroup_rotate: bool) -> Self { + self.shader_subgroup_rotate = shader_subgroup_rotate.into(); + self + } + pub fn shader_subgroup_rotate_clustered( + mut self, + shader_subgroup_rotate_clustered: bool, + ) -> Self { + self.shader_subgroup_rotate_clustered = shader_subgroup_rotate_clustered + .into(); + self + } + pub fn shader_float_controls2(mut self, shader_float_controls2: bool) -> Self { + self.shader_float_controls2 = shader_float_controls2.into(); + self + } + pub fn shader_expect_assume(mut self, shader_expect_assume: bool) -> Self { + self.shader_expect_assume = shader_expect_assume.into(); + self + } + pub fn rectangular_lines(mut self, rectangular_lines: bool) -> Self { + self.rectangular_lines = rectangular_lines.into(); + self + } + pub fn bresenham_lines(mut self, bresenham_lines: bool) -> Self { + self.bresenham_lines = bresenham_lines.into(); + self + } + pub fn smooth_lines(mut self, smooth_lines: bool) -> Self { + self.smooth_lines = smooth_lines.into(); + self + } + pub fn stippled_rectangular_lines( + mut self, + stippled_rectangular_lines: bool, + ) -> Self { + self.stippled_rectangular_lines = stippled_rectangular_lines.into(); + self + } + pub fn stippled_bresenham_lines( + mut self, + stippled_bresenham_lines: bool, + ) -> Self { + self.stippled_bresenham_lines = stippled_bresenham_lines.into(); + self + } + pub fn stippled_smooth_lines(mut self, stippled_smooth_lines: bool) -> Self { + self.stippled_smooth_lines = stippled_smooth_lines.into(); + self + } + pub fn vertex_attribute_instance_rate_divisor( + mut self, + vertex_attribute_instance_rate_divisor: bool, + ) -> Self { + self.vertex_attribute_instance_rate_divisor = vertex_attribute_instance_rate_divisor + .into(); + self + } + pub fn vertex_attribute_instance_rate_zero_divisor( + mut self, + vertex_attribute_instance_rate_zero_divisor: bool, + ) -> Self { + self.vertex_attribute_instance_rate_zero_divisor = vertex_attribute_instance_rate_zero_divisor + .into(); + self + } + pub fn index_type_uint8(mut self, index_type_uint8: bool) -> Self { + self.index_type_uint8 = index_type_uint8.into(); + self + } + pub fn dynamic_rendering_local_read( + mut self, + dynamic_rendering_local_read: bool, + ) -> Self { + self.dynamic_rendering_local_read = dynamic_rendering_local_read.into(); + self + } + pub fn maintenance5(mut self, maintenance5: bool) -> Self { + self.maintenance5 = maintenance5.into(); + self + } + pub fn maintenance6(mut self, maintenance6: bool) -> Self { + self.maintenance6 = maintenance6.into(); + self + } + pub fn pipeline_protected_access( + mut self, + pipeline_protected_access: bool, + ) -> Self { + self.pipeline_protected_access = pipeline_protected_access.into(); + self + } + pub fn pipeline_robustness(mut self, pipeline_robustness: bool) -> Self { + self.pipeline_robustness = pipeline_robustness.into(); + self + } + pub fn host_image_copy(mut self, host_image_copy: bool) -> Self { + self.host_image_copy = host_image_copy.into(); + self + } + pub fn push_descriptor(mut self, push_descriptor: bool) -> Self { + self.push_descriptor = push_descriptor.into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceVulkan14Properties<'a> { @@ -548,6 +1320,223 @@ pub(crate) mod reexport { pub identical_memory_type_requirements: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for PhysicalDeviceVulkan14Properties<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_VULKAN_1_4_PROPERTIES; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceVulkan14Properties<'a> {} + impl<'a> Default for PhysicalDeviceVulkan14Properties<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + line_sub_pixel_precision_bits: Default::default(), + max_vertex_attrib_divisor: Default::default(), + supports_non_zero_first_instance: Default::default(), + max_push_descriptors: Default::default(), + dynamic_rendering_local_read_depth_stencil_attachments: Default::default(), + dynamic_rendering_local_read_multisampled_attachments: Default::default(), + early_fragment_multisample_coverage_after_sample_counting: Default::default(), + early_fragment_sample_mask_test_before_sample_counting: Default::default(), + depth_stencil_swizzle_one_support: Default::default(), + polygon_mode_point_size: Default::default(), + non_strict_single_pixel_wide_lines_use_parallelogram: Default::default(), + non_strict_wide_lines_use_parallelogram: Default::default(), + block_texel_view_compatible_multiple_layers: Default::default(), + max_combined_image_sampler_descriptor_count: Default::default(), + fragment_shading_rate_clamp_combiner_inputs: Default::default(), + default_robustness_storage_buffers: Default::default(), + default_robustness_uniform_buffers: Default::default(), + default_robustness_vertex_inputs: Default::default(), + default_robustness_images: Default::default(), + copy_src_layout_count: Default::default(), + p_copy_src_layouts: Default::default(), + copy_dst_layout_count: Default::default(), + p_copy_dst_layouts: Default::default(), + optimal_tiling_layout_uuid: unsafe { core::mem::zeroed() }, + identical_memory_type_requirements: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceVulkan14Properties<'a> { + pub fn line_sub_pixel_precision_bits( + mut self, + line_sub_pixel_precision_bits: u32, + ) -> Self { + self.line_sub_pixel_precision_bits = line_sub_pixel_precision_bits; + self + } + pub fn max_vertex_attrib_divisor( + mut self, + max_vertex_attrib_divisor: u32, + ) -> Self { + self.max_vertex_attrib_divisor = max_vertex_attrib_divisor; + self + } + pub fn supports_non_zero_first_instance( + mut self, + supports_non_zero_first_instance: bool, + ) -> Self { + self.supports_non_zero_first_instance = supports_non_zero_first_instance + .into(); + self + } + pub fn max_push_descriptors(mut self, max_push_descriptors: u32) -> Self { + self.max_push_descriptors = max_push_descriptors; + self + } + pub fn dynamic_rendering_local_read_depth_stencil_attachments( + mut self, + dynamic_rendering_local_read_depth_stencil_attachments: bool, + ) -> Self { + self.dynamic_rendering_local_read_depth_stencil_attachments = dynamic_rendering_local_read_depth_stencil_attachments + .into(); + self + } + pub fn dynamic_rendering_local_read_multisampled_attachments( + mut self, + dynamic_rendering_local_read_multisampled_attachments: bool, + ) -> Self { + self.dynamic_rendering_local_read_multisampled_attachments = dynamic_rendering_local_read_multisampled_attachments + .into(); + self + } + pub fn early_fragment_multisample_coverage_after_sample_counting( + mut self, + early_fragment_multisample_coverage_after_sample_counting: bool, + ) -> Self { + self.early_fragment_multisample_coverage_after_sample_counting = early_fragment_multisample_coverage_after_sample_counting + .into(); + self + } + pub fn early_fragment_sample_mask_test_before_sample_counting( + mut self, + early_fragment_sample_mask_test_before_sample_counting: bool, + ) -> Self { + self.early_fragment_sample_mask_test_before_sample_counting = early_fragment_sample_mask_test_before_sample_counting + .into(); + self + } + pub fn depth_stencil_swizzle_one_support( + mut self, + depth_stencil_swizzle_one_support: bool, + ) -> Self { + self.depth_stencil_swizzle_one_support = depth_stencil_swizzle_one_support + .into(); + self + } + pub fn polygon_mode_point_size(mut self, polygon_mode_point_size: bool) -> Self { + self.polygon_mode_point_size = polygon_mode_point_size.into(); + self + } + pub fn non_strict_single_pixel_wide_lines_use_parallelogram( + mut self, + non_strict_single_pixel_wide_lines_use_parallelogram: bool, + ) -> Self { + self.non_strict_single_pixel_wide_lines_use_parallelogram = non_strict_single_pixel_wide_lines_use_parallelogram + .into(); + self + } + pub fn non_strict_wide_lines_use_parallelogram( + mut self, + non_strict_wide_lines_use_parallelogram: bool, + ) -> Self { + self.non_strict_wide_lines_use_parallelogram = non_strict_wide_lines_use_parallelogram + .into(); + self + } + pub fn block_texel_view_compatible_multiple_layers( + mut self, + block_texel_view_compatible_multiple_layers: bool, + ) -> Self { + self.block_texel_view_compatible_multiple_layers = block_texel_view_compatible_multiple_layers + .into(); + self + } + pub fn max_combined_image_sampler_descriptor_count( + mut self, + max_combined_image_sampler_descriptor_count: u32, + ) -> Self { + self.max_combined_image_sampler_descriptor_count = max_combined_image_sampler_descriptor_count; + self + } + pub fn fragment_shading_rate_clamp_combiner_inputs( + mut self, + fragment_shading_rate_clamp_combiner_inputs: bool, + ) -> Self { + self.fragment_shading_rate_clamp_combiner_inputs = fragment_shading_rate_clamp_combiner_inputs + .into(); + self + } + pub fn default_robustness_storage_buffers( + mut self, + default_robustness_storage_buffers: crate::vk::PipelineRobustnessBufferBehavior, + ) -> Self { + self.default_robustness_storage_buffers = default_robustness_storage_buffers; + self + } + pub fn default_robustness_uniform_buffers( + mut self, + default_robustness_uniform_buffers: crate::vk::PipelineRobustnessBufferBehavior, + ) -> Self { + self.default_robustness_uniform_buffers = default_robustness_uniform_buffers; + self + } + pub fn default_robustness_vertex_inputs( + mut self, + default_robustness_vertex_inputs: crate::vk::PipelineRobustnessBufferBehavior, + ) -> Self { + self.default_robustness_vertex_inputs = default_robustness_vertex_inputs; + self + } + pub fn default_robustness_images( + mut self, + default_robustness_images: crate::vk::PipelineRobustnessImageBehavior, + ) -> Self { + self.default_robustness_images = default_robustness_images; + self + } + pub fn copy_src_layout_count(mut self, copy_src_layout_count: u32) -> Self { + self.copy_src_layout_count = copy_src_layout_count; + self + } + pub fn p_copy_src_layouts( + mut self, + p_copy_src_layouts: &'a mut [crate::vk::ImageLayout], + ) -> Self { + self.copy_src_layout_count = p_copy_src_layouts.len() as _; + self.p_copy_src_layouts = p_copy_src_layouts.as_mut_ptr(); + self + } + pub fn copy_dst_layout_count(mut self, copy_dst_layout_count: u32) -> Self { + self.copy_dst_layout_count = copy_dst_layout_count; + self + } + pub fn p_copy_dst_layouts( + mut self, + p_copy_dst_layouts: &'a mut [crate::vk::ImageLayout], + ) -> Self { + self.copy_dst_layout_count = p_copy_dst_layouts.len() as _; + self.p_copy_dst_layouts = p_copy_dst_layouts.as_mut_ptr(); + self + } + pub fn optimal_tiling_layout_uuid( + mut self, + optimal_tiling_layout_uuid: [u8; crate::vk::UUID_SIZE as _], + ) -> Self { + self.optimal_tiling_layout_uuid = optimal_tiling_layout_uuid; + self + } + pub fn identical_memory_type_requirements( + mut self, + identical_memory_type_requirements: bool, + ) -> Self { + self.identical_memory_type_requirements = identical_memory_type_requirements + .into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceHostImageCopyFeatures<'a> { @@ -556,6 +1545,30 @@ pub(crate) mod reexport { pub host_image_copy: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceHostImageCopyFeatures<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceHostImageCopyFeatures<'a> {} + unsafe impl<'a> crate::Extends> + for PhysicalDeviceHostImageCopyFeatures<'a> {} + impl<'a> Default for PhysicalDeviceHostImageCopyFeatures<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + host_image_copy: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceHostImageCopyFeatures<'a> { + pub fn host_image_copy(mut self, host_image_copy: bool) -> Self { + self.host_image_copy = host_image_copy.into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceHostImageCopyProperties<'a> { @@ -569,6 +1582,68 @@ pub(crate) mod reexport { pub identical_memory_type_requirements: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceHostImageCopyProperties<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceHostImageCopyProperties<'a> {} + impl<'a> Default for PhysicalDeviceHostImageCopyProperties<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + copy_src_layout_count: Default::default(), + p_copy_src_layouts: Default::default(), + copy_dst_layout_count: Default::default(), + p_copy_dst_layouts: Default::default(), + optimal_tiling_layout_uuid: unsafe { core::mem::zeroed() }, + identical_memory_type_requirements: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceHostImageCopyProperties<'a> { + pub fn copy_src_layout_count(mut self, copy_src_layout_count: u32) -> Self { + self.copy_src_layout_count = copy_src_layout_count; + self + } + pub fn p_copy_src_layouts( + mut self, + p_copy_src_layouts: &'a mut [crate::vk::ImageLayout], + ) -> Self { + self.copy_src_layout_count = p_copy_src_layouts.len() as _; + self.p_copy_src_layouts = p_copy_src_layouts.as_mut_ptr(); + self + } + pub fn copy_dst_layout_count(mut self, copy_dst_layout_count: u32) -> Self { + self.copy_dst_layout_count = copy_dst_layout_count; + self + } + pub fn p_copy_dst_layouts( + mut self, + p_copy_dst_layouts: &'a mut [crate::vk::ImageLayout], + ) -> Self { + self.copy_dst_layout_count = p_copy_dst_layouts.len() as _; + self.p_copy_dst_layouts = p_copy_dst_layouts.as_mut_ptr(); + self + } + pub fn optimal_tiling_layout_uuid( + mut self, + optimal_tiling_layout_uuid: [u8; crate::vk::UUID_SIZE as _], + ) -> Self { + self.optimal_tiling_layout_uuid = optimal_tiling_layout_uuid; + self + } + pub fn identical_memory_type_requirements( + mut self, + identical_memory_type_requirements: bool, + ) -> Self { + self.identical_memory_type_requirements = identical_memory_type_requirements + .into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct MemoryToImageCopy<'a> { @@ -582,6 +1657,53 @@ pub(crate) mod reexport { pub image_extent: crate::vk::Extent3D, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for MemoryToImageCopy<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::MEMORY_TO_IMAGE_COPY; + } + impl<'a> Default for MemoryToImageCopy<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + p_host_pointer: Default::default(), + memory_row_length: Default::default(), + memory_image_height: Default::default(), + image_subresource: Default::default(), + image_offset: Default::default(), + image_extent: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> MemoryToImageCopy<'a> { + pub fn p_host_pointer(mut self, p_host_pointer: &'a core::ffi::c_void) -> Self { + self.p_host_pointer = p_host_pointer; + self + } + pub fn memory_row_length(mut self, memory_row_length: u32) -> Self { + self.memory_row_length = memory_row_length; + self + } + pub fn memory_image_height(mut self, memory_image_height: u32) -> Self { + self.memory_image_height = memory_image_height; + self + } + pub fn image_subresource( + mut self, + image_subresource: crate::vk::ImageSubresourceLayers, + ) -> Self { + self.image_subresource = image_subresource; + self + } + pub fn image_offset(mut self, image_offset: crate::vk::Offset3D) -> Self { + self.image_offset = image_offset; + self + } + pub fn image_extent(mut self, image_extent: crate::vk::Extent3D) -> Self { + self.image_extent = image_extent; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct ImageToMemoryCopy<'a> { @@ -595,6 +1717,56 @@ pub(crate) mod reexport { pub image_extent: crate::vk::Extent3D, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for ImageToMemoryCopy<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::IMAGE_TO_MEMORY_COPY; + } + impl<'a> Default for ImageToMemoryCopy<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + p_host_pointer: Default::default(), + memory_row_length: Default::default(), + memory_image_height: Default::default(), + image_subresource: Default::default(), + image_offset: Default::default(), + image_extent: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> ImageToMemoryCopy<'a> { + pub fn p_host_pointer( + mut self, + p_host_pointer: &'a mut core::ffi::c_void, + ) -> Self { + self.p_host_pointer = p_host_pointer; + self + } + pub fn memory_row_length(mut self, memory_row_length: u32) -> Self { + self.memory_row_length = memory_row_length; + self + } + pub fn memory_image_height(mut self, memory_image_height: u32) -> Self { + self.memory_image_height = memory_image_height; + self + } + pub fn image_subresource( + mut self, + image_subresource: crate::vk::ImageSubresourceLayers, + ) -> Self { + self.image_subresource = image_subresource; + self + } + pub fn image_offset(mut self, image_offset: crate::vk::Offset3D) -> Self { + self.image_offset = image_offset; + self + } + pub fn image_extent(mut self, image_extent: crate::vk::Extent3D) -> Self { + self.image_extent = image_extent; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct CopyMemoryToImageInfo<'a> { @@ -607,6 +1779,52 @@ pub(crate) mod reexport { pub p_regions: *const crate::vk::MemoryToImageCopy<'a>, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for CopyMemoryToImageInfo<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::COPY_MEMORY_TO_IMAGE_INFO; + } + impl<'a> Default for CopyMemoryToImageInfo<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + flags: Default::default(), + dst_image: Default::default(), + dst_image_layout: Default::default(), + region_count: Default::default(), + p_regions: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> CopyMemoryToImageInfo<'a> { + pub fn flags(mut self, flags: crate::vk::HostImageCopyFlags) -> Self { + self.flags = flags; + self + } + pub fn dst_image(mut self, dst_image: crate::vk::Image) -> Self { + self.dst_image = dst_image; + self + } + pub fn dst_image_layout( + mut self, + dst_image_layout: crate::vk::ImageLayout, + ) -> Self { + self.dst_image_layout = dst_image_layout; + self + } + pub fn region_count(mut self, region_count: u32) -> Self { + self.region_count = region_count; + self + } + pub fn p_regions( + mut self, + p_regions: &'a [crate::vk::MemoryToImageCopy<'a>], + ) -> Self { + self.region_count = p_regions.len() as _; + self.p_regions = p_regions.as_ptr(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct CopyImageToMemoryInfo<'a> { @@ -619,6 +1837,52 @@ pub(crate) mod reexport { pub p_regions: *const crate::vk::ImageToMemoryCopy<'a>, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for CopyImageToMemoryInfo<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::COPY_IMAGE_TO_MEMORY_INFO; + } + impl<'a> Default for CopyImageToMemoryInfo<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + flags: Default::default(), + src_image: Default::default(), + src_image_layout: Default::default(), + region_count: Default::default(), + p_regions: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> CopyImageToMemoryInfo<'a> { + pub fn flags(mut self, flags: crate::vk::HostImageCopyFlags) -> Self { + self.flags = flags; + self + } + pub fn src_image(mut self, src_image: crate::vk::Image) -> Self { + self.src_image = src_image; + self + } + pub fn src_image_layout( + mut self, + src_image_layout: crate::vk::ImageLayout, + ) -> Self { + self.src_image_layout = src_image_layout; + self + } + pub fn region_count(mut self, region_count: u32) -> Self { + self.region_count = region_count; + self + } + pub fn p_regions( + mut self, + p_regions: &'a [crate::vk::ImageToMemoryCopy<'a>], + ) -> Self { + self.region_count = p_regions.len() as _; + self.p_regions = p_regions.as_ptr(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct CopyImageToImageInfo<'a> { @@ -633,6 +1897,62 @@ pub(crate) mod reexport { pub p_regions: *const crate::vk::ImageCopy2<'a>, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for CopyImageToImageInfo<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::COPY_IMAGE_TO_IMAGE_INFO; + } + impl<'a> Default for CopyImageToImageInfo<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + flags: Default::default(), + src_image: Default::default(), + src_image_layout: Default::default(), + dst_image: Default::default(), + dst_image_layout: Default::default(), + region_count: Default::default(), + p_regions: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> CopyImageToImageInfo<'a> { + pub fn flags(mut self, flags: crate::vk::HostImageCopyFlags) -> Self { + self.flags = flags; + self + } + pub fn src_image(mut self, src_image: crate::vk::Image) -> Self { + self.src_image = src_image; + self + } + pub fn src_image_layout( + mut self, + src_image_layout: crate::vk::ImageLayout, + ) -> Self { + self.src_image_layout = src_image_layout; + self + } + pub fn dst_image(mut self, dst_image: crate::vk::Image) -> Self { + self.dst_image = dst_image; + self + } + pub fn dst_image_layout( + mut self, + dst_image_layout: crate::vk::ImageLayout, + ) -> Self { + self.dst_image_layout = dst_image_layout; + self + } + pub fn region_count(mut self, region_count: u32) -> Self { + self.region_count = region_count; + self + } + pub fn p_regions(mut self, p_regions: &'a [crate::vk::ImageCopy2<'a>]) -> Self { + self.region_count = p_regions.len() as _; + self.p_regions = p_regions.as_ptr(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct HostImageLayoutTransitionInfo<'a> { @@ -644,6 +1964,43 @@ pub(crate) mod reexport { pub subresource_range: crate::vk::ImageSubresourceRange, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for HostImageLayoutTransitionInfo<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::HOST_IMAGE_LAYOUT_TRANSITION_INFO; + } + impl<'a> Default for HostImageLayoutTransitionInfo<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + image: Default::default(), + old_layout: Default::default(), + new_layout: Default::default(), + subresource_range: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> HostImageLayoutTransitionInfo<'a> { + pub fn image(mut self, image: crate::vk::Image) -> Self { + self.image = image; + self + } + pub fn old_layout(mut self, old_layout: crate::vk::ImageLayout) -> Self { + self.old_layout = old_layout; + self + } + pub fn new_layout(mut self, new_layout: crate::vk::ImageLayout) -> Self { + self.new_layout = new_layout; + self + } + pub fn subresource_range( + mut self, + subresource_range: crate::vk::ImageSubresourceRange, + ) -> Self { + self.subresource_range = subresource_range; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct SubresourceHostMemcpySize<'a> { @@ -652,6 +2009,27 @@ pub(crate) mod reexport { pub size: crate::vk::DeviceSize, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for SubresourceHostMemcpySize<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::SUBRESOURCE_HOST_MEMCPY_SIZE; + } + unsafe impl<'a> crate::Extends> + for SubresourceHostMemcpySize<'a> {} + impl<'a> Default for SubresourceHostMemcpySize<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + size: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> SubresourceHostMemcpySize<'a> { + pub fn size(mut self, size: crate::vk::DeviceSize) -> Self { + self.size = size; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct HostImageCopyDevicePerformanceQuery<'a> { @@ -661,6 +2039,33 @@ pub(crate) mod reexport { pub identical_memory_layout: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for HostImageCopyDevicePerformanceQuery<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY; + } + unsafe impl<'a> crate::Extends> + for HostImageCopyDevicePerformanceQuery<'a> {} + impl<'a> Default for HostImageCopyDevicePerformanceQuery<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + optimal_device_access: Default::default(), + identical_memory_layout: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> HostImageCopyDevicePerformanceQuery<'a> { + pub fn optimal_device_access(mut self, optimal_device_access: bool) -> Self { + self.optimal_device_access = optimal_device_access.into(); + self + } + pub fn identical_memory_layout(mut self, identical_memory_layout: bool) -> Self { + self.identical_memory_layout = identical_memory_layout.into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDevicePipelineProtectedAccessFeatures<'a> { @@ -669,6 +2074,33 @@ pub(crate) mod reexport { pub pipeline_protected_access: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDevicePipelineProtectedAccessFeatures<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES; + } + unsafe impl<'a> crate::Extends> + for PhysicalDevicePipelineProtectedAccessFeatures<'a> {} + unsafe impl<'a> crate::Extends> + for PhysicalDevicePipelineProtectedAccessFeatures<'a> {} + impl<'a> Default for PhysicalDevicePipelineProtectedAccessFeatures<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + pipeline_protected_access: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDevicePipelineProtectedAccessFeatures<'a> { + pub fn pipeline_protected_access( + mut self, + pipeline_protected_access: bool, + ) -> Self { + self.pipeline_protected_access = pipeline_protected_access.into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct ImageSubresource2<'a> { @@ -677,6 +2109,28 @@ pub(crate) mod reexport { pub image_subresource: crate::vk::ImageSubresource, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for ImageSubresource2<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::IMAGE_SUBRESOURCE_2; + } + impl<'a> Default for ImageSubresource2<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + image_subresource: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> ImageSubresource2<'a> { + pub fn image_subresource( + mut self, + image_subresource: crate::vk::ImageSubresource, + ) -> Self { + self.image_subresource = image_subresource; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct SubresourceLayout2<'a> { @@ -685,6 +2139,28 @@ pub(crate) mod reexport { pub subresource_layout: crate::vk::SubresourceLayout, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for SubresourceLayout2<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::SUBRESOURCE_LAYOUT_2; + } + impl<'a> Default for SubresourceLayout2<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + subresource_layout: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> SubresourceLayout2<'a> { + pub fn subresource_layout( + mut self, + subresource_layout: crate::vk::SubresourceLayout, + ) -> Self { + self.subresource_layout = subresource_layout; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDevicePipelineRobustnessFeatures<'a> { @@ -693,6 +2169,30 @@ pub(crate) mod reexport { pub pipeline_robustness: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDevicePipelineRobustnessFeatures<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES; + } + unsafe impl<'a> crate::Extends> + for PhysicalDevicePipelineRobustnessFeatures<'a> {} + unsafe impl<'a> crate::Extends> + for PhysicalDevicePipelineRobustnessFeatures<'a> {} + impl<'a> Default for PhysicalDevicePipelineRobustnessFeatures<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + pipeline_robustness: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDevicePipelineRobustnessFeatures<'a> { + pub fn pipeline_robustness(mut self, pipeline_robustness: bool) -> Self { + self.pipeline_robustness = pipeline_robustness.into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PipelineRobustnessCreateInfo<'a> { @@ -704,6 +2204,60 @@ pub(crate) mod reexport { pub images: crate::vk::PipelineRobustnessImageBehavior, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for PipelineRobustnessCreateInfo<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PIPELINE_ROBUSTNESS_CREATE_INFO; + } + unsafe impl<'a> crate::Extends> + for PipelineRobustnessCreateInfo<'a> {} + unsafe impl<'a> crate::Extends> + for PipelineRobustnessCreateInfo<'a> {} + unsafe impl<'a> crate::Extends> + for PipelineRobustnessCreateInfo<'a> {} + unsafe impl<'a> crate::Extends> + for PipelineRobustnessCreateInfo<'a> {} + impl<'a> Default for PipelineRobustnessCreateInfo<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + storage_buffers: Default::default(), + uniform_buffers: Default::default(), + vertex_inputs: Default::default(), + images: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PipelineRobustnessCreateInfo<'a> { + pub fn storage_buffers( + mut self, + storage_buffers: crate::vk::PipelineRobustnessBufferBehavior, + ) -> Self { + self.storage_buffers = storage_buffers; + self + } + pub fn uniform_buffers( + mut self, + uniform_buffers: crate::vk::PipelineRobustnessBufferBehavior, + ) -> Self { + self.uniform_buffers = uniform_buffers; + self + } + pub fn vertex_inputs( + mut self, + vertex_inputs: crate::vk::PipelineRobustnessBufferBehavior, + ) -> Self { + self.vertex_inputs = vertex_inputs; + self + } + pub fn images( + mut self, + images: crate::vk::PipelineRobustnessImageBehavior, + ) -> Self { + self.images = images; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDevicePipelineRobustnessProperties<'a> { @@ -715,6 +2269,55 @@ pub(crate) mod reexport { pub default_robustness_images: crate::vk::PipelineRobustnessImageBehavior, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDevicePipelineRobustnessProperties<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES; + } + unsafe impl<'a> crate::Extends> + for PhysicalDevicePipelineRobustnessProperties<'a> {} + impl<'a> Default for PhysicalDevicePipelineRobustnessProperties<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + default_robustness_storage_buffers: Default::default(), + default_robustness_uniform_buffers: Default::default(), + default_robustness_vertex_inputs: Default::default(), + default_robustness_images: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDevicePipelineRobustnessProperties<'a> { + pub fn default_robustness_storage_buffers( + mut self, + default_robustness_storage_buffers: crate::vk::PipelineRobustnessBufferBehavior, + ) -> Self { + self.default_robustness_storage_buffers = default_robustness_storage_buffers; + self + } + pub fn default_robustness_uniform_buffers( + mut self, + default_robustness_uniform_buffers: crate::vk::PipelineRobustnessBufferBehavior, + ) -> Self { + self.default_robustness_uniform_buffers = default_robustness_uniform_buffers; + self + } + pub fn default_robustness_vertex_inputs( + mut self, + default_robustness_vertex_inputs: crate::vk::PipelineRobustnessBufferBehavior, + ) -> Self { + self.default_robustness_vertex_inputs = default_robustness_vertex_inputs; + self + } + pub fn default_robustness_images( + mut self, + default_robustness_images: crate::vk::PipelineRobustnessImageBehavior, + ) -> Self { + self.default_robustness_images = default_robustness_images; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct DeviceImageSubresourceInfo<'a> { @@ -724,6 +2327,36 @@ pub(crate) mod reexport { pub p_subresource: *const crate::vk::ImageSubresource2<'a>, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for DeviceImageSubresourceInfo<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::DEVICE_IMAGE_SUBRESOURCE_INFO; + } + impl<'a> Default for DeviceImageSubresourceInfo<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + p_create_info: Default::default(), + p_subresource: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> DeviceImageSubresourceInfo<'a> { + pub fn p_create_info( + mut self, + p_create_info: &'a crate::vk::ImageCreateInfo<'a>, + ) -> Self { + self.p_create_info = p_create_info; + self + } + pub fn p_subresource( + mut self, + p_subresource: &'a crate::vk::ImageSubresource2<'a>, + ) -> Self { + self.p_subresource = p_subresource; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct MemoryMapInfo<'a> { @@ -735,6 +2368,40 @@ pub(crate) mod reexport { pub size: crate::vk::DeviceSize, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for MemoryMapInfo<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::MEMORY_MAP_INFO; + } + impl<'a> Default for MemoryMapInfo<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + flags: Default::default(), + memory: Default::default(), + offset: Default::default(), + size: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> MemoryMapInfo<'a> { + pub fn flags(mut self, flags: crate::vk::MemoryMapFlags) -> Self { + self.flags = flags; + self + } + pub fn memory(mut self, memory: crate::vk::DeviceMemory) -> Self { + self.memory = memory; + self + } + pub fn offset(mut self, offset: crate::vk::DeviceSize) -> Self { + self.offset = offset; + self + } + pub fn size(mut self, size: crate::vk::DeviceSize) -> Self { + self.size = size; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct MemoryUnmapInfo<'a> { @@ -744,6 +2411,30 @@ pub(crate) mod reexport { pub memory: crate::vk::DeviceMemory, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for MemoryUnmapInfo<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::MEMORY_UNMAP_INFO; + } + impl<'a> Default for MemoryUnmapInfo<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + flags: Default::default(), + memory: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> MemoryUnmapInfo<'a> { + pub fn flags(mut self, flags: crate::vk::MemoryUnmapFlags) -> Self { + self.flags = flags; + self + } + pub fn memory(mut self, memory: crate::vk::DeviceMemory) -> Self { + self.memory = memory; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct BindMemoryStatus<'a> { @@ -752,6 +2443,29 @@ pub(crate) mod reexport { pub p_result: *mut crate::vk::Result, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for BindMemoryStatus<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::BIND_MEMORY_STATUS; + } + unsafe impl<'a> crate::Extends> + for BindMemoryStatus<'a> {} + unsafe impl<'a> crate::Extends> + for BindMemoryStatus<'a> {} + impl<'a> Default for BindMemoryStatus<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + p_result: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> BindMemoryStatus<'a> { + pub fn p_result(mut self, p_result: &'a mut crate::vk::Result) -> Self { + self.p_result = p_result; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct BindDescriptorSetsInfo<'a> { @@ -766,6 +2480,60 @@ pub(crate) mod reexport { pub p_dynamic_offsets: *const u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for BindDescriptorSetsInfo<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::BIND_DESCRIPTOR_SETS_INFO; + } + impl<'a> Default for BindDescriptorSetsInfo<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + stage_flags: Default::default(), + layout: Default::default(), + first_set: Default::default(), + descriptor_set_count: Default::default(), + p_descriptor_sets: Default::default(), + dynamic_offset_count: Default::default(), + p_dynamic_offsets: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> BindDescriptorSetsInfo<'a> { + pub fn stage_flags(mut self, stage_flags: crate::vk::ShaderStageFlags) -> Self { + self.stage_flags = stage_flags; + self + } + pub fn layout(mut self, layout: crate::vk::PipelineLayout) -> Self { + self.layout = layout; + self + } + pub fn first_set(mut self, first_set: u32) -> Self { + self.first_set = first_set; + self + } + pub fn descriptor_set_count(mut self, descriptor_set_count: u32) -> Self { + self.descriptor_set_count = descriptor_set_count; + self + } + pub fn p_descriptor_sets( + mut self, + p_descriptor_sets: &'a [crate::vk::DescriptorSet], + ) -> Self { + self.descriptor_set_count = p_descriptor_sets.len() as _; + self.p_descriptor_sets = p_descriptor_sets.as_ptr(); + self + } + pub fn dynamic_offset_count(mut self, dynamic_offset_count: u32) -> Self { + self.dynamic_offset_count = dynamic_offset_count; + self + } + pub fn p_dynamic_offsets(mut self, p_dynamic_offsets: &'a [u32]) -> Self { + self.dynamic_offset_count = p_dynamic_offsets.len() as _; + self.p_dynamic_offsets = p_dynamic_offsets.as_ptr(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PushConstantsInfo<'a> { @@ -778,6 +2546,46 @@ pub(crate) mod reexport { pub p_values: *const core::ffi::c_void, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for PushConstantsInfo<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PUSH_CONSTANTS_INFO; + } + impl<'a> Default for PushConstantsInfo<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + layout: Default::default(), + stage_flags: Default::default(), + offset: Default::default(), + size: Default::default(), + p_values: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PushConstantsInfo<'a> { + pub fn layout(mut self, layout: crate::vk::PipelineLayout) -> Self { + self.layout = layout; + self + } + pub fn stage_flags(mut self, stage_flags: crate::vk::ShaderStageFlags) -> Self { + self.stage_flags = stage_flags; + self + } + pub fn offset(mut self, offset: u32) -> Self { + self.offset = offset; + self + } + pub fn size(mut self, size: u32) -> Self { + self.size = size; + self + } + pub fn p_values(mut self, p_values: &'a [u8]) -> Self { + self.size = p_values.len() as _; + self.p_values = p_values.as_ptr().cast(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PushDescriptorSetInfo<'a> { @@ -790,6 +2598,49 @@ pub(crate) mod reexport { pub p_descriptor_writes: *const crate::vk::WriteDescriptorSet<'a>, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for PushDescriptorSetInfo<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PUSH_DESCRIPTOR_SET_INFO; + } + impl<'a> Default for PushDescriptorSetInfo<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + stage_flags: Default::default(), + layout: Default::default(), + set: Default::default(), + descriptor_write_count: Default::default(), + p_descriptor_writes: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PushDescriptorSetInfo<'a> { + pub fn stage_flags(mut self, stage_flags: crate::vk::ShaderStageFlags) -> Self { + self.stage_flags = stage_flags; + self + } + pub fn layout(mut self, layout: crate::vk::PipelineLayout) -> Self { + self.layout = layout; + self + } + pub fn set(mut self, set: u32) -> Self { + self.set = set; + self + } + pub fn descriptor_write_count(mut self, descriptor_write_count: u32) -> Self { + self.descriptor_write_count = descriptor_write_count; + self + } + pub fn p_descriptor_writes( + mut self, + p_descriptor_writes: &'a [crate::vk::WriteDescriptorSet<'a>], + ) -> Self { + self.descriptor_write_count = p_descriptor_writes.len() as _; + self.p_descriptor_writes = p_descriptor_writes.as_ptr(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PushDescriptorSetWithTemplateInfo<'a> { @@ -801,6 +2652,44 @@ pub(crate) mod reexport { pub p_data: *const core::ffi::c_void, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PushDescriptorSetWithTemplateInfo<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PUSH_DESCRIPTOR_SET_WITH_TEMPLATE_INFO; + } + impl<'a> Default for PushDescriptorSetWithTemplateInfo<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + descriptor_update_template: Default::default(), + layout: Default::default(), + set: Default::default(), + p_data: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PushDescriptorSetWithTemplateInfo<'a> { + pub fn descriptor_update_template( + mut self, + descriptor_update_template: crate::vk::DescriptorUpdateTemplate, + ) -> Self { + self.descriptor_update_template = descriptor_update_template; + self + } + pub fn layout(mut self, layout: crate::vk::PipelineLayout) -> Self { + self.layout = layout; + self + } + pub fn set(mut self, set: u32) -> Self { + self.set = set; + self + } + pub fn p_data(mut self, p_data: &'a core::ffi::c_void) -> Self { + self.p_data = p_data; + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceShaderSubgroupRotateFeatures<'a> { @@ -810,6 +2699,39 @@ pub(crate) mod reexport { pub shader_subgroup_rotate_clustered: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceShaderSubgroupRotateFeatures<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceShaderSubgroupRotateFeatures<'a> {} + unsafe impl<'a> crate::Extends> + for PhysicalDeviceShaderSubgroupRotateFeatures<'a> {} + impl<'a> Default for PhysicalDeviceShaderSubgroupRotateFeatures<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + shader_subgroup_rotate: Default::default(), + shader_subgroup_rotate_clustered: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceShaderSubgroupRotateFeatures<'a> { + pub fn shader_subgroup_rotate(mut self, shader_subgroup_rotate: bool) -> Self { + self.shader_subgroup_rotate = shader_subgroup_rotate.into(); + self + } + pub fn shader_subgroup_rotate_clustered( + mut self, + shader_subgroup_rotate_clustered: bool, + ) -> Self { + self.shader_subgroup_rotate_clustered = shader_subgroup_rotate_clustered + .into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceShaderExpectAssumeFeatures<'a> { @@ -818,6 +2740,30 @@ pub(crate) mod reexport { pub shader_expect_assume: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceShaderExpectAssumeFeatures<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceShaderExpectAssumeFeatures<'a> {} + unsafe impl<'a> crate::Extends> + for PhysicalDeviceShaderExpectAssumeFeatures<'a> {} + impl<'a> Default for PhysicalDeviceShaderExpectAssumeFeatures<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + shader_expect_assume: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceShaderExpectAssumeFeatures<'a> { + pub fn shader_expect_assume(mut self, shader_expect_assume: bool) -> Self { + self.shader_expect_assume = shader_expect_assume.into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceShaderFloatControls2Features<'a> { @@ -826,6 +2772,30 @@ pub(crate) mod reexport { pub shader_float_controls2: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceShaderFloatControls2Features<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceShaderFloatControls2Features<'a> {} + unsafe impl<'a> crate::Extends> + for PhysicalDeviceShaderFloatControls2Features<'a> {} + impl<'a> Default for PhysicalDeviceShaderFloatControls2Features<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + shader_float_controls2: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceShaderFloatControls2Features<'a> { + pub fn shader_float_controls2(mut self, shader_float_controls2: bool) -> Self { + self.shader_float_controls2 = shader_float_controls2.into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct PhysicalDeviceDynamicRenderingLocalReadFeatures<'a> { @@ -834,6 +2804,33 @@ pub(crate) mod reexport { pub dynamic_rendering_local_read: crate::vk::Bool32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for PhysicalDeviceDynamicRenderingLocalReadFeatures<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES; + } + unsafe impl<'a> crate::Extends> + for PhysicalDeviceDynamicRenderingLocalReadFeatures<'a> {} + unsafe impl<'a> crate::Extends> + for PhysicalDeviceDynamicRenderingLocalReadFeatures<'a> {} + impl<'a> Default for PhysicalDeviceDynamicRenderingLocalReadFeatures<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + dynamic_rendering_local_read: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> PhysicalDeviceDynamicRenderingLocalReadFeatures<'a> { + pub fn dynamic_rendering_local_read( + mut self, + dynamic_rendering_local_read: bool, + ) -> Self { + self.dynamic_rendering_local_read = dynamic_rendering_local_read.into(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct RenderingAttachmentLocationInfo<'a> { @@ -843,6 +2840,38 @@ pub(crate) mod reexport { pub p_color_attachment_locations: *const u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> for RenderingAttachmentLocationInfo<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::RENDERING_ATTACHMENT_LOCATION_INFO; + } + unsafe impl<'a> crate::Extends> + for RenderingAttachmentLocationInfo<'a> {} + unsafe impl<'a> crate::Extends> + for RenderingAttachmentLocationInfo<'a> {} + impl<'a> Default for RenderingAttachmentLocationInfo<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + color_attachment_count: Default::default(), + p_color_attachment_locations: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> RenderingAttachmentLocationInfo<'a> { + pub fn color_attachment_count(mut self, color_attachment_count: u32) -> Self { + self.color_attachment_count = color_attachment_count; + self + } + pub fn p_color_attachment_locations( + mut self, + p_color_attachment_locations: &'a [u32], + ) -> Self { + self.color_attachment_count = p_color_attachment_locations.len() as _; + self.p_color_attachment_locations = p_color_attachment_locations.as_ptr(); + self + } + } #[repr(C)] #[derive(Clone, Copy)] pub struct RenderingInputAttachmentIndexInfo<'a> { @@ -854,6 +2883,56 @@ pub(crate) mod reexport { pub p_stencil_input_attachment_index: *const u32, pub _marker: ::core::marker::PhantomData<&'a ()>, } + unsafe impl<'a> crate::TaggedStructure<'a> + for RenderingInputAttachmentIndexInfo<'a> { + const STRUCTURE_TYPE: crate::vk::StructureType = crate::vk::StructureType::RENDERING_INPUT_ATTACHMENT_INDEX_INFO; + } + unsafe impl<'a> crate::Extends> + for RenderingInputAttachmentIndexInfo<'a> {} + unsafe impl<'a> crate::Extends> + for RenderingInputAttachmentIndexInfo<'a> {} + impl<'a> Default for RenderingInputAttachmentIndexInfo<'a> { + fn default() -> Self { + Self { + s_type: ::STRUCTURE_TYPE, + p_next: Default::default(), + color_attachment_count: Default::default(), + p_color_attachment_input_indices: Default::default(), + p_depth_input_attachment_index: Default::default(), + p_stencil_input_attachment_index: Default::default(), + _marker: ::core::marker::PhantomData, + } + } + } + impl<'a> RenderingInputAttachmentIndexInfo<'a> { + pub fn color_attachment_count(mut self, color_attachment_count: u32) -> Self { + self.color_attachment_count = color_attachment_count; + self + } + pub fn p_color_attachment_input_indices( + mut self, + p_color_attachment_input_indices: &'a [u32], + ) -> Self { + self.color_attachment_count = p_color_attachment_input_indices.len() as _; + self.p_color_attachment_input_indices = p_color_attachment_input_indices + .as_ptr(); + self + } + pub fn p_depth_input_attachment_index( + mut self, + p_depth_input_attachment_index: &'a u32, + ) -> Self { + self.p_depth_input_attachment_index = p_depth_input_attachment_index; + self + } + pub fn p_stencil_input_attachment_index( + mut self, + p_stencil_input_attachment_index: &'a u32, + ) -> Self { + self.p_stencil_input_attachment_index = p_stencil_input_attachment_index; + self + } + } ///Provided by [`vk1_4`](crate::vk1_4) impl crate::vk::ImageLayout { pub const RENDERING_LOCAL_READ: Self = Self(1000232000); @@ -1112,7 +3191,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct MemoryUnmapFlagBits(pub(crate) u32); ///Provided by [`vk1_4`](crate::vk1_4) impl crate::vk::SubgroupFeatureFlagBits { @@ -1337,7 +3416,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct PipelineCreateFlagBits2(pub(crate) u64); ///Provided by [`vk1_4`](crate::vk1_4) impl PipelineCreateFlagBits2 { @@ -1532,7 +3611,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct BufferUsageFlagBits2(pub(crate) u64); ///Provided by [`vk1_4`](crate::vk1_4) impl BufferUsageFlagBits2 { @@ -1617,7 +3696,7 @@ pub(crate) mod reexport { } } #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct HostImageCopyFlagBits(pub(crate) u32); ///Provided by [`vk1_4`](crate::vk1_4) impl HostImageCopyFlagBits { diff --git a/ash-rewrite/src/lib.rs b/ash-rewrite/src/lib.rs index 784ec32b5..3ffa7907e 100644 --- a/ash-rewrite/src/lib.rs +++ b/ash-rewrite/src/lib.rs @@ -135,6 +135,51 @@ where } } +#[derive(Debug)] +pub struct CStrTooLargeForStaticArray { + pub static_array_size: usize, + pub c_str_size: usize, +} + +impl core::error::Error for CStrTooLargeForStaticArray {} +impl core::fmt::Display for CStrTooLargeForStaticArray { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(f, "static `c_char` target array of length `{}` is too small to write a `CStr` (with `NUL`-terminator) of length `{}`", self.static_array_size, self.c_str_size) + } +} + +pub(crate) fn write_c_str_slice_with_nul( + target: &mut [core::ffi::c_char], + str: &core::ffi::CStr, +) -> Result<(), CStrTooLargeForStaticArray> { + let bytes = str.to_bytes_with_nul(); + // SAFETY: cast from c_char to u8 is ok because c_char is always one byte + let bytes = unsafe { core::slice::from_raw_parts(bytes.as_ptr().cast(), bytes.len()) }; + let static_array_size = target.len(); + target + .get_mut(..bytes.len()) + .ok_or(CStrTooLargeForStaticArray { + static_array_size, + c_str_size: bytes.len(), + })? + .copy_from_slice(bytes); + Ok(()) +} + +pub(crate) fn wrap_c_str_slice_until_nul( + str: &[core::ffi::c_char], +) -> Result<&core::ffi::CStr, core::ffi::FromBytesUntilNulError> { + // SAFETY: The cast from c_char to u8 is ok because a c_char is always one byte. + let bytes = unsafe { core::slice::from_raw_parts(str.as_ptr().cast(), str.len()) }; + core::ffi::CStr::from_bytes_until_nul(bytes) +} + +pub unsafe trait TaggedStructure<'a>: Sized { + const STRUCTURE_TYPE: StructureType; +} + +pub unsafe trait Extends {} + pub use device::*; pub use entry::*; pub use instance::*; @@ -148,3 +193,5 @@ pub use vk1_1::InstanceFnV1_1; pub use vk1_2::DeviceFnV1_2; pub use vk1_3::DeviceFnV1_3; pub use vk1_3::InstanceFnV1_3; + +use self::generated::vk::StructureType; diff --git a/generator-rewrite/src/item/bitmask.rs b/generator-rewrite/src/item/bitmask.rs index a7f0efaf6..897e0cbce 100644 --- a/generator-rewrite/src/item/bitmask.rs +++ b/generator-rewrite/src/item/bitmask.rs @@ -30,7 +30,7 @@ impl Code for BitMask { bits_code = quote! { #[repr(transparent)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Default)] pub struct #bits_name_tokens(pub(crate) #base_ty); }; diff --git a/generator-rewrite/src/item/structure.rs b/generator-rewrite/src/item/structure.rs index fff31ccff..9707cd19c 100644 --- a/generator-rewrite/src/item/structure.rs +++ b/generator-rewrite/src/item/structure.rs @@ -1,13 +1,18 @@ +use core::str::FromStr; + use super::{Code, Context}; use crate::output::{CodeMap, Destination}; use analysis::{ + decl::{CPrimaryType, Decl, Mutability, RustType, Ty}, item::{ Named, - structure::{Struct, StructMember, Union}, + structure::{Length, Struct, StructDecl, StructMember, Union}, }, lifetime::Lifetime, + name::TypeName, to_rust::RustTranslator, }; +use proc_macro2::{Literal, TokenStream}; use quote::{format_ident, quote}; use tracing::{instrument, trace}; @@ -17,9 +22,19 @@ impl Code for Struct { trace!("generating"); let lifetime = Lifetime(format_ident!("a")); let name = ctx.type_to_rust(self.name(), false, &lifetime); + + let lifetime_tok = ctx + .type_has_lifetime(self.name()) + .then(|| quote! { #lifetime }); let mut bitfield_i = 0; + + let mut contains_static_array = false; let members = (self.members.iter()).map(|member| match member { - StructMember::Normal(decl) => { + StructMember::Normal(StructDecl { decl, .. }) => { + if let Ty::Array(_, _) = &decl.ty { + contains_static_array = true + } + let decl = decl.to_rust(ctx, &lifetime); quote! { pub #decl } } @@ -43,24 +58,302 @@ impl Code for Struct { quote! { pub _marker: ::core::marker::PhantomData<& #lifetime ()> } }); - let code = quote! { + let lifetime_marker_val = ctx.type_has_lifetime(self.name()).then(|| { + quote! { _marker: ::core::marker::PhantomData } + }); + + let tagged_structure = self.structure_type.as_ref().map(|ty| { + let structure_ty = ctx.type_to_rust(TypeName::VK_STRUCTURE_TYPE, true, &lifetime); + let ty = ctx.enumerator_to_rust(*ty, TypeName::VK_STRUCTURE_TYPE, true); + let anon = Lifetime::placeholder(); + let extends = self + .extends + .iter() + .map(|ty| ctx.type_to_rust(*ty, true, &anon)); + quote! { + unsafe impl<#lifetime> crate::TaggedStructure<#lifetime> for #name { + const STRUCTURE_TYPE: #structure_ty = #ty; + } + + #(unsafe impl<#lifetime_tok> crate::Extends<#extends> for #name {})* + } + }); + + let repr = quote! { #[repr(C)] - #[derive(Clone, Copy)] + }; + + let code = quote! { pub struct #name { #( #members, )* #lifetime_marker } + + #tagged_structure + }; + + bitfield_i = 0; + let default = if contains_static_array || tagged_structure.is_some() { + let defaults = self.members.iter().map(|member| match member { + StructMember::Normal(StructDecl { decl, .. }) => { + let field_name = ctx.var_name_to_rust(decl.name); + if tagged_structure.is_some() + && decl.name.original() == "sType" + && let Ty::SpecType(ty) = &decl.ty + && ty == &TypeName::VK_STRUCTURE_TYPE + { + quote! { #field_name: ::STRUCTURE_TYPE } + } else if let Ty::Array(_, _) = &decl.ty { + quote! { #field_name: unsafe { core::mem::zeroed() } } + } else { + quote! { #field_name: Default::default() } + } + } + StructMember::BitField(_) => { + let name = format_ident!("bitfield{bitfield_i}"); + bitfield_i += 1; + quote! { #name: Default::default() } + } + }); + + Some(quote! { + impl<#lifetime_tok> Default for #name { + fn default() -> Self { + Self { + #( #defaults, )* + #lifetime_marker_val + } + } + } + }) + } else { + None + }; + + let derive_default = if default.is_none() { + Some(quote! {Default}) + } else { + None + }; + + let derives = quote! { + #[derive(Clone, Copy, #derive_default)] + }; + + let mut bitfield_i = 0; + let builders = self + .members + .iter() + .filter(|member| match member { + StructMember::Normal(StructDecl { decl, .. }) => { + !matches!(decl.name.original(), "sType" | "pNext") + } + _ => true, + }) + .flat_map(|member| match member { + StructMember::Normal(StructDecl { decl, len }) => itertools::Either::Left( + core::iter::once(decl_setter_and_getter(decl, len, ctx, &lifetime)), + ), + StructMember::BitField(bitfield_ranges) => { + let name = format_ident!("bitfield{bitfield_i}"); + bitfield_i += 1; + itertools::Either::Right(bitfield_ranges.iter().map(move |range| { + let field_name = ctx.var_name_to_rust(range.decl.name); + let mask = { + let top = u32::MAX >> (u32::BITS - range.range.end as u32); + let bottom = u32::MAX << (range.range.start); + top & bottom + }; + let mask_tok = Literal::from_str(&format!("0x{mask:08X}")).unwrap(); + let mask_inv_tok = Literal::from_str(&format!("0x{:08X}", !mask)).unwrap(); + let offset = range.range.start as u32; + let field_shift = if offset != 0 { + quote! { (#field_name << #offset) } + } else { + quote! { #field_name } + }; + quote! { + pub fn #field_name(mut self, #field_name: u32) -> Self { + let rest = self.#name & #mask_inv_tok; + self.#name = (#field_shift & #mask_tok) | rest; + self + } + } + })) + } + }); + let code = quote! { + #repr + #derives + #code + #default + + impl<#lifetime_tok> #name { + #(#builders)* + } }; CodeMap::new(Destination::new(self.required_by), code) } } +fn decl_setter_and_getter( + decl: &Decl, + len: &[Length], + ctx: &Context<'_>, + lifetime: &Lifetime, +) -> TokenStream { + let field_name = ctx.var_name_to_rust(decl.name); + + match decl.ty { + Ty::SpecType(TypeName::VK_BOOL32) => { + quote! { + pub fn #field_name(mut self, #field_name: bool) -> Self { + self.#field_name = #field_name.into(); + self + } + } + } + Ty::Ptr(Ty::CPrimary(CPrimaryType::Char), mutability) + if len.first().is_some_and(|l| l == &Length::NullTerminated) => + { + let ty = Ty::Ref(&Ty::RustType(RustType::CStr), mutability).to_rust(ctx, lifetime); + let field_name_as_cstr = format_ident!("{field_name}_as_c_str"); + quote! { + pub fn #field_name(mut self, #field_name: #ty) -> Self { + self.#field_name = #field_name.as_ptr(); + self + } + + pub unsafe fn #field_name_as_cstr(&self) -> Option<&core::ffi::CStr> { + if self.#field_name.is_null() { + None + } else { + Some(unsafe { core::ffi::CStr::from_ptr(self.#field_name) }) + } + } + } + } + Ty::Array(Ty::CPrimary(CPrimaryType::Char), _) + if len.first().is_some_and(|l| l == &Length::NullTerminated) => + { + let field_name_as_cstr = format_ident!("{field_name}_as_c_str"); + quote! { + pub fn #field_name(mut self, #field_name: &core::ffi::CStr) -> core::result::Result { + crate::write_c_str_slice_with_nul(&mut self.#field_name, #field_name).map(|_| self) + } + + pub fn #field_name_as_cstr(&self) -> core::result::Result<&core::ffi::CStr, core::ffi::FromBytesUntilNulError> { + crate::wrap_c_str_slice_until_nul(&self.#field_name) + } + } + } + Ty::Array(base, _) if let Some(Length::Member(len_var)) = len.first() => { + let len_var = ctx.var_name_to_rust(*len_var); + let field_name_as_slice = format_ident!("{field_name}_as_slice"); + let base_ty = array_base_ty(base, ctx, lifetime, len); + quote! { + pub fn #field_name(mut self, #field_name: &[#base_ty]) -> Self { + self.#len_var = #field_name.len() as _; + self.#field_name[..#field_name.len()].copy_from_slice(#field_name); + self + } + + pub fn #field_name_as_slice(&self) -> &[#base_ty] { + &self.#field_name[..self.#len_var as _] + } + } + } + Ty::Ptr(base, mutability) if let Some(Length::Member(len_var)) = len.first() => { + let mut ptr = match mutability { + Mutability::Not => quote! { .as_ptr() }, + Mutability::Mut => quote! { .as_mut_ptr() }, + }; + let base_ty = match base { + Ty::CPrimary(CPrimaryType::Void) => { + ptr = quote! { #ptr.cast() }; + quote! { [u8] } + } + _ => { + let ty = array_base_ty(base, ctx, lifetime, len); + if len.get(1) == Some(&Length::Pointer) { + ptr = quote! { #ptr.cast() } + } + quote! { [#ty] } + } + }; + + let len_var = ctx.var_name_to_rust(*len_var); + let mutability = match mutability { + Mutability::Not => quote! {}, + Mutability::Mut => quote! {mut}, + }; + quote! { + pub fn #field_name(mut self, #field_name: &#lifetime #mutability #base_ty) -> Self { + self.#len_var = #field_name.len() as _; + self.#field_name = #field_name #ptr; + self + } + } + } + Ty::Ptr(base, mutability) if len.first().is_none_or(|l| l == &Length::Pointer) => { + let ty = Ty::Ref(base, mutability).to_rust(ctx, lifetime); + quote! { + pub fn #field_name(mut self, #field_name: #ty) -> Self { + self.#field_name = #field_name; + self + } + } + } + Ty::Ptr(base, mutability) if let Some(Length::Custom(custom)) = len.first() => { + match *custom { + _ => { + tracing::warn!(?custom, "unhandled custom length"); + let ty = decl.ty.to_rust(ctx, lifetime); + quote! { + pub fn #field_name(mut self, #field_name: #ty) -> Self { + self.#field_name = #field_name; + self + } + } + } + } + } + _ => { + let ty = decl.ty.to_rust(ctx, lifetime); + quote! { + pub fn #field_name(mut self, #field_name: #ty) -> Self { + self.#field_name = #field_name; + self + } + } + } + } +} + +fn array_base_ty(base: &Ty, ctx: &Context<'_>, lifetime: &Lifetime, len: &[Length]) -> TokenStream { + match base { + Ty::Ptr(ty, mutability) if len.get(1).is_some_and(|l| l == &Length::Pointer) => { + Ty::Ref(ty, *mutability).to_rust(ctx, lifetime) + } + ty @ (Ty::SpecType(_) + | Ty::SpecFuncPointer(_) + | Ty::CPrimary(_) + | Ty::Array(_, _) + | Ty::Ptr(_, _) + | Ty::Platform(_)) => ty.to_rust(ctx, lifetime), + _ => unreachable!("Ty::RustType, Ty::Ref, and Ty::Slice cannot be emitted from a registry"), + } +} + impl Code for Union { #[instrument(skip(ctx))] fn code(&self, ctx: &Context) -> CodeMap { trace!("generating"); let lifetime = Lifetime(format_ident!("a")); + let lifetime_tok = ctx + .type_has_lifetime(self.name()) + .then(|| quote! { #lifetime }); let name = ctx.type_to_rust(self.name(), false, &lifetime); let members = (self.members.iter()).map(|decl| decl.to_rust(ctx, &lifetime)); @@ -70,6 +363,12 @@ impl Code for Union { pub union #name { #( pub #members ),* } + + impl<#lifetime_tok> Default for #name { + fn default() -> Self { + unsafe { core::mem::zeroed() } + } + } }; CodeMap::new(Destination::new(self.required_by), code) diff --git a/generator-rewrite/src/lib.rs b/generator-rewrite/src/lib.rs index 11b20f768..c37cd146e 100644 --- a/generator-rewrite/src/lib.rs +++ b/generator-rewrite/src/lib.rs @@ -4,13 +4,10 @@ mod output; use crate::output::CodeMap; use analysis::{ - Analysis, AnalysisResult, - lifetime::Lifetime, - name::{ + Analysis, AnalysisResult, decl::RustType, lifetime::Lifetime, name::{ CMacroName, CommandName, ConstantName, EnumeratorName, FuncPointerName, TypeName, VariableName, - }, - to_rust::RustTranslator, + }, to_rust::RustTranslator }; use heck::{ToShoutySnekCase, ToSnekCase}; use proc_macro2::TokenStream; @@ -123,7 +120,13 @@ impl<'a> RustTranslator for Context<'a> { quote! { #path #ident } } - fn platform_type_to_rust(&self, raw: &'static str, qualified: bool) -> TokenStream { + fn rust_type_to_rust(&self, ty: &RustType) -> TokenStream { + match ty { + RustType::CStr => quote! { core::ffi::CStr }, + } + } + + fn platform_type_to_rust(&self, raw: &str, qualified: bool) -> TokenStream { let ident: Ident = syn::parse_str(raw).unwrap(); let path = qualified.then(|| quote! { crate::platform_types:: }); quote! { #path #ident } diff --git a/generator-rewrite/src/output.rs b/generator-rewrite/src/output.rs index 05e24099c..ed9dc5d3b 100644 --- a/generator-rewrite/src/output.rs +++ b/generator-rewrite/src/output.rs @@ -232,7 +232,11 @@ impl CodeMap { ); } - vfs.write("vk.rs", quote! { pub use crate::Handle; }); + vfs.write("vk.rs", quote! { + pub use crate::Handle; + pub use crate::TaggedStructure; + pub use crate::Extends; + }); vfs.sync_to(output_path) } }