erupt/generated/extensions/
khr_win32_keyed_mutex.rs1#[doc(alias = "VK_KHR_WIN32_KEYED_MUTEX_SPEC_VERSION")]
4pub const KHR_WIN32_KEYED_MUTEX_SPEC_VERSION: u32 = 1;
5#[doc(alias = "VK_KHR_WIN32_KEYED_MUTEX_EXTENSION_NAME")]
7pub const KHR_WIN32_KEYED_MUTEX_EXTENSION_NAME: *const std::os::raw::c_char = crate::cstr!(
8    "VK_KHR_win32_keyed_mutex"
9);
10impl crate::vk1_0::StructureType {
12    pub const WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR: Self = Self(1000075000);
13}
14impl<'a> crate::ExtendableFrom<'a, Win32KeyedMutexAcquireReleaseInfoKHR>
15for crate::vk1_0::SubmitInfoBuilder<'a> {}
16impl<'a> crate::ExtendableFrom<'a, Win32KeyedMutexAcquireReleaseInfoKHRBuilder<'_>>
17for crate::vk1_0::SubmitInfoBuilder<'a> {}
18#[doc(alias = "VkWin32KeyedMutexAcquireReleaseInfoKHR")]
20#[derive(Copy, Clone)]
21#[repr(C)]
22pub struct Win32KeyedMutexAcquireReleaseInfoKHR {
23    pub s_type: crate::vk1_0::StructureType,
24    pub p_next: *const std::ffi::c_void,
25    pub acquire_count: u32,
26    pub p_acquire_syncs: *const crate::vk1_0::DeviceMemory,
27    pub p_acquire_keys: *const u64,
28    pub p_acquire_timeouts: *const u32,
29    pub release_count: u32,
30    pub p_release_syncs: *const crate::vk1_0::DeviceMemory,
31    pub p_release_keys: *const u64,
32}
33impl Win32KeyedMutexAcquireReleaseInfoKHR {
34    pub const STRUCTURE_TYPE: crate::vk1_0::StructureType = crate::vk1_0::StructureType::WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR;
35}
36impl Default for Win32KeyedMutexAcquireReleaseInfoKHR {
37    fn default() -> Self {
38        Self {
39            s_type: Self::STRUCTURE_TYPE,
40            p_next: std::ptr::null(),
41            acquire_count: Default::default(),
42            p_acquire_syncs: std::ptr::null(),
43            p_acquire_keys: std::ptr::null(),
44            p_acquire_timeouts: std::ptr::null(),
45            release_count: Default::default(),
46            p_release_syncs: std::ptr::null(),
47            p_release_keys: std::ptr::null(),
48        }
49    }
50}
51impl std::fmt::Debug for Win32KeyedMutexAcquireReleaseInfoKHR {
52    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
53        f.debug_struct("Win32KeyedMutexAcquireReleaseInfoKHR")
54            .field("s_type", &self.s_type)
55            .field("p_next", &self.p_next)
56            .field("acquire_count", &self.acquire_count)
57            .field("p_acquire_syncs", &self.p_acquire_syncs)
58            .field("p_acquire_keys", &self.p_acquire_keys)
59            .field("p_acquire_timeouts", &self.p_acquire_timeouts)
60            .field("release_count", &self.release_count)
61            .field("p_release_syncs", &self.p_release_syncs)
62            .field("p_release_keys", &self.p_release_keys)
63            .finish()
64    }
65}
66impl Win32KeyedMutexAcquireReleaseInfoKHR {
67    #[inline]
68    pub fn into_builder<'a>(self) -> Win32KeyedMutexAcquireReleaseInfoKHRBuilder<'a> {
69        Win32KeyedMutexAcquireReleaseInfoKHRBuilder(self, std::marker::PhantomData)
70    }
71}
72#[derive(Copy, Clone)]
73#[repr(transparent)]
75pub struct Win32KeyedMutexAcquireReleaseInfoKHRBuilder<'a>(
76    Win32KeyedMutexAcquireReleaseInfoKHR,
77    std::marker::PhantomData<&'a ()>,
78);
79impl<'a> Win32KeyedMutexAcquireReleaseInfoKHRBuilder<'a> {
80    #[inline]
81    pub fn new() -> Win32KeyedMutexAcquireReleaseInfoKHRBuilder<'a> {
82        Win32KeyedMutexAcquireReleaseInfoKHRBuilder(
83            Default::default(),
84            std::marker::PhantomData,
85        )
86    }
87    #[inline]
88    #[must_use]
89    pub fn acquire_syncs(
90        mut self,
91        acquire_syncs: &'a [crate::vk1_0::DeviceMemory],
92    ) -> Self {
93        self.0.p_acquire_syncs = acquire_syncs.as_ptr() as _;
94        self.0.acquire_count = acquire_syncs.len() as _;
95        self
96    }
97    #[inline]
98    #[must_use]
99    pub fn acquire_keys(mut self, acquire_keys: &'a [u64]) -> Self {
100        self.0.p_acquire_keys = acquire_keys.as_ptr() as _;
101        self.0.acquire_count = acquire_keys.len() as _;
102        self
103    }
104    #[inline]
105    #[must_use]
106    pub fn acquire_timeouts(mut self, acquire_timeouts: &'a [u32]) -> Self {
107        self.0.p_acquire_timeouts = acquire_timeouts.as_ptr() as _;
108        self.0.acquire_count = acquire_timeouts.len() as _;
109        self
110    }
111    #[inline]
112    #[must_use]
113    pub fn release_syncs(
114        mut self,
115        release_syncs: &'a [crate::vk1_0::DeviceMemory],
116    ) -> Self {
117        self.0.p_release_syncs = release_syncs.as_ptr() as _;
118        self.0.release_count = release_syncs.len() as _;
119        self
120    }
121    #[inline]
122    #[must_use]
123    pub fn release_keys(mut self, release_keys: &'a [u64]) -> Self {
124        self.0.p_release_keys = release_keys.as_ptr() as _;
125        self.0.release_count = release_keys.len() as _;
126        self
127    }
128    #[inline]
129    pub fn build_dangling(self) -> Win32KeyedMutexAcquireReleaseInfoKHR {
132        self.0
133    }
134}
135impl<'a> std::default::Default for Win32KeyedMutexAcquireReleaseInfoKHRBuilder<'a> {
136    fn default() -> Win32KeyedMutexAcquireReleaseInfoKHRBuilder<'a> {
137        Self::new()
138    }
139}
140impl<'a> std::fmt::Debug for Win32KeyedMutexAcquireReleaseInfoKHRBuilder<'a> {
141    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
142        std::fmt::Debug::fmt(&self.0, f)
143    }
144}
145impl<'a> std::ops::Deref for Win32KeyedMutexAcquireReleaseInfoKHRBuilder<'a> {
146    type Target = Win32KeyedMutexAcquireReleaseInfoKHR;
147    fn deref(&self) -> &Self::Target {
148        &self.0
149    }
150}
151impl<'a> std::ops::DerefMut for Win32KeyedMutexAcquireReleaseInfoKHRBuilder<'a> {
152    fn deref_mut(&mut self) -> &mut Self::Target {
153        &mut self.0
154    }
155}
156impl<'a> crate::ExtendableFrom<'a, Win32KeyedMutexAcquireReleaseInfoKHR>
157for crate::vk1_3::SubmitInfo2Builder<'a> {}
158impl<'a> crate::ExtendableFrom<'a, Win32KeyedMutexAcquireReleaseInfoKHRBuilder<'_>>
159for crate::vk1_3::SubmitInfo2Builder<'a> {}