erupt/generated/extensions/
ext_validation_cache.rs1#[doc(alias = "VK_EXT_VALIDATION_CACHE_SPEC_VERSION")]
4pub const EXT_VALIDATION_CACHE_SPEC_VERSION: u32 = 1;
5#[doc(alias = "VK_EXT_VALIDATION_CACHE_EXTENSION_NAME")]
7pub const EXT_VALIDATION_CACHE_EXTENSION_NAME: *const std::os::raw::c_char = crate::cstr!(
8 "VK_EXT_validation_cache"
9);
10pub const FN_CREATE_VALIDATION_CACHE_EXT: *const std::os::raw::c_char = crate::cstr!(
12 "vkCreateValidationCacheEXT"
13);
14pub const FN_DESTROY_VALIDATION_CACHE_EXT: *const std::os::raw::c_char = crate::cstr!(
16 "vkDestroyValidationCacheEXT"
17);
18pub const FN_GET_VALIDATION_CACHE_DATA_EXT: *const std::os::raw::c_char = crate::cstr!(
20 "vkGetValidationCacheDataEXT"
21);
22pub const FN_MERGE_VALIDATION_CACHES_EXT: *const std::os::raw::c_char = crate::cstr!(
24 "vkMergeValidationCachesEXT"
25);
26crate::non_dispatchable_handle!(
27 ValidationCacheEXT, VALIDATION_CACHE_EXT,
28 "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkValidationCacheEXT.html) · Non-dispatchable Handle",
29 "VkValidationCacheEXT"
30);
31bitflags::bitflags! {
32 #[doc =
33 "[Vulkan Manual Page](https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkValidationCacheCreateFlagsEXT.html) · Bitmask of [`ValidationCacheCreateFlagBitsEXT`]"]
34 #[doc(alias = "VkValidationCacheCreateFlagsEXT")] #[derive(Default)]
35 #[repr(transparent)] pub struct ValidationCacheCreateFlagsEXT : u32 {
36 #[cfg(empty_bitflag_workaround)] const EMPTY_BITFLAG_WORKAROUND = 0; }
37}
38#[doc(alias = "VkValidationCacheCreateFlagBitsEXT")]
40#[derive(Copy, Clone, PartialEq, Eq, Hash, Default, Ord, PartialOrd)]
41#[repr(transparent)]
42pub struct ValidationCacheCreateFlagBitsEXT(pub u32);
43impl ValidationCacheCreateFlagBitsEXT {
44 #[inline]
45 pub const fn bitmask(&self) -> ValidationCacheCreateFlagsEXT {
47 ValidationCacheCreateFlagsEXT::from_bits_truncate(self.0)
48 }
49}
50impl std::fmt::Debug for ValidationCacheCreateFlagBitsEXT {
51 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
52 f.write_str(
53 match self {
54 _ => "(unknown variant)",
55 },
56 )
57 }
58}
59impl crate::vk1_0::StructureType {
61 pub const VALIDATION_CACHE_CREATE_INFO_EXT: Self = Self(1000160000);
62 pub const SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT: Self = Self(1000160001);
63}
64impl crate::vk1_0::ObjectType {
66 pub const VALIDATION_CACHE_EXT: Self = Self(1000160000);
67}
68#[doc(alias = "VkValidationCacheHeaderVersionEXT")]
70#[derive(Copy, Clone, PartialEq, Eq, Hash, Default, Ord, PartialOrd)]
71#[repr(transparent)]
72pub struct ValidationCacheHeaderVersionEXT(pub i32);
73impl std::fmt::Debug for ValidationCacheHeaderVersionEXT {
74 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
75 f.write_str(
76 match self {
77 &Self::ONE_EXT => "ONE_EXT",
78 _ => "(unknown variant)",
79 },
80 )
81 }
82}
83impl crate::extensions::ext_validation_cache::ValidationCacheHeaderVersionEXT {
85 pub const ONE_EXT: Self = Self(1);
86}
87#[allow(non_camel_case_types)]
89pub type PFN_vkCreateValidationCacheEXT = unsafe extern "system" fn(
90 device: crate::vk1_0::Device,
91 p_create_info: *const crate::extensions::ext_validation_cache::ValidationCacheCreateInfoEXT,
92 p_allocator: *const crate::vk1_0::AllocationCallbacks,
93 p_validation_cache: *mut crate::extensions::ext_validation_cache::ValidationCacheEXT,
94) -> crate::vk1_0::Result;
95#[allow(non_camel_case_types)]
97pub type PFN_vkDestroyValidationCacheEXT = unsafe extern "system" fn(
98 device: crate::vk1_0::Device,
99 validation_cache: crate::extensions::ext_validation_cache::ValidationCacheEXT,
100 p_allocator: *const crate::vk1_0::AllocationCallbacks,
101) -> ();
102#[allow(non_camel_case_types)]
104pub type PFN_vkGetValidationCacheDataEXT = unsafe extern "system" fn(
105 device: crate::vk1_0::Device,
106 validation_cache: crate::extensions::ext_validation_cache::ValidationCacheEXT,
107 p_data_size: *mut usize,
108 p_data: *mut std::ffi::c_void,
109) -> crate::vk1_0::Result;
110#[allow(non_camel_case_types)]
112pub type PFN_vkMergeValidationCachesEXT = unsafe extern "system" fn(
113 device: crate::vk1_0::Device,
114 dst_cache: crate::extensions::ext_validation_cache::ValidationCacheEXT,
115 src_cache_count: u32,
116 p_src_caches: *const crate::extensions::ext_validation_cache::ValidationCacheEXT,
117) -> crate::vk1_0::Result;
118impl<'a> crate::ExtendableFrom<'a, ShaderModuleValidationCacheCreateInfoEXT>
119for crate::vk1_0::ShaderModuleCreateInfoBuilder<'a> {}
120impl<'a> crate::ExtendableFrom<'a, ShaderModuleValidationCacheCreateInfoEXTBuilder<'_>>
121for crate::vk1_0::ShaderModuleCreateInfoBuilder<'a> {}
122#[doc(alias = "VkValidationCacheCreateInfoEXT")]
124#[derive(Copy, Clone)]
125#[repr(C)]
126pub struct ValidationCacheCreateInfoEXT {
127 pub s_type: crate::vk1_0::StructureType,
128 pub p_next: *const std::ffi::c_void,
129 pub flags: crate::extensions::ext_validation_cache::ValidationCacheCreateFlagsEXT,
130 pub initial_data_size: usize,
131 pub p_initial_data: *const std::ffi::c_void,
132}
133impl ValidationCacheCreateInfoEXT {
134 pub const STRUCTURE_TYPE: crate::vk1_0::StructureType = crate::vk1_0::StructureType::VALIDATION_CACHE_CREATE_INFO_EXT;
135}
136impl Default for ValidationCacheCreateInfoEXT {
137 fn default() -> Self {
138 Self {
139 s_type: Self::STRUCTURE_TYPE,
140 p_next: std::ptr::null(),
141 flags: Default::default(),
142 initial_data_size: Default::default(),
143 p_initial_data: std::ptr::null(),
144 }
145 }
146}
147impl std::fmt::Debug for ValidationCacheCreateInfoEXT {
148 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
149 f.debug_struct("ValidationCacheCreateInfoEXT")
150 .field("s_type", &self.s_type)
151 .field("p_next", &self.p_next)
152 .field("flags", &self.flags)
153 .field("initial_data_size", &self.initial_data_size)
154 .field("p_initial_data", &self.p_initial_data)
155 .finish()
156 }
157}
158impl ValidationCacheCreateInfoEXT {
159 #[inline]
160 pub fn into_builder<'a>(self) -> ValidationCacheCreateInfoEXTBuilder<'a> {
161 ValidationCacheCreateInfoEXTBuilder(self, std::marker::PhantomData)
162 }
163}
164#[derive(Copy, Clone)]
165#[repr(transparent)]
167pub struct ValidationCacheCreateInfoEXTBuilder<'a>(
168 ValidationCacheCreateInfoEXT,
169 std::marker::PhantomData<&'a ()>,
170);
171impl<'a> ValidationCacheCreateInfoEXTBuilder<'a> {
172 #[inline]
173 pub fn new() -> ValidationCacheCreateInfoEXTBuilder<'a> {
174 ValidationCacheCreateInfoEXTBuilder(Default::default(), std::marker::PhantomData)
175 }
176 #[inline]
177 #[must_use]
178 pub fn flags(
179 mut self,
180 flags: crate::extensions::ext_validation_cache::ValidationCacheCreateFlagsEXT,
181 ) -> Self {
182 self.0.flags = flags as _;
183 self
184 }
185 #[inline]
186 #[must_use]
187 pub fn initial_data_size(mut self, initial_data_size: usize) -> Self {
188 self.0.initial_data_size = initial_data_size;
189 self
190 }
191 #[inline]
192 #[must_use]
193 pub fn initial_data(mut self, initial_data: *const std::ffi::c_void) -> Self {
194 self.0.p_initial_data = initial_data;
195 self
196 }
197 #[inline]
198 pub fn build_dangling(self) -> ValidationCacheCreateInfoEXT {
201 self.0
202 }
203}
204impl<'a> std::default::Default for ValidationCacheCreateInfoEXTBuilder<'a> {
205 fn default() -> ValidationCacheCreateInfoEXTBuilder<'a> {
206 Self::new()
207 }
208}
209impl<'a> std::fmt::Debug for ValidationCacheCreateInfoEXTBuilder<'a> {
210 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
211 std::fmt::Debug::fmt(&self.0, f)
212 }
213}
214impl<'a> std::ops::Deref for ValidationCacheCreateInfoEXTBuilder<'a> {
215 type Target = ValidationCacheCreateInfoEXT;
216 fn deref(&self) -> &Self::Target {
217 &self.0
218 }
219}
220impl<'a> std::ops::DerefMut for ValidationCacheCreateInfoEXTBuilder<'a> {
221 fn deref_mut(&mut self) -> &mut Self::Target {
222 &mut self.0
223 }
224}
225#[doc(alias = "VkShaderModuleValidationCacheCreateInfoEXT")]
227#[derive(Copy, Clone)]
228#[repr(C)]
229pub struct ShaderModuleValidationCacheCreateInfoEXT {
230 pub s_type: crate::vk1_0::StructureType,
231 pub p_next: *const std::ffi::c_void,
232 pub validation_cache: crate::extensions::ext_validation_cache::ValidationCacheEXT,
233}
234impl ShaderModuleValidationCacheCreateInfoEXT {
235 pub const STRUCTURE_TYPE: crate::vk1_0::StructureType = crate::vk1_0::StructureType::SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT;
236}
237impl Default for ShaderModuleValidationCacheCreateInfoEXT {
238 fn default() -> Self {
239 Self {
240 s_type: Self::STRUCTURE_TYPE,
241 p_next: std::ptr::null(),
242 validation_cache: Default::default(),
243 }
244 }
245}
246impl std::fmt::Debug for ShaderModuleValidationCacheCreateInfoEXT {
247 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
248 f.debug_struct("ShaderModuleValidationCacheCreateInfoEXT")
249 .field("s_type", &self.s_type)
250 .field("p_next", &self.p_next)
251 .field("validation_cache", &self.validation_cache)
252 .finish()
253 }
254}
255impl ShaderModuleValidationCacheCreateInfoEXT {
256 #[inline]
257 pub fn into_builder<'a>(
258 self,
259 ) -> ShaderModuleValidationCacheCreateInfoEXTBuilder<'a> {
260 ShaderModuleValidationCacheCreateInfoEXTBuilder(self, std::marker::PhantomData)
261 }
262}
263#[derive(Copy, Clone)]
264#[repr(transparent)]
266pub struct ShaderModuleValidationCacheCreateInfoEXTBuilder<'a>(
267 ShaderModuleValidationCacheCreateInfoEXT,
268 std::marker::PhantomData<&'a ()>,
269);
270impl<'a> ShaderModuleValidationCacheCreateInfoEXTBuilder<'a> {
271 #[inline]
272 pub fn new() -> ShaderModuleValidationCacheCreateInfoEXTBuilder<'a> {
273 ShaderModuleValidationCacheCreateInfoEXTBuilder(
274 Default::default(),
275 std::marker::PhantomData,
276 )
277 }
278 #[inline]
279 #[must_use]
280 pub fn validation_cache(
281 mut self,
282 validation_cache: crate::extensions::ext_validation_cache::ValidationCacheEXT,
283 ) -> Self {
284 self.0.validation_cache = validation_cache as _;
285 self
286 }
287 #[inline]
288 pub fn build_dangling(self) -> ShaderModuleValidationCacheCreateInfoEXT {
291 self.0
292 }
293}
294impl<'a> std::default::Default for ShaderModuleValidationCacheCreateInfoEXTBuilder<'a> {
295 fn default() -> ShaderModuleValidationCacheCreateInfoEXTBuilder<'a> {
296 Self::new()
297 }
298}
299impl<'a> std::fmt::Debug for ShaderModuleValidationCacheCreateInfoEXTBuilder<'a> {
300 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
301 std::fmt::Debug::fmt(&self.0, f)
302 }
303}
304impl<'a> std::ops::Deref for ShaderModuleValidationCacheCreateInfoEXTBuilder<'a> {
305 type Target = ShaderModuleValidationCacheCreateInfoEXT;
306 fn deref(&self) -> &Self::Target {
307 &self.0
308 }
309}
310impl<'a> std::ops::DerefMut for ShaderModuleValidationCacheCreateInfoEXTBuilder<'a> {
311 fn deref_mut(&mut self) -> &mut Self::Target {
312 &mut self.0
313 }
314}
315impl crate::DeviceLoader {
317 #[inline]
318 #[track_caller]
319 #[doc(alias = "vkCreateValidationCacheEXT")]
321 pub unsafe fn create_validation_cache_ext(
322 &self,
323 create_info: &crate::extensions::ext_validation_cache::ValidationCacheCreateInfoEXT,
324 allocator: Option<&crate::vk1_0::AllocationCallbacks>,
325 ) -> crate::utils::VulkanResult<
326 crate::extensions::ext_validation_cache::ValidationCacheEXT,
327 > {
328 let _function = self
329 .create_validation_cache_ext
330 .expect(crate::NOT_LOADED_MESSAGE);
331 let mut validation_cache = Default::default();
332 let _return = _function(
333 self.handle,
334 create_info as _,
335 match allocator {
336 Some(v) => v,
337 None => std::ptr::null(),
338 },
339 &mut validation_cache,
340 );
341 crate::utils::VulkanResult::new(_return, validation_cache)
342 }
343 #[inline]
344 #[track_caller]
345 #[doc(alias = "vkDestroyValidationCacheEXT")]
347 pub unsafe fn destroy_validation_cache_ext(
348 &self,
349 validation_cache: crate::extensions::ext_validation_cache::ValidationCacheEXT,
350 allocator: Option<&crate::vk1_0::AllocationCallbacks>,
351 ) -> () {
352 let _function = self
353 .destroy_validation_cache_ext
354 .expect(crate::NOT_LOADED_MESSAGE);
355 let _return = _function(
356 self.handle,
357 validation_cache as _,
358 match allocator {
359 Some(v) => v,
360 None => std::ptr::null(),
361 },
362 );
363 ()
364 }
365 #[inline]
366 #[track_caller]
367 #[doc(alias = "vkGetValidationCacheDataEXT")]
369 pub unsafe fn get_validation_cache_data_ext(
370 &self,
371 validation_cache: crate::extensions::ext_validation_cache::ValidationCacheEXT,
372 data_size: *mut usize,
373 data: *mut std::ffi::c_void,
374 ) -> crate::utils::VulkanResult<()> {
375 let _function = self
376 .get_validation_cache_data_ext
377 .expect(crate::NOT_LOADED_MESSAGE);
378 let _return = _function(self.handle, validation_cache as _, data_size, data);
379 crate::utils::VulkanResult::new(_return, ())
380 }
381 #[inline]
382 #[track_caller]
383 #[doc(alias = "vkMergeValidationCachesEXT")]
385 pub unsafe fn merge_validation_caches_ext(
386 &self,
387 dst_cache: crate::extensions::ext_validation_cache::ValidationCacheEXT,
388 src_caches: &[crate::extensions::ext_validation_cache::ValidationCacheEXT],
389 ) -> crate::utils::VulkanResult<()> {
390 let _function = self
391 .merge_validation_caches_ext
392 .expect(crate::NOT_LOADED_MESSAGE);
393 let src_cache_count = src_caches.len();
394 let _return = _function(
395 self.handle,
396 dst_cache as _,
397 src_cache_count as _,
398 src_caches.as_ptr() as _,
399 );
400 crate::utils::VulkanResult::new(_return, ())
401 }
402}